Skip to content

Commit a9fc586

Browse files
borsbors
committed
Auto merge of #115583 - RalfJung:packed-unsized, r=<try>
fix detecting references to packed unsized fields Fixes #115396 This is a breaking change, but permitted as a soundness fix.
2 parents 5f6ee65 + ad7045e commit a9fc586

File tree

3 files changed

+73
-12
lines changed

3 files changed

+73
-12
lines changed

‎compiler/rustc_const_eval/src/util/alignment.rs

+9-1
Original file line numberDiff line numberDiff line change
@@ -21,10 +21,18 @@ where
2121
};
2222

2323
let ty = place.ty(local_decls, tcx).ty;
24+
let unsized_tail = || tcx.struct_tail_with_normalize(ty, |ty| ty, || {});
2425
match tcx.layout_of(param_env.and(ty)) {
25-
Ok(layout) if layout.align.abi <= pack => {
26+
Ok(layout)
27+
if layout.align.abi <= pack
28+
&& (layout.is_sized()
29+
|| matches!(unsized_tail().kind(), ty::Slice(..) | ty::Str)) =>
30+
{
2631
// If the packed alignment is greater or equal to the field alignment, the type won't be
2732
// further disaligned.
33+
// However we need to ensure the field is sized; for unsized fields, `layout.align` is
34+
// just an approximation -- except when the unsized tail is a slice, where the alignment
35+
// is fully determined by the type.
2836
debug!(
2937
"is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
3038
place,

‎tests/ui/lint/unaligned_references.rs

+23
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,6 @@
1+
use std::mem::ManuallyDrop;
2+
use std::fmt::Debug;
3+
14
#[repr(packed)]
25
pub struct Good {
36
data: u64,
@@ -27,6 +30,26 @@ impl Foo for Packed2 {
2730
}
2831
}
2932

33+
// Test for #115396
34+
fn packed_dyn() {
35+
#[repr(packed)]
36+
struct Unaligned<T: ?Sized>(ManuallyDrop<T>);
37+
38+
let ref local = Unaligned(ManuallyDrop::new([3, 5, 8u64]));
39+
let foo: &Unaligned<dyn Debug> = &*local;
40+
println!("{:?}", &*foo.0); //~ ERROR reference to packed field
41+
let foo: &Unaligned<[u64]> = &*local;
42+
println!("{:?}", &*foo.0); //~ ERROR reference to packed field
43+
44+
// Even if the actual alignment is 1, we cannot know that when looking at `dyn Debug.`
45+
let ref local = Unaligned(ManuallyDrop::new([3, 5, 8u8]));
46+
let foo: &Unaligned<dyn Debug> = &*local;
47+
println!("{:?}", &*foo.0); //~ ERROR reference to packed field
48+
// However, we *can* know the alignment when looking at a slice.
49+
let foo: &Unaligned<[u8]> = &*local;
50+
println!("{:?}", &*foo.0); // no error!
51+
}
52+
3053
fn main() {
3154
unsafe {
3255
let good = Good { data: 0, ptr: &0, data2: [0, 0], aligned: [0; 32] };

‎tests/ui/lint/unaligned_references.stderr

+41-11
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
error[E0793]: reference to packed field is unaligned
2-
--> $DIR/unaligned_references.rs:25:13
2+
--> $DIR/unaligned_references.rs:28:13
33
|
44
LL | &self.x;
55
| ^^^^^^^
@@ -9,7 +9,37 @@ LL | &self.x;
99
= 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)
1010

1111
error[E0793]: reference to packed field is unaligned
12-
--> $DIR/unaligned_references.rs:34:17
12+
--> $DIR/unaligned_references.rs:40:24
13+
|
14+
LL | println!("{:?}", &*foo.0);
15+
| ^^^^^
16+
|
17+
= note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
18+
= note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
19+
= 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)
20+
21+
error[E0793]: reference to packed field is unaligned
22+
--> $DIR/unaligned_references.rs:42:24
23+
|
24+
LL | println!("{:?}", &*foo.0);
25+
| ^^^^^
26+
|
27+
= note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
28+
= note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
29+
= 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)
30+
31+
error[E0793]: reference to packed field is unaligned
32+
--> $DIR/unaligned_references.rs:47:24
33+
|
34+
LL | println!("{:?}", &*foo.0);
35+
| ^^^^^
36+
|
37+
= note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
38+
= note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
39+
= 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)
40+
41+
error[E0793]: reference to packed field is unaligned
42+
--> $DIR/unaligned_references.rs:57:17
1343
|
1444
LL | let _ = &good.ptr;
1545
| ^^^^^^^^^
@@ -19,7 +49,7 @@ LL | let _ = &good.ptr;
1949
= 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)
2050

2151
error[E0793]: reference to packed field is unaligned
22-
--> $DIR/unaligned_references.rs:35:17
52+
--> $DIR/unaligned_references.rs:58:17
2353
|
2454
LL | let _ = &good.data;
2555
| ^^^^^^^^^^
@@ -29,7 +59,7 @@ LL | let _ = &good.data;
2959
= 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)
3060

3161
error[E0793]: reference to packed field is unaligned
32-
--> $DIR/unaligned_references.rs:37:17
62+
--> $DIR/unaligned_references.rs:60:17
3363
|
3464
LL | let _ = &good.data as *const _;
3565
| ^^^^^^^^^^
@@ -39,7 +69,7 @@ LL | let _ = &good.data as *const _;
3969
= 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)
4070

4171
error[E0793]: reference to packed field is unaligned
42-
--> $DIR/unaligned_references.rs:38:27
72+
--> $DIR/unaligned_references.rs:61:27
4373
|
4474
LL | let _: *const _ = &good.data;
4575
| ^^^^^^^^^^
@@ -49,7 +79,7 @@ LL | let _: *const _ = &good.data;
4979
= 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)
5080

5181
error[E0793]: reference to packed field is unaligned
52-
--> $DIR/unaligned_references.rs:40:17
82+
--> $DIR/unaligned_references.rs:63:17
5383
|
5484
LL | let _ = good.data.clone();
5585
| ^^^^^^^^^
@@ -59,7 +89,7 @@ LL | let _ = good.data.clone();
5989
= 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)
6090

6191
error[E0793]: reference to packed field is unaligned
62-
--> $DIR/unaligned_references.rs:42:17
92+
--> $DIR/unaligned_references.rs:65:17
6393
|
6494
LL | let _ = &good.data2[0];
6595
| ^^^^^^^^^^^^^^
@@ -69,7 +99,7 @@ LL | let _ = &good.data2[0];
6999
= 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)
70100

71101
error[E0793]: reference to packed field is unaligned
72-
--> $DIR/unaligned_references.rs:51:17
102+
--> $DIR/unaligned_references.rs:74:17
73103
|
74104
LL | let _ = &packed2.x;
75105
| ^^^^^^^^^^
@@ -79,7 +109,7 @@ LL | let _ = &packed2.x;
79109
= 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)
80110

81111
error[E0793]: reference to packed field is unaligned
82-
--> $DIR/unaligned_references.rs:90:20
112+
--> $DIR/unaligned_references.rs:113:20
83113
|
84114
LL | let _ref = &m1.1.a;
85115
| ^^^^^^^
@@ -89,7 +119,7 @@ LL | let _ref = &m1.1.a;
89119
= 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)
90120

91121
error[E0793]: reference to packed field is unaligned
92-
--> $DIR/unaligned_references.rs:93:20
122+
--> $DIR/unaligned_references.rs:116:20
93123
|
94124
LL | let _ref = &m2.1.a;
95125
| ^^^^^^^
@@ -98,6 +128,6 @@ LL | let _ref = &m2.1.a;
98128
= note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
99129
= 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)
100130

101-
error: aborting due to 10 previous errors
131+
error: aborting due to 13 previous errors
102132

103133
For more information about this error, try `rustc --explain E0793`.

0 commit comments

Comments
 (0)