From 82b4d0d8aa9e1da2c9df3701bc970cb46b00778e Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Sun, 11 Aug 2024 12:53:48 +0100
Subject: [PATCH 01/12] std::fs::get_path freebsd update.
what matters is we re doing the right things as doing sizeof, rather than
KINFO_FILE_SIZE (only defined on intel architectures), the kernel
making sure it matches the expectation in its side.
---
library/std/src/sys/pal/unix/fs.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/library/std/src/sys/pal/unix/fs.rs b/library/std/src/sys/pal/unix/fs.rs
index 39aabf0b2d67..1d962fbc0c24 100644
--- a/library/std/src/sys/pal/unix/fs.rs
+++ b/library/std/src/sys/pal/unix/fs.rs
@@ -1538,7 +1538,7 @@ impl fmt::Debug for File {
Some(PathBuf::from(OsString::from_vec(buf)))
}
- #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))]
+ #[cfg(target_os = "freebsd")]
fn get_path(fd: c_int) -> Option<PathBuf> {
let info = Box::<libc::kinfo_file>::new_zeroed();
let mut info = unsafe { info.assume_init() };
@@ -1566,7 +1566,7 @@ impl fmt::Debug for File {
#[cfg(not(any(
target_os = "linux",
target_os = "vxworks",
- all(target_os = "freebsd", target_arch = "x86_64"),
+ target_os = "freebsd",
target_os = "netbsd",
target_os = "illumos",
target_os = "solaris",
From 65532e71131869fac507e5791b7e49cb5d4cfe93 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Thu, 3 Oct 2024 22:44:14 +0100
Subject: [PATCH 02/12] update libc version
---
library/std/Cargo.toml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 63c65b8ef399..aed3ca80d26f 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -39,7 +39,7 @@ miniz_oxide = { version = "0.7.0", optional = true, default-features = false }
addr2line = { version = "0.22.0", optional = true, default-features = false }
[target.'cfg(not(all(windows, target_env = "msvc")))'.dependencies]
-libc = { version = "0.2.156", default-features = false, features = [
+libc = { version = "0.2.159", default-features = false, features = [
'rustc-dep-of-std',
], public = true }
From 0b00a54976cfa70b47dbb897db6066cb9557813c Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Fri, 4 Oct 2024 18:22:54 -0700
Subject: [PATCH 03/12] library: Stabilize const `MaybeUninit::assume_init_mut`
Co-authored-by: Ralf Jung <post@ralfj.de>
---
library/core/src/lib.rs | 1 -
library/core/src/mem/maybe_uninit.rs | 9 +++++++--
2 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 65721800ea88..4b161ce132aa 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -131,7 +131,6 @@
#![feature(const_ipv6)]
#![feature(const_likely)]
#![feature(const_make_ascii)]
-#![feature(const_maybe_uninit_assume_init)]
#![feature(const_nonnull_new)]
#![feature(const_num_midpoint)]
#![feature(const_option)]
diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index c67796ad3db8..f992785c43bb 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -913,7 +913,11 @@ impl<T> MaybeUninit<T> {
/// };
/// ```
#[stable(feature = "maybe_uninit_ref", since = "1.55.0")]
- #[rustc_const_unstable(feature = "const_maybe_uninit_assume_init", issue = "none")]
+ #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))]
+ #[rustc_const_stable(
+ feature = "const_maybe_uninit_assume_init",
+ since = "CURRENT_RUSTC_VERSION"
+ )]
#[inline(always)]
pub const unsafe fn assume_init_mut(&mut self) -> &mut T {
// SAFETY: the caller must guarantee that `self` is initialized.
@@ -999,7 +1003,8 @@ impl<T> MaybeUninit<T> {
///
/// [`assume_init_mut`]: MaybeUninit::assume_init_mut
#[unstable(feature = "maybe_uninit_slice", issue = "63569")]
- #[rustc_const_unstable(feature = "const_maybe_uninit_assume_init", issue = "none")]
+ #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))]
+ #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
#[inline(always)]
pub const unsafe fn slice_assume_init_mut(slice: &mut [Self]) -> &mut [T] {
// SAFETY: similar to safety notes for `slice_get_ref`, but we have a
From 2c38ecfc9077000db7de14bf501fa5294eeecedd Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Thu, 10 Oct 2024 23:53:29 -0700
Subject: [PATCH 04/12] emscripten: Use the latest emsdk 3.1.68
This should fix our precompiled std being unsound in `std::fs` code.
---
src/ci/docker/scripts/emscripten.sh | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/ci/docker/scripts/emscripten.sh b/src/ci/docker/scripts/emscripten.sh
index 3f5e2c6ff1dc..8b2b39ee1629 100644
--- a/src/ci/docker/scripts/emscripten.sh
+++ b/src/ci/docker/scripts/emscripten.sh
@@ -20,5 +20,5 @@ exit 1
git clone https://github.com/emscripten-core/emsdk.git /emsdk-portable
cd /emsdk-portable
-hide_output ./emsdk install 2.0.5
-./emsdk activate 2.0.5
+hide_output ./emsdk install 3.1.68
+./emsdk activate 3.1.68
From 559de745626901cf1fba5aaa5a2b96fbc92e09ff Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Tue, 8 Oct 2024 19:07:43 -0700
Subject: [PATCH 05/12] compiler: Move impl of ToJson for abi::Endian
---
compiler/rustc_target/src/abi/mod.rs | 8 --------
compiler/rustc_target/src/json.rs | 6 ++++++
2 files changed, 6 insertions(+), 8 deletions(-)
diff --git a/compiler/rustc_target/src/abi/mod.rs b/compiler/rustc_target/src/abi/mod.rs
index b744d5ad4eda..9f26c98df860 100644
--- a/compiler/rustc_target/src/abi/mod.rs
+++ b/compiler/rustc_target/src/abi/mod.rs
@@ -6,19 +6,11 @@ use Primitive::*;
use rustc_data_structures::intern::Interned;
use rustc_macros::HashStable_Generic;
-use crate::json::{Json, ToJson};
-
pub mod call;
// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
pub use rustc_abi::{Float, *};
-impl ToJson for Endian {
- fn to_json(&self) -> Json {
- self.as_str().to_json()
- }
-}
-
rustc_index::newtype_index! {
/// The *source-order* index of a field in a variant.
///
diff --git a/compiler/rustc_target/src/json.rs b/compiler/rustc_target/src/json.rs
index 2c367defe7ba..b09d8d724efd 100644
--- a/compiler/rustc_target/src/json.rs
+++ b/compiler/rustc_target/src/json.rs
@@ -134,3 +134,9 @@ impl ToJson for TargetMetadata {
})
}
}
+
+impl ToJson for rustc_abi::Endian {
+ fn to_json(&self) -> Json {
+ self.as_str().to_json()
+ }
+}
From 255bdd2f24de119d85073e0c48acdebca25af551 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 9 Oct 2024 11:07:22 -0700
Subject: [PATCH 06/12] compiler: Empty out rustc_target::abi
---
.../{rustc_target/src/abi/mod.rs => rustc_abi/src/layout/ty.rs} | 0
compiler/rustc_target/src/{abi/call => callconv}/aarch64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/amdgpu.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/arm.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/avr.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/bpf.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/csky.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/hexagon.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/loongarch.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/m68k.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/mips.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/mips64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/mod.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/msp430.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/nvptx64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/powerpc.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/powerpc64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/riscv.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/s390x.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/sparc.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/sparc64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/wasm.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/x86.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/x86_64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/x86_win64.rs | 0
compiler/rustc_target/src/{abi/call => callconv}/xtensa.rs | 0
26 files changed, 0 insertions(+), 0 deletions(-)
rename compiler/{rustc_target/src/abi/mod.rs => rustc_abi/src/layout/ty.rs} (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/aarch64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/amdgpu.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/arm.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/avr.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/bpf.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/csky.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/hexagon.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/loongarch.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/m68k.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/mips.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/mips64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/mod.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/msp430.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/nvptx64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/powerpc.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/powerpc64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/riscv.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/s390x.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/sparc.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/sparc64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/wasm.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/x86.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/x86_64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/x86_win64.rs (100%)
rename compiler/rustc_target/src/{abi/call => callconv}/xtensa.rs (100%)
diff --git a/compiler/rustc_target/src/abi/mod.rs b/compiler/rustc_abi/src/layout/ty.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/mod.rs
rename to compiler/rustc_abi/src/layout/ty.rs
diff --git a/compiler/rustc_target/src/abi/call/aarch64.rs b/compiler/rustc_target/src/callconv/aarch64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/aarch64.rs
rename to compiler/rustc_target/src/callconv/aarch64.rs
diff --git a/compiler/rustc_target/src/abi/call/amdgpu.rs b/compiler/rustc_target/src/callconv/amdgpu.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/amdgpu.rs
rename to compiler/rustc_target/src/callconv/amdgpu.rs
diff --git a/compiler/rustc_target/src/abi/call/arm.rs b/compiler/rustc_target/src/callconv/arm.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/arm.rs
rename to compiler/rustc_target/src/callconv/arm.rs
diff --git a/compiler/rustc_target/src/abi/call/avr.rs b/compiler/rustc_target/src/callconv/avr.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/avr.rs
rename to compiler/rustc_target/src/callconv/avr.rs
diff --git a/compiler/rustc_target/src/abi/call/bpf.rs b/compiler/rustc_target/src/callconv/bpf.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/bpf.rs
rename to compiler/rustc_target/src/callconv/bpf.rs
diff --git a/compiler/rustc_target/src/abi/call/csky.rs b/compiler/rustc_target/src/callconv/csky.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/csky.rs
rename to compiler/rustc_target/src/callconv/csky.rs
diff --git a/compiler/rustc_target/src/abi/call/hexagon.rs b/compiler/rustc_target/src/callconv/hexagon.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/hexagon.rs
rename to compiler/rustc_target/src/callconv/hexagon.rs
diff --git a/compiler/rustc_target/src/abi/call/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/loongarch.rs
rename to compiler/rustc_target/src/callconv/loongarch.rs
diff --git a/compiler/rustc_target/src/abi/call/m68k.rs b/compiler/rustc_target/src/callconv/m68k.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/m68k.rs
rename to compiler/rustc_target/src/callconv/m68k.rs
diff --git a/compiler/rustc_target/src/abi/call/mips.rs b/compiler/rustc_target/src/callconv/mips.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/mips.rs
rename to compiler/rustc_target/src/callconv/mips.rs
diff --git a/compiler/rustc_target/src/abi/call/mips64.rs b/compiler/rustc_target/src/callconv/mips64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/mips64.rs
rename to compiler/rustc_target/src/callconv/mips64.rs
diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/mod.rs
rename to compiler/rustc_target/src/callconv/mod.rs
diff --git a/compiler/rustc_target/src/abi/call/msp430.rs b/compiler/rustc_target/src/callconv/msp430.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/msp430.rs
rename to compiler/rustc_target/src/callconv/msp430.rs
diff --git a/compiler/rustc_target/src/abi/call/nvptx64.rs b/compiler/rustc_target/src/callconv/nvptx64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/nvptx64.rs
rename to compiler/rustc_target/src/callconv/nvptx64.rs
diff --git a/compiler/rustc_target/src/abi/call/powerpc.rs b/compiler/rustc_target/src/callconv/powerpc.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/powerpc.rs
rename to compiler/rustc_target/src/callconv/powerpc.rs
diff --git a/compiler/rustc_target/src/abi/call/powerpc64.rs b/compiler/rustc_target/src/callconv/powerpc64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/powerpc64.rs
rename to compiler/rustc_target/src/callconv/powerpc64.rs
diff --git a/compiler/rustc_target/src/abi/call/riscv.rs b/compiler/rustc_target/src/callconv/riscv.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/riscv.rs
rename to compiler/rustc_target/src/callconv/riscv.rs
diff --git a/compiler/rustc_target/src/abi/call/s390x.rs b/compiler/rustc_target/src/callconv/s390x.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/s390x.rs
rename to compiler/rustc_target/src/callconv/s390x.rs
diff --git a/compiler/rustc_target/src/abi/call/sparc.rs b/compiler/rustc_target/src/callconv/sparc.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/sparc.rs
rename to compiler/rustc_target/src/callconv/sparc.rs
diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/callconv/sparc64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/sparc64.rs
rename to compiler/rustc_target/src/callconv/sparc64.rs
diff --git a/compiler/rustc_target/src/abi/call/wasm.rs b/compiler/rustc_target/src/callconv/wasm.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/wasm.rs
rename to compiler/rustc_target/src/callconv/wasm.rs
diff --git a/compiler/rustc_target/src/abi/call/x86.rs b/compiler/rustc_target/src/callconv/x86.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/x86.rs
rename to compiler/rustc_target/src/callconv/x86.rs
diff --git a/compiler/rustc_target/src/abi/call/x86_64.rs b/compiler/rustc_target/src/callconv/x86_64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/x86_64.rs
rename to compiler/rustc_target/src/callconv/x86_64.rs
diff --git a/compiler/rustc_target/src/abi/call/x86_win64.rs b/compiler/rustc_target/src/callconv/x86_win64.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/x86_win64.rs
rename to compiler/rustc_target/src/callconv/x86_win64.rs
diff --git a/compiler/rustc_target/src/abi/call/xtensa.rs b/compiler/rustc_target/src/callconv/xtensa.rs
similarity index 100%
rename from compiler/rustc_target/src/abi/call/xtensa.rs
rename to compiler/rustc_target/src/callconv/xtensa.rs
From 10721909f29024ba56a9ce667da8652a99a04784 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 9 Oct 2024 12:20:28 -0700
Subject: [PATCH 07/12] compiler: Wire `{TyAnd,}Layout` into `rustc_abi`
This finally unites TyAndLayout, Layout, and LayoutS into the same crate,
as one might imagine they would be placed. No functional changes.
---
compiler/rustc_abi/src/callconv.rs | 254 ++++++++++++++++++++++
compiler/rustc_abi/src/layout.rs | 4 +
compiler/rustc_abi/src/layout/ty.rs | 4 +-
compiler/rustc_abi/src/lib.rs | 8 +-
compiler/rustc_middle/src/ty/context.rs | 2 +-
compiler/rustc_target/src/callconv/mod.rs | 249 +--------------------
compiler/rustc_target/src/lib.rs | 11 +-
7 files changed, 279 insertions(+), 253 deletions(-)
create mode 100644 compiler/rustc_abi/src/callconv.rs
diff --git a/compiler/rustc_abi/src/callconv.rs b/compiler/rustc_abi/src/callconv.rs
new file mode 100644
index 000000000000..2ecac8a9df1c
--- /dev/null
+++ b/compiler/rustc_abi/src/callconv.rs
@@ -0,0 +1,254 @@
+mod abi {
+ pub(crate) use crate::Primitive::*;
+ pub(crate) use crate::Variants;
+}
+
+use rustc_macros::HashStable_Generic;
+
+use crate::{Abi, Align, FieldsShape, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
+pub enum RegKind {
+ Integer,
+ Float,
+ Vector,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
+pub struct Reg {
+ pub kind: RegKind,
+ pub size: Size,
+}
+
+macro_rules! reg_ctor {
+ ($name:ident, $kind:ident, $bits:expr) => {
+ pub fn $name() -> Reg {
+ Reg { kind: RegKind::$kind, size: Size::from_bits($bits) }
+ }
+ };
+}
+
+impl Reg {
+ reg_ctor!(i8, Integer, 8);
+ reg_ctor!(i16, Integer, 16);
+ reg_ctor!(i32, Integer, 32);
+ reg_ctor!(i64, Integer, 64);
+ reg_ctor!(i128, Integer, 128);
+
+ reg_ctor!(f32, Float, 32);
+ reg_ctor!(f64, Float, 64);
+}
+
+impl Reg {
+ pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
+ let dl = cx.data_layout();
+ match self.kind {
+ RegKind::Integer => match self.size.bits() {
+ 1 => dl.i1_align.abi,
+ 2..=8 => dl.i8_align.abi,
+ 9..=16 => dl.i16_align.abi,
+ 17..=32 => dl.i32_align.abi,
+ 33..=64 => dl.i64_align.abi,
+ 65..=128 => dl.i128_align.abi,
+ _ => panic!("unsupported integer: {self:?}"),
+ },
+ RegKind::Float => match self.size.bits() {
+ 16 => dl.f16_align.abi,
+ 32 => dl.f32_align.abi,
+ 64 => dl.f64_align.abi,
+ 128 => dl.f128_align.abi,
+ _ => panic!("unsupported float: {self:?}"),
+ },
+ RegKind::Vector => dl.vector_align(self.size).abi,
+ }
+ }
+}
+
+/// Return value from the `homogeneous_aggregate` test function.
+#[derive(Copy, Clone, Debug)]
+pub enum HomogeneousAggregate {
+ /// Yes, all the "leaf fields" of this struct are passed in the
+ /// same way (specified in the `Reg` value).
+ Homogeneous(Reg),
+
+ /// There are no leaf fields at all.
+ NoData,
+}
+
+/// Error from the `homogeneous_aggregate` test function, indicating
+/// there are distinct leaf fields passed in different ways,
+/// or this is uninhabited.
+#[derive(Copy, Clone, Debug)]
+pub struct Heterogeneous;
+
+impl HomogeneousAggregate {
+ /// If this is a homogeneous aggregate, returns the homogeneous
+ /// unit, else `None`.
+ pub fn unit(self) -> Option<Reg> {
+ match self {
+ HomogeneousAggregate::Homogeneous(reg) => Some(reg),
+ HomogeneousAggregate::NoData => None,
+ }
+ }
+
+ /// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
+ /// the same `struct`. Only succeeds if only one of them has any data,
+ /// or both units are identical.
+ fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
+ match (self, other) {
+ (x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
+
+ (HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
+ if a != b {
+ return Err(Heterogeneous);
+ }
+ Ok(self)
+ }
+ }
+ }
+}
+
+impl<'a, Ty> TyAndLayout<'a, Ty> {
+ /// Returns `true` if this is an aggregate type (including a ScalarPair!)
+ pub fn is_aggregate(&self) -> bool {
+ match self.abi {
+ Abi::Uninhabited | Abi::Scalar(_) | Abi::Vector { .. } => false,
+ Abi::ScalarPair(..) | Abi::Aggregate { .. } => true,
+ }
+ }
+
+ /// Returns `Homogeneous` if this layout is an aggregate containing fields of
+ /// only a single type (e.g., `(u32, u32)`). Such aggregates are often
+ /// special-cased in ABIs.
+ ///
+ /// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
+ ///
+ /// This is public so that it can be used in unit tests, but
+ /// should generally only be relevant to the ABI details of
+ /// specific targets.
+ pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
+ where
+ Ty: TyAbiInterface<'a, C> + Copy,
+ {
+ match self.abi {
+ Abi::Uninhabited => Err(Heterogeneous),
+
+ // The primitive for this algorithm.
+ Abi::Scalar(scalar) => {
+ let kind = match scalar.primitive() {
+ abi::Int(..) | abi::Pointer(_) => RegKind::Integer,
+ abi::Float(_) => RegKind::Float,
+ };
+ Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
+ }
+
+ Abi::Vector { .. } => {
+ assert!(!self.is_zst());
+ Ok(HomogeneousAggregate::Homogeneous(Reg {
+ kind: RegKind::Vector,
+ size: self.size,
+ }))
+ }
+
+ Abi::ScalarPair(..) | Abi::Aggregate { sized: true } => {
+ // Helper for computing `homogeneous_aggregate`, allowing a custom
+ // starting offset (used below for handling variants).
+ let from_fields_at =
+ |layout: Self,
+ start: Size|
+ -> Result<(HomogeneousAggregate, Size), Heterogeneous> {
+ let is_union = match layout.fields {
+ FieldsShape::Primitive => {
+ unreachable!("aggregates can't have `FieldsShape::Primitive`")
+ }
+ FieldsShape::Array { count, .. } => {
+ assert_eq!(start, Size::ZERO);
+
+ let result = if count > 0 {
+ layout.field(cx, 0).homogeneous_aggregate(cx)?
+ } else {
+ HomogeneousAggregate::NoData
+ };
+ return Ok((result, layout.size));
+ }
+ FieldsShape::Union(_) => true,
+ FieldsShape::Arbitrary { .. } => false,
+ };
+
+ let mut result = HomogeneousAggregate::NoData;
+ let mut total = start;
+
+ for i in 0..layout.fields.count() {
+ let field = layout.field(cx, i);
+ if field.is_1zst() {
+ // No data here and no impact on layout, can be ignored.
+ // (We might be able to also ignore all aligned ZST but that's less clear.)
+ continue;
+ }
+
+ if !is_union && total != layout.fields.offset(i) {
+ // This field isn't just after the previous one we considered, abort.
+ return Err(Heterogeneous);
+ }
+
+ result = result.merge(field.homogeneous_aggregate(cx)?)?;
+
+ // Keep track of the offset (without padding).
+ let size = field.size;
+ if is_union {
+ total = total.max(size);
+ } else {
+ total += size;
+ }
+ }
+
+ Ok((result, total))
+ };
+
+ let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
+
+ match &self.variants {
+ abi::Variants::Single { .. } => {}
+ abi::Variants::Multiple { variants, .. } => {
+ // Treat enum variants like union members.
+ // HACK(eddyb) pretend the `enum` field (discriminant)
+ // is at the start of every variant (otherwise the gap
+ // at the start of all variants would disqualify them).
+ //
+ // NB: for all tagged `enum`s (which include all non-C-like
+ // `enum`s with defined FFI representation), this will
+ // match the homogeneous computation on the equivalent
+ // `struct { tag; union { variant1; ... } }` and/or
+ // `union { struct { tag; variant1; } ... }`
+ // (the offsets of variant fields should be identical
+ // between the two for either to be a homogeneous aggregate).
+ let variant_start = total;
+ for variant_idx in variants.indices() {
+ let (variant_result, variant_total) =
+ from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
+
+ result = result.merge(variant_result)?;
+ total = total.max(variant_total);
+ }
+ }
+ }
+
+ // There needs to be no padding.
+ if total != self.size {
+ Err(Heterogeneous)
+ } else {
+ match result {
+ HomogeneousAggregate::Homogeneous(_) => {
+ assert_ne!(total, Size::ZERO);
+ }
+ HomogeneousAggregate::NoData => {
+ assert_eq!(total, Size::ZERO);
+ }
+ }
+ Ok(result)
+ }
+ }
+ Abi::Aggregate { sized: false } => Err(Heterogeneous),
+ }
+ }
+}
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 620a051eeb7d..6e1299944a09 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -11,6 +11,10 @@ use crate::{
Variants, WrappingRange,
};
+mod ty;
+
+pub use ty::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
+
// A variant is absent if it's uninhabited and only has ZST fields.
// Present uninhabited variants only require space for their fields,
// but *not* an encoding of the discriminant (e.g., a tag value).
diff --git a/compiler/rustc_abi/src/layout/ty.rs b/compiler/rustc_abi/src/layout/ty.rs
index 9f26c98df860..c6812c4d4c07 100644
--- a/compiler/rustc_abi/src/layout/ty.rs
+++ b/compiler/rustc_abi/src/layout/ty.rs
@@ -6,10 +6,8 @@ use Primitive::*;
use rustc_data_structures::intern::Interned;
use rustc_macros::HashStable_Generic;
-pub mod call;
-
// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
-pub use rustc_abi::{Float, *};
+use crate::{Float, *};
rustc_index::newtype_index! {
/// The *source-order* index of a field in a variant.
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index fa7c98a7fa0c..84d756b6d517 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1,6 +1,7 @@
// tidy-alphabetical-start
#![cfg_attr(feature = "nightly", allow(internal_features))]
#![cfg_attr(feature = "nightly", doc(rust_logo))]
+#![cfg_attr(feature = "nightly", feature(rustc_attrs))]
#![cfg_attr(feature = "nightly", feature(rustdoc_internals))]
#![cfg_attr(feature = "nightly", feature(step_trait))]
#![warn(unreachable_pub)]
@@ -22,11 +23,16 @@ use rustc_macros::HashStable_Generic;
#[cfg(feature = "nightly")]
use rustc_macros::{Decodable_Generic, Encodable_Generic};
+mod callconv;
mod layout;
#[cfg(test)]
mod tests;
-pub use layout::{LayoutCalculator, LayoutCalculatorError};
+pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
+pub use layout::{
+ FIRST_VARIANT, FieldIdx, Layout, LayoutCalculator, LayoutCalculatorError, TyAbiInterface,
+ TyAndLayout, VariantIdx,
+};
/// Requirements for a `StableHashingContext` to be used in this crate.
/// This is a hack to allow using the `HashStable_Generic` derive macro
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 50e7be82a79a..1bdcae4dfb47 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -12,6 +12,7 @@ use std::marker::PhantomData;
use std::ops::{Bound, Deref};
use std::{fmt, iter, mem};
+use rustc_abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx};
use rustc_ast::{self as ast, attr};
use rustc_data_structures::defer;
use rustc_data_structures::fingerprint::Fingerprint;
@@ -48,7 +49,6 @@ use rustc_session::{Limit, MetadataKind, Session};
use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId};
use rustc_span::symbol::{Ident, Symbol, kw, sym};
use rustc_span::{DUMMY_SP, Span};
-use rustc_target::abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx};
use rustc_target::spec::abi;
use rustc_type_ir::TyKind::*;
use rustc_type_ir::fold::TypeFoldable;
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 352861c5ccb4..832246495bc9 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -1,10 +1,11 @@
use std::fmt;
use std::str::FromStr;
+pub use rustc_abi::{Reg, RegKind};
use rustc_macros::HashStable_Generic;
use rustc_span::Symbol;
-use crate::abi::{self, Abi, Align, FieldsShape, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
+use crate::abi::{self, Abi, Align, HasDataLayout, Size, TyAbiInterface, TyAndLayout};
use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt, WasmCAbi};
mod aarch64;
@@ -192,63 +193,6 @@ impl ArgAttributes {
}
}
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
-pub enum RegKind {
- Integer,
- Float,
- Vector,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
-pub struct Reg {
- pub kind: RegKind,
- pub size: Size,
-}
-
-macro_rules! reg_ctor {
- ($name:ident, $kind:ident, $bits:expr) => {
- pub fn $name() -> Reg {
- Reg { kind: RegKind::$kind, size: Size::from_bits($bits) }
- }
- };
-}
-
-impl Reg {
- reg_ctor!(i8, Integer, 8);
- reg_ctor!(i16, Integer, 16);
- reg_ctor!(i32, Integer, 32);
- reg_ctor!(i64, Integer, 64);
- reg_ctor!(i128, Integer, 128);
-
- reg_ctor!(f32, Float, 32);
- reg_ctor!(f64, Float, 64);
-}
-
-impl Reg {
- pub fn align<C: HasDataLayout>(&self, cx: &C) -> Align {
- let dl = cx.data_layout();
- match self.kind {
- RegKind::Integer => match self.size.bits() {
- 1 => dl.i1_align.abi,
- 2..=8 => dl.i8_align.abi,
- 9..=16 => dl.i16_align.abi,
- 17..=32 => dl.i32_align.abi,
- 33..=64 => dl.i64_align.abi,
- 65..=128 => dl.i128_align.abi,
- _ => panic!("unsupported integer: {self:?}"),
- },
- RegKind::Float => match self.size.bits() {
- 16 => dl.f16_align.abi,
- 32 => dl.f32_align.abi,
- 64 => dl.f64_align.abi,
- 128 => dl.f128_align.abi,
- _ => panic!("unsupported float: {self:?}"),
- },
- RegKind::Vector => dl.vector_align(self.size).abi,
- }
- }
-}
-
/// An argument passed entirely registers with the
/// same kind (e.g., HFA / HVA on PPC64 and AArch64).
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
@@ -380,195 +324,6 @@ impl CastTarget {
}
}
-/// Return value from the `homogeneous_aggregate` test function.
-#[derive(Copy, Clone, Debug)]
-pub enum HomogeneousAggregate {
- /// Yes, all the "leaf fields" of this struct are passed in the
- /// same way (specified in the `Reg` value).
- Homogeneous(Reg),
-
- /// There are no leaf fields at all.
- NoData,
-}
-
-/// Error from the `homogeneous_aggregate` test function, indicating
-/// there are distinct leaf fields passed in different ways,
-/// or this is uninhabited.
-#[derive(Copy, Clone, Debug)]
-pub struct Heterogeneous;
-
-impl HomogeneousAggregate {
- /// If this is a homogeneous aggregate, returns the homogeneous
- /// unit, else `None`.
- pub fn unit(self) -> Option<Reg> {
- match self {
- HomogeneousAggregate::Homogeneous(reg) => Some(reg),
- HomogeneousAggregate::NoData => None,
- }
- }
-
- /// Try to combine two `HomogeneousAggregate`s, e.g. from two fields in
- /// the same `struct`. Only succeeds if only one of them has any data,
- /// or both units are identical.
- fn merge(self, other: HomogeneousAggregate) -> Result<HomogeneousAggregate, Heterogeneous> {
- match (self, other) {
- (x, HomogeneousAggregate::NoData) | (HomogeneousAggregate::NoData, x) => Ok(x),
-
- (HomogeneousAggregate::Homogeneous(a), HomogeneousAggregate::Homogeneous(b)) => {
- if a != b {
- return Err(Heterogeneous);
- }
- Ok(self)
- }
- }
- }
-}
-
-impl<'a, Ty> TyAndLayout<'a, Ty> {
- /// Returns `true` if this is an aggregate type (including a ScalarPair!)
- fn is_aggregate(&self) -> bool {
- match self.abi {
- Abi::Uninhabited | Abi::Scalar(_) | Abi::Vector { .. } => false,
- Abi::ScalarPair(..) | Abi::Aggregate { .. } => true,
- }
- }
-
- /// Returns `Homogeneous` if this layout is an aggregate containing fields of
- /// only a single type (e.g., `(u32, u32)`). Such aggregates are often
- /// special-cased in ABIs.
- ///
- /// Note: We generally ignore 1-ZST fields when computing this value (see #56877).
- ///
- /// This is public so that it can be used in unit tests, but
- /// should generally only be relevant to the ABI details of
- /// specific targets.
- pub fn homogeneous_aggregate<C>(&self, cx: &C) -> Result<HomogeneousAggregate, Heterogeneous>
- where
- Ty: TyAbiInterface<'a, C> + Copy,
- {
- match self.abi {
- Abi::Uninhabited => Err(Heterogeneous),
-
- // The primitive for this algorithm.
- Abi::Scalar(scalar) => {
- let kind = match scalar.primitive() {
- abi::Int(..) | abi::Pointer(_) => RegKind::Integer,
- abi::Float(_) => RegKind::Float,
- };
- Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
- }
-
- Abi::Vector { .. } => {
- assert!(!self.is_zst());
- Ok(HomogeneousAggregate::Homogeneous(Reg {
- kind: RegKind::Vector,
- size: self.size,
- }))
- }
-
- Abi::ScalarPair(..) | Abi::Aggregate { sized: true } => {
- // Helper for computing `homogeneous_aggregate`, allowing a custom
- // starting offset (used below for handling variants).
- let from_fields_at =
- |layout: Self,
- start: Size|
- -> Result<(HomogeneousAggregate, Size), Heterogeneous> {
- let is_union = match layout.fields {
- FieldsShape::Primitive => {
- unreachable!("aggregates can't have `FieldsShape::Primitive`")
- }
- FieldsShape::Array { count, .. } => {
- assert_eq!(start, Size::ZERO);
-
- let result = if count > 0 {
- layout.field(cx, 0).homogeneous_aggregate(cx)?
- } else {
- HomogeneousAggregate::NoData
- };
- return Ok((result, layout.size));
- }
- FieldsShape::Union(_) => true,
- FieldsShape::Arbitrary { .. } => false,
- };
-
- let mut result = HomogeneousAggregate::NoData;
- let mut total = start;
-
- for i in 0..layout.fields.count() {
- let field = layout.field(cx, i);
- if field.is_1zst() {
- // No data here and no impact on layout, can be ignored.
- // (We might be able to also ignore all aligned ZST but that's less clear.)
- continue;
- }
-
- if !is_union && total != layout.fields.offset(i) {
- // This field isn't just after the previous one we considered, abort.
- return Err(Heterogeneous);
- }
-
- result = result.merge(field.homogeneous_aggregate(cx)?)?;
-
- // Keep track of the offset (without padding).
- let size = field.size;
- if is_union {
- total = total.max(size);
- } else {
- total += size;
- }
- }
-
- Ok((result, total))
- };
-
- let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
-
- match &self.variants {
- abi::Variants::Single { .. } => {}
- abi::Variants::Multiple { variants, .. } => {
- // Treat enum variants like union members.
- // HACK(eddyb) pretend the `enum` field (discriminant)
- // is at the start of every variant (otherwise the gap
- // at the start of all variants would disqualify them).
- //
- // NB: for all tagged `enum`s (which include all non-C-like
- // `enum`s with defined FFI representation), this will
- // match the homogeneous computation on the equivalent
- // `struct { tag; union { variant1; ... } }` and/or
- // `union { struct { tag; variant1; } ... }`
- // (the offsets of variant fields should be identical
- // between the two for either to be a homogeneous aggregate).
- let variant_start = total;
- for variant_idx in variants.indices() {
- let (variant_result, variant_total) =
- from_fields_at(self.for_variant(cx, variant_idx), variant_start)?;
-
- result = result.merge(variant_result)?;
- total = total.max(variant_total);
- }
- }
- }
-
- // There needs to be no padding.
- if total != self.size {
- Err(Heterogeneous)
- } else {
- match result {
- HomogeneousAggregate::Homogeneous(_) => {
- assert_ne!(total, Size::ZERO);
- }
- HomogeneousAggregate::NoData => {
- assert_eq!(total, Size::ZERO);
- }
- }
- Ok(result)
- }
- }
- Abi::Aggregate { sized: false } => Err(Heterogeneous),
- }
- }
-}
-
/// Information about how to pass an argument to,
/// or return a value from, a function, under some ABI.
#[derive(Clone, PartialEq, Eq, Hash, HashStable_Generic)]
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index 2121c4110dde..50679ab8cc81 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -21,8 +21,8 @@
use std::path::{Path, PathBuf};
-pub mod abi;
pub mod asm;
+pub mod callconv;
pub mod json;
pub mod spec;
pub mod target_features;
@@ -30,6 +30,15 @@ pub mod target_features;
#[cfg(test)]
mod tests;
+pub mod abi {
+ pub(crate) use Float::*;
+ pub(crate) use Primitive::*;
+ // Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
+ pub use rustc_abi::{Float, *};
+
+ pub use crate::callconv as call;
+}
+
pub use rustc_abi::HashStableContext;
/// The name of rustc's own place to organize libraries.
From bc4366b099e7a4d115650dcfec4aeeb62bfc3c54 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Oct 2024 12:14:28 +0200
Subject: [PATCH 08/12] miri: avoid cloning AllocExtra
---
.../src/const_eval/machine.rs | 2 +-
.../rustc_const_eval/src/interpret/memory.rs | 31 +++++++++++--------
src/tools/miri/src/diagnostics.rs | 4 +--
src/tools/miri/src/eval.rs | 2 +-
src/tools/miri/src/machine.rs | 10 +++++-
5 files changed, 31 insertions(+), 18 deletions(-)
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 4aec74595bc8..2db43a0f787e 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -140,7 +140,7 @@ impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxIndexMap<K, V> {
#[inline(always)]
fn filter_map_collect<T>(&self, mut f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T> {
- self.iter().filter_map(move |(k, v)| f(k, &*v)).collect()
+ self.iter().filter_map(move |(k, v)| f(k, v)).collect()
}
#[inline(always)]
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index e6ab8ca12a88..7700eb792eff 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -993,11 +993,14 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
bytes
}
- /// Find leaked allocations. Allocations reachable from `static_roots` or a `Global` allocation
- /// are not considered leaked, as well as leaks whose kind's `may_leak()` returns true.
- pub fn find_leaked_allocations(
- &self,
- static_roots: &[AllocId],
+ /// Find leaked allocations, remove them from memory and return them. Allocations reachable from
+ /// `static_roots` or a `Global` allocation are not considered leaked, as well as leaks whose
+ /// kind's `may_leak()` returns true.
+ ///
+ /// This is highly destructive, no more execution can happen after this!
+ pub fn take_leaked_allocations(
+ &mut self,
+ static_roots: impl FnOnce(&Self) -> &[AllocId],
) -> Vec<(AllocId, MemoryKind<M::MemoryKind>, Allocation<M::Provenance, M::AllocExtra, M::Bytes>)>
{
// Collect the set of allocations that are *reachable* from `Global` allocations.
@@ -1008,7 +1011,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
self.memory.alloc_map.filter_map_collect(move |&id, &(kind, _)| {
if Some(kind) == global_kind { Some(id) } else { None }
});
- todo.extend(static_roots);
+ todo.extend(static_roots(self));
while let Some(id) = todo.pop() {
if reachable.insert(id) {
// This is a new allocation, add the allocation it points to `todo`.
@@ -1023,13 +1026,15 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
};
// All allocations that are *not* `reachable` and *not* `may_leak` are considered leaking.
- self.memory.alloc_map.filter_map_collect(|id, (kind, alloc)| {
- if kind.may_leak() || reachable.contains(id) {
- None
- } else {
- Some((*id, *kind, alloc.clone()))
- }
- })
+ let leaked: Vec<_> = self.memory.alloc_map.filter_map_collect(|&id, &(kind, _)| {
+ if kind.may_leak() || reachable.contains(&id) { None } else { Some(id) }
+ });
+ let mut result = Vec::new();
+ for &id in leaked.iter() {
+ let (kind, alloc) = self.memory.alloc_map.remove(&id).unwrap();
+ result.push((id, kind, alloc));
+ }
+ result
}
/// Runs the closure in "validation" mode, which means the machine's memory read hooks will be
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 5b1bad28c07c..475139a3b519 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -473,14 +473,14 @@ pub fn report_leaks<'tcx>(
leaks: Vec<(AllocId, MemoryKind, Allocation<Provenance, AllocExtra<'tcx>, MiriAllocBytes>)>,
) {
let mut any_pruned = false;
- for (id, kind, mut alloc) in leaks {
+ for (id, kind, alloc) in leaks {
let mut title = format!(
"memory leaked: {id:?} ({}, size: {:?}, align: {:?})",
kind,
alloc.size().bytes(),
alloc.align.bytes()
);
- let Some(backtrace) = alloc.extra.backtrace.take() else {
+ let Some(backtrace) = alloc.extra.backtrace else {
ecx.tcx.dcx().err(title);
continue;
};
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index ece76e581f24..57b226de28cb 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -476,7 +476,7 @@ pub fn eval_entry<'tcx>(
}
// Check for memory leaks.
info!("Additional static roots: {:?}", ecx.machine.static_roots);
- let leaks = ecx.find_leaked_allocations(&ecx.machine.static_roots);
+ let leaks = ecx.take_leaked_allocations(|ecx| &ecx.machine.static_roots);
if !leaks.is_empty() {
report_leaks(&ecx, leaks);
tcx.dcx().note("set `MIRIFLAGS=-Zmiri-ignore-leaks` to disable this check");
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index b9cebcfe9cd8..d346cd7b03ec 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -321,7 +321,7 @@ impl ProvenanceExtra {
}
/// Extra per-allocation data
-#[derive(Debug, Clone)]
+#[derive(Debug)]
pub struct AllocExtra<'tcx> {
/// Global state of the borrow tracker, if enabled.
pub borrow_tracker: Option<borrow_tracker::AllocState>,
@@ -338,6 +338,14 @@ pub struct AllocExtra<'tcx> {
pub backtrace: Option<Vec<FrameInfo<'tcx>>>,
}
+// We need a `Clone` impl because the machine passes `Allocation` through `Cow`...
+// but that should never end up actually cloning our `AllocExtra`.
+impl<'tcx> Clone for AllocExtra<'tcx> {
+ fn clone(&self) -> Self {
+ panic!("our allocations should never be cloned");
+ }
+}
+
impl VisitProvenance for AllocExtra<'_> {
fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
let AllocExtra { borrow_tracker, data_race, weak_memory, backtrace: _ } = self;
From 1ebfd9705165cf6902dae1eacc49cb4c0a0e142e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Oct 2024 19:08:34 +0200
Subject: [PATCH 09/12] merge const_ipv4 / const_ipv6 feature gate into 'ip'
feature gate
---
library/core/src/lib.rs | 2 --
library/core/src/net/ip_addr.rs | 14 --------------
library/core/tests/lib.rs | 3 ---
library/std/src/lib.rs | 3 ---
4 files changed, 22 deletions(-)
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 726aa209fdf4..6851664a89eb 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -124,8 +124,6 @@
#![feature(const_hash)]
#![feature(const_heap)]
#![feature(const_index_range_slice_index)]
-#![feature(const_ipv4)]
-#![feature(const_ipv6)]
#![feature(const_likely)]
#![feature(const_make_ascii)]
#![feature(const_maybe_uninit_assume_init)]
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 919f681f911f..fbf61cf614bd 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -295,7 +295,6 @@ impl IpAddr {
/// assert_eq!(IpAddr::V4(Ipv4Addr::new(80, 9, 12, 3)).is_global(), true);
/// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1)).is_global(), true);
/// ```
- #[rustc_const_unstable(feature = "const_ip", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -348,7 +347,6 @@ impl IpAddr {
/// true
/// );
/// ```
- #[rustc_const_unstable(feature = "const_ip", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -776,7 +774,6 @@ impl Ipv4Addr {
///
/// // For a complete overview see the IANA IPv4 Special-Purpose Address Registry.
/// ```
- #[rustc_const_unstable(feature = "const_ipv4", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -813,7 +810,6 @@ impl Ipv4Addr {
/// assert_eq!(Ipv4Addr::new(100, 127, 255, 255).is_shared(), true);
/// assert_eq!(Ipv4Addr::new(100, 128, 0, 0).is_shared(), false);
/// ```
- #[rustc_const_unstable(feature = "const_ipv4", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -841,7 +837,6 @@ impl Ipv4Addr {
/// assert_eq!(Ipv4Addr::new(198, 19, 255, 255).is_benchmarking(), true);
/// assert_eq!(Ipv4Addr::new(198, 20, 0, 0).is_benchmarking(), false);
/// ```
- #[rustc_const_unstable(feature = "const_ipv4", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -878,7 +873,6 @@ impl Ipv4Addr {
/// // The broadcast address is not considered as reserved for future use by this implementation
/// assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_reserved(), false);
/// ```
- #[rustc_const_unstable(feature = "const_ipv4", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1510,7 +1504,6 @@ impl Ipv6Addr {
///
/// // For a complete overview see the IANA IPv6 Special-Purpose Address Registry.
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1562,7 +1555,6 @@ impl Ipv6Addr {
/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false);
/// assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1591,7 +1583,6 @@ impl Ipv6Addr {
/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast(), true);
/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_unicast(), false);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1643,7 +1634,6 @@ impl Ipv6Addr {
/// assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0).is_unicast_link_local(), true);
/// assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1668,7 +1658,6 @@ impl Ipv6Addr {
/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false);
/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1729,7 +1718,6 @@ impl Ipv6Addr {
/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);
/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1758,7 +1746,6 @@ impl Ipv6Addr {
/// );
/// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
@@ -1818,7 +1805,6 @@ impl Ipv6Addr {
///
/// assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_ipv4_mapped(), false);
/// ```
- #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
#[unstable(feature = "ip", issue = "27709")]
#[must_use]
#[inline]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 9e15bb1dd8fc..7616c38cbc2b 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -19,9 +19,6 @@
#![feature(const_black_box)]
#![feature(const_hash)]
#![feature(const_heap)]
-#![feature(const_ip)]
-#![feature(const_ipv4)]
-#![feature(const_ipv6)]
#![feature(const_likely)]
#![feature(const_nonnull_new)]
#![feature(const_option_ext)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 65a9aa66c7cc..057a57f79977 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -414,9 +414,6 @@
// tidy-alphabetical-start
#![feature(const_collections_with_hasher)]
#![feature(const_hash)]
-#![feature(const_ip)]
-#![feature(const_ipv4)]
-#![feature(const_ipv6)]
#![feature(thread_local_internals)]
// tidy-alphabetical-end
//
From b5e91a00c89a065f618693873ad7074a13ad6b90 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Sun, 13 Oct 2024 18:13:30 +0200
Subject: [PATCH 10/12] Also use outermost const-anon for impl items in
`non_local_defs` lint
---
compiler/rustc_lint/src/non_local_def.rs | 10 +++++++---
.../convoluted-locals-131474-with-mods.rs | 11 +++++++++++
.../lint/non-local-defs/convoluted-locals-131474.rs | 9 +++++++++
3 files changed, 27 insertions(+), 3 deletions(-)
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
index 6fecddb33194..3c31b879bd6a 100644
--- a/compiler/rustc_lint/src/non_local_def.rs
+++ b/compiler/rustc_lint/src/non_local_def.rs
@@ -301,9 +301,13 @@ fn did_has_local_parent(
return false;
};
- peel_parent_while(tcx, parent_did, |tcx, did| tcx.def_kind(did) == DefKind::Mod)
- .map(|parent_did| parent_did == impl_parent || Some(parent_did) == outermost_impl_parent)
- .unwrap_or(false)
+ peel_parent_while(tcx, parent_did, |tcx, did| {
+ tcx.def_kind(did) == DefKind::Mod
+ || (tcx.def_kind(did) == DefKind::Const
+ && tcx.opt_item_name(did) == Some(kw::Underscore))
+ })
+ .map(|parent_did| parent_did == impl_parent || Some(parent_did) == outermost_impl_parent)
+ .unwrap_or(false)
}
/// Given a `DefId` checks if it satisfies `f` if it does check with it's parent and continue
diff --git a/tests/ui/lint/non-local-defs/convoluted-locals-131474-with-mods.rs b/tests/ui/lint/non-local-defs/convoluted-locals-131474-with-mods.rs
index cef0f0205e80..72fd056d461a 100644
--- a/tests/ui/lint/non-local-defs/convoluted-locals-131474-with-mods.rs
+++ b/tests/ui/lint/non-local-defs/convoluted-locals-131474-with-mods.rs
@@ -31,4 +31,15 @@ const _: () = {
};
};
+// https://github.com/rust-lang/rust/issues/131643
+const _: () = {
+ const _: () = {
+ impl tmp::InnerTest {}
+ };
+
+ mod tmp {
+ pub(super) struct InnerTest;
+ }
+};
+
fn main() {}
diff --git a/tests/ui/lint/non-local-defs/convoluted-locals-131474.rs b/tests/ui/lint/non-local-defs/convoluted-locals-131474.rs
index 4881723f13bc..8e738544a718 100644
--- a/tests/ui/lint/non-local-defs/convoluted-locals-131474.rs
+++ b/tests/ui/lint/non-local-defs/convoluted-locals-131474.rs
@@ -21,4 +21,13 @@ const _: () = {
};
};
+// https://github.com/rust-lang/rust/issues/131643
+const _: () = {
+ const _: () = {
+ impl InnerTest {}
+ };
+
+ struct InnerTest;
+};
+
fn main() {}
From 725d1f7905821dd0d819e305a5c200713963f937 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Mon, 7 Oct 2024 16:11:39 +0200
Subject: [PATCH 11/12] core/net: add Ipv[46]Addr::from_octets,
Ipv6Addr::from_segments
---
library/core/src/net/ip_addr.rs | 77 +++++++++++++++++++++++++++++++
library/core/tests/lib.rs | 1 +
library/core/tests/net/ip_addr.rs | 24 +++++++++-
3 files changed, 101 insertions(+), 1 deletion(-)
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 919f681f911f..bd08ce2ee347 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -600,6 +600,24 @@ impl Ipv4Addr {
self.octets
}
+ /// Creates an `Ipv4Addr` from a four element byte array.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ip_from)]
+ /// use std::net::Ipv4Addr;
+ ///
+ /// let addr = Ipv4Addr::from_octets([13u8, 12u8, 11u8, 10u8]);
+ /// assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);
+ /// ```
+ #[unstable(feature = "ip_from", issue = "131360")]
+ #[must_use]
+ #[inline]
+ pub const fn from_octets(octets: [u8; 4]) -> Ipv4Addr {
+ Ipv4Addr { octets }
+ }
+
/// Returns [`true`] for the special 'unspecified' address (`0.0.0.0`).
///
/// This property is defined in _UNIX Network Programming, Second Edition_,
@@ -1400,6 +1418,36 @@ impl Ipv6Addr {
]
}
+ /// Creates an `Ipv6Addr` from an eight element 16-bit array.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ip_from)]
+ /// use std::net::Ipv6Addr;
+ ///
+ /// let addr = Ipv6Addr::from_segments([
+ /// 525u16, 524u16, 523u16, 522u16,
+ /// 521u16, 520u16, 519u16, 518u16,
+ /// ]);
+ /// assert_eq!(
+ /// Ipv6Addr::new(
+ /// 0x20d, 0x20c,
+ /// 0x20b, 0x20a,
+ /// 0x209, 0x208,
+ /// 0x207, 0x206
+ /// ),
+ /// addr
+ /// );
+ /// ```
+ #[unstable(feature = "ip_from", issue = "131360")]
+ #[must_use]
+ #[inline]
+ pub const fn from_segments(segments: [u16; 8]) -> Ipv6Addr {
+ let [a, b, c, d, e, f, g, h] = segments;
+ Ipv6Addr::new(a, b, c, d, e, f, g, h)
+ }
+
/// Returns [`true`] for the special 'unspecified' address (`::`).
///
/// This property is defined in [IETF RFC 4291].
@@ -1941,6 +1989,35 @@ impl Ipv6Addr {
pub const fn octets(&self) -> [u8; 16] {
self.octets
}
+
+ /// Creates an `Ipv6Addr` from a sixteen element byte array.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(ip_from)]
+ /// use std::net::Ipv6Addr;
+ ///
+ /// let addr = Ipv6Addr::from_octets([
+ /// 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
+ /// 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
+ /// ]);
+ /// assert_eq!(
+ /// Ipv6Addr::new(
+ /// 0x1918, 0x1716,
+ /// 0x1514, 0x1312,
+ /// 0x1110, 0x0f0e,
+ /// 0x0d0c, 0x0b0a
+ /// ),
+ /// addr
+ /// );
+ /// ```
+ #[unstable(feature = "ip_from", issue = "131360")]
+ #[must_use]
+ #[inline]
+ pub const fn from_octets(octets: [u8; 16]) -> Ipv6Addr {
+ Ipv6Addr { octets }
+ }
}
/// Writes an Ipv6Addr, conforming to the canonical style described by
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 196e91ee3e92..28636f7f5d7d 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -57,6 +57,7 @@
#![feature(hashmap_internals)]
#![feature(int_roundings)]
#![feature(ip)]
+#![feature(ip_from)]
#![feature(is_ascii_octdigit)]
#![feature(isqrt)]
#![feature(iter_advance_by)]
diff --git a/library/core/tests/net/ip_addr.rs b/library/core/tests/net/ip_addr.rs
index a10b51c550d5..707f9a160e12 100644
--- a/library/core/tests/net/ip_addr.rs
+++ b/library/core/tests/net/ip_addr.rs
@@ -494,6 +494,7 @@ fn ipv6_properties() {
let octets = &[$($octet),*];
assert_eq!(&ip!($s).octets(), octets);
assert_eq!(Ipv6Addr::from(*octets), ip!($s));
+ assert_eq!(Ipv6Addr::from_octets(*octets), ip!($s));
let unspecified: u32 = 1 << 0;
let loopback: u32 = 1 << 1;
@@ -846,15 +847,19 @@ fn ipv6_from_constructors() {
#[test]
fn ipv4_from_octets() {
- assert_eq!(Ipv4Addr::from([127, 0, 0, 1]), Ipv4Addr::new(127, 0, 0, 1))
+ assert_eq!(Ipv4Addr::from([127, 0, 0, 1]), Ipv4Addr::new(127, 0, 0, 1));
+ assert_eq!(Ipv4Addr::from_octets([127, 0, 0, 1]), Ipv4Addr::new(127, 0, 0, 1));
}
#[test]
fn ipv6_from_segments() {
let from_u16s =
Ipv6Addr::from([0x0011, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0xccdd, 0xeeff]);
+ let from_u16s_explicit =
+ Ipv6Addr::from_segments([0x0011, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0xccdd, 0xeeff]);
let new = Ipv6Addr::new(0x0011, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0xccdd, 0xeeff);
assert_eq!(new, from_u16s);
+ assert_eq!(new, from_u16s_explicit);
}
#[test]
@@ -865,7 +870,15 @@ fn ipv6_from_octets() {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
0xff,
]);
+ let from_u16s_explicit =
+ Ipv6Addr::from_segments([0x0011, 0x2233, 0x4455, 0x6677, 0x8899, 0xaabb, 0xccdd, 0xeeff]);
+ let from_u8s_explicit = Ipv6Addr::from_octets([
+ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
+ 0xff,
+ ]);
assert_eq!(from_u16s, from_u8s);
+ assert_eq!(from_u16s, from_u16s_explicit);
+ assert_eq!(from_u16s_explicit, from_u8s_explicit);
}
#[test]
@@ -915,6 +928,9 @@ fn ipv4_const() {
const OCTETS: [u8; 4] = IP_ADDRESS.octets();
assert_eq!(OCTETS, [127, 0, 0, 1]);
+ const FROM_OCTETS: Ipv4Addr = Ipv4Addr::from_octets(OCTETS);
+ assert_eq!(IP_ADDRESS, FROM_OCTETS);
+
const IS_UNSPECIFIED: bool = IP_ADDRESS.is_unspecified();
assert!(!IS_UNSPECIFIED);
@@ -971,9 +987,15 @@ fn ipv6_const() {
const SEGMENTS: [u16; 8] = IP_ADDRESS.segments();
assert_eq!(SEGMENTS, [0, 0, 0, 0, 0, 0, 0, 1]);
+ const FROM_SEGMENTS: Ipv6Addr = Ipv6Addr::from_segments(SEGMENTS);
+ assert_eq!(IP_ADDRESS, FROM_SEGMENTS);
+
const OCTETS: [u8; 16] = IP_ADDRESS.octets();
assert_eq!(OCTETS, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
+ const FROM_OCTETS: Ipv6Addr = Ipv6Addr::from_octets(OCTETS);
+ assert_eq!(IP_ADDRESS, FROM_OCTETS);
+
const IS_UNSPECIFIED: bool = IP_ADDRESS.is_unspecified();
assert!(!IS_UNSPECIFIED);
From 0b7e39908ee6314dd8b8561dd4c8a47ce3ba2f38 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Sun, 13 Oct 2024 20:27:24 +0200
Subject: [PATCH 12/12] core/net: use hex for ipv6 doctests for consistency.
---
library/core/src/net/ip_addr.rs | 62 +++++++++++++--------------------
1 file changed, 25 insertions(+), 37 deletions(-)
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index bd08ce2ee347..05e1f3ee7a26 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -1427,15 +1427,13 @@ impl Ipv6Addr {
/// use std::net::Ipv6Addr;
///
/// let addr = Ipv6Addr::from_segments([
- /// 525u16, 524u16, 523u16, 522u16,
- /// 521u16, 520u16, 519u16, 518u16,
+ /// 0x20du16, 0x20cu16, 0x20bu16, 0x20au16,
+ /// 0x209u16, 0x208u16, 0x207u16, 0x206u16,
/// ]);
/// assert_eq!(
/// Ipv6Addr::new(
- /// 0x20d, 0x20c,
- /// 0x20b, 0x20a,
- /// 0x209, 0x208,
- /// 0x207, 0x206
+ /// 0x20d, 0x20c, 0x20b, 0x20a,
+ /// 0x209, 0x208, 0x207, 0x206,
/// ),
/// addr
/// );
@@ -1980,7 +1978,7 @@ impl Ipv6Addr {
/// use std::net::Ipv6Addr;
///
/// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),
- /// [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+ /// [0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
/// ```
#[rustc_const_stable(feature = "const_ip_32", since = "1.32.0")]
#[stable(feature = "ipv6_to_octets", since = "1.12.0")]
@@ -1999,15 +1997,13 @@ impl Ipv6Addr {
/// use std::net::Ipv6Addr;
///
/// let addr = Ipv6Addr::from_octets([
- /// 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
- /// 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
+ /// 0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,
+ /// 0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,
/// ]);
/// assert_eq!(
/// Ipv6Addr::new(
- /// 0x1918, 0x1716,
- /// 0x1514, 0x1312,
- /// 0x1110, 0x0f0e,
- /// 0x0d0c, 0x0b0a
+ /// 0x1918, 0x1716, 0x1514, 0x1312,
+ /// 0x1110, 0x0f0e, 0x0d0c, 0x0b0a,
/// ),
/// addr
/// );
@@ -2190,15 +2186,13 @@ impl From<[u8; 16]> for Ipv6Addr {
/// use std::net::Ipv6Addr;
///
/// let addr = Ipv6Addr::from([
- /// 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
- /// 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
+ /// 0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,
+ /// 0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,
/// ]);
/// assert_eq!(
/// Ipv6Addr::new(
- /// 0x1918, 0x1716,
- /// 0x1514, 0x1312,
- /// 0x1110, 0x0f0e,
- /// 0x0d0c, 0x0b0a
+ /// 0x1918, 0x1716, 0x1514, 0x1312,
+ /// 0x1110, 0x0f0e, 0x0d0c, 0x0b0a,
/// ),
/// addr
/// );
@@ -2219,15 +2213,13 @@ impl From<[u16; 8]> for Ipv6Addr {
/// use std::net::Ipv6Addr;
///
/// let addr = Ipv6Addr::from([
- /// 525u16, 524u16, 523u16, 522u16,
- /// 521u16, 520u16, 519u16, 518u16,
+ /// 0x20du16, 0x20cu16, 0x20bu16, 0x20au16,
+ /// 0x209u16, 0x208u16, 0x207u16, 0x206u16,
/// ]);
/// assert_eq!(
/// Ipv6Addr::new(
- /// 0x20d, 0x20c,
- /// 0x20b, 0x20a,
- /// 0x209, 0x208,
- /// 0x207, 0x206
+ /// 0x20d, 0x20c, 0x20b, 0x20a,
+ /// 0x209, 0x208, 0x207, 0x206,
/// ),
/// addr
/// );
@@ -2249,15 +2241,13 @@ impl From<[u8; 16]> for IpAddr {
/// use std::net::{IpAddr, Ipv6Addr};
///
/// let addr = IpAddr::from([
- /// 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
- /// 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
+ /// 0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,
+ /// 0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,
/// ]);
/// assert_eq!(
/// IpAddr::V6(Ipv6Addr::new(
- /// 0x1918, 0x1716,
- /// 0x1514, 0x1312,
- /// 0x1110, 0x0f0e,
- /// 0x0d0c, 0x0b0a
+ /// 0x1918, 0x1716, 0x1514, 0x1312,
+ /// 0x1110, 0x0f0e, 0x0d0c, 0x0b0a,
/// )),
/// addr
/// );
@@ -2278,15 +2268,13 @@ impl From<[u16; 8]> for IpAddr {
/// use std::net::{IpAddr, Ipv6Addr};
///
/// let addr = IpAddr::from([
- /// 525u16, 524u16, 523u16, 522u16,
- /// 521u16, 520u16, 519u16, 518u16,
+ /// 0x20du16, 0x20cu16, 0x20bu16, 0x20au16,
+ /// 0x209u16, 0x208u16, 0x207u16, 0x206u16,
/// ]);
/// assert_eq!(
/// IpAddr::V6(Ipv6Addr::new(
- /// 0x20d, 0x20c,
- /// 0x20b, 0x20a,
- /// 0x209, 0x208,
- /// 0x207, 0x206
+ /// 0x20d, 0x20c, 0x20b, 0x20a,
+ /// 0x209, 0x208, 0x207, 0x206,
/// )),
/// addr
/// );