2020-05-16 14:17:07 +00:00
|
|
|
#[repr(packed)]
|
|
|
|
pub struct Good {
|
2020-05-27 18:31:17 +00:00
|
|
|
data: u64,
|
|
|
|
ptr: &'static u64,
|
|
|
|
data2: [u64; 2],
|
2020-05-16 14:17:07 +00:00
|
|
|
aligned: [u8; 32],
|
|
|
|
}
|
|
|
|
|
2021-03-28 10:50:20 +00:00
|
|
|
#[repr(packed(2))]
|
|
|
|
pub struct Packed2 {
|
|
|
|
x: u32,
|
|
|
|
y: u16,
|
|
|
|
z: u8,
|
|
|
|
}
|
|
|
|
|
2023-02-16 17:17:55 +00:00
|
|
|
trait Foo {
|
|
|
|
fn evil(&self);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test for #108122
|
|
|
|
#[automatically_derived]
|
|
|
|
impl Foo for Packed2 {
|
|
|
|
fn evil(&self) {
|
|
|
|
unsafe {
|
|
|
|
&self.x; //~ ERROR reference to packed field
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-16 14:17:07 +00:00
|
|
|
fn main() {
|
|
|
|
unsafe {
|
2020-05-27 18:31:17 +00:00
|
|
|
let good = Good { data: 0, ptr: &0, data2: [0, 0], aligned: [0; 32] };
|
2020-05-16 14:17:07 +00:00
|
|
|
|
2020-05-27 18:31:17 +00:00
|
|
|
let _ = &good.ptr; //~ ERROR reference to packed field
|
2020-05-16 14:17:07 +00:00
|
|
|
let _ = &good.data; //~ ERROR reference to packed field
|
2020-05-27 18:31:17 +00:00
|
|
|
// Error even when turned into raw pointer immediately.
|
2020-05-25 09:15:38 +00:00
|
|
|
let _ = &good.data as *const _; //~ ERROR reference to packed field
|
|
|
|
let _: *const _ = &good.data; //~ ERROR reference to packed field
|
2020-05-27 18:31:17 +00:00
|
|
|
// Error on method call.
|
|
|
|
let _ = good.data.clone(); //~ ERROR reference to packed field
|
|
|
|
// Error for nested fields.
|
2020-05-16 14:17:07 +00:00
|
|
|
let _ = &good.data2[0]; //~ ERROR reference to packed field
|
2020-05-27 18:31:17 +00:00
|
|
|
|
|
|
|
let _ = &*good.ptr; // ok, behind a pointer
|
2020-05-16 14:17:07 +00:00
|
|
|
let _ = &good.aligned; // ok, has align 1
|
|
|
|
let _ = &good.aligned[2]; // ok, has align 1
|
|
|
|
}
|
2021-03-28 10:50:20 +00:00
|
|
|
|
|
|
|
unsafe {
|
|
|
|
let packed2 = Packed2 { x: 0, y: 0, z: 0 };
|
|
|
|
let _ = &packed2.x; //~ ERROR reference to packed field
|
|
|
|
let _ = &packed2.y; // ok, has align 2 in packed(2) struct
|
|
|
|
let _ = &packed2.z; // ok, has align 1
|
2023-02-16 17:17:55 +00:00
|
|
|
packed2.evil();
|
2021-03-28 10:50:20 +00:00
|
|
|
}
|
2022-08-02 16:21:38 +00:00
|
|
|
|
|
|
|
unsafe {
|
|
|
|
struct U16(u16);
|
|
|
|
|
|
|
|
impl Drop for U16 {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
println!("{:p}", self);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct HasDrop;
|
|
|
|
|
|
|
|
impl Drop for HasDrop {
|
|
|
|
fn drop(&mut self) {}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(unused)]
|
|
|
|
struct Wrapper {
|
|
|
|
a: U16,
|
|
|
|
b: HasDrop,
|
|
|
|
}
|
|
|
|
#[allow(unused)]
|
|
|
|
#[repr(packed(2))]
|
|
|
|
struct Wrapper2 {
|
|
|
|
a: U16,
|
|
|
|
b: HasDrop,
|
|
|
|
}
|
|
|
|
|
|
|
|
// An outer struct with more restrictive packing than the inner struct -- make sure we
|
|
|
|
// notice that!
|
|
|
|
#[repr(packed)]
|
|
|
|
struct Misalign<T>(u8, T);
|
|
|
|
|
2023-02-16 17:17:55 +00:00
|
|
|
let m1 = Misalign(0, Wrapper { a: U16(10), b: HasDrop });
|
2022-08-02 16:21:38 +00:00
|
|
|
let _ref = &m1.1.a; //~ ERROR reference to packed field
|
|
|
|
|
2023-02-16 17:17:55 +00:00
|
|
|
let m2 = Misalign(0, Wrapper2 { a: U16(10), b: HasDrop });
|
2022-08-02 16:21:38 +00:00
|
|
|
let _ref = &m2.1.a; //~ ERROR reference to packed field
|
|
|
|
}
|
2020-05-16 14:17:07 +00:00
|
|
|
}
|