mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #127546 - workingjubilee:5-level-paging-exists, r=saethlin

Browse Source 
Correct outdated object size limit

The comment here about 48 bit addresses being enough was written in 2016 but was made incorrect in 2019 by 5-level paging, and then persisted for another 5 years before being noticed and corrected.

The bolding of the "exclusive" part is merely to call attention to something I missed when reading it and doublechecking the math.

try-job: i686-msvc
try-job: test-various
This commit is contained in:
bors 2024-09-21 16:20:10 +00:00
commit 1d68e6dd1d
44 changed files with 103 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_abi/src/lib.rs
View File

@ -337,23 +337,21 @@ pub fn parse_from_llvm_datalayout_string<'a>(
Ok(dl)
}
/// Returns exclusive upper bound on object size.
/// Returns **exclusive** upper bound on object size in bytes.
///
/// The theoretical maximum object size is defined as the maximum positive `isize` value.
/// This ensures that the `offset` semantics remain well-defined by allowing it to correctly
/// index every address within an object along with one byte past the end, along with allowing
/// `isize` to store the difference between any two pointers into an object.
///
/// The upper bound on 64-bit currently needs to be lower because LLVM uses a 64-bit integer
/// to represent object size in bits. It would need to be 1 << 61 to account for this, but is
/// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable
/// address space on 64-bit ARMv8 and x86_64.
/// LLVM uses a 64-bit integer to represent object size in *bits*, but we care only for bytes,
/// so we adopt such a more-constrained size bound due to its technical limitations.
#[inline]
pub fn obj_size_bound(&self) -> u64 {
match self.pointer_size.bits() {
16 => 1 << 15,
32 => 1 << 31,
64 => 1 << 47,
64 => 1 << 61,
bits => panic!("obj_size_bound: unknown pointer bit size {bits}"),
}
}

2
compiler/rustc_hir_analysis/messages.ftl
View File

@ -478,7 +478,7 @@ hir_analysis_tait_forward_compat2 = item does not constrain `{$opaque_type}`, bu
hir_analysis_target_feature_on_main = `main` function is not allowed to have `#[target_feature]`
hir_analysis_too_large_static = extern static is too large for the current architecture
hir_analysis_too_large_static = extern static is too large for the target architecture
hir_analysis_track_caller_on_main = `main` function is not allowed to be `#[track_caller]`
.suggestion = remove this annotation

2
compiler/rustc_hir_typeck/src/intrinsicck.rs
View File

@ -95,7 +95,7 @@ pub(crate) fn check_transmute(&self, from: Ty<'tcx>, to: Ty<'tcx>, hir_id: HirId
format!("{v} bits")
} else {
// `u128` should definitely be able to hold the size of different architectures
// larger sizes should be reported as error `are too big for the current architecture`
// larger sizes should be reported as error `are too big for the target architecture`
// otherwise we have a bug somewhere
bug!("{:?} overflow for u128", size)
}

2
compiler/rustc_middle/messages.ftl
View File

@ -103,5 +103,5 @@ middle_unknown_layout =
the type `{$ty}` has an unknown layout
middle_values_too_big =
values of the type `{$ty}` are too big for the current architecture
values of the type `{$ty}` are too big for the target architecture
middle_written_to_path = the full type name has been written to '{$path}'

2
compiler/rustc_middle/src/ty/layout.rs
View File

@ -264,7 +264,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
LayoutError::Unknown(ty) => write!(f, "the type `{ty}` has an unknown layout"),
LayoutError::SizeOverflow(ty) => {
write!(f, "values of the type `{ty}` are too big for the current architecture")
write!(f, "values of the type `{ty}` are too big for the target architecture")
}
LayoutError::NormalizationFailure(t, e) => write!(
f,

4
compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
View File

@ -2269,12 +2269,12 @@ fn get_safe_transmute_error_and_reason(
}
rustc_transmute::Reason::SrcSizeOverflow => {
format!(
"values of the type `{src}` are too big for the current architecture"
"values of the type `{src}` are too big for the target architecture"
)
}
rustc_transmute::Reason::DstSizeOverflow => {
format!(
"values of the type `{dst}` are too big for the current architecture"
"values of the type `{dst}` are too big for the target architecture"
)
}
rustc_transmute::Reason::DstHasStricterAlignment {

4
src/tools/miri/tests/fail/type-too-large.stderr
View File

@ -1,8 +1,8 @@
error: post-monomorphization error: values of the type `[u8; 2305843011361177600]` are too big for the current architecture
error: post-monomorphization error: values of the type `[u8; 2305843011361177600]` are too big for the target architecture
--> tests/fail/type-too-large.rs:LL:CC
|
LL | _fat = [0; (1u64 << 61) as usize + (1u64 << 31) as usize];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843011361177600]` are too big for the current architecture
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843011361177600]` are too big for the target architecture
|
= note: BACKTRACE:
= note: inside `main` at tests/fail/type-too-large.rs:LL:CC

2
src/tools/tidy/src/issues.txt
View File

@ -552,7 +552,6 @@ ui/const-generics/infer/issue-77092.rs
ui/const-generics/issue-102124.rs
ui/const-generics/issue-105689.rs
ui/const-generics/issue-106419-struct-with-multiple-const-params.rs
ui/const-generics/issue-112505-overflow.rs
ui/const-generics/issue-46511.rs
ui/const-generics/issue-66451.rs
ui/const-generics/issue-70408.rs
@ -2717,7 +2716,6 @@ ui/limits/issue-15919-32.rs
ui/limits/issue-15919-64.rs
ui/limits/issue-17913.rs
ui/limits/issue-55878.rs
ui/limits/issue-56762.rs
ui/limits/issue-69485-var-size-diffs-too-large.rs
ui/limits/issue-75158-64.rs
ui/linkage-attr/auxiliary/issue-12133-dylib.rs

2
tests/crashes/125476.rs
View File

@ -1,4 +1,4 @@
//@ known-bug: rust-lang/rust#125476
//@ only-x86_64
pub struct Data([u8; usize::MAX >> 16]);
pub struct Data([u8; usize::MAX >> 2]);
const _: &'static [Data] = &[];

7
tests/ui/const-generics/issue-112505-overflow.rs
View File

@ -1,7 +0,0 @@
#![feature(transmute_generic_consts)]
fn overflow(v: [[[u32; 8888888]; 9999999]; 777777777]) -> [[[u32; 9999999]; 777777777]; 239] {
unsafe { std::mem::transmute(v) } //~ ERROR cannot transmute between types of different sizes
}
fn main() { }

12
tests/ui/const-generics/issue-112505-overflow.stderr
View File

@ -1,12 +0,0 @@
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/issue-112505-overflow.rs:4:14
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
= note: target type: `[[[u32; 9999999]; 777777777]; 239]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0512`.

10
tests/ui/const-generics/transmute-fail.rs
View File

@ -1,3 +1,8 @@
// ignore-tidy-linelength
//@ normalize-stderr-32bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
//@ normalize-stderr-64bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
#![feature(transmute_generic_consts)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
@ -31,6 +36,11 @@
}
}
fn overflow_more(v: [[[u32; 8888888]; 9999999]; 777777777]) -> [[[u32; 9999999]; 777777777]; 239] {
unsafe { std::mem::transmute(v) } //~ ERROR cannot transmute between types of different sizes
}
fn transpose<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
unsafe {
std::mem::transmute(v)

43
tests/ui/const-generics/transmute-fail.stderr
View File

@ -1,11 +1,11 @@
error: the constant `W` is not of type `usize`
--> $DIR/transmute-fail.rs:12:42
--> $DIR/transmute-fail.rs:17:42
|
LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
| ^^^^^^^^^^^^^ expected `usize`, found `bool`
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:7:9
--> $DIR/transmute-fail.rs:12:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -14,13 +14,13 @@ LL | std::mem::transmute(v)
= note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])
error: the constant `W` is not of type `usize`
--> $DIR/transmute-fail.rs:15:9
--> $DIR/transmute-fail.rs:20:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:22:9
--> $DIR/transmute-fail.rs:27:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -29,16 +29,25 @@ LL | std::mem::transmute(v)
= note: target type: `[u32; W * H * H]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:29:9
--> $DIR/transmute-fail.rs:34:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
= note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
= note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:36:9
--> $DIR/transmute-fail.rs:40:14
|
LL | unsafe { std::mem::transmute(v) }
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
= note: target type: `[[[u32; 9999999]; 777777777]; 239]` (values of the type $REALLY_TOO_BIG are too big for the target architecture)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:46:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -47,7 +56,7 @@ LL | std::mem::transmute(v)
= note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:47:9
--> $DIR/transmute-fail.rs:57:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -56,7 +65,7 @@ LL | std::mem::transmute(v)
= note: target type: `[u32; W * H]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:54:9
--> $DIR/transmute-fail.rs:64:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -65,7 +74,7 @@ LL | std::mem::transmute(v)
= note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:63:9
--> $DIR/transmute-fail.rs:73:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -74,7 +83,7 @@ LL | std::mem::transmute(v)
= note: target type: `[u32; D * W * H]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:72:9
--> $DIR/transmute-fail.rs:82:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -83,7 +92,7 @@ LL | std::mem::transmute(v)
= note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:79:9
--> $DIR/transmute-fail.rs:89:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -92,7 +101,7 @@ LL | std::mem::transmute(v)
= note: target type: `[u8; L * 2]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:86:9
--> $DIR/transmute-fail.rs:96:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -101,7 +110,7 @@ LL | std::mem::transmute(v)
= note: target type: `[u16; L]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:93:9
--> $DIR/transmute-fail.rs:103:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -110,7 +119,7 @@ LL | std::mem::transmute(v)
= note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> $DIR/transmute-fail.rs:102:9
--> $DIR/transmute-fail.rs:112:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
@ -118,6 +127,6 @@ LL | std::mem::transmute(v)
= note: source type: `[[u32; 2 * H]; W + W]` (size can vary because of [u32; 2 * H])
= note: target type: `[[u32; W + W]; 2 * H]` (size can vary because of [u32; W + W])
error: aborting due to 14 previous errors
error: aborting due to 15 previous errors
For more information about this error, try `rustc --explain E0512`.

2
tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.rs
View File

@ -3,7 +3,7 @@
//@ compile-flags:-C debuginfo=2
//@ build-fail
//@ error-pattern: too big for the current architecture
//@ error-pattern: too big for the target architecture
//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
//@ normalize-stderr-32bit: "4294967295" -> "SIZE"

2
tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; usize::MAX]` are too big for the current architecture
error: values of the type `[u8; usize::MAX]` are too big for the target architecture
error: aborting due to 1 previous error

2
tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.rs
View File

@ -5,7 +5,7 @@
//@ compile-flags:-C debuginfo=2
//@ build-fail
//@ error-pattern: too big for the current architecture
//@ error-pattern: too big for the target architecture
//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
//@ normalize-stderr-32bit: "4294967295" -> "SIZE"

2
tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; usize::MAX]` are too big for the current architecture
error: values of the type `[u8; usize::MAX]` are too big for the target architecture
error: aborting due to 1 previous error

30
tests/ui/extern/extern-static-size-overflow.rs vendored
View File

@ -4,31 +4,13 @@ struct ReallyBig {
}
// The limit for "too big for the current architecture" is dependent on the target pointer size
// however it's artificially limited on 64 bits
// logic copied from rustc_target::abi::TargetDataLayout::obj_size_bound()
// but is artificially limited due to LLVM's internal architecture
// logic based on rustc_target::abi::TargetDataLayout::obj_size_bound()
const fn max_size() -> usize {
#[cfg(target_pointer_width = "16")]
{
1 << 15
}
#[cfg(target_pointer_width = "32")]
{
1 << 31
}
#[cfg(target_pointer_width = "64")]
{
1 << 47
}
#[cfg(not(any(
target_pointer_width = "16",
target_pointer_width = "32",
target_pointer_width = "64"
)))]
{
isize::MAX as usize
if usize::BITS < 61 {
1 << (usize::BITS - 1)
} else {
1 << 61
}
}

12
tests/ui/extern/extern-static-size-overflow.stderr vendored
View File

@ -1,17 +1,17 @@
error: extern static is too large for the current architecture
--> $DIR/extern-static-size-overflow.rs:38:5
error: extern static is too large for the target architecture
--> $DIR/extern-static-size-overflow.rs:20:5
|
LL | static BAZ: [u8; max_size()];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: extern static is too large for the current architecture
--> $DIR/extern-static-size-overflow.rs:39:5
error: extern static is too large for the target architecture
--> $DIR/extern-static-size-overflow.rs:21:5
|
LL | static UWU: [usize; usize::MAX];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: extern static is too large for the current architecture
--> $DIR/extern-static-size-overflow.rs:40:5
error: extern static is too large for the target architecture
--> $DIR/extern-static-size-overflow.rs:22:5
|
LL | static A: ReallyBig;
| ^^^^^^^^^^^^^^^^^^^

2
tests/ui/layout/size-of-val-raw-too-big.rs
View File

@ -1,7 +1,7 @@
//@ build-fail
//@ compile-flags: --crate-type lib
//@ only-32bit Layout computation rejects this layout for different reasons on 64-bit.
//@ error-pattern: too big for the current architecture
//@ error-pattern: too big for the target architecture
#![feature(core_intrinsics)]
#![allow(internal_features)]

2
tests/ui/layout/size-of-val-raw-too-big.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `Example` are too big for the current architecture
error: values of the type `Example` are too big for the target architecture
error: aborting due to 1 previous error

2
tests/ui/layout/too-big-with-padding.rs
View File

@ -10,7 +10,7 @@
#[repr(C, align(2))]
pub struct Example([u8; 0x7fffffff]);
pub fn lib(_x: Example) {} //~ERROR: too big for the current architecture
pub fn lib(_x: Example) {} //~ERROR: too big for the target architecture
#[lang = "sized"]
pub trait Sized {}

2
tests/ui/layout/too-big-with-padding.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `Example` are too big for the current architecture
error: values of the type `Example` are too big for the target architecture
--> $DIR/too-big-with-padding.rs:13:1
|
LL | pub fn lib(_x: Example) {}

2
tests/ui/limits/huge-array-simple-32.rs
View File

@ -4,6 +4,6 @@
#![allow(arithmetic_overflow)]
fn main() {
let _fat: [u8; (1<<31)+(1<<15)] = //~ ERROR too big for the current architecture
let _fat: [u8; (1<<31)+(1<<15)] = //~ ERROR too big for the target architecture
[0; (1u32<<31) as usize +(1u32<<15) as usize];
}

2
tests/ui/limits/huge-array-simple-32.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; 2147516416]` are too big for the current architecture
error: values of the type `[u8; 2147516416]` are too big for the target architecture
--> $DIR/huge-array-simple-32.rs:7:9
|
LL | let _fat: [u8; (1<<31)+(1<<15)] =

2
tests/ui/limits/huge-array-simple-64.rs
View File

@ -4,6 +4,6 @@
#![allow(arithmetic_overflow)]
fn main() {
let _fat: [u8; (1<<61)+(1<<31)] = //~ ERROR too big for the current architecture
let _fat: [u8; (1<<61)+(1<<31)] = //~ ERROR too big for the target architecture
[0; (1u64<<61) as usize +(1u64<<31) as usize];
}

2
tests/ui/limits/huge-array-simple-64.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; 2305843011361177600]` are too big for the current architecture
error: values of the type `[u8; 2305843011361177600]` are too big for the target architecture
--> $DIR/huge-array-simple-64.rs:7:9
|
LL | let _fat: [u8; (1<<61)+(1<<31)] =

2
tests/ui/limits/huge-array.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[[u8; 1518599999]; 1518600000]` are too big for the current architecture
error: values of the type `[[u8; 1518599999]; 1518600000]` are too big for the target architecture
--> $DIR/huge-array.rs:4:9
|
LL | let s: [T; 1518600000] = [t; 1518600000];

4
tests/ui/limits/huge-enum.rs
View File

@ -6,9 +6,9 @@
type BIG = Option<[u32; (1<<29)-1]>;
#[cfg(target_pointer_width = "64")]
type BIG = Option<[u32; (1<<45)-1]>;
type BIG = Option<[u32; (1<<59)-1]>;
fn main() {
let big: BIG = None;
//~^ ERROR are too big for the current architecture
//~^ ERROR are too big for the target architecture
}

2
tests/ui/limits/huge-enum.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `Option<TYPE>` are too big for the current architecture
error: values of the type `Option<TYPE>` are too big for the target architecture
--> $DIR/huge-enum.rs:12:9
|
LL | let big: BIG = None;

7
tests/ui/limits/issue-56762.rs → tests/ui/limits/huge-static.rs
View File

@ -1,6 +1,9 @@
//@ only-x86_64
//@ only-64bit
const HUGE_SIZE: usize = !0usize / 8;
// This test validates we gracefully fail computing a const or static of absurdly large size.
// The oddly-specific number is because of LLVM measuring object sizes in bits.
const HUGE_SIZE: usize = 1 << 61;
pub struct TooBigArray {

8
tests/ui/limits/issue-56762.stderr → tests/ui/limits/huge-static.stderr
View File

@ -1,14 +1,14 @@
error[E0080]: could not evaluate static initializer
--> $DIR/issue-56762.rs:16:1
--> $DIR/huge-static.rs:19:1
|
LL | static MY_TOO_BIG_ARRAY_1: TooBigArray = TooBigArray::new();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843009213693951]` are too big for the current architecture
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843009213693952]` are too big for the target architecture
error[E0080]: could not evaluate static initializer
--> $DIR/issue-56762.rs:19:1
--> $DIR/huge-static.rs:22:1
|
LL | static MY_TOO_BIG_ARRAY_2: [u8; HUGE_SIZE] = [0x00; HUGE_SIZE];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843009213693951]` are too big for the current architecture
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; 2305843009213693952]` are too big for the target architecture
error: aborting due to 2 previous errors

6
tests/ui/limits/huge-struct.rs
View File

@ -1,7 +1,9 @@
// ignore-tidy-linelength
//@ build-fail
//@ normalize-stderr-test: "S32" -> "SXX"
//@ normalize-stderr-test: "S1M" -> "SXX"
//@ error-pattern: too big for the current
//@ normalize-stderr-32bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
//@ normalize-stderr-64bit: "values of the type `[^`]+` are too big" -> "values of the type $$REALLY_TOO_BIG are too big"
struct S32<T> {
v0: T,
@ -44,6 +46,6 @@ struct S1M<T> { val: S1k<S1k<T>> }
fn main() {
let fat: Option<S1M<S1M<S1M<u32>>>> = None;
//~^ ERROR are too big for the current architecture
//~^ ERROR are too big for the target architecture
}

4
tests/ui/limits/huge-struct.stderr
View File

@ -1,5 +1,5 @@
error: values of the type `SXX<SXX<SXX<u32>>>` are too big for the current architecture
--> $DIR/huge-struct.rs:46:9
error: values of the type $REALLY_TOO_BIG are too big for the target architecture
--> $DIR/huge-struct.rs:48:9
|
LL | let fat: Option<SXX<SXX<SXX<u32>>>> = None;
| ^^^

2
tests/ui/limits/issue-15919-32.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[usize; usize::MAX]` are too big for the current architecture
error: values of the type `[usize; usize::MAX]` are too big for the target architecture
--> $DIR/issue-15919-32.rs:5:9
|
LL | let x = [0usize; 0xffff_ffff];

2
tests/ui/limits/issue-15919-64.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[usize; usize::MAX]` are too big for the current architecture
error: values of the type `[usize; usize::MAX]` are too big for the target architecture
--> $DIR/issue-15919-64.rs:5:9
|
LL | let x = [0usize; 0xffff_ffff_ffff_ffff];

2
tests/ui/limits/issue-17913.rs
View File

@ -1,6 +1,6 @@
//@ build-fail
//@ normalize-stderr-test: "\[&usize; \d+\]" -> "[&usize; usize::MAX]"
//@ error-pattern: too big for the current architecture
//@ error-pattern: too big for the target architecture
#[cfg(target_pointer_width = "64")]
fn main() {

2
tests/ui/limits/issue-17913.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[&usize; usize::MAX]` are too big for the current architecture
error: values of the type `[&usize; usize::MAX]` are too big for the target architecture
--> $SRC_DIR/alloc/src/boxed.rs:LL:COL
error: aborting due to 1 previous error

2
tests/ui/limits/issue-55878.rs
View File

@ -2,7 +2,7 @@
//@ normalize-stderr-64bit: "18446744073709551615" -> "SIZE"
//@ normalize-stderr-32bit: "4294967295" -> "SIZE"
//@ error-pattern: are too big for the current architecture
//@ error-pattern: are too big for the target architecture
fn main() {
println!("Size: {}", std::mem::size_of::<[u8; u64::MAX as usize]>());
}

2
tests/ui/limits/issue-55878.stderr
View File

@ -1,7 +1,7 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/mem/mod.rs:LL:COL
|
= note: values of the type `[u8; usize::MAX]` are too big for the current architecture
= note: values of the type `[u8; usize::MAX]` are too big for the target architecture
|
note: inside `std::mem::size_of::<[u8; usize::MAX]>`
--> $SRC_DIR/core/src/mem/mod.rs:LL:COL

2
tests/ui/limits/issue-69485-var-size-diffs-too-large.rs
View File

@ -3,7 +3,7 @@
//@ compile-flags: -Zmir-opt-level=0
fn main() {
Bug::V([0; !0]); //~ ERROR are too big for the current
Bug::V([0; !0]); //~ ERROR are too big for the target
}
enum Bug {

2
tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; usize::MAX]` are too big for the current architecture
error: values of the type `[u8; usize::MAX]` are too big for the target architecture
--> $DIR/issue-69485-var-size-diffs-too-large.rs:6:5
|
LL | Bug::V([0; !0]);

2
tests/ui/limits/issue-75158-64.stderr
View File

@ -1,4 +1,4 @@
error: values of the type `[u8; usize::MAX]` are too big for the current architecture
error: values of the type `[u8; usize::MAX]` are too big for the target architecture
error: aborting due to 1 previous error

4
tests/ui/transmutability/arrays/huge-len.stderr
View File

@ -2,7 +2,7 @@ error[E0277]: `()` cannot be safely transmuted into `ExplicitlyPadded`
--> $DIR/huge-len.rs:21:41
|
LL | assert::is_maybe_transmutable::<(), ExplicitlyPadded>();
| ^^^^^^^^^^^^^^^^ values of the type `ExplicitlyPadded` are too big for the current architecture
| ^^^^^^^^^^^^^^^^ values of the type `ExplicitlyPadded` are too big for the target architecture
|
note: required by a bound in `is_maybe_transmutable`
--> $DIR/huge-len.rs:8:14
@ -17,7 +17,7 @@ error[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()`
--> $DIR/huge-len.rs:24:55
|
LL | assert::is_maybe_transmutable::<ExplicitlyPadded, ()>();
| ^^ values of the type `ExplicitlyPadded` are too big for the current architecture
| ^^ values of the type `ExplicitlyPadded` are too big for the target architecture
|
note: required by a bound in `is_maybe_transmutable`
--> $DIR/huge-len.rs:8:14