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 2d8fed2

Browse files
cjgillotcjgillot
committedOct 16, 2023
Run filecheck on reference_prop.rs
1 parent af04c10 commit 2d8fed2

File tree

1 file changed

+319
-16
lines changed

1 file changed

+319
-16
lines changed
 

‎tests/mir-opt/reference_prop.rs

Lines changed: 319 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
// skip-filecheck
21
// unit-test: ReferencePropagation
32
// needs-unwind
43

@@ -9,16 +8,31 @@
98
fn opaque(_: impl Sized) {}
109

1110
fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
11+
// CHECK-LABEL: fn reference_propagation(
12+
1213
// Propagation through a reference.
1314
{
15+
// CHECK: bb0: {
16+
// CHECK: [[a:_.*]] = const 5_usize;
17+
// CHECK: [[b:_.*]] = &[[a]];
18+
// CHECK: [[c:_.*]] = [[a]];
19+
1420
let a = 5_usize;
1521
let b = &a; // This borrow is only used once.
1622
let c = *b; // This should be optimized.
1723
opaque(()); // We use opaque to separate cases into basic blocks in the MIR.
1824
}
1925

20-
// Propagation through a two references.
26+
// Propagation through two references.
2127
{
28+
// CHECK: bb1: {
29+
// CHECK: [[a:_.*]] = const 5_usize;
30+
// CHECK: [[a2:_.*]] = const 7_usize;
31+
// CHECK: [[b:_.*]] = &[[a]];
32+
// CHECK: [[btmp:_.*]] = &[[a2]];
33+
// CHECK: [[b]] = move [[btmp]];
34+
// CHECK: [[c:_.*]] = (*[[b]]);
35+
2236
let a = 5_usize;
2337
let a2 = 7_usize;
2438
let mut b = &a;
@@ -30,15 +44,27 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
3044

3145
// Propagation through a borrowed reference.
3246
{
47+
// CHECK: bb2: {
48+
// CHECK: [[a:_.*]] = const 5_usize;
49+
// CHECK: [[b:_.*]] = &[[a]];
50+
// CHECK: [[d:_.*]] = &[[b]];
51+
// CHECK: [[c:_.*]] = (*[[b]]);
52+
3353
let a = 5_usize;
3454
let b = &a;
3555
let d = &b;
3656
let c = *b; // `b` is immutably borrowed, we know its value, but do not propagate it
3757
opaque(d); // prevent `d` from being removed.
3858
}
3959

40-
// Propagation through a borrowed reference.
60+
// Propagation through a mutably borrowed reference.
4161
{
62+
// CHECK: bb3: {
63+
// CHECK: [[a:_.*]] = const 5_usize;
64+
// CHECK: [[b:_.*]] = &[[a]];
65+
// CHECK: [[d:_.*]] = &raw mut [[b]];
66+
// CHECK: [[c:_.*]] = (*[[b]]);
67+
4268
let a = 5_usize;
4369
let mut b = &a;
4470
let d = &raw mut b;
@@ -48,6 +74,11 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
4874

4975
// Propagation through an escaping borrow.
5076
{
77+
// CHECK: bb4: {
78+
// CHECK: [[a:_.*]] = const 7_usize;
79+
// CHECK: [[b:_.*]] = &[[a]];
80+
// CHECK: [[c:_.*]] = [[a]];
81+
5182
let a = 7_usize;
5283
let b = &a;
5384
let c = *b;
@@ -56,6 +87,14 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
5687

5788
// Propagation through a transitively escaping borrow.
5889
{
90+
// CHECK: bb5: {
91+
// CHECK: [[a:_.*]] = const 7_usize;
92+
// CHECK: [[b1:_.*]] = &[[a]];
93+
// CHECK: [[c:_.*]] = [[a]];
94+
// CHECK: [[b2:_.*]] = [[b1]];
95+
// CHECK: [[c2:_.*]] = [[a]];
96+
// CHECK: [[b3:_.*]] = [[b2]];
97+
5998
let a = 7_usize;
6099
let b1 = &a;
61100
let c = *b1;
@@ -69,13 +108,23 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
69108

70109
// Propagation a reborrow of an argument.
71110
{
111+
// CHECK: bb6: {
112+
// CHECK-NOT: {{_.*}} = &(*_1);
113+
// CHECK: [[b:_.*]] = (*_1);
114+
72115
let a = &*single;
73116
let b = *a; // This should be optimized as `*single`.
74117
opaque(());
75118
}
76119

77120
// Propagation a reborrow of a mutated argument.
78121
{
122+
// CHECK: bb7: {
123+
// CHECK: [[a:_.*]] = &(*_2);
124+
// CHECK: [[tmp:_.*]] = &(*_1);
125+
// CHECK: _2 = move [[tmp]];
126+
// CHECK: [[b:_.*]] = (*[[a]]);
127+
79128
let a = &*multiple;
80129
multiple = &*single;
81130
let b = *a; // This should not be optimized.
@@ -84,15 +133,29 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
84133

85134
// Fixed-point propagation through a borrowed reference.
86135
{
136+
// CHECK: bb8: {
137+
// CHECK: [[a:_.*]] = const 5_usize;
138+
// CHECK: [[b:_.*]] = &[[a]];
139+
// CHECK: [[d:_.*]] = &[[b]];
140+
// FIXME this could be [[a]]
141+
// CHECK: [[c:_.*]] = (*[[b]]);
142+
87143
let a = 5_usize;
88144
let b = &a;
89145
let d = &b; // first round promotes debuginfo for `d`
90146
let c = *b; // second round propagates this dereference
91147
opaque(());
92148
}
93149

94-
// Fixed-point propagation through a borrowed reference.
150+
// Fixed-point propagation through a mutably borrowed reference.
95151
{
152+
// CHECK: bb9: {
153+
// CHECK: [[a:_.*]] = const 5_usize;
154+
// CHECK: [[b:_.*]] = &[[a]];
155+
// CHECK: [[d:_.*]] = &mut [[b]];
156+
// FIXME this could be [[a]]
157+
// CHECK: [[c:_.*]] = (*[[b]]);
158+
96159
let a = 5_usize;
97160
let mut b = &a;
98161
let d = &mut b; // first round promotes debuginfo for `d`
@@ -102,16 +165,31 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
102165
}
103166

104167
fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a mut T) {
168+
// CHECK-LABEL: fn reference_propagation_mut(
169+
105170
// Propagation through a reference.
106171
{
172+
// CHECK: bb0: {
173+
// CHECK: [[a:_.*]] = const 5_usize;
174+
// CHECK: [[b:_.*]] = &mut [[a]];
175+
// CHECK: [[c:_.*]] = [[a]];
176+
107177
let mut a = 5_usize;
108178
let b = &mut a; // This borrow is only used once.
109179
let c = *b; // This should be optimized.
110180
opaque(());
111181
}
112182

113-
// Propagation through a two references.
183+
// Propagation through two references.
114184
{
185+
// CHECK: bb1: {
186+
// CHECK: [[a:_.*]] = const 5_usize;
187+
// CHECK: [[a2:_.*]] = const 7_usize;
188+
// CHECK: [[b:_.*]] = &mut [[a]];
189+
// CHECK: [[btmp:_.*]] = &mut [[a2]];
190+
// CHECK: [[b]] = move [[btmp]];
191+
// CHECK: [[c:_.*]] = (*[[b]]);
192+
115193
let mut a = 5_usize;
116194
let mut a2 = 7_usize;
117195
let mut b = &mut a;
@@ -123,15 +201,27 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
123201

124202
// Propagation through a borrowed reference.
125203
{
204+
// CHECK: bb2: {
205+
// CHECK: [[a:_.*]] = const 5_usize;
206+
// CHECK: [[b:_.*]] = &mut [[a]];
207+
// CHECK: [[d:_.*]] = &[[b]];
208+
// CHECK: [[c:_.*]] = (*[[b]]);
209+
126210
let mut a = 5_usize;
127211
let b = &mut a;
128212
let d = &b;
129213
let c = *b; // `b` is immutably borrowed, we know its value, but cannot be removed.
130214
opaque(d); // prevent `d` from being removed.
131215
}
132216

133-
// Propagation through a borrowed reference.
217+
// Propagation through a mutably borrowed reference.
134218
{
219+
// CHECK: bb3: {
220+
// CHECK: [[a:_.*]] = const 5_usize;
221+
// CHECK: [[b:_.*]] = &mut [[a]];
222+
// CHECK: [[d:_.*]] = &raw mut [[b]];
223+
// CHECK: [[c:_.*]] = (*[[b]]);
224+
135225
let mut a = 5_usize;
136226
let mut b = &mut a;
137227
let d = &raw mut b;
@@ -141,6 +231,11 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
141231

142232
// Propagation through an escaping borrow.
143233
{
234+
// CHECK: bb4: {
235+
// CHECK: [[a:_.*]] = const 7_usize;
236+
// CHECK: [[b:_.*]] = &mut [[a]];
237+
// CHECK: [[c:_.*]] = (*[[b]]);
238+
144239
let mut a = 7_usize;
145240
let b = &mut a;
146241
let c = *b;
@@ -149,6 +244,14 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
149244

150245
// Propagation through a transitively escaping borrow.
151246
{
247+
// CHECK: bb5: {
248+
// CHECK: [[a:_.*]] = const 7_usize;
249+
// CHECK: [[b1:_.*]] = &mut [[a]];
250+
// CHECK: [[c:_.*]] = (*[[b1]]);
251+
// CHECK: [[b2:_.*]] = move [[b1]];
252+
// CHECK: [[c2:_.*]] = (*[[b2]]);
253+
// CHECK: [[b3:_.*]] = move [[b2]];
254+
152255
let mut a = 7_usize;
153256
let b1 = &mut a;
154257
let c = *b1;
@@ -162,13 +265,23 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
162265

163266
// Propagation a reborrow of an argument.
164267
{
268+
// CHECK: bb6: {
269+
// CHECK-NOT: {{_.*}} = &(*_1);
270+
// CHECK: [[b:_.*]] = (*_1);
271+
165272
let a = &mut *single;
166273
let b = *a; // This should be optimized as `*single`.
167274
opaque(());
168275
}
169276

170277
// Propagation a reborrow of a mutated argument.
171278
{
279+
// CHECK: bb7: {
280+
// CHECK: [[a:_.*]] = &mut (*_2);
281+
// CHECK: [[tmp:_.*]] = &mut (*_1);
282+
// CHECK: _2 = move [[tmp]];
283+
// CHECK: [[b:_.*]] = (*[[a]]);
284+
172285
let a = &mut *multiple;
173286
multiple = &mut *single;
174287
let b = *a; // This should not be optimized.
@@ -177,15 +290,29 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
177290

178291
// Fixed-point propagation through a borrowed reference.
179292
{
293+
// CHECK: bb8: {
294+
// CHECK: [[a:_.*]] = const 5_usize;
295+
// CHECK: [[b:_.*]] = &mut [[a]];
296+
// CHECK: [[d:_.*]] = &[[b]];
297+
// FIXME this could be [[a]]
298+
// CHECK: [[c:_.*]] = (*[[b]]);
299+
180300
let mut a = 5_usize;
181301
let b = &mut a;
182302
let d = &b; // first round promotes debuginfo for `d`
183303
let c = *b; // second round propagates this dereference
184304
opaque(());
185305
}
186306

187-
// Fixed-point propagation through a borrowed reference.
307+
// Fixed-point propagation through a mutably borrowed reference.
188308
{
309+
// CHECK: bb9: {
310+
// CHECK: [[a:_.*]] = const 5_usize;
311+
// CHECK: [[b:_.*]] = &mut [[a]];
312+
// CHECK: [[d:_.*]] = &mut [[b]];
313+
// FIXME this could be [[a]]
314+
// CHECK: [[c:_.*]] = (*[[b]]);
315+
189316
let mut a = 5_usize;
190317
let mut b = &mut a;
191318
let d = &mut b; // first round promotes debuginfo for `d`
@@ -195,16 +322,31 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
195322
}
196323

197324
fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *const T) {
325+
// CHECK-LABEL: fn reference_propagation_const_ptr(
326+
198327
// Propagation through a reference.
199328
unsafe {
329+
// CHECK: bb0: {
330+
// CHECK: [[a:_.*]] = const 5_usize;
331+
// CHECK: [[b:_.*]] = &raw const [[a]];
332+
// CHECK: [[c:_.*]] = [[a]];
333+
200334
let a = 5_usize;
201335
let b = &raw const a; // This borrow is only used once.
202336
let c = *b; // This should be optimized.
203337
opaque(());
204338
}
205339

206-
// Propagation through a two references.
340+
// Propagation through two references.
207341
unsafe {
342+
// CHECK: bb1: {
343+
// CHECK: [[a:_.*]] = const 5_usize;
344+
// CHECK: [[a2:_.*]] = const 7_usize;
345+
// CHECK: [[b:_.*]] = &raw const [[a]];
346+
// CHECK: [[btmp:_.*]] = &raw const [[a2]];
347+
// CHECK: [[b]] = move [[btmp]];
348+
// CHECK: [[c:_.*]] = (*[[b]]);
349+
208350
let a = 5_usize;
209351
let a2 = 7_usize;
210352
let mut b = &raw const a;
@@ -216,15 +358,27 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
216358

217359
// Propagation through a borrowed reference.
218360
unsafe {
361+
// CHECK: bb2: {
362+
// CHECK: [[a:_.*]] = const 5_usize;
363+
// CHECK: [[b:_.*]] = &raw const [[a]];
364+
// CHECK: [[d:_.*]] = &[[b]];
365+
// CHECK: [[c:_.*]] = (*[[b]]);
366+
219367
let a = 5_usize;
220368
let b = &raw const a;
221369
let d = &b;
222370
let c = *b; // `b` is immutably borrowed, we know its value, but cannot be removed.
223371
opaque(d); // prevent `d` from being removed.
224372
}
225373

226-
// Propagation through a borrowed reference.
374+
// Propagation through a mutably borrowed reference.
227375
unsafe {
376+
// CHECK: bb3: {
377+
// CHECK: [[a:_.*]] = const 5_usize;
378+
// CHECK: [[b:_.*]] = &raw const [[a]];
379+
// CHECK: [[d:_.*]] = &raw mut [[b]];
380+
// CHECK: [[c:_.*]] = (*[[b]]);
381+
228382
let a = 5_usize;
229383
let mut b = &raw const a;
230384
let d = &raw mut b;
@@ -234,6 +388,11 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
234388

235389
// Propagation through an escaping borrow.
236390
unsafe {
391+
// CHECK: bb4: {
392+
// CHECK: [[a:_.*]] = const 7_usize;
393+
// CHECK: [[b:_.*]] = &raw const [[a]];
394+
// CHECK: [[c:_.*]] = [[a]];
395+
237396
let a = 7_usize;
238397
let b = &raw const a;
239398
let c = *b;
@@ -242,6 +401,14 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
242401

243402
// Propagation through a transitively escaping borrow.
244403
unsafe {
404+
// CHECK: bb5: {
405+
// CHECK: [[a:_.*]] = const 7_usize;
406+
// CHECK: [[b1:_.*]] = &raw const [[a]];
407+
// CHECK: [[c:_.*]] = [[a]];
408+
// CHECK: [[b2:_.*]] = [[b1]];
409+
// CHECK: [[c2:_.*]] = [[a]];
410+
// CHECK: [[b3:_.*]] = [[b2]];
411+
245412
let a = 7_usize;
246413
let b1 = &raw const a;
247414
let c = *b1;
@@ -255,13 +422,23 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
255422

256423
// Propagation a reborrow of an argument.
257424
unsafe {
425+
// CHECK: bb6: {
426+
// CHECK-NOT: {{_.*}} = &(*_1);
427+
// CHECK: [[b:_.*]] = (*_1);
428+
258429
let a = &raw const *single;
259430
let b = *a; // This should be optimized as `*single`.
260431
opaque(());
261432
}
262433

263434
// Propagation a reborrow of a mutated argument.
264435
unsafe {
436+
// CHECK: bb7: {
437+
// CHECK: [[a:_.*]] = &raw const (*_2);
438+
// CHECK: [[tmp:_.*]] = &raw const (*_1);
439+
// CHECK: _2 = move [[tmp]];
440+
// CHECK: [[b:_.*]] = (*[[a]]);
441+
265442
let a = &raw const *multiple;
266443
multiple = &raw const *single;
267444
let b = *a; // This should not be optimized.
@@ -270,6 +447,12 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
270447

271448
// Propagation through a reborrow.
272449
unsafe {
450+
// CHECK: bb8: {
451+
// CHECK: [[a:_.*]] = const 13_usize;
452+
// CHECK: [[b:_.*]] = &raw const [[a]];
453+
// CHECK: [[d:_.*]] = &raw const [[a]];
454+
// CHECK: [[c:_.*]] = [[a]];
455+
273456
let a = 13_usize;
274457
let b = &raw const a;
275458
let c = &raw const *b;
@@ -279,6 +462,13 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
279462

280463
// Fixed-point propagation through a borrowed reference.
281464
unsafe {
465+
// CHECK: bb9: {
466+
// CHECK: [[a:_.*]] = const 5_usize;
467+
// CHECK: [[b:_.*]] = &raw const [[a]];
468+
// CHECK: [[d:_.*]] = &[[b]];
469+
// FIXME this could be [[a]]
470+
// CHECK: [[c:_.*]] = (*[[b]]);
471+
282472
let a = 5_usize;
283473
let b = &raw const a;
284474
let d = &b; // first round promotes debuginfo for `d`
@@ -288,6 +478,13 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
288478

289479
// Fixed-point propagation through a borrowed reference.
290480
unsafe {
481+
// CHECK: bb10: {
482+
// CHECK: [[a:_.*]] = const 5_usize;
483+
// CHECK: [[b:_.*]] = &raw const [[a]];
484+
// CHECK: [[d:_.*]] = &mut [[b]];
485+
// FIXME this could be [[a]]
486+
// CHECK: [[c:_.*]] = (*[[b]]);
487+
291488
let a = 5_usize;
292489
let mut b = &raw const a;
293490
let d = &mut b; // first round promotes debuginfo for `d`
@@ -297,16 +494,31 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
297494
}
298495

299496
fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T) {
497+
// CHECK-LABEL: fn reference_propagation_mut_ptr(
498+
300499
// Propagation through a reference.
301500
unsafe {
501+
// CHECK: bb0: {
502+
// CHECK: [[a:_.*]] = const 5_usize;
503+
// CHECK: [[b:_.*]] = &raw mut [[a]];
504+
// CHECK: [[c:_.*]] = [[a]];
505+
302506
let mut a = 5_usize;
303507
let b = &raw mut a; // This borrow is only used once.
304508
let c = *b; // This should be optimized.
305509
opaque(());
306510
}
307511

308-
// Propagation through a two references.
512+
// Propagation through two references.
309513
unsafe {
514+
// CHECK: bb1: {
515+
// CHECK: [[a:_.*]] = const 5_usize;
516+
// CHECK: [[a2:_.*]] = const 7_usize;
517+
// CHECK: [[b:_.*]] = &raw mut [[a]];
518+
// CHECK: [[btmp:_.*]] = &raw mut [[a2]];
519+
// CHECK: [[b]] = move [[btmp]];
520+
// CHECK: [[c:_.*]] = (*[[b]]);
521+
310522
let mut a = 5_usize;
311523
let mut a2 = 7_usize;
312524
let mut b = &raw mut a;
@@ -318,15 +530,27 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
318530

319531
// Propagation through a borrowed reference.
320532
unsafe {
533+
// CHECK: bb2: {
534+
// CHECK: [[a:_.*]] = const 5_usize;
535+
// CHECK: [[b:_.*]] = &raw mut [[a]];
536+
// CHECK: [[d:_.*]] = &[[b]];
537+
// CHECK: [[c:_.*]] = (*[[b]]);
538+
321539
let mut a = 5_usize;
322540
let b = &raw mut a;
323541
let d = &b;
324542
let c = *b; // `b` is immutably borrowed, we know its value, but cannot be removed.
325543
opaque(d); // prevent `d` from being removed.
326544
}
327545

328-
// Propagation through a borrowed reference.
546+
// Propagation through a mutably borrowed reference.
329547
unsafe {
548+
// CHECK: bb3: {
549+
// CHECK: [[a:_.*]] = const 5_usize;
550+
// CHECK: [[b:_.*]] = &raw mut [[a]];
551+
// CHECK: [[d:_.*]] = &raw mut [[b]];
552+
// CHECK: [[c:_.*]] = (*[[b]]);
553+
330554
let mut a = 5_usize;
331555
let mut b = &raw mut a;
332556
let d = &raw mut b;
@@ -336,6 +560,11 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
336560

337561
// Propagation through an escaping borrow.
338562
unsafe {
563+
// CHECK: bb4: {
564+
// CHECK: [[a:_.*]] = const 7_usize;
565+
// CHECK: [[b:_.*]] = &raw mut [[a]];
566+
// CHECK: [[c:_.*]] = (*[[b]]);
567+
339568
let mut a = 7_usize;
340569
let b = &raw mut a;
341570
let c = *b;
@@ -344,6 +573,14 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
344573

345574
// Propagation through a transitively escaping borrow.
346575
unsafe {
576+
// CHECK: bb5: {
577+
// CHECK: [[a:_.*]] = const 7_usize;
578+
// CHECK: [[b1:_.*]] = &raw mut [[a]];
579+
// CHECK: [[c:_.*]] = (*[[b1]]);
580+
// CHECK: [[b2:_.*]] = [[b1]];
581+
// CHECK: [[c2:_.*]] = (*[[b2]]);
582+
// CHECK: [[b3:_.*]] = [[b2]];
583+
347584
let mut a = 7_usize;
348585
let b1 = &raw mut a;
349586
let c = *b1;
@@ -357,13 +594,23 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
357594

358595
// Propagation a reborrow of an argument.
359596
unsafe {
597+
// CHECK: bb6: {
598+
// CHECK-NOT: {{_.*}} = &(*_1);
599+
// CHECK: [[b:_.*]] = (*_1);
600+
360601
let a = &raw mut *single;
361602
let b = *a; // This should be optimized as `*single`.
362603
opaque(());
363604
}
364605

365606
// Propagation a reborrow of a mutated argument.
366607
unsafe {
608+
// CHECK: bb7: {
609+
// CHECK: [[a:_.*]] = &raw mut (*_2);
610+
// CHECK: [[tmp:_.*]] = &raw mut (*_1);
611+
// CHECK: _2 = move [[tmp]];
612+
// CHECK: [[b:_.*]] = (*[[a]]);
613+
367614
let a = &raw mut *multiple;
368615
multiple = &raw mut *single;
369616
let b = *a; // This should not be optimized.
@@ -372,15 +619,29 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
372619

373620
// Fixed-point propagation through a borrowed reference.
374621
unsafe {
622+
// CHECK: bb8: {
623+
// CHECK: [[a:_.*]] = const 5_usize;
624+
// CHECK: [[b:_.*]] = &raw mut [[a]];
625+
// CHECK: [[d:_.*]] = &[[b]];
626+
// FIXME this could be [[a]]
627+
// CHECK: [[c:_.*]] = (*[[b]]);
628+
375629
let mut a = 5_usize;
376630
let b = &raw mut a;
377631
let d = &b; // first round promotes debuginfo for `d`
378632
let c = *b; // second round propagates this dereference
379633
opaque(());
380634
}
381635

382-
// Fixed-point propagation through a borrowed reference.
636+
// Fixed-point propagation through a mutably borrowed reference.
383637
unsafe {
638+
// CHECK: bb9: {
639+
// CHECK: [[a:_.*]] = const 5_usize;
640+
// CHECK: [[b:_.*]] = &raw mut [[a]];
641+
// CHECK: [[d:_.*]] = &mut [[b]];
642+
// FIXME this could be [[a]]
643+
// CHECK: [[c:_.*]] = (*[[b]]);
644+
384645
let mut a = 5_usize;
385646
let mut b = &raw mut a;
386647
let d = &mut b; // first round promotes debuginfo for `d`
@@ -391,8 +652,13 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
391652

392653
#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
393654
fn read_through_raw(x: &mut usize) -> usize {
394-
use std::intrinsics::mir::*;
655+
// CHECK-LABEL: read_through_raw
656+
// CHECK: bb0: {
657+
// CHECK-NEXT: _0 = (*_1);
658+
// CHECK-NEXT: _0 = (*_1);
659+
// CHECK-NEXT: return;
395660

661+
use std::intrinsics::mir::*;
396662
mir!(
397663
let r1: &mut usize;
398664
let r2: &mut usize;
@@ -414,8 +680,10 @@ fn read_through_raw(x: &mut usize) -> usize {
414680

415681
#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
416682
fn multiple_storage() {
417-
use std::intrinsics::mir::*;
683+
// CHECK-LABEL: multiple_storage
684+
// CHECK: _3 = (*_2);
418685

686+
use std::intrinsics::mir::*;
419687
mir!(
420688
let x: i32;
421689
{
@@ -438,8 +706,10 @@ fn multiple_storage() {
438706

439707
#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
440708
fn dominate_storage() {
441-
use std::intrinsics::mir::*;
709+
// CHECK-LABEL: dominate_storage
710+
// CHECK: _5 = (*_2);
442711

712+
use std::intrinsics::mir::*;
443713
mir!(
444714
let x: i32;
445715
let r: &i32;
@@ -466,8 +736,10 @@ fn dominate_storage() {
466736

467737
#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
468738
fn maybe_dead(m: bool) {
469-
use std::intrinsics::mir::*;
739+
// CHECK-LABEL: fn maybe_dead(
740+
// CHECK: (*_5) = const 7_i32;
470741

742+
use std::intrinsics::mir::*;
471743
mir!(
472744
let x: i32;
473745
let y: i32;
@@ -507,6 +779,9 @@ fn maybe_dead(m: bool) {
507779
}
508780

509781
fn mut_raw_then_mut_shr() -> (i32, i32) {
782+
// CHECK-LABEL: fn mut_raw_then_mut_shr(
783+
// CHECK-NOT: (*{{_.*}})
784+
510785
let mut x = 2;
511786
let xref = &mut x;
512787
let xraw = &mut *xref as *mut _;
@@ -518,6 +793,18 @@ fn mut_raw_then_mut_shr() -> (i32, i32) {
518793
}
519794

520795
fn unique_with_copies() {
796+
// CHECK-LABEL: fn unique_with_copies(
797+
// CHECK: [[a:_.*]] = const 0_i32;
798+
// CHECK: [[x:_.*]] = &raw mut [[a]];
799+
// CHECK-NOT: [[a]]
800+
// CHECK: [[tmp:_.*]] = (*[[x]]);
801+
// CHECK-NEXT: opaque::<i32>(move [[tmp]])
802+
// CHECK-NOT: [[a]]
803+
// CHECK: StorageDead([[a]]);
804+
// CHECK-NOT: [[a]]
805+
// CHECK: [[tmp:_.*]] = (*[[x]]);
806+
// CHECK-NEXT: opaque::<i32>(move [[tmp]])
807+
521808
let y = {
522809
let mut a = 0;
523810
let x = &raw mut a;
@@ -530,6 +817,17 @@ fn unique_with_copies() {
530817
}
531818

532819
fn debuginfo() {
820+
// CHECK-LABEL: fn debuginfo(
821+
// FIXME: This features waits for DWARF implicit pointers in LLVM.
822+
// CHECK: debug ref_mut_u8 => _{{.*}};
823+
// CHECK: debug field => _{{.*}};
824+
// CHECK: debug reborrow => _{{.*}};
825+
// CHECK: debug variant_field => _{{.*}};
826+
// CHECK: debug constant_index => _{{.*}};
827+
// CHECK: debug subslice => _{{.*}};
828+
// CHECK: debug constant_index_from_end => _{{.*}};
829+
// CHECK: debug multiple_borrow => _{{.*}};
830+
533831
struct T(u8);
534832

535833
let ref_mut_u8 = &mut 5_u8;
@@ -552,6 +850,10 @@ fn debuginfo() {
552850
}
553851

554852
fn many_debuginfo() {
853+
// CHECK-LABEL: fn many_debuginfo(
854+
// FIXME: This features waits for DWARF implicit pointers in LLVM.
855+
// CHECK: debug many_borrow => _{{.*}};
856+
555857
let a = 0;
556858

557859
// Verify that we do not ICE on deeply nested borrows.
@@ -591,3 +893,4 @@ fn main() {
591893
// EMIT_MIR reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff
592894
// EMIT_MIR reference_prop.unique_with_copies.ReferencePropagation.diff
593895
// EMIT_MIR reference_prop.debuginfo.ReferencePropagation.diff
896+
// CHECK-LABEL: fn main(

0 commit comments

Comments
 (0)
Please sign in to comment.