Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit aa05458

Browse files
cjgillotcjgillot
committedJan 18, 2024
Split gvn wide ptr tests.
1 parent cf3ad0e commit aa05458

8 files changed

+894
-799
lines changed
 

‎compiler/rustc_mir_transform/src/gvn.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1042,6 +1042,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
10421042

10431043
let mut from = operand.ty(self.local_decls, self.tcx);
10441044
let mut value = self.simplify_operand(operand, location)?;
1045+
if from == to {
1046+
return Some(value);
1047+
}
10451048

10461049
if let CastKind::PointerCoercion(ReifyFnPointer | ClosureFnPointer(_)) = kind {
10471050
// Each reification of a generic fn may get a different pointer.

‎tests/mir-opt/gvn.rs

Lines changed: 43 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -644,25 +644,53 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
644644
opaque(b)
645645
}
646646

647-
fn wide_ptr_ops() {
647+
/// Check that we do not attempt to simplify anything when there is provenance.
648+
fn wide_ptr_provenance() {
649+
// CHECK-LABEL: fn wide_ptr_provenance(
648650
let a: *const dyn Send = &1 as &dyn Send;
649651
let b: *const dyn Send = &1 as &dyn Send;
650-
let _val = a == b;
651-
let _val = a != b;
652-
let _val = a < b;
653-
let _val = a <= b;
654-
let _val = a > b;
655-
let _val = a >= b;
652+
653+
// CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
654+
// CHECK: opaque::<bool>(move [[eqp]])
655+
opaque(a == b);
656+
// CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
657+
// CHECK: opaque::<bool>(move [[nep]])
658+
opaque(a != b);
659+
// CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
660+
// CHECK: opaque::<bool>(move [[ltp]])
661+
opaque(a < b);
662+
// CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
663+
// CHECK: opaque::<bool>(move [[lep]])
664+
opaque(a <= b);
665+
// CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
666+
// CHECK: opaque::<bool>(move [[gtp]])
667+
opaque(a > b);
668+
// CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
669+
// CHECK: opaque::<bool>(move [[gep]])
670+
opaque(a >= b);
671+
}
672+
673+
/// Check that we do simplify when there is no provenance, and do not ICE.
674+
fn wide_ptr_integer() {
675+
// CHECK-LABEL: fn wide_ptr_integer(
676+
// CHECK: debug a => [[a:_.*]];
677+
// CHECK: debug b => [[b:_.*]];
656678

657679
let a: *const [u8] = unsafe { transmute((1usize, 1usize)) };
658680
let b: *const [u8] = unsafe { transmute((1usize, 2usize)) };
659681

660-
opaque(!(a == b));
682+
// CHECK: opaque::<bool>(const false)
683+
opaque(a == b);
684+
// CHECK: opaque::<bool>(const true)
661685
opaque(a != b);
662-
opaque(a <= b);
686+
// CHECK: opaque::<bool>(const true)
663687
opaque(a < b);
664-
opaque(!(a >= b));
665-
opaque(!(a > b));
688+
// CHECK: opaque::<bool>(const true)
689+
opaque(a <= b);
690+
// CHECK: opaque::<bool>(const false)
691+
opaque(a > b);
692+
// CHECK: opaque::<bool>(const false)
693+
opaque(a >= b);
666694
}
667695

668696
fn main() {
@@ -685,7 +713,8 @@ fn main() {
685713
fn_pointers();
686714
indirect_static();
687715
constant_index_overflow(&[5, 3]);
688-
wide_ptr_ops();
716+
wide_ptr_provenance();
717+
wide_ptr_integer();
689718
}
690719

691720
#[inline(never)]
@@ -714,4 +743,5 @@ fn identity<T>(x: T) -> T {
714743
// EMIT_MIR gvn.fn_pointers.GVN.diff
715744
// EMIT_MIR gvn.indirect_static.GVN.diff
716745
// EMIT_MIR gvn.constant_index_overflow.GVN.diff
717-
// EMIT_MIR gvn.wide_ptr_ops.GVN.diff
746+
// EMIT_MIR gvn.wide_ptr_provenance.GVN.diff
747+
// EMIT_MIR gvn.wide_ptr_integer.GVN.diff

‎tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff

Lines changed: 192 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,192 @@
1+
- // MIR for `wide_ptr_integer` before GVN
2+
+ // MIR for `wide_ptr_integer` after GVN
3+
4+
fn wide_ptr_integer() -> () {
5+
let mut _0: ();
6+
let _1: *const [u8];
7+
let mut _2: (usize, usize);
8+
let mut _4: (usize, usize);
9+
let _5: ();
10+
let mut _6: bool;
11+
let mut _7: *const [u8];
12+
let mut _8: *const [u8];
13+
let _9: ();
14+
let mut _10: bool;
15+
let mut _11: *const [u8];
16+
let mut _12: *const [u8];
17+
let _13: ();
18+
let mut _14: bool;
19+
let mut _15: *const [u8];
20+
let mut _16: *const [u8];
21+
let _17: ();
22+
let mut _18: bool;
23+
let mut _19: *const [u8];
24+
let mut _20: *const [u8];
25+
let _21: ();
26+
let mut _22: bool;
27+
let mut _23: *const [u8];
28+
let mut _24: *const [u8];
29+
let _25: ();
30+
let mut _26: bool;
31+
let mut _27: *const [u8];
32+
let mut _28: *const [u8];
33+
scope 1 {
34+
debug a => _1;
35+
let _3: *const [u8];
36+
scope 3 {
37+
debug b => _3;
38+
}
39+
scope 4 {
40+
}
41+
}
42+
scope 2 {
43+
}
44+
45+
bb0: {
46+
- StorageLive(_1);
47+
+ nop;
48+
StorageLive(_2);
49+
- _2 = (const 1_usize, const 1_usize);
50+
- _1 = move _2 as *const [u8] (Transmute);
51+
+ _2 = const (1_usize, 1_usize);
52+
+ _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
53+
StorageDead(_2);
54+
- StorageLive(_3);
55+
+ nop;
56+
StorageLive(_4);
57+
- _4 = (const 1_usize, const 2_usize);
58+
- _3 = move _4 as *const [u8] (Transmute);
59+
+ _4 = const (1_usize, 2_usize);
60+
+ _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
61+
StorageDead(_4);
62+
StorageLive(_5);
63+
StorageLive(_6);
64+
StorageLive(_7);
65+
- _7 = _1;
66+
+ _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
67+
StorageLive(_8);
68+
- _8 = _3;
69+
- _6 = Eq(move _7, move _8);
70+
+ _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
71+
+ _6 = const false;
72+
StorageDead(_8);
73+
StorageDead(_7);
74+
- _5 = opaque::<bool>(move _6) -> [return: bb1, unwind unreachable];
75+
+ _5 = opaque::<bool>(const false) -> [return: bb1, unwind unreachable];
76+
}
77+
78+
bb1: {
79+
StorageDead(_6);
80+
StorageDead(_5);
81+
StorageLive(_9);
82+
StorageLive(_10);
83+
StorageLive(_11);
84+
- _11 = _1;
85+
+ _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
86+
StorageLive(_12);
87+
- _12 = _3;
88+
- _10 = Ne(move _11, move _12);
89+
+ _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
90+
+ _10 = const true;
91+
StorageDead(_12);
92+
StorageDead(_11);
93+
- _9 = opaque::<bool>(move _10) -> [return: bb2, unwind unreachable];
94+
+ _9 = opaque::<bool>(const true) -> [return: bb2, unwind unreachable];
95+
}
96+
97+
bb2: {
98+
StorageDead(_10);
99+
StorageDead(_9);
100+
StorageLive(_13);
101+
StorageLive(_14);
102+
StorageLive(_15);
103+
- _15 = _1;
104+
+ _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
105+
StorageLive(_16);
106+
- _16 = _3;
107+
- _14 = Lt(move _15, move _16);
108+
+ _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
109+
+ _14 = const true;
110+
StorageDead(_16);
111+
StorageDead(_15);
112+
- _13 = opaque::<bool>(move _14) -> [return: bb3, unwind unreachable];
113+
+ _13 = opaque::<bool>(const true) -> [return: bb3, unwind unreachable];
114+
}
115+
116+
bb3: {
117+
StorageDead(_14);
118+
StorageDead(_13);
119+
StorageLive(_17);
120+
StorageLive(_18);
121+
StorageLive(_19);
122+
- _19 = _1;
123+
+ _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
124+
StorageLive(_20);
125+
- _20 = _3;
126+
- _18 = Le(move _19, move _20);
127+
+ _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
128+
+ _18 = const true;
129+
StorageDead(_20);
130+
StorageDead(_19);
131+
- _17 = opaque::<bool>(move _18) -> [return: bb4, unwind unreachable];
132+
+ _17 = opaque::<bool>(const true) -> [return: bb4, unwind unreachable];
133+
}
134+
135+
bb4: {
136+
StorageDead(_18);
137+
StorageDead(_17);
138+
StorageLive(_21);
139+
StorageLive(_22);
140+
StorageLive(_23);
141+
- _23 = _1;
142+
+ _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
143+
StorageLive(_24);
144+
- _24 = _3;
145+
- _22 = Gt(move _23, move _24);
146+
+ _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
147+
+ _22 = const false;
148+
StorageDead(_24);
149+
StorageDead(_23);
150+
- _21 = opaque::<bool>(move _22) -> [return: bb5, unwind unreachable];
151+
+ _21 = opaque::<bool>(const false) -> [return: bb5, unwind unreachable];
152+
}
153+
154+
bb5: {
155+
StorageDead(_22);
156+
StorageDead(_21);
157+
StorageLive(_25);
158+
StorageLive(_26);
159+
StorageLive(_27);
160+
- _27 = _1;
161+
+ _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
162+
StorageLive(_28);
163+
- _28 = _3;
164+
- _26 = Ge(move _27, move _28);
165+
+ _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
166+
+ _26 = const false;
167+
StorageDead(_28);
168+
StorageDead(_27);
169+
- _25 = opaque::<bool>(move _26) -> [return: bb6, unwind unreachable];
170+
+ _25 = opaque::<bool>(const false) -> [return: bb6, unwind unreachable];
171+
}
172+
173+
bb6: {
174+
StorageDead(_26);
175+
StorageDead(_25);
176+
_0 = const ();
177+
- StorageDead(_3);
178+
- StorageDead(_1);
179+
+ nop;
180+
+ nop;
181+
return;
182+
}
183+
+ }
184+
+
185+
+ ALLOC1 (size: 16, align: 8) {
186+
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
187+
+ }
188+
+
189+
+ ALLOC0 (size: 16, align: 8) {
190+
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
191+
}
192+

‎tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff

Lines changed: 192 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,192 @@
1+
- // MIR for `wide_ptr_integer` before GVN
2+
+ // MIR for `wide_ptr_integer` after GVN
3+
4+
fn wide_ptr_integer() -> () {
5+
let mut _0: ();
6+
let _1: *const [u8];
7+
let mut _2: (usize, usize);
8+
let mut _4: (usize, usize);
9+
let _5: ();
10+
let mut _6: bool;
11+
let mut _7: *const [u8];
12+
let mut _8: *const [u8];
13+
let _9: ();
14+
let mut _10: bool;
15+
let mut _11: *const [u8];
16+
let mut _12: *const [u8];
17+
let _13: ();
18+
let mut _14: bool;
19+
let mut _15: *const [u8];
20+
let mut _16: *const [u8];
21+
let _17: ();
22+
let mut _18: bool;
23+
let mut _19: *const [u8];
24+
let mut _20: *const [u8];
25+
let _21: ();
26+
let mut _22: bool;
27+
let mut _23: *const [u8];
28+
let mut _24: *const [u8];
29+
let _25: ();
30+
let mut _26: bool;
31+
let mut _27: *const [u8];
32+
let mut _28: *const [u8];
33+
scope 1 {
34+
debug a => _1;
35+
let _3: *const [u8];
36+
scope 3 {
37+
debug b => _3;
38+
}
39+
scope 4 {
40+
}
41+
}
42+
scope 2 {
43+
}
44+
45+
bb0: {
46+
- StorageLive(_1);
47+
+ nop;
48+
StorageLive(_2);
49+
- _2 = (const 1_usize, const 1_usize);
50+
- _1 = move _2 as *const [u8] (Transmute);
51+
+ _2 = const (1_usize, 1_usize);
52+
+ _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
53+
StorageDead(_2);
54+
- StorageLive(_3);
55+
+ nop;
56+
StorageLive(_4);
57+
- _4 = (const 1_usize, const 2_usize);
58+
- _3 = move _4 as *const [u8] (Transmute);
59+
+ _4 = const (1_usize, 2_usize);
60+
+ _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
61+
StorageDead(_4);
62+
StorageLive(_5);
63+
StorageLive(_6);
64+
StorageLive(_7);
65+
- _7 = _1;
66+
+ _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
67+
StorageLive(_8);
68+
- _8 = _3;
69+
- _6 = Eq(move _7, move _8);
70+
+ _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
71+
+ _6 = const false;
72+
StorageDead(_8);
73+
StorageDead(_7);
74+
- _5 = opaque::<bool>(move _6) -> [return: bb1, unwind continue];
75+
+ _5 = opaque::<bool>(const false) -> [return: bb1, unwind continue];
76+
}
77+
78+
bb1: {
79+
StorageDead(_6);
80+
StorageDead(_5);
81+
StorageLive(_9);
82+
StorageLive(_10);
83+
StorageLive(_11);
84+
- _11 = _1;
85+
+ _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
86+
StorageLive(_12);
87+
- _12 = _3;
88+
- _10 = Ne(move _11, move _12);
89+
+ _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
90+
+ _10 = const true;
91+
StorageDead(_12);
92+
StorageDead(_11);
93+
- _9 = opaque::<bool>(move _10) -> [return: bb2, unwind continue];
94+
+ _9 = opaque::<bool>(const true) -> [return: bb2, unwind continue];
95+
}
96+
97+
bb2: {
98+
StorageDead(_10);
99+
StorageDead(_9);
100+
StorageLive(_13);
101+
StorageLive(_14);
102+
StorageLive(_15);
103+
- _15 = _1;
104+
+ _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
105+
StorageLive(_16);
106+
- _16 = _3;
107+
- _14 = Lt(move _15, move _16);
108+
+ _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
109+
+ _14 = const true;
110+
StorageDead(_16);
111+
StorageDead(_15);
112+
- _13 = opaque::<bool>(move _14) -> [return: bb3, unwind continue];
113+
+ _13 = opaque::<bool>(const true) -> [return: bb3, unwind continue];
114+
}
115+
116+
bb3: {
117+
StorageDead(_14);
118+
StorageDead(_13);
119+
StorageLive(_17);
120+
StorageLive(_18);
121+
StorageLive(_19);
122+
- _19 = _1;
123+
+ _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
124+
StorageLive(_20);
125+
- _20 = _3;
126+
- _18 = Le(move _19, move _20);
127+
+ _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
128+
+ _18 = const true;
129+
StorageDead(_20);
130+
StorageDead(_19);
131+
- _17 = opaque::<bool>(move _18) -> [return: bb4, unwind continue];
132+
+ _17 = opaque::<bool>(const true) -> [return: bb4, unwind continue];
133+
}
134+
135+
bb4: {
136+
StorageDead(_18);
137+
StorageDead(_17);
138+
StorageLive(_21);
139+
StorageLive(_22);
140+
StorageLive(_23);
141+
- _23 = _1;
142+
+ _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
143+
StorageLive(_24);
144+
- _24 = _3;
145+
- _22 = Gt(move _23, move _24);
146+
+ _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
147+
+ _22 = const false;
148+
StorageDead(_24);
149+
StorageDead(_23);
150+
- _21 = opaque::<bool>(move _22) -> [return: bb5, unwind continue];
151+
+ _21 = opaque::<bool>(const false) -> [return: bb5, unwind continue];
152+
}
153+
154+
bb5: {
155+
StorageDead(_22);
156+
StorageDead(_21);
157+
StorageLive(_25);
158+
StorageLive(_26);
159+
StorageLive(_27);
160+
- _27 = _1;
161+
+ _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
162+
StorageLive(_28);
163+
- _28 = _3;
164+
- _26 = Ge(move _27, move _28);
165+
+ _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
166+
+ _26 = const false;
167+
StorageDead(_28);
168+
StorageDead(_27);
169+
- _25 = opaque::<bool>(move _26) -> [return: bb6, unwind continue];
170+
+ _25 = opaque::<bool>(const false) -> [return: bb6, unwind continue];
171+
}
172+
173+
bb6: {
174+
StorageDead(_26);
175+
StorageDead(_25);
176+
_0 = const ();
177+
- StorageDead(_3);
178+
- StorageDead(_1);
179+
+ nop;
180+
+ nop;
181+
return;
182+
}
183+
+ }
184+
+
185+
+ ALLOC1 (size: 16, align: 8) {
186+
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
187+
+ }
188+
+
189+
+ ALLOC0 (size: 16, align: 8) {
190+
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
191+
}
192+

‎tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff

Lines changed: 0 additions & 393 deletions
This file was deleted.

‎tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff

Lines changed: 0 additions & 393 deletions
This file was deleted.

‎tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff

Lines changed: 232 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,232 @@
1+
- // MIR for `wide_ptr_provenance` before GVN
2+
+ // MIR for `wide_ptr_provenance` after GVN
3+
4+
fn wide_ptr_provenance() -> () {
5+
let mut _0: ();
6+
let _1: *const dyn std::marker::Send;
7+
let mut _2: *const dyn std::marker::Send;
8+
let _3: &dyn std::marker::Send;
9+
let mut _4: &i32;
10+
let _5: &i32;
11+
let _6: i32;
12+
let mut _8: *const dyn std::marker::Send;
13+
let _9: &dyn std::marker::Send;
14+
let mut _10: &i32;
15+
let _11: &i32;
16+
let _12: i32;
17+
let _13: ();
18+
let mut _14: bool;
19+
let mut _15: *const dyn std::marker::Send;
20+
let mut _16: *const dyn std::marker::Send;
21+
let mut _17: *const dyn std::marker::Send;
22+
let _18: ();
23+
let mut _19: bool;
24+
let mut _20: *const dyn std::marker::Send;
25+
let mut _21: *const dyn std::marker::Send;
26+
let mut _22: *const dyn std::marker::Send;
27+
let _23: ();
28+
let mut _24: bool;
29+
let mut _25: *const dyn std::marker::Send;
30+
let mut _26: *const dyn std::marker::Send;
31+
let mut _27: *const dyn std::marker::Send;
32+
let _28: ();
33+
let mut _29: bool;
34+
let mut _30: *const dyn std::marker::Send;
35+
let mut _31: *const dyn std::marker::Send;
36+
let mut _32: *const dyn std::marker::Send;
37+
let _33: ();
38+
let mut _34: bool;
39+
let mut _35: *const dyn std::marker::Send;
40+
let mut _36: *const dyn std::marker::Send;
41+
let mut _37: *const dyn std::marker::Send;
42+
let _38: ();
43+
let mut _39: bool;
44+
let mut _40: *const dyn std::marker::Send;
45+
let mut _41: *const dyn std::marker::Send;
46+
let mut _42: *const dyn std::marker::Send;
47+
let mut _44: &i32;
48+
scope 1 {
49+
debug a => _1;
50+
let _7: *const dyn std::marker::Send;
51+
let mut _43: &i32;
52+
scope 2 {
53+
debug b => _7;
54+
}
55+
}
56+
57+
bb0: {
58+
StorageLive(_1);
59+
- StorageLive(_2);
60+
+ nop;
61+
StorageLive(_3);
62+
StorageLive(_4);
63+
StorageLive(_5);
64+
_44 = const _;
65+
_5 = &(*_44);
66+
_4 = &(*_5);
67+
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
68+
StorageDead(_4);
69+
_2 = &raw const (*_3);
70+
- _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
71+
- StorageDead(_2);
72+
+ _1 = _2;
73+
+ nop;
74+
StorageDead(_5);
75+
StorageDead(_3);
76+
StorageLive(_7);
77+
- StorageLive(_8);
78+
+ nop;
79+
StorageLive(_9);
80+
StorageLive(_10);
81+
StorageLive(_11);
82+
_43 = const _;
83+
_11 = &(*_43);
84+
_10 = &(*_11);
85+
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
86+
StorageDead(_10);
87+
_8 = &raw const (*_9);
88+
- _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
89+
- StorageDead(_8);
90+
+ _7 = _8;
91+
+ nop;
92+
StorageDead(_11);
93+
StorageDead(_9);
94+
StorageLive(_13);
95+
StorageLive(_14);
96+
StorageLive(_15);
97+
- _15 = _1;
98+
+ _15 = _2;
99+
StorageLive(_16);
100+
StorageLive(_17);
101+
- _17 = _7;
102+
- _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
103+
+ _17 = _8;
104+
+ _16 = _8;
105+
StorageDead(_17);
106+
- _14 = Eq(move _15, move _16);
107+
+ _14 = Eq(_2, _8);
108+
StorageDead(_16);
109+
StorageDead(_15);
110+
_13 = opaque::<bool>(move _14) -> [return: bb1, unwind unreachable];
111+
}
112+
113+
bb1: {
114+
StorageDead(_14);
115+
StorageDead(_13);
116+
StorageLive(_18);
117+
StorageLive(_19);
118+
StorageLive(_20);
119+
- _20 = _1;
120+
+ _20 = _2;
121+
StorageLive(_21);
122+
StorageLive(_22);
123+
- _22 = _7;
124+
- _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
125+
+ _22 = _8;
126+
+ _21 = _8;
127+
StorageDead(_22);
128+
- _19 = Ne(move _20, move _21);
129+
+ _19 = Ne(_2, _8);
130+
StorageDead(_21);
131+
StorageDead(_20);
132+
_18 = opaque::<bool>(move _19) -> [return: bb2, unwind unreachable];
133+
}
134+
135+
bb2: {
136+
StorageDead(_19);
137+
StorageDead(_18);
138+
StorageLive(_23);
139+
StorageLive(_24);
140+
StorageLive(_25);
141+
- _25 = _1;
142+
+ _25 = _2;
143+
StorageLive(_26);
144+
StorageLive(_27);
145+
- _27 = _7;
146+
- _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
147+
+ _27 = _8;
148+
+ _26 = _8;
149+
StorageDead(_27);
150+
- _24 = Lt(move _25, move _26);
151+
+ _24 = Lt(_2, _8);
152+
StorageDead(_26);
153+
StorageDead(_25);
154+
_23 = opaque::<bool>(move _24) -> [return: bb3, unwind unreachable];
155+
}
156+
157+
bb3: {
158+
StorageDead(_24);
159+
StorageDead(_23);
160+
StorageLive(_28);
161+
StorageLive(_29);
162+
StorageLive(_30);
163+
- _30 = _1;
164+
+ _30 = _2;
165+
StorageLive(_31);
166+
StorageLive(_32);
167+
- _32 = _7;
168+
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
169+
+ _32 = _8;
170+
+ _31 = _8;
171+
StorageDead(_32);
172+
- _29 = Le(move _30, move _31);
173+
+ _29 = Le(_2, _8);
174+
StorageDead(_31);
175+
StorageDead(_30);
176+
_28 = opaque::<bool>(move _29) -> [return: bb4, unwind unreachable];
177+
}
178+
179+
bb4: {
180+
StorageDead(_29);
181+
StorageDead(_28);
182+
StorageLive(_33);
183+
StorageLive(_34);
184+
StorageLive(_35);
185+
- _35 = _1;
186+
+ _35 = _2;
187+
StorageLive(_36);
188+
StorageLive(_37);
189+
- _37 = _7;
190+
- _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
191+
+ _37 = _8;
192+
+ _36 = _8;
193+
StorageDead(_37);
194+
- _34 = Gt(move _35, move _36);
195+
+ _34 = Gt(_2, _8);
196+
StorageDead(_36);
197+
StorageDead(_35);
198+
_33 = opaque::<bool>(move _34) -> [return: bb5, unwind unreachable];
199+
}
200+
201+
bb5: {
202+
StorageDead(_34);
203+
StorageDead(_33);
204+
StorageLive(_38);
205+
StorageLive(_39);
206+
StorageLive(_40);
207+
- _40 = _1;
208+
+ _40 = _2;
209+
StorageLive(_41);
210+
StorageLive(_42);
211+
- _42 = _7;
212+
- _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
213+
+ _42 = _8;
214+
+ _41 = _8;
215+
StorageDead(_42);
216+
- _39 = Ge(move _40, move _41);
217+
+ _39 = Ge(_2, _8);
218+
StorageDead(_41);
219+
StorageDead(_40);
220+
_38 = opaque::<bool>(move _39) -> [return: bb6, unwind unreachable];
221+
}
222+
223+
bb6: {
224+
StorageDead(_39);
225+
StorageDead(_38);
226+
_0 = const ();
227+
StorageDead(_7);
228+
StorageDead(_1);
229+
return;
230+
}
231+
}
232+

‎tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff

Lines changed: 232 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,232 @@
1+
- // MIR for `wide_ptr_provenance` before GVN
2+
+ // MIR for `wide_ptr_provenance` after GVN
3+
4+
fn wide_ptr_provenance() -> () {
5+
let mut _0: ();
6+
let _1: *const dyn std::marker::Send;
7+
let mut _2: *const dyn std::marker::Send;
8+
let _3: &dyn std::marker::Send;
9+
let mut _4: &i32;
10+
let _5: &i32;
11+
let _6: i32;
12+
let mut _8: *const dyn std::marker::Send;
13+
let _9: &dyn std::marker::Send;
14+
let mut _10: &i32;
15+
let _11: &i32;
16+
let _12: i32;
17+
let _13: ();
18+
let mut _14: bool;
19+
let mut _15: *const dyn std::marker::Send;
20+
let mut _16: *const dyn std::marker::Send;
21+
let mut _17: *const dyn std::marker::Send;
22+
let _18: ();
23+
let mut _19: bool;
24+
let mut _20: *const dyn std::marker::Send;
25+
let mut _21: *const dyn std::marker::Send;
26+
let mut _22: *const dyn std::marker::Send;
27+
let _23: ();
28+
let mut _24: bool;
29+
let mut _25: *const dyn std::marker::Send;
30+
let mut _26: *const dyn std::marker::Send;
31+
let mut _27: *const dyn std::marker::Send;
32+
let _28: ();
33+
let mut _29: bool;
34+
let mut _30: *const dyn std::marker::Send;
35+
let mut _31: *const dyn std::marker::Send;
36+
let mut _32: *const dyn std::marker::Send;
37+
let _33: ();
38+
let mut _34: bool;
39+
let mut _35: *const dyn std::marker::Send;
40+
let mut _36: *const dyn std::marker::Send;
41+
let mut _37: *const dyn std::marker::Send;
42+
let _38: ();
43+
let mut _39: bool;
44+
let mut _40: *const dyn std::marker::Send;
45+
let mut _41: *const dyn std::marker::Send;
46+
let mut _42: *const dyn std::marker::Send;
47+
let mut _44: &i32;
48+
scope 1 {
49+
debug a => _1;
50+
let _7: *const dyn std::marker::Send;
51+
let mut _43: &i32;
52+
scope 2 {
53+
debug b => _7;
54+
}
55+
}
56+
57+
bb0: {
58+
StorageLive(_1);
59+
- StorageLive(_2);
60+
+ nop;
61+
StorageLive(_3);
62+
StorageLive(_4);
63+
StorageLive(_5);
64+
_44 = const _;
65+
_5 = &(*_44);
66+
_4 = &(*_5);
67+
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
68+
StorageDead(_4);
69+
_2 = &raw const (*_3);
70+
- _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
71+
- StorageDead(_2);
72+
+ _1 = _2;
73+
+ nop;
74+
StorageDead(_5);
75+
StorageDead(_3);
76+
StorageLive(_7);
77+
- StorageLive(_8);
78+
+ nop;
79+
StorageLive(_9);
80+
StorageLive(_10);
81+
StorageLive(_11);
82+
_43 = const _;
83+
_11 = &(*_43);
84+
_10 = &(*_11);
85+
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
86+
StorageDead(_10);
87+
_8 = &raw const (*_9);
88+
- _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
89+
- StorageDead(_8);
90+
+ _7 = _8;
91+
+ nop;
92+
StorageDead(_11);
93+
StorageDead(_9);
94+
StorageLive(_13);
95+
StorageLive(_14);
96+
StorageLive(_15);
97+
- _15 = _1;
98+
+ _15 = _2;
99+
StorageLive(_16);
100+
StorageLive(_17);
101+
- _17 = _7;
102+
- _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
103+
+ _17 = _8;
104+
+ _16 = _8;
105+
StorageDead(_17);
106+
- _14 = Eq(move _15, move _16);
107+
+ _14 = Eq(_2, _8);
108+
StorageDead(_16);
109+
StorageDead(_15);
110+
_13 = opaque::<bool>(move _14) -> [return: bb1, unwind continue];
111+
}
112+
113+
bb1: {
114+
StorageDead(_14);
115+
StorageDead(_13);
116+
StorageLive(_18);
117+
StorageLive(_19);
118+
StorageLive(_20);
119+
- _20 = _1;
120+
+ _20 = _2;
121+
StorageLive(_21);
122+
StorageLive(_22);
123+
- _22 = _7;
124+
- _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
125+
+ _22 = _8;
126+
+ _21 = _8;
127+
StorageDead(_22);
128+
- _19 = Ne(move _20, move _21);
129+
+ _19 = Ne(_2, _8);
130+
StorageDead(_21);
131+
StorageDead(_20);
132+
_18 = opaque::<bool>(move _19) -> [return: bb2, unwind continue];
133+
}
134+
135+
bb2: {
136+
StorageDead(_19);
137+
StorageDead(_18);
138+
StorageLive(_23);
139+
StorageLive(_24);
140+
StorageLive(_25);
141+
- _25 = _1;
142+
+ _25 = _2;
143+
StorageLive(_26);
144+
StorageLive(_27);
145+
- _27 = _7;
146+
- _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
147+
+ _27 = _8;
148+
+ _26 = _8;
149+
StorageDead(_27);
150+
- _24 = Lt(move _25, move _26);
151+
+ _24 = Lt(_2, _8);
152+
StorageDead(_26);
153+
StorageDead(_25);
154+
_23 = opaque::<bool>(move _24) -> [return: bb3, unwind continue];
155+
}
156+
157+
bb3: {
158+
StorageDead(_24);
159+
StorageDead(_23);
160+
StorageLive(_28);
161+
StorageLive(_29);
162+
StorageLive(_30);
163+
- _30 = _1;
164+
+ _30 = _2;
165+
StorageLive(_31);
166+
StorageLive(_32);
167+
- _32 = _7;
168+
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
169+
+ _32 = _8;
170+
+ _31 = _8;
171+
StorageDead(_32);
172+
- _29 = Le(move _30, move _31);
173+
+ _29 = Le(_2, _8);
174+
StorageDead(_31);
175+
StorageDead(_30);
176+
_28 = opaque::<bool>(move _29) -> [return: bb4, unwind continue];
177+
}
178+
179+
bb4: {
180+
StorageDead(_29);
181+
StorageDead(_28);
182+
StorageLive(_33);
183+
StorageLive(_34);
184+
StorageLive(_35);
185+
- _35 = _1;
186+
+ _35 = _2;
187+
StorageLive(_36);
188+
StorageLive(_37);
189+
- _37 = _7;
190+
- _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
191+
+ _37 = _8;
192+
+ _36 = _8;
193+
StorageDead(_37);
194+
- _34 = Gt(move _35, move _36);
195+
+ _34 = Gt(_2, _8);
196+
StorageDead(_36);
197+
StorageDead(_35);
198+
_33 = opaque::<bool>(move _34) -> [return: bb5, unwind continue];
199+
}
200+
201+
bb5: {
202+
StorageDead(_34);
203+
StorageDead(_33);
204+
StorageLive(_38);
205+
StorageLive(_39);
206+
StorageLive(_40);
207+
- _40 = _1;
208+
+ _40 = _2;
209+
StorageLive(_41);
210+
StorageLive(_42);
211+
- _42 = _7;
212+
- _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
213+
+ _42 = _8;
214+
+ _41 = _8;
215+
StorageDead(_42);
216+
- _39 = Ge(move _40, move _41);
217+
+ _39 = Ge(_2, _8);
218+
StorageDead(_41);
219+
StorageDead(_40);
220+
_38 = opaque::<bool>(move _39) -> [return: bb6, unwind continue];
221+
}
222+
223+
bb6: {
224+
StorageDead(_39);
225+
StorageDead(_38);
226+
_0 = const ();
227+
StorageDead(_7);
228+
StorageDead(_1);
229+
return;
230+
}
231+
}
232+

0 commit comments

Comments
 (0)
Please sign in to comment.