fork/rust

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

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

master
4.2 KiB165 linesraw
1- // MIR for `arithmetic_float` before GVN
2+ // MIR for `arithmetic_float` after GVN
3  
4  fn arithmetic_float(_1: f64) -> () {
5      debug x => _1;
6      let mut _0: ();
7      let _2: ();
8      let mut _3: f64;
9      let mut _4: f64;
10      let _5: ();
11      let mut _6: f64;
12      let mut _7: f64;
13      let _8: ();
14      let mut _9: f64;
15      let mut _10: f64;
16      let _11: ();
17      let mut _12: f64;
18      let mut _13: f64;
19      let _14: ();
20      let mut _15: f64;
21      let mut _16: f64;
22      let _17: ();
23      let mut _18: f64;
24      let mut _19: f64;
25      let _20: ();
26      let mut _21: f64;
27      let mut _22: f64;
28      let _23: ();
29      let mut _24: bool;
30      let mut _25: f64;
31      let mut _26: f64;
32      let _27: ();
33      let mut _28: bool;
34      let mut _29: f64;
35      let mut _30: f64;
36  
37      bb0: {
38          StorageLive(_2);
39          StorageLive(_3);
40-         StorageLive(_4);
41-         _4 = _1;
42-         _3 = Add(move _4, const 0f64);
43-         StorageDead(_4);
44+         _3 = Add(_1, const 0f64);
45          _2 = opaque::<f64>(move _3) -> [return: bb1, unwind unreachable];
46      }
47  
48      bb1: {
49          StorageDead(_3);
50          StorageDead(_2);
51          StorageLive(_5);
52          StorageLive(_6);
53-         StorageLive(_7);
54-         _7 = _1;
55-         _6 = Sub(move _7, const 0f64);
56-         StorageDead(_7);
57+         _6 = Sub(_1, const 0f64);
58          _5 = opaque::<f64>(move _6) -> [return: bb2, unwind unreachable];
59      }
60  
61      bb2: {
62          StorageDead(_6);
63          StorageDead(_5);
64          StorageLive(_8);
65          StorageLive(_9);
66-         StorageLive(_10);
67-         _10 = _1;
68-         _9 = Mul(move _10, const 0f64);
69-         StorageDead(_10);
70+         _9 = Mul(_1, const 0f64);
71          _8 = opaque::<f64>(move _9) -> [return: bb3, unwind unreachable];
72      }
73  
74      bb3: {
75          StorageDead(_9);
76          StorageDead(_8);
77          StorageLive(_11);
78          StorageLive(_12);
79-         StorageLive(_13);
80-         _13 = _1;
81-         _12 = Div(move _13, const 0f64);
82-         StorageDead(_13);
83+         _12 = Div(_1, const 0f64);
84          _11 = opaque::<f64>(move _12) -> [return: bb4, unwind unreachable];
85      }
86  
87      bb4: {
88          StorageDead(_12);
89          StorageDead(_11);
90          StorageLive(_14);
91          StorageLive(_15);
92-         StorageLive(_16);
93-         _16 = _1;
94-         _15 = Div(const 0f64, move _16);
95-         StorageDead(_16);
96+         _15 = Div(const 0f64, _1);
97          _14 = opaque::<f64>(move _15) -> [return: bb5, unwind unreachable];
98      }
99  
100      bb5: {
101          StorageDead(_15);
102          StorageDead(_14);
103          StorageLive(_17);
104          StorageLive(_18);
105-         StorageLive(_19);
106-         _19 = _1;
107-         _18 = Rem(move _19, const 0f64);
108-         StorageDead(_19);
109+         _18 = Rem(_1, const 0f64);
110          _17 = opaque::<f64>(move _18) -> [return: bb6, unwind unreachable];
111      }
112  
113      bb6: {
114          StorageDead(_18);
115          StorageDead(_17);
116          StorageLive(_20);
117          StorageLive(_21);
118-         StorageLive(_22);
119-         _22 = _1;
120-         _21 = Rem(const 0f64, move _22);
121-         StorageDead(_22);
122+         _21 = Rem(const 0f64, _1);
123          _20 = opaque::<f64>(move _21) -> [return: bb7, unwind unreachable];
124      }
125  
126      bb7: {
127          StorageDead(_21);
128          StorageDead(_20);
129          StorageLive(_23);
130          StorageLive(_24);
131-         StorageLive(_25);
132-         _25 = _1;
133-         StorageLive(_26);
134-         _26 = _1;
135-         _24 = Eq(move _25, move _26);
136-         StorageDead(_26);
137-         StorageDead(_25);
138+         _24 = Eq(_1, _1);
139          _23 = opaque::<bool>(move _24) -> [return: bb8, unwind unreachable];
140      }
141  
142      bb8: {
143          StorageDead(_24);
144          StorageDead(_23);
145          StorageLive(_27);
146          StorageLive(_28);
147-         StorageLive(_29);
148-         _29 = _1;
149-         StorageLive(_30);
150-         _30 = _1;
151-         _28 = Ne(move _29, move _30);
152-         StorageDead(_30);
153-         StorageDead(_29);
154+         _28 = Ne(_1, _1);
155          _27 = opaque::<bool>(move _28) -> [return: bb9, unwind unreachable];
156      }
157  
158      bb9: {
159          StorageDead(_28);
160          StorageDead(_27);
161          _0 = const ();
162          return;
163      }
164  }
165