fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
11.5 KiB445 linesraw
1- // MIR for `reference_propagation_mut_ptr` before ReferencePropagation
2+ // MIR for `reference_propagation_mut_ptr` after ReferencePropagation
3  
4  fn reference_propagation_mut_ptr(_1: *mut T, _2: *mut T) -> () {
5      debug single => _1;
6      debug multiple => _2;
7      let mut _0: ();
8      let _3: ();
9      let _7: ();
10      let mut _8: ();
11      let _9: ();
12      let mut _13: *mut usize;
13      let _15: ();
14      let mut _16: ();
15      let _17: ();
16      let _22: ();
17      let mut _23: &*mut usize;
18      let _24: ();
19      let _29: ();
20      let mut _30: *mut *mut usize;
21      let _31: ();
22      let _35: ();
23      let mut _36: *mut usize;
24      let _37: ();
25      let _44: ();
26      let mut _45: *mut usize;
27      let _46: ();
28      let _49: ();
29      let mut _50: ();
30      let _51: ();
31      let mut _53: *mut T;
32      let _55: ();
33      let mut _56: ();
34      let _57: ();
35      let _62: ();
36      let mut _63: ();
37      let _68: ();
38      let mut _69: ();
39      scope 1 {
40          let mut _4: usize;
41          scope 2 {
42              debug a => _4;
43              let _5: *mut usize;
44              scope 3 {
45                  debug b => _5;
46                  let _6: usize;
47                  scope 4 {
48                      debug c => _6;
49                  }
50              }
51          }
52      }
53      scope 5 {
54          let mut _10: usize;
55          scope 6 {
56              debug a => _10;
57              let mut _11: usize;
58              scope 7 {
59                  debug a2 => _11;
60                  let mut _12: *mut usize;
61                  scope 8 {
62                      debug b => _12;
63                      let _14: usize;
64                      scope 9 {
65                          debug c => _14;
66                      }
67                  }
68              }
69          }
70      }
71      scope 10 {
72          let mut _18: usize;
73          scope 11 {
74              debug a => _18;
75              let _19: *mut usize;
76              scope 12 {
77                  debug b => _19;
78                  let _20: &*mut usize;
79                  scope 13 {
80                      debug d => _20;
81                      let _21: usize;
82                      scope 14 {
83                          debug c => _21;
84                      }
85                  }
86              }
87          }
88      }
89      scope 15 {
90          let mut _25: usize;
91          scope 16 {
92              debug a => _25;
93              let mut _26: *mut usize;
94              scope 17 {
95                  debug b => _26;
96                  let _27: *mut *mut usize;
97                  scope 18 {
98                      debug d => _27;
99                      let _28: usize;
100                      scope 19 {
101                          debug c => _28;
102                      }
103                  }
104              }
105          }
106      }
107      scope 20 {
108          let mut _32: usize;
109          scope 21 {
110              debug a => _32;
111              let _33: *mut usize;
112              scope 22 {
113                  debug b => _33;
114                  let _34: usize;
115                  scope 23 {
116                      debug c => _34;
117                  }
118              }
119          }
120      }
121      scope 24 {
122          let mut _38: usize;
123          scope 25 {
124              debug a => _38;
125              let _39: *mut usize;
126              scope 26 {
127                  debug b1 => _39;
128                  let _40: usize;
129                  scope 27 {
130                      debug c => _40;
131                      let _41: *mut usize;
132                      scope 28 {
133                          debug b2 => _41;
134                          let _42: usize;
135                          scope 29 {
136                              debug c2 => _42;
137                              let _43: *mut usize;
138                              scope 30 {
139                                  debug b3 => _43;
140                              }
141                          }
142                      }
143                  }
144              }
145          }
146      }
147      scope 31 {
148          let _47: *mut T;
149          scope 32 {
150-             debug a => _47;
151+             debug a => _1;
152              let _48: T;
153              scope 33 {
154                  debug b => _48;
155              }
156          }
157      }
158      scope 34 {
159          let _52: *mut T;
160          scope 35 {
161              debug a => _52;
162              let _54: T;
163              scope 36 {
164                  debug b => _54;
165              }
166          }
167      }
168      scope 37 {
169          let mut _58: usize;
170          scope 38 {
171              debug a => _58;
172              let _59: *mut usize;
173              scope 39 {
174                  debug b => _59;
175                  let _60: &*mut usize;
176                  scope 40 {
177                      debug d => _60;
178                      let _61: usize;
179                      scope 41 {
180                          debug c => _61;
181                      }
182                  }
183              }
184          }
185      }
186      scope 42 {
187          let mut _64: usize;
188          scope 43 {
189              debug a => _64;
190              let mut _65: *mut usize;
191              scope 44 {
192                  debug b => _65;
193                  let _66: &mut *mut usize;
194                  scope 45 {
195                      debug d => _66;
196                      let _67: usize;
197                      scope 46 {
198                          debug c => _67;
199                      }
200                  }
201              }
202          }
203      }
204  
205      bb0: {
206-         StorageLive(_3);
207          StorageLive(_4);
208          _4 = const 5_usize;
209          StorageLive(_5);
210          _5 = &raw mut _4;
211          StorageLive(_6);
212-         _6 = (*_5);
213+         _6 = _4;
214          StorageLive(_7);
215          StorageLive(_8);
216          _8 = ();
217          _7 = opaque::<()>(move _8) -> [return: bb1, unwind continue];
218      }
219  
220      bb1: {
221          StorageDead(_8);
222          StorageDead(_7);
223-         _3 = const ();
224          StorageDead(_6);
225          StorageDead(_5);
226          StorageDead(_4);
227-         StorageDead(_3);
228-         StorageLive(_9);
229          StorageLive(_10);
230          _10 = const 5_usize;
231          StorageLive(_11);
232          _11 = const 7_usize;
233          StorageLive(_12);
234          _12 = &raw mut _10;
235          StorageLive(_13);
236          _13 = &raw mut _11;
237          _12 = move _13;
238          StorageDead(_13);
239          StorageLive(_14);
240          _14 = (*_12);
241          StorageLive(_15);
242          StorageLive(_16);
243          _16 = ();
244          _15 = opaque::<()>(move _16) -> [return: bb2, unwind continue];
245      }
246  
247      bb2: {
248          StorageDead(_16);
249          StorageDead(_15);
250-         _9 = const ();
251          StorageDead(_14);
252          StorageDead(_12);
253          StorageDead(_11);
254          StorageDead(_10);
255-         StorageDead(_9);
256-         StorageLive(_17);
257          StorageLive(_18);
258          _18 = const 5_usize;
259          StorageLive(_19);
260          _19 = &raw mut _18;
261          StorageLive(_20);
262          _20 = &_19;
263          StorageLive(_21);
264          _21 = (*_19);
265          StorageLive(_22);
266          StorageLive(_23);
267          _23 = _20;
268          _22 = opaque::<&*mut usize>(move _23) -> [return: bb3, unwind continue];
269      }
270  
271      bb3: {
272          StorageDead(_23);
273          StorageDead(_22);
274-         _17 = const ();
275          StorageDead(_21);
276          StorageDead(_20);
277          StorageDead(_19);
278          StorageDead(_18);
279-         StorageDead(_17);
280-         StorageLive(_24);
281          StorageLive(_25);
282          _25 = const 5_usize;
283          StorageLive(_26);
284          _26 = &raw mut _25;
285          StorageLive(_27);
286          _27 = &raw mut _26;
287          StorageLive(_28);
288          _28 = (*_26);
289          StorageLive(_29);
290          StorageLive(_30);
291          _30 = _27;
292          _29 = opaque::<*mut *mut usize>(move _30) -> [return: bb4, unwind continue];
293      }
294  
295      bb4: {
296          StorageDead(_30);
297          StorageDead(_29);
298-         _24 = const ();
299          StorageDead(_28);
300          StorageDead(_27);
301          StorageDead(_26);
302          StorageDead(_25);
303-         StorageDead(_24);
304-         StorageLive(_31);
305          StorageLive(_32);
306          _32 = const 7_usize;
307          StorageLive(_33);
308          _33 = &raw mut _32;
309          StorageLive(_34);
310          _34 = (*_33);
311          StorageLive(_35);
312          StorageLive(_36);
313          _36 = _33;
314          _35 = opaque::<*mut usize>(move _36) -> [return: bb5, unwind continue];
315      }
316  
317      bb5: {
318          StorageDead(_36);
319          StorageDead(_35);
320-         _31 = const ();
321          StorageDead(_34);
322          StorageDead(_33);
323          StorageDead(_32);
324-         StorageDead(_31);
325-         StorageLive(_37);
326          StorageLive(_38);
327          _38 = const 7_usize;
328          StorageLive(_39);
329          _39 = &raw mut _38;
330          StorageLive(_40);
331          _40 = (*_39);
332          StorageLive(_41);
333          _41 = _39;
334          StorageLive(_42);
335          _42 = (*_41);
336          StorageLive(_43);
337          _43 = _41;
338          StorageLive(_44);
339          StorageLive(_45);
340          _45 = _43;
341          _44 = opaque::<*mut usize>(move _45) -> [return: bb6, unwind continue];
342      }
343  
344      bb6: {
345          StorageDead(_45);
346          StorageDead(_44);
347-         _37 = const ();
348          StorageDead(_43);
349          StorageDead(_42);
350          StorageDead(_41);
351          StorageDead(_40);
352          StorageDead(_39);
353          StorageDead(_38);
354-         StorageDead(_37);
355-         StorageLive(_46);
356-         StorageLive(_47);
357-         _47 = &raw mut (*_1);
358          StorageLive(_48);
359-         _48 = (*_47);
360+         _48 = (*_1);
361          StorageLive(_49);
362          StorageLive(_50);
363          _50 = ();
364          _49 = opaque::<()>(move _50) -> [return: bb7, unwind continue];
365      }
366  
367      bb7: {
368          StorageDead(_50);
369          StorageDead(_49);
370-         _46 = const ();
371          StorageDead(_48);
372-         StorageDead(_47);
373-         StorageDead(_46);
374-         StorageLive(_51);
375          StorageLive(_52);
376          _52 = &raw mut (*_2);
377          StorageLive(_53);
378          _53 = &raw mut (*_1);
379          _2 = move _53;
380          StorageDead(_53);
381          StorageLive(_54);
382          _54 = (*_52);
383          StorageLive(_55);
384          StorageLive(_56);
385          _56 = ();
386          _55 = opaque::<()>(move _56) -> [return: bb8, unwind continue];
387      }
388  
389      bb8: {
390          StorageDead(_56);
391          StorageDead(_55);
392-         _51 = const ();
393          StorageDead(_54);
394          StorageDead(_52);
395-         StorageDead(_51);
396-         StorageLive(_57);
397          StorageLive(_58);
398          _58 = const 5_usize;
399          StorageLive(_59);
400          _59 = &raw mut _58;
401          StorageLive(_60);
402          _60 = &_59;
403          StorageLive(_61);
404          _61 = (*_59);
405          StorageLive(_62);
406          StorageLive(_63);
407          _63 = ();
408          _62 = opaque::<()>(move _63) -> [return: bb9, unwind continue];
409      }
410  
411      bb9: {
412          StorageDead(_63);
413          StorageDead(_62);
414-         _57 = const ();
415          StorageDead(_61);
416          StorageDead(_60);
417          StorageDead(_59);
418          StorageDead(_58);
419-         StorageDead(_57);
420          StorageLive(_64);
421          _64 = const 5_usize;
422          StorageLive(_65);
423          _65 = &raw mut _64;
424          StorageLive(_66);
425          _66 = &mut _65;
426          StorageLive(_67);
427          _67 = (*_65);
428          StorageLive(_68);
429          StorageLive(_69);
430          _69 = ();
431          _68 = opaque::<()>(move _69) -> [return: bb10, unwind continue];
432      }
433  
434      bb10: {
435          StorageDead(_69);
436          StorageDead(_68);
437          _0 = const ();
438          StorageDead(_67);
439          StorageDead(_66);
440          StorageDead(_65);
441          StorageDead(_64);
442          return;
443      }
444  }
445