Skip to content

Commit bf5efc5

Browse files
cjgillotcjgillot
committed
Add test for ptr ops with same provenance.
1 parent 3071e48 commit bf5efc5

File tree

3 files changed

+564
-0
lines changed

3 files changed

+564
-0
lines changed

‎tests/mir-opt/gvn.rs

+28
Original file line numberDiff line numberDiff line change
@@ -670,6 +670,33 @@ fn wide_ptr_provenance() {
670670
opaque(a >= b);
671671
}
672672

673+
/// Both pointers come form the same allocation, so we could probably fold the comparisons.
674+
fn wide_ptr_same_provenance() {
675+
// CHECK-LABEL: fn wide_ptr_same_provenance(
676+
let slice = &[1, 2];
677+
let a: *const dyn Send = &slice[0] as &dyn Send;
678+
let b: *const dyn Send = &slice[1] as &dyn Send;
679+
680+
// CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
681+
// CHECK: opaque::<bool>(move [[eqp]])
682+
opaque(a == b);
683+
// CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
684+
// CHECK: opaque::<bool>(move [[nep]])
685+
opaque(a != b);
686+
// CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
687+
// CHECK: opaque::<bool>(move [[ltp]])
688+
opaque(a < b);
689+
// CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
690+
// CHECK: opaque::<bool>(move [[lep]])
691+
opaque(a <= b);
692+
// CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
693+
// CHECK: opaque::<bool>(move [[gtp]])
694+
opaque(a > b);
695+
// CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
696+
// CHECK: opaque::<bool>(move [[gep]])
697+
opaque(a >= b);
698+
}
699+
673700
/// Check that we do simplify when there is no provenance, and do not ICE.
674701
fn wide_ptr_integer() {
675702
// CHECK-LABEL: fn wide_ptr_integer(
@@ -744,4 +771,5 @@ fn identity<T>(x: T) -> T {
744771
// EMIT_MIR gvn.indirect_static.GVN.diff
745772
// EMIT_MIR gvn.constant_index_overflow.GVN.diff
746773
// EMIT_MIR gvn.wide_ptr_provenance.GVN.diff
774+
// EMIT_MIR gvn.wide_ptr_same_provenance.GVN.diff
747775
// EMIT_MIR gvn.wide_ptr_integer.GVN.diff

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

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

0 commit comments

Comments
 (0)