fork/rust

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

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

master
13.5 KiB501 linesraw
1- // MIR for `cast` before GVN
2+ // MIR for `cast` after GVN
3  
4  fn cast() -> () {
5      let mut _0: ();
6      let _1: i64;
7      let _4: ();
8      let mut _5: u8;
9      let mut _6: i64;
10      let _7: ();
11      let mut _8: u16;
12      let mut _9: i64;
13      let _10: ();
14      let mut _11: u32;
15      let mut _12: i64;
16      let _13: ();
17      let mut _14: u64;
18      let mut _15: i64;
19      let _16: ();
20      let mut _17: i8;
21      let mut _18: i64;
22      let _19: ();
23      let mut _20: i16;
24      let mut _21: i64;
25      let _22: ();
26      let mut _23: i32;
27      let mut _24: i64;
28      let _25: ();
29      let mut _26: i64;
30      let _27: ();
31      let mut _28: f32;
32      let mut _29: i64;
33      let _30: ();
34      let mut _31: f64;
35      let mut _32: i64;
36      let _33: ();
37      let mut _34: u8;
38      let mut _35: u64;
39      let _36: ();
40      let mut _37: u16;
41      let mut _38: u64;
42      let _39: ();
43      let mut _40: u32;
44      let mut _41: u64;
45      let _42: ();
46      let mut _43: u64;
47      let _44: ();
48      let mut _45: i8;
49      let mut _46: u64;
50      let _47: ();
51      let mut _48: i16;
52      let mut _49: u64;
53      let _50: ();
54      let mut _51: i32;
55      let mut _52: u64;
56      let _53: ();
57      let mut _54: i64;
58      let mut _55: u64;
59      let _56: ();
60      let mut _57: f32;
61      let mut _58: u64;
62      let _59: ();
63      let mut _60: f64;
64      let mut _61: u64;
65      let _62: ();
66      let mut _63: u8;
67      let mut _64: f64;
68      let _65: ();
69      let mut _66: u16;
70      let mut _67: f64;
71      let _68: ();
72      let mut _69: u32;
73      let mut _70: f64;
74      let _71: ();
75      let mut _72: u64;
76      let mut _73: f64;
77      let _74: ();
78      let mut _75: i8;
79      let mut _76: f64;
80      let _77: ();
81      let mut _78: i16;
82      let mut _79: f64;
83      let _80: ();
84      let mut _81: i32;
85      let mut _82: f64;
86      let _83: ();
87      let mut _84: i64;
88      let mut _85: f64;
89      let _86: ();
90      let mut _87: f32;
91      let mut _88: f64;
92      let _89: ();
93      let mut _90: f64;
94      scope 1 {
95          debug i => _1;
96          let _2: u64;
97          scope 2 {
98              debug u => _2;
99              let _3: f64;
100              scope 3 {
101                  debug f => _3;
102              }
103          }
104      }
105  
106      bb0: {
107-         StorageLive(_1);
108          _1 = const 1_i64;
109-         StorageLive(_2);
110          _2 = const 1_u64;
111-         StorageLive(_3);
112          _3 = const 1f64;
113          StorageLive(_4);
114          StorageLive(_5);
115-         StorageLive(_6);
116-         _6 = _1;
117-         _5 = move _6 as u8 (IntToInt);
118-         StorageDead(_6);
119+         _5 = const 1_i64 as u8 (IntToInt);
120          _4 = opaque::<u8>(move _5) -> [return: bb1, unwind continue];
121      }
122  
123      bb1: {
124          StorageDead(_5);
125          StorageDead(_4);
126          StorageLive(_7);
127          StorageLive(_8);
128-         StorageLive(_9);
129-         _9 = _1;
130-         _8 = move _9 as u16 (IntToInt);
131-         StorageDead(_9);
132+         _8 = const 1_i64 as u16 (IntToInt);
133          _7 = opaque::<u16>(move _8) -> [return: bb2, unwind continue];
134      }
135  
136      bb2: {
137          StorageDead(_8);
138          StorageDead(_7);
139          StorageLive(_10);
140          StorageLive(_11);
141-         StorageLive(_12);
142-         _12 = _1;
143-         _11 = move _12 as u32 (IntToInt);
144-         StorageDead(_12);
145+         _11 = const 1_i64 as u32 (IntToInt);
146          _10 = opaque::<u32>(move _11) -> [return: bb3, unwind continue];
147      }
148  
149      bb3: {
150          StorageDead(_11);
151          StorageDead(_10);
152          StorageLive(_13);
153          StorageLive(_14);
154-         StorageLive(_15);
155-         _15 = _1;
156-         _14 = move _15 as u64 (IntToInt);
157-         StorageDead(_15);
158+         _14 = const 1_i64 as u64 (IntToInt);
159          _13 = opaque::<u64>(move _14) -> [return: bb4, unwind continue];
160      }
161  
162      bb4: {
163          StorageDead(_14);
164          StorageDead(_13);
165          StorageLive(_16);
166          StorageLive(_17);
167-         StorageLive(_18);
168-         _18 = _1;
169-         _17 = move _18 as i8 (IntToInt);
170-         StorageDead(_18);
171+         _17 = const 1_i64 as i8 (IntToInt);
172          _16 = opaque::<i8>(move _17) -> [return: bb5, unwind continue];
173      }
174  
175      bb5: {
176          StorageDead(_17);
177          StorageDead(_16);
178          StorageLive(_19);
179          StorageLive(_20);
180-         StorageLive(_21);
181-         _21 = _1;
182-         _20 = move _21 as i16 (IntToInt);
183-         StorageDead(_21);
184+         _20 = const 1_i64 as i16 (IntToInt);
185          _19 = opaque::<i16>(move _20) -> [return: bb6, unwind continue];
186      }
187  
188      bb6: {
189          StorageDead(_20);
190          StorageDead(_19);
191          StorageLive(_22);
192          StorageLive(_23);
193-         StorageLive(_24);
194-         _24 = _1;
195-         _23 = move _24 as i32 (IntToInt);
196-         StorageDead(_24);
197+         _23 = const 1_i64 as i32 (IntToInt);
198          _22 = opaque::<i32>(move _23) -> [return: bb7, unwind continue];
199      }
200  
201      bb7: {
202          StorageDead(_23);
203          StorageDead(_22);
204          StorageLive(_25);
205-         StorageLive(_26);
206-         _26 = _1;
207-         _25 = opaque::<i64>(move _26) -> [return: bb8, unwind continue];
208+         _25 = opaque::<i64>(const 1_i64) -> [return: bb8, unwind continue];
209      }
210  
211      bb8: {
212-         StorageDead(_26);
213          StorageDead(_25);
214          StorageLive(_27);
215          StorageLive(_28);
216-         StorageLive(_29);
217-         _29 = _1;
218-         _28 = move _29 as f32 (IntToFloat);
219-         StorageDead(_29);
220+         _28 = const 1_i64 as f32 (IntToFloat);
221          _27 = opaque::<f32>(move _28) -> [return: bb9, unwind continue];
222      }
223  
224      bb9: {
225          StorageDead(_28);
226          StorageDead(_27);
227          StorageLive(_30);
228          StorageLive(_31);
229-         StorageLive(_32);
230-         _32 = _1;
231-         _31 = move _32 as f64 (IntToFloat);
232-         StorageDead(_32);
233+         _31 = const 1_i64 as f64 (IntToFloat);
234          _30 = opaque::<f64>(move _31) -> [return: bb10, unwind continue];
235      }
236  
237      bb10: {
238          StorageDead(_31);
239          StorageDead(_30);
240          StorageLive(_33);
241          StorageLive(_34);
242-         StorageLive(_35);
243-         _35 = _2;
244-         _34 = move _35 as u8 (IntToInt);
245-         StorageDead(_35);
246+         _34 = const 1_u64 as u8 (IntToInt);
247          _33 = opaque::<u8>(move _34) -> [return: bb11, unwind continue];
248      }
249  
250      bb11: {
251          StorageDead(_34);
252          StorageDead(_33);
253          StorageLive(_36);
254          StorageLive(_37);
255-         StorageLive(_38);
256-         _38 = _2;
257-         _37 = move _38 as u16 (IntToInt);
258-         StorageDead(_38);
259+         _37 = const 1_u64 as u16 (IntToInt);
260          _36 = opaque::<u16>(move _37) -> [return: bb12, unwind continue];
261      }
262  
263      bb12: {
264          StorageDead(_37);
265          StorageDead(_36);
266          StorageLive(_39);
267          StorageLive(_40);
268-         StorageLive(_41);
269-         _41 = _2;
270-         _40 = move _41 as u32 (IntToInt);
271-         StorageDead(_41);
272+         _40 = const 1_u64 as u32 (IntToInt);
273          _39 = opaque::<u32>(move _40) -> [return: bb13, unwind continue];
274      }
275  
276      bb13: {
277          StorageDead(_40);
278          StorageDead(_39);
279          StorageLive(_42);
280-         StorageLive(_43);
281-         _43 = _2;
282-         _42 = opaque::<u64>(move _43) -> [return: bb14, unwind continue];
283+         _42 = opaque::<u64>(const 1_u64) -> [return: bb14, unwind continue];
284      }
285  
286      bb14: {
287-         StorageDead(_43);
288          StorageDead(_42);
289          StorageLive(_44);
290          StorageLive(_45);
291-         StorageLive(_46);
292-         _46 = _2;
293-         _45 = move _46 as i8 (IntToInt);
294-         StorageDead(_46);
295+         _45 = const 1_u64 as i8 (IntToInt);
296          _44 = opaque::<i8>(move _45) -> [return: bb15, unwind continue];
297      }
298  
299      bb15: {
300          StorageDead(_45);
301          StorageDead(_44);
302          StorageLive(_47);
303          StorageLive(_48);
304-         StorageLive(_49);
305-         _49 = _2;
306-         _48 = move _49 as i16 (IntToInt);
307-         StorageDead(_49);
308+         _48 = const 1_u64 as i16 (IntToInt);
309          _47 = opaque::<i16>(move _48) -> [return: bb16, unwind continue];
310      }
311  
312      bb16: {
313          StorageDead(_48);
314          StorageDead(_47);
315          StorageLive(_50);
316          StorageLive(_51);
317-         StorageLive(_52);
318-         _52 = _2;
319-         _51 = move _52 as i32 (IntToInt);
320-         StorageDead(_52);
321+         _51 = const 1_u64 as i32 (IntToInt);
322          _50 = opaque::<i32>(move _51) -> [return: bb17, unwind continue];
323      }
324  
325      bb17: {
326          StorageDead(_51);
327          StorageDead(_50);
328          StorageLive(_53);
329          StorageLive(_54);
330-         StorageLive(_55);
331-         _55 = _2;
332-         _54 = move _55 as i64 (IntToInt);
333-         StorageDead(_55);
334+         _54 = const 1_u64 as i64 (IntToInt);
335          _53 = opaque::<i64>(move _54) -> [return: bb18, unwind continue];
336      }
337  
338      bb18: {
339          StorageDead(_54);
340          StorageDead(_53);
341          StorageLive(_56);
342          StorageLive(_57);
343-         StorageLive(_58);
344-         _58 = _2;
345-         _57 = move _58 as f32 (IntToFloat);
346-         StorageDead(_58);
347+         _57 = const 1_u64 as f32 (IntToFloat);
348          _56 = opaque::<f32>(move _57) -> [return: bb19, unwind continue];
349      }
350  
351      bb19: {
352          StorageDead(_57);
353          StorageDead(_56);
354          StorageLive(_59);
355          StorageLive(_60);
356-         StorageLive(_61);
357-         _61 = _2;
358-         _60 = move _61 as f64 (IntToFloat);
359-         StorageDead(_61);
360+         _60 = const 1_u64 as f64 (IntToFloat);
361          _59 = opaque::<f64>(move _60) -> [return: bb20, unwind continue];
362      }
363  
364      bb20: {
365          StorageDead(_60);
366          StorageDead(_59);
367          StorageLive(_62);
368          StorageLive(_63);
369-         StorageLive(_64);
370-         _64 = _3;
371-         _63 = move _64 as u8 (FloatToInt);
372-         StorageDead(_64);
373+         _63 = const 1f64 as u8 (FloatToInt);
374          _62 = opaque::<u8>(move _63) -> [return: bb21, unwind continue];
375      }
376  
377      bb21: {
378          StorageDead(_63);
379          StorageDead(_62);
380          StorageLive(_65);
381          StorageLive(_66);
382-         StorageLive(_67);
383-         _67 = _3;
384-         _66 = move _67 as u16 (FloatToInt);
385-         StorageDead(_67);
386+         _66 = const 1f64 as u16 (FloatToInt);
387          _65 = opaque::<u16>(move _66) -> [return: bb22, unwind continue];
388      }
389  
390      bb22: {
391          StorageDead(_66);
392          StorageDead(_65);
393          StorageLive(_68);
394          StorageLive(_69);
395-         StorageLive(_70);
396-         _70 = _3;
397-         _69 = move _70 as u32 (FloatToInt);
398-         StorageDead(_70);
399+         _69 = const 1f64 as u32 (FloatToInt);
400          _68 = opaque::<u32>(move _69) -> [return: bb23, unwind continue];
401      }
402  
403      bb23: {
404          StorageDead(_69);
405          StorageDead(_68);
406          StorageLive(_71);
407          StorageLive(_72);
408-         StorageLive(_73);
409-         _73 = _3;
410-         _72 = move _73 as u64 (FloatToInt);
411-         StorageDead(_73);
412+         _72 = const 1f64 as u64 (FloatToInt);
413          _71 = opaque::<u64>(move _72) -> [return: bb24, unwind continue];
414      }
415  
416      bb24: {
417          StorageDead(_72);
418          StorageDead(_71);
419          StorageLive(_74);
420          StorageLive(_75);
421-         StorageLive(_76);
422-         _76 = _3;
423-         _75 = move _76 as i8 (FloatToInt);
424-         StorageDead(_76);
425+         _75 = const 1f64 as i8 (FloatToInt);
426          _74 = opaque::<i8>(move _75) -> [return: bb25, unwind continue];
427      }
428  
429      bb25: {
430          StorageDead(_75);
431          StorageDead(_74);
432          StorageLive(_77);
433          StorageLive(_78);
434-         StorageLive(_79);
435-         _79 = _3;
436-         _78 = move _79 as i16 (FloatToInt);
437-         StorageDead(_79);
438+         _78 = const 1f64 as i16 (FloatToInt);
439          _77 = opaque::<i16>(move _78) -> [return: bb26, unwind continue];
440      }
441  
442      bb26: {
443          StorageDead(_78);
444          StorageDead(_77);
445          StorageLive(_80);
446          StorageLive(_81);
447-         StorageLive(_82);
448-         _82 = _3;
449-         _81 = move _82 as i32 (FloatToInt);
450-         StorageDead(_82);
451+         _81 = const 1f64 as i32 (FloatToInt);
452          _80 = opaque::<i32>(move _81) -> [return: bb27, unwind continue];
453      }
454  
455      bb27: {
456          StorageDead(_81);
457          StorageDead(_80);
458          StorageLive(_83);
459          StorageLive(_84);
460-         StorageLive(_85);
461-         _85 = _3;
462-         _84 = move _85 as i64 (FloatToInt);
463-         StorageDead(_85);
464+         _84 = const 1f64 as i64 (FloatToInt);
465          _83 = opaque::<i64>(move _84) -> [return: bb28, unwind continue];
466      }
467  
468      bb28: {
469          StorageDead(_84);
470          StorageDead(_83);
471          StorageLive(_86);
472          StorageLive(_87);
473-         StorageLive(_88);
474-         _88 = _3;
475-         _87 = move _88 as f32 (FloatToFloat);
476-         StorageDead(_88);
477+         _87 = const 1f64 as f32 (FloatToFloat);
478          _86 = opaque::<f32>(move _87) -> [return: bb29, unwind continue];
479      }
480  
481      bb29: {
482          StorageDead(_87);
483          StorageDead(_86);
484          StorageLive(_89);
485-         StorageLive(_90);
486-         _90 = _3;
487-         _89 = opaque::<f64>(move _90) -> [return: bb30, unwind continue];
488+         _89 = opaque::<f64>(const 1f64) -> [return: bb30, unwind continue];
489      }
490  
491      bb30: {
492-         StorageDead(_90);
493          StorageDead(_89);
494          _0 = const ();
495-         StorageDead(_3);
496-         StorageDead(_2);
497-         StorageDead(_1);
498          return;
499      }
500  }
501