diff options
Diffstat (limited to 'src/test/ui/packed')
25 files changed, 0 insertions, 1142 deletions
diff --git a/src/test/ui/packed/auxiliary/packed.rs b/src/test/ui/packed/auxiliary/packed.rs deleted file mode 100644 index cba166fac..000000000 --- a/src/test/ui/packed/auxiliary/packed.rs +++ /dev/null @@ -1,19 +0,0 @@ -#[repr(packed)] -pub struct P1S5 { - a: u8, - b: u32 -} - -#[repr(packed(2))] -pub struct P2S6 { - a: u8, - b: u32, - c: u8 -} - -#[repr(C, packed(2))] -pub struct P2CS8 { - a: u8, - b: u32, - c: u8 -} diff --git a/src/test/ui/packed/issue-27060-2.rs b/src/test/ui/packed/issue-27060-2.rs deleted file mode 100644 index a001ce1e0..000000000 --- a/src/test/ui/packed/issue-27060-2.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[repr(packed)] -pub struct Bad<T: ?Sized> { - data: T, //~ ERROR the size for values of type -} - -fn main() {} diff --git a/src/test/ui/packed/issue-27060-2.stderr b/src/test/ui/packed/issue-27060-2.stderr deleted file mode 100644 index 0836ceaec..000000000 --- a/src/test/ui/packed/issue-27060-2.stderr +++ /dev/null @@ -1,27 +0,0 @@ -error[E0277]: the size for values of type `T` cannot be known at compilation time - --> $DIR/issue-27060-2.rs:3:11 - | -LL | pub struct Bad<T: ?Sized> { - | - this type parameter needs to be `std::marker::Sized` -LL | data: T, - | ^ doesn't have a size known at compile-time - | - = note: the last field of a packed struct may only have a dynamically sized type if it does not need drop to be run - = help: change the field's type to have a statically known size -help: consider removing the `?Sized` bound to make the type parameter `Sized` - | -LL - pub struct Bad<T: ?Sized> { -LL + pub struct Bad<T> { - | -help: borrowed types always have a statically known size - | -LL | data: &T, - | + -help: the `Box` type always has a statically known size and allocates its contents in the heap - | -LL | data: Box<T>, - | ++++ + - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/ui/packed/issue-27060-rpass.rs b/src/test/ui/packed/issue-27060-rpass.rs deleted file mode 100644 index d9159f666..000000000 --- a/src/test/ui/packed/issue-27060-rpass.rs +++ /dev/null @@ -1,23 +0,0 @@ -// run-pass -#![allow(dead_code)] -#[repr(packed)] -pub struct Good { - data: &'static u32, - data2: [&'static u32; 2], - aligned: [u8; 32], -} - -// kill this test when that turns to a hard error -#[allow(unaligned_references)] -fn main() { - let good = Good { data: &0, data2: [&0, &0], aligned: [0; 32] }; - - let _ = &good.data; // ok - let _ = &good.data2[0]; // ok - - let _ = &good.data; - let _ = &good.data2[0]; - let _ = &*good.data; // ok, behind a pointer - let _ = &good.aligned; // ok, has align 1 - let _ = &good.aligned[2]; // ok, has align 1 -} diff --git a/src/test/ui/packed/issue-27060-rpass.stderr b/src/test/ui/packed/issue-27060-rpass.stderr deleted file mode 100644 index adf9ae9f5..000000000 --- a/src/test/ui/packed/issue-27060-rpass.stderr +++ /dev/null @@ -1,68 +0,0 @@ -Future incompatibility report: Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/issue-27060-rpass.rs:15:13 - | -LL | let _ = &good.data; // ok - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/issue-27060-rpass.rs:11:9 - | -LL | #[allow(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/issue-27060-rpass.rs:16:13 - | -LL | let _ = &good.data2[0]; // ok - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/issue-27060-rpass.rs:11:9 - | -LL | #[allow(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/issue-27060-rpass.rs:18:13 - | -LL | let _ = &good.data; - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/issue-27060-rpass.rs:11:9 - | -LL | #[allow(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/issue-27060-rpass.rs:19:13 - | -LL | let _ = &good.data2[0]; - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/issue-27060-rpass.rs:11:9 - | -LL | #[allow(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - diff --git a/src/test/ui/packed/issue-27060.rs b/src/test/ui/packed/issue-27060.rs deleted file mode 100644 index 886a00239..000000000 --- a/src/test/ui/packed/issue-27060.rs +++ /dev/null @@ -1,27 +0,0 @@ -#[repr(packed)] -pub struct Good { - data: &'static u32, - data2: [&'static u32; 2], - aligned: [u8; 32], -} - -fn main() { - let good = Good { - data: &0, - data2: [&0, &0], - aligned: [0; 32] - }; - - let _ = &good.data; //~ ERROR reference to packed field - //~| hard error - let _ = &good.data2[0]; //~ ERROR reference to packed field - //~| hard error - - let _ = &good.data; //~ ERROR reference to packed field - //~| hard error - let _ = &good.data2[0]; //~ ERROR reference to packed field - //~| hard error - let _ = &*good.data; // ok, behind a pointer - let _ = &good.aligned; // ok, has align 1 - let _ = &good.aligned[2]; // ok, has align 1 -} diff --git a/src/test/ui/packed/issue-27060.stderr b/src/test/ui/packed/issue-27060.stderr deleted file mode 100644 index 85e08fa02..000000000 --- a/src/test/ui/packed/issue-27060.stderr +++ /dev/null @@ -1,99 +0,0 @@ -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:15:13 - | -LL | let _ = &good.data; - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - = note: `#[deny(unaligned_references)]` on by default - -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:17:13 - | -LL | let _ = &good.data2[0]; - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:20:13 - | -LL | let _ = &good.data; - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:22:13 - | -LL | let _ = &good.data2[0]; - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - -error: aborting due to 4 previous errors - -Future incompatibility report: Future breakage diagnostic: -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:15:13 - | -LL | let _ = &good.data; - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - = note: `#[deny(unaligned_references)]` on by default - -Future breakage diagnostic: -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:17:13 - | -LL | let _ = &good.data2[0]; - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - = note: `#[deny(unaligned_references)]` on by default - -Future breakage diagnostic: -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:20:13 - | -LL | let _ = &good.data; - | ^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - = note: `#[deny(unaligned_references)]` on by default - -Future breakage diagnostic: -error: reference to packed field is unaligned - --> $DIR/issue-27060.rs:22:13 - | -LL | let _ = &good.data2[0]; - | ^^^^^^^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - = note: `#[deny(unaligned_references)]` on by default - diff --git a/src/test/ui/packed/issue-46152.rs b/src/test/ui/packed/issue-46152.rs deleted file mode 100644 index fb1c9fb78..000000000 --- a/src/test/ui/packed/issue-46152.rs +++ /dev/null @@ -1,24 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(unused_variables)] -#![feature(unsize, coerce_unsized)] - -#[repr(packed)] -struct UnalignedPtr<'a, T: ?Sized> - where T: 'a, -{ - data: &'a T, -} - -fn main() { - - impl<'a, T, U> std::ops::CoerceUnsized<UnalignedPtr<'a, U>> for UnalignedPtr<'a, T> - where - T: std::marker::Unsize<U> + ?Sized, - U: ?Sized, - { } - - let arr = [1, 2, 3]; - let arr_unaligned: UnalignedPtr<[i32; 3]> = UnalignedPtr { data: &arr }; - let arr_unaligned: UnalignedPtr<[i32]> = arr_unaligned; -} diff --git a/src/test/ui/packed/packed-struct-address-of-element.rs b/src/test/ui/packed/packed-struct-address-of-element.rs deleted file mode 100644 index d86698cbf..000000000 --- a/src/test/ui/packed/packed-struct-address-of-element.rs +++ /dev/null @@ -1,36 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![feature(raw_ref_op)] -// ignore-emscripten weird assertion? - -#[repr(packed)] -struct Foo1 { - bar: u8, - baz: usize -} - -#[repr(packed(2))] -struct Foo2 { - bar: u8, - baz: usize -} - -#[repr(C, packed(4))] -struct Foo4C { - bar: u8, - baz: usize -} - -pub fn main() { - let foo = Foo1 { bar: 1, baz: 2 }; - let brw = &raw const foo.baz; - unsafe { assert_eq!(brw.read_unaligned(), 2); } - - let foo = Foo2 { bar: 1, baz: 2 }; - let brw = &raw const foo.baz; - unsafe { assert_eq!(brw.read_unaligned(), 2); } - - let mut foo = Foo4C { bar: 1, baz: 2 }; - let brw = &raw mut foo.baz; - unsafe { assert_eq!(brw.read_unaligned(), 2); } -} diff --git a/src/test/ui/packed/packed-struct-borrow-element-64bit.rs b/src/test/ui/packed/packed-struct-borrow-element-64bit.rs deleted file mode 100644 index 00bddfe40..000000000 --- a/src/test/ui/packed/packed-struct-borrow-element-64bit.rs +++ /dev/null @@ -1,18 +0,0 @@ -// run-pass (note: this is spec-UB, but it works for now) -// ignore-32bit (needs `usize` to be 8-aligned to reproduce all the errors below) -#![allow(dead_code)] -// ignore-emscripten weird assertion? - -#[repr(C, packed(4))] -struct Foo4C { - bar: u8, - baz: usize -} - -#[warn(unaligned_references)] -pub fn main() { - let foo = Foo4C { bar: 1, baz: 2 }; - let brw = &foo.baz; //~WARN reference to packed field is unaligned - //~^ previously accepted - assert_eq!(*brw, 2); -} diff --git a/src/test/ui/packed/packed-struct-borrow-element-64bit.stderr b/src/test/ui/packed/packed-struct-borrow-element-64bit.stderr deleted file mode 100644 index fb2f5615c..000000000 --- a/src/test/ui/packed/packed-struct-borrow-element-64bit.stderr +++ /dev/null @@ -1,35 +0,0 @@ -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element-64bit.rs:15:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/packed-struct-borrow-element-64bit.rs:12:8 - | -LL | #[warn(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -warning: 1 warning emitted - -Future incompatibility report: Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element-64bit.rs:15:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/packed-struct-borrow-element-64bit.rs:12:8 - | -LL | #[warn(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - diff --git a/src/test/ui/packed/packed-struct-borrow-element.rs b/src/test/ui/packed/packed-struct-borrow-element.rs deleted file mode 100644 index a6ee90cef..000000000 --- a/src/test/ui/packed/packed-struct-borrow-element.rs +++ /dev/null @@ -1,34 +0,0 @@ -// run-pass (note: this is spec-UB, but it works for now) -#![allow(dead_code)] -// ignore-emscripten weird assertion? - -#[repr(packed)] -struct Foo1 { - bar: u8, - baz: usize -} - -#[repr(packed(2))] -struct Foo2 { - bar: u8, - baz: usize -} - -#[repr(C, packed(4))] -struct Foo4C { - bar: u8, - baz: usize -} - -#[warn(unaligned_references)] -pub fn main() { - let foo = Foo1 { bar: 1, baz: 2 }; - let brw = &foo.baz; //~WARN reference to packed field is unaligned - //~^ previously accepted - assert_eq!(*brw, 2); - - let foo = Foo2 { bar: 1, baz: 2 }; - let brw = &foo.baz; //~WARN reference to packed field is unaligned - //~^ previously accepted - assert_eq!(*brw, 2); -} diff --git a/src/test/ui/packed/packed-struct-borrow-element.stderr b/src/test/ui/packed/packed-struct-borrow-element.stderr deleted file mode 100644 index 75d55c4f6..000000000 --- a/src/test/ui/packed/packed-struct-borrow-element.stderr +++ /dev/null @@ -1,63 +0,0 @@ -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element.rs:26:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/packed-struct-borrow-element.rs:23:8 - | -LL | #[warn(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element.rs:31:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) - -warning: 2 warnings emitted - -Future incompatibility report: Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element.rs:26:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/packed-struct-borrow-element.rs:23:8 - | -LL | #[warn(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - -Future breakage diagnostic: -warning: reference to packed field is unaligned - --> $DIR/packed-struct-borrow-element.rs:31:15 - | -LL | let brw = &foo.baz; - | ^^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> - = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) - = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) -note: the lint level is defined here - --> $DIR/packed-struct-borrow-element.rs:23:8 - | -LL | #[warn(unaligned_references)] - | ^^^^^^^^^^^^^^^^^^^^ - diff --git a/src/test/ui/packed/packed-struct-drop-aligned.rs b/src/test/ui/packed/packed-struct-drop-aligned.rs deleted file mode 100644 index 9f9f41e25..000000000 --- a/src/test/ui/packed/packed-struct-drop-aligned.rs +++ /dev/null @@ -1,57 +0,0 @@ -// run-pass -#![feature(generators)] -#![feature(generator_trait)] -use std::cell::Cell; -use std::mem; -use std::ops::Generator; -use std::pin::Pin; - -struct Aligned<'a> { - drop_count: &'a Cell<usize> -} - -#[inline(never)] -fn check_align(ptr: *const Aligned) { - assert_eq!(ptr as usize % mem::align_of::<Aligned>(), - 0); -} - -impl<'a> Drop for Aligned<'a> { - fn drop(&mut self) { - check_align(self); - self.drop_count.set(self.drop_count.get() + 1); - } -} - -#[repr(transparent)] -struct NotCopy(#[allow(unused_tuple_struct_fields)] u8); - -#[repr(packed)] -struct Packed<'a>(NotCopy, Aligned<'a>); - -fn main() { - let drop_count = &Cell::new(0); - { - let mut p = Packed(NotCopy(0), Aligned { drop_count }); - p.1 = Aligned { drop_count }; - assert_eq!(drop_count.get(), 1); - } - assert_eq!(drop_count.get(), 2); - - let drop_count = &Cell::new(0); - let mut g = || { - let mut p = Packed(NotCopy(0), Aligned { drop_count }); - let _ = &p; - p.1 = Aligned { drop_count }; - assert_eq!(drop_count.get(), 1); - // Test that a generator drop function moves a value from a packed - // struct to a separate local before dropping it. We move out the - // first field to generate and open drop for the second field. - drop(p.0); - yield; - }; - Pin::new(&mut g).resume(()); - assert_eq!(drop_count.get(), 1); - drop(g); - assert_eq!(drop_count.get(), 2); -} diff --git a/src/test/ui/packed/packed-struct-generic-layout.rs b/src/test/ui/packed/packed-struct-generic-layout.rs deleted file mode 100644 index e064eede4..000000000 --- a/src/test/ui/packed/packed-struct-generic-layout.rs +++ /dev/null @@ -1,32 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(overflowing_literals)] - - -use std::mem; - -#[repr(packed)] -struct S<T, S> { - a: T, - b: u8, - c: S -} - -pub fn main() { - unsafe { - let s = S { a: 0xff_ff_ff_ffu32, b: 1, c: 0xaa_aa_aa_aa as i32 }; - let transd : [u8; 9] = mem::transmute(s); - // Don't worry about endianness, the numbers are palindromic. - assert_eq!(transd, - [0xff, 0xff, 0xff, 0xff, - 1, - 0xaa, 0xaa, 0xaa, 0xaa]); - - - let s = S { a: 1u8, b: 2u8, c: 0b10000001_10000001 as i16}; - let transd : [u8; 4] = mem::transmute(s); - // Again, no endianness problems. - assert_eq!(transd, - [1, 2, 0b10000001, 0b10000001]); - } -} diff --git a/src/test/ui/packed/packed-struct-generic-size.rs b/src/test/ui/packed/packed-struct-generic-size.rs deleted file mode 100644 index 7c93e46c3..000000000 --- a/src/test/ui/packed/packed-struct-generic-size.rs +++ /dev/null @@ -1,44 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(unused_comparisons)] - -use std::mem; - -#[repr(packed)] -struct P1<T, S> { - a: T, - b: u8, - c: S -} - -#[repr(packed(2))] -struct P2<T, S> { - a: T, - b: u8, - c: S -} - -#[repr(C, packed(4))] -struct P4C<T, S> { - a: T, - b: u8, - c: S -} - -macro_rules! check { - ($t:ty, $align:expr, $size:expr) => ({ - assert_eq!(mem::align_of::<$t>(), $align); - assert_eq!(mem::size_of::<$t>(), $size); - }); -} - -pub fn main() { - check!(P1<u8, u8>, 1, 3); - check!(P1<u64, u16>, 1, 11); - - check!(P2<u8, u8>, 1, 3); - check!(P2<u64, u16>, 2, 12); - - check!(P4C<u8, u8>, 1, 3); - check!(P4C<u16, u64>, 4, 12); -} diff --git a/src/test/ui/packed/packed-struct-layout.rs b/src/test/ui/packed/packed-struct-layout.rs deleted file mode 100644 index d49c222e6..000000000 --- a/src/test/ui/packed/packed-struct-layout.rs +++ /dev/null @@ -1,28 +0,0 @@ -// run-pass -#![allow(dead_code)] -use std::mem; - -#[repr(packed)] -struct S4 { - a: u8, - b: [u8; 3], -} - -#[repr(packed)] -struct S5 { - a: u8, - b: u32 -} - -pub fn main() { - unsafe { - let s4 = S4 { a: 1, b: [2,3,4] }; - let transd : [u8; 4] = mem::transmute(s4); - assert_eq!(transd, [1, 2, 3, 4]); - - let s5 = S5 { a: 1, b: 0xff_00_00_ff }; - let transd : [u8; 5] = mem::transmute(s5); - // Don't worry about endianness, the u32 is palindromic. - assert_eq!(transd, [1, 0xff, 0, 0, 0xff]); - } -} diff --git a/src/test/ui/packed/packed-struct-match.rs b/src/test/ui/packed/packed-struct-match.rs deleted file mode 100644 index 9a572ced7..000000000 --- a/src/test/ui/packed/packed-struct-match.rs +++ /dev/null @@ -1,45 +0,0 @@ -// run-pass - -#[repr(packed)] -struct Foo1 { - bar: u8, - baz: usize -} - -#[repr(packed(2))] -struct Foo2 { - bar: u8, - baz: usize -} - -#[repr(C, packed(4))] -struct Foo4C { - bar: u8, - baz: usize -} - -pub fn main() { - let foo1 = Foo1 { bar: 1, baz: 2 }; - match foo1 { - Foo1 {bar, baz} => { - assert_eq!(bar, 1); - assert_eq!(baz, 2); - } - } - - let foo2 = Foo2 { bar: 1, baz: 2 }; - match foo2 { - Foo2 {bar, baz} => { - assert_eq!(bar, 1); - assert_eq!(baz, 2); - } - } - - let foo4 = Foo4C { bar: 1, baz: 2 }; - match foo4 { - Foo4C {bar, baz} => { - assert_eq!(bar, 1); - assert_eq!(baz, 2); - } - } -} diff --git a/src/test/ui/packed/packed-struct-optimized-enum.rs b/src/test/ui/packed/packed-struct-optimized-enum.rs deleted file mode 100644 index 5e1a1f518..000000000 --- a/src/test/ui/packed/packed-struct-optimized-enum.rs +++ /dev/null @@ -1,36 +0,0 @@ -// run-pass -#[repr(packed)] -struct Packed<T: Copy>(#[allow(unused_tuple_struct_fields)] T); - -impl<T: Copy> Copy for Packed<T> {} -impl<T: Copy> Clone for Packed<T> { - fn clone(&self) -> Self { *self } -} - -fn sanity_check_size<T: Copy>(one: T) { - let two = [one, one]; - let stride = (&two[1] as *const _ as usize) - (&two[0] as *const _ as usize); - let (size, align) = (std::mem::size_of::<T>(), std::mem::align_of::<T>()); - assert_eq!(stride, size); - assert_eq!(size % align, 0); -} - -fn main() { - // This can fail if rustc and LLVM disagree on the size of a type. - // In this case, `Option<Packed<(&(), u32)>>` was erroneously not - // marked as packed despite needing alignment `1` and containing - // its `&()` discriminant, which has alignment larger than `1`. - sanity_check_size((Some(Packed((&(), 0))), true)); - - // In #46769, `Option<(Packed<&()>, bool)>` was found to have - // pointer alignment, without actually being aligned in size. - // e.g., on 64-bit platforms, it had alignment `8` but size `9`. - type PackedRefAndBool<'a> = (Packed<&'a ()>, bool); - sanity_check_size::<Option<PackedRefAndBool>>(Some((Packed(&()), true))); - - // Make sure we don't pay for the enum optimization in size, - // e.g., we shouldn't need extra padding after the packed data. - assert_eq!(std::mem::align_of::<Option<PackedRefAndBool>>(), 1); - assert_eq!(std::mem::size_of::<Option<PackedRefAndBool>>(), - std::mem::size_of::<PackedRefAndBool>()); -} diff --git a/src/test/ui/packed/packed-struct-size-xc.rs b/src/test/ui/packed/packed-struct-size-xc.rs deleted file mode 100644 index 46112d51d..000000000 --- a/src/test/ui/packed/packed-struct-size-xc.rs +++ /dev/null @@ -1,20 +0,0 @@ -// run-pass -// aux-build:packed.rs - - -extern crate packed; - -use std::mem; - -macro_rules! check { - ($t:ty, $align:expr, $size:expr) => ({ - assert_eq!(mem::align_of::<$t>(), $align); - assert_eq!(mem::size_of::<$t>(), $size); - }); -} - -pub fn main() { - check!(packed::P1S5, 1, 5); - check!(packed::P2S6, 2, 6); - check!(packed::P2CS8, 2, 8); -} diff --git a/src/test/ui/packed/packed-struct-size.rs b/src/test/ui/packed/packed-struct-size.rs deleted file mode 100644 index c832c7cfa..000000000 --- a/src/test/ui/packed/packed-struct-size.rs +++ /dev/null @@ -1,157 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(non_camel_case_types)] -#![allow(non_upper_case_globals)] - -use std::mem; - -#[repr(packed)] -struct P1S4 { - a: u8, - b: [u8; 3], -} - -#[repr(packed(2))] -struct P2S4 { - a: u8, - b: [u8; 3], -} - -#[repr(packed)] -struct P1S5 { - a: u8, - b: u32 -} - -#[repr(packed(2))] -struct P2S2 { - a: u8, - b: u8 -} - -#[repr(packed(2))] -struct P2S6 { - a: u8, - b: u32 -} - -#[repr(packed(2))] -struct P2S12 { - a: u32, - b: u64 -} - -#[repr(packed)] -struct P1S13 { - a: i64, - b: f32, - c: u8, -} - -#[repr(packed(2))] -struct P2S14 { - a: i64, - b: f32, - c: u8, -} - -#[repr(packed(4))] -struct P4S16 { - a: u8, - b: f32, - c: i64, - d: u16, -} - -#[repr(C, packed(4))] -struct P4CS20 { - a: u8, - b: f32, - c: i64, - d: u16, -} - -enum Foo { - Bar = 1, - Baz = 2 -} - -#[repr(packed)] -struct P1S3_Foo { - a: u8, - b: u16, - c: Foo -} - -#[repr(packed(2))] -struct P2_Foo { - a: Foo, -} - -#[repr(packed(2))] -struct P2S3_Foo { - a: u8, - b: u16, - c: Foo -} - -#[repr(packed)] -struct P1S7_Option { - a: f32, - b: u8, - c: u16, - d: Option<Box<f64>> -} - -#[repr(packed(2))] -struct P2_Option { - a: Option<Box<f64>> -} - -#[repr(packed(2))] -struct P2S7_Option { - a: f32, - b: u8, - c: u16, - d: Option<Box<f64>> -} - -// Placing packed structs in statics should work -static TEST_P1S4: P1S4 = P1S4 { a: 1, b: [2, 3, 4] }; -static TEST_P1S5: P1S5 = P1S5 { a: 3, b: 67 }; -static TEST_P1S3_Foo: P1S3_Foo = P1S3_Foo { a: 1, b: 2, c: Foo::Baz }; -static TEST_P2S2: P2S2 = P2S2 { a: 1, b: 2 }; -static TEST_P2S4: P2S4 = P2S4 { a: 1, b: [2, 3, 4] }; -static TEST_P2S6: P2S6 = P2S6 { a: 1, b: 2 }; -static TEST_P2S12: P2S12 = P2S12 { a: 1, b: 2 }; -static TEST_P4S16: P4S16 = P4S16 { a: 1, b: 2.0, c: 3, d: 4 }; -static TEST_P4CS20: P4CS20 = P4CS20 { a: 1, b: 2.0, c: 3, d: 4 }; - -fn align_to(value: usize, align: usize) -> usize { - (value + (align - 1)) & !(align - 1) -} - -macro_rules! check { - ($t:ty, $align:expr, $size:expr) => ({ - assert_eq!(mem::align_of::<$t>(), $align); - assert_eq!(mem::size_of::<$t>(), $size); - }); -} - -pub fn main() { - check!(P1S4, 1, 4); - check!(P1S5, 1, 5); - check!(P1S13, 1, 13); - check!(P1S3_Foo, 1, 3 + mem::size_of::<Foo>()); - check!(P1S7_Option, 1, 7 + mem::size_of::<Option<Box<f64>>>()); - - check!(P2S2, 1, 2); - check!(P2S4, 1, 4); - check!(P2S6, 2, 6); - check!(P2S12, 2, 12); - check!(P2S14, 2, 14); - check!(P4S16, 4, 16); - check!(P4CS20, 4, 20); - check!(P2S3_Foo, 2, align_to(3 + mem::size_of::<P2_Foo>(), 2)); - check!(P2S7_Option, 2, align_to(7 + mem::size_of::<P2_Option>(), 2)); -} diff --git a/src/test/ui/packed/packed-struct-vec.rs b/src/test/ui/packed/packed-struct-vec.rs deleted file mode 100644 index 18676cfc2..000000000 --- a/src/test/ui/packed/packed-struct-vec.rs +++ /dev/null @@ -1,120 +0,0 @@ -// run-pass - -use std::fmt; -use std::mem; - -#[repr(packed)] -#[derive(Copy, Clone)] -struct Foo1 { - bar: u8, - baz: u64 -} - -impl PartialEq for Foo1 { - fn eq(&self, other: &Foo1) -> bool { - self.bar == other.bar && self.baz == other.baz - } -} - -impl fmt::Debug for Foo1 { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let bar = self.bar; - let baz = self.baz; - - f.debug_struct("Foo1") - .field("bar", &bar) - .field("baz", &baz) - .finish() - } -} - -#[repr(packed(2))] -#[derive(Copy, Clone)] -struct Foo2 { - bar: u8, - baz: u64 -} - -impl PartialEq for Foo2 { - fn eq(&self, other: &Foo2) -> bool { - self.bar == other.bar && self.baz == other.baz - } -} - -impl fmt::Debug for Foo2 { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let bar = self.bar; - let baz = self.baz; - - f.debug_struct("Foo2") - .field("bar", &bar) - .field("baz", &baz) - .finish() - } -} - -#[repr(C, packed(4))] -#[derive(Copy, Clone)] -struct Foo4C { - bar: u8, - baz: u64 -} - -impl PartialEq for Foo4C { - fn eq(&self, other: &Foo4C) -> bool { - self.bar == other.bar && self.baz == other.baz - } -} - -impl fmt::Debug for Foo4C { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let bar = self.bar; - let baz = self.baz; - - f.debug_struct("Foo4C") - .field("bar", &bar) - .field("baz", &baz) - .finish() - } -} - -pub fn main() { - let foo1s = [Foo1 { bar: 1, baz: 2 }; 10]; - - assert_eq!(mem::align_of::<[Foo1; 10]>(), 1); - assert_eq!(mem::size_of::<[Foo1; 10]>(), 90); - - for i in 0..10 { - assert_eq!(foo1s[i], Foo1 { bar: 1, baz: 2}); - } - - for &foo in &foo1s { - assert_eq!(foo, Foo1 { bar: 1, baz: 2 }); - } - - let foo2s = [Foo2 { bar: 1, baz: 2 }; 10]; - - assert_eq!(mem::align_of::<[Foo2; 10]>(), 2); - assert_eq!(mem::size_of::<[Foo2; 10]>(), 100); - - for i in 0..10 { - assert_eq!(foo2s[i], Foo2 { bar: 1, baz: 2}); - } - - for &foo in &foo2s { - assert_eq!(foo, Foo2 { bar: 1, baz: 2 }); - } - - let foo4s = [Foo4C { bar: 1, baz: 2 }; 10]; - - assert_eq!(mem::align_of::<[Foo4C; 10]>(), 4); - assert_eq!(mem::size_of::<[Foo4C; 10]>(), 120); - - for i in 0..10 { - assert_eq!(foo4s[i], Foo4C { bar: 1, baz: 2}); - } - - for &foo in &foo4s { - assert_eq!(foo, Foo4C { bar: 1, baz: 2 }); - } -} diff --git a/src/test/ui/packed/packed-tuple-struct-layout.rs b/src/test/ui/packed/packed-tuple-struct-layout.rs deleted file mode 100644 index 931be5b94..000000000 --- a/src/test/ui/packed/packed-tuple-struct-layout.rs +++ /dev/null @@ -1,23 +0,0 @@ -// run-pass -use std::mem; - -#[repr(packed)] -#[allow(unused_tuple_struct_fields)] -struct S4(u8,[u8; 3]); - -#[repr(packed)] -#[allow(unused_tuple_struct_fields)] -struct S5(u8,u32); - -pub fn main() { - unsafe { - let s4 = S4(1, [2,3,4]); - let transd : [u8; 4] = mem::transmute(s4); - assert_eq!(transd, [1, 2, 3, 4]); - - let s5 = S5(1, 0xff_00_00_ff); - let transd : [u8; 5] = mem::transmute(s5); - // Don't worry about endianness, the u32 is palindromic. - assert_eq!(transd, [1, 0xff, 0, 0, 0xff]); - } -} diff --git a/src/test/ui/packed/packed-tuple-struct-size.rs b/src/test/ui/packed/packed-tuple-struct-size.rs deleted file mode 100644 index f7a3c903f..000000000 --- a/src/test/ui/packed/packed-tuple-struct-size.rs +++ /dev/null @@ -1,79 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(non_camel_case_types)] - -use std::mem; - -#[repr(packed)] -struct P1S4(u8,[u8; 3]); - -#[repr(packed(2))] -struct P2S4(u8,[u8; 3]); - -#[repr(packed)] -struct P1S5(u8, u32); - -#[repr(packed(2))] -struct P2S6(u8, u32); - -#[repr(packed)] -struct P1S13(i64, f32, u8); - -#[repr(packed(2))] -struct P2S14(i64, f32, u8); - -#[repr(packed(4))] -struct P4S16(u8, f32, i64, u16); - -#[repr(C, packed(4))] -struct P4CS20(u8, f32, i64, u16); - -enum Foo { - Bar = 1, - Baz = 2 -} - -#[repr(packed)] -struct P1S3_Foo(u8, u16, Foo); - -#[repr(packed(2))] -struct P2_Foo(Foo); - -#[repr(packed(2))] -struct P2S3_Foo(u8, u16, Foo); - -#[repr(packed)] -struct P1S7_Option(f32, u8, u16, Option<Box<f64>>); - -#[repr(packed(2))] -struct P2_Option(Option<Box<f64>>); - -#[repr(packed(2))] -struct P2S7_Option(f32, u8, u16, Option<Box<f64>>); - -fn align_to(value: usize, align: usize) -> usize { - (value + (align - 1)) & !(align - 1) -} - -macro_rules! check { - ($t:ty, $align:expr, $size:expr) => ({ - assert_eq!(mem::align_of::<$t>(), $align); - assert_eq!(mem::size_of::<$t>(), $size); - }); -} - -pub fn main() { - check!(P1S4, 1, 4); - check!(P1S5, 1, 5); - check!(P1S13, 1, 13); - check!(P1S3_Foo, 1, 3 + mem::size_of::<Foo>()); - check!(P1S7_Option, 1, 7 + mem::size_of::<Option<Box<f64>>>()); - - check!(P2S4, 1, 4); - check!(P2S6, 2, 6); - check!(P2S14, 2, 14); - check!(P4S16, 4, 16); - check!(P4CS20, 4, 20); - check!(P2S3_Foo, 2, align_to(3 + mem::size_of::<P2_Foo>(), 2)); - check!(P2S7_Option, 2, align_to(7 + mem::size_of::<P2_Option>(), 2)); -} diff --git a/src/test/ui/packed/packed-with-inference-vars-issue-61402.rs b/src/test/ui/packed/packed-with-inference-vars-issue-61402.rs deleted file mode 100644 index 659864c1d..000000000 --- a/src/test/ui/packed/packed-with-inference-vars-issue-61402.rs +++ /dev/null @@ -1,22 +0,0 @@ -// run-pass -// If a struct is packed and its last field has drop glue, then that -// field needs to be Sized (to allow it to be destroyed out-of-place). -// -// This is checked by the compiler during wfcheck. That check used -// to have problems with associated types in the last field - test -// that this doesn't ICE. - -#![allow(unused_imports, dead_code)] - -pub struct S; - -pub trait Trait<R> { type Assoc; } - -impl<X> Trait<X> for S { type Assoc = X; } - -#[repr(C, packed)] -struct PackedAssocSized { - pos: Box<<S as Trait<usize>>::Assoc>, -} - -fn main() { println!("Hello, world!"); } |