| 
1 | 1 | // WARNING: This output format is intended for human consumers only  | 
2 | 2 | // and is subject to change without notice. Knock yourself out.  | 
3 | 3 | fn test_binop(_1: usize, _2: usize) -> () {  | 
4 |  | -    debug x => _1;                       // in scope 0 at test-binop.rs:1:15: 1:16  | 
5 |  | -    debug y => _2;                       // in scope 0 at test-binop.rs:1:24: 1:25  | 
6 |  | -    let mut _0: ();                      // return place in scope 0 at test-binop.rs:1:36: 1:38  | 
7 |  | -    let mut _3: bool;                    // in scope 0 at test-binop.rs:2:5: 2:23  | 
8 |  | -    let mut _4: bool;                    // in scope 0 at test-binop.rs:2:13: 2:22  | 
9 |  | -    let mut _5: usize;                   // in scope 0 at test-binop.rs:2:13: 2:18  | 
10 |  | -    let mut _6: usize;                   // in scope 0 at test-binop.rs:2:13: 2:14  | 
11 |  | -    let mut _7: usize;                   // in scope 0 at test-binop.rs:2:17: 2:18  | 
12 |  | -    let mut _8: usize;                   // in scope 0 at test-binop.rs:2:21: 2:22  | 
13 |  | -    let mut _9: !;                       // in scope 0 at test-binop.rs:2:5: 2:23  | 
14 |  | -    let mut _10: bool;                   // in scope 0 at test-binop.rs:3:5: 3:25  | 
15 |  | -    let mut _11: bool;                   // in scope 0 at test-binop.rs:3:13: 3:24  | 
16 |  | -    let mut _12: usize;                  // in scope 0 at test-binop.rs:3:13: 3:18  | 
17 |  | -    let mut _13: usize;                  // in scope 0 at test-binop.rs:3:13: 3:14  | 
18 |  | -    let mut _14: usize;                  // in scope 0 at test-binop.rs:3:17: 3:18  | 
19 |  | -    let mut _15: !;                      // in scope 0 at test-binop.rs:3:5: 3:25  | 
20 |  | -    let mut _16: bool;                   // in scope 0 at test-binop.rs:4:5: 4:28  | 
21 |  | -    let mut _17: bool;                   // in scope 0 at test-binop.rs:4:13: 4:27  | 
22 |  | -    let mut _18: usize;                  // in scope 0 at test-binop.rs:4:13: 4:18  | 
23 |  | -    let mut _19: usize;                  // in scope 0 at test-binop.rs:4:13: 4:14  | 
24 |  | -    let mut _20: usize;                  // in scope 0 at test-binop.rs:4:17: 4:18  | 
25 |  | -    let mut _21: usize;                  // in scope 0 at test-binop.rs:4:22: 4:27  | 
26 |  | -    let mut _22: usize;                  // in scope 0 at test-binop.rs:4:22: 4:23  | 
27 |  | -    let mut _23: usize;                  // in scope 0 at test-binop.rs:4:26: 4:27  | 
28 |  | -    let mut _24: !;                      // in scope 0 at test-binop.rs:4:5: 4:28  | 
29 |  | -    let mut _25: bool;                   // in scope 0 at test-binop.rs:5:5: 5:25  | 
30 |  | -    let mut _26: bool;                   // in scope 0 at test-binop.rs:5:13: 5:24  | 
31 |  | -    let mut _27: usize;                  // in scope 0 at test-binop.rs:5:13: 5:18  | 
32 |  | -    let mut _28: usize;                  // in scope 0 at test-binop.rs:5:13: 5:14  | 
33 |  | -    let mut _29: usize;                  // in scope 0 at test-binop.rs:5:17: 5:18  | 
34 |  | -    let mut _30: !;                      // in scope 0 at test-binop.rs:5:5: 5:25  | 
35 |  | -    let mut _31: bool;                   // in scope 0 at test-binop.rs:6:5: 6:25  | 
36 |  | -    let mut _32: bool;                   // in scope 0 at test-binop.rs:6:13: 6:24  | 
37 |  | -    let mut _33: usize;                  // in scope 0 at test-binop.rs:6:13: 6:18  | 
38 |  | -    let mut _34: usize;                  // in scope 0 at test-binop.rs:6:13: 6:14  | 
39 |  | -    let mut _35: usize;                  // in scope 0 at test-binop.rs:6:17: 6:18  | 
40 |  | -    let mut _36: !;                      // in scope 0 at test-binop.rs:6:5: 6:25  | 
 | 4 | +    debug x => _1;  | 
 | 5 | +    debug y => _2;  | 
 | 6 | +    let mut _0: ();  | 
 | 7 | +    let mut _3: bool;  | 
 | 8 | +    let mut _4: bool;  | 
 | 9 | +    let mut _5: usize;  | 
 | 10 | +    let mut _6: !;  | 
 | 11 | +    let mut _7: bool;  | 
 | 12 | +    let mut _8: bool;  | 
 | 13 | +    let mut _9: usize;  | 
 | 14 | +    let mut _10: !;  | 
 | 15 | +    let mut _11: bool;  | 
 | 16 | +    let mut _12: bool;  | 
 | 17 | +    let mut _13: usize;  | 
 | 18 | +    let mut _14: usize;  | 
 | 19 | +    let mut _15: !;  | 
 | 20 | +    let mut _16: bool;  | 
 | 21 | +    let mut _17: bool;  | 
 | 22 | +    let mut _18: usize;  | 
 | 23 | +    let mut _19: !;  | 
 | 24 | +    let mut _20: bool;  | 
 | 25 | +    let mut _21: bool;  | 
 | 26 | +    let mut _22: usize;  | 
 | 27 | +    let mut _23: !;  | 
41 | 28 | 
 
  | 
42 | 29 |     bb0: {  | 
43 |  | -        _6 = _1;                         // scope 0 at test-binop.rs:2:13: 2:14  | 
44 |  | -        _7 = _2;                         // scope 0 at test-binop.rs:2:17: 2:18  | 
45 |  | -        _5 = Add(move _6, move _7);      // scope 0 at test-binop.rs:2:13: 2:18  | 
46 |  | -        _8 = _1;                         // scope 0 at test-binop.rs:2:21: 2:22  | 
47 |  | -        _4 = Gt(move _5, move _8);       // scope 0 at test-binop.rs:2:13: 2:22  | 
48 |  | -        _3 = Not(move _4);               // scope 0 at test-binop.rs:2:5: 2:23  | 
49 |  | -        switchInt(move _3) -> [0: bb2, otherwise: bb1]; // scope 0 at test-binop.rs:2:5: 2:23  | 
 | 30 | +        _5 = Add(_1, _2);  | 
 | 31 | +        _4 = Gt(move _5, _1);  | 
 | 32 | +        _3 = Not(move _4);  | 
 | 33 | +        switchInt(move _3) -> [0: bb2, otherwise: bb1];  | 
50 | 34 |     }  | 
51 | 35 | 
 
  | 
52 | 36 |     bb1: {  | 
53 |  | -        _9 = core::panicking::panic(const "assertion failed: x + y > x"); // scope 0 at test-binop.rs:2:5: 2:23  | 
54 |  | -                                         // mir::Constant  | 
55 |  | -                                         // + span: test-binop.rs:2:5: 2:23  | 
56 |  | -                                         // + literal: Const { ty: fn(&'static str) -> ! {core::panicking::panic}, val: Value(<ZST>) }  | 
57 |  | -                                         // mir::Constant  | 
58 |  | -                                         // + span: no-location  | 
59 |  | -                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }  | 
 | 37 | +        _6 = core::panicking::panic(const "assertion failed: x + y > x");  | 
60 | 38 |     }  | 
61 | 39 | 
 
  | 
62 | 40 |     bb2: {  | 
63 |  | -        _13 = _1;                        // scope 0 at test-binop.rs:3:13: 3:14  | 
64 |  | -        _14 = _2;                        // scope 0 at test-binop.rs:3:17: 3:18  | 
65 |  | -        _12 = Add(move _13, move _14);   // scope 0 at test-binop.rs:3:13: 3:18  | 
66 |  | -        _11 = Eq(move _12, const 52_usize); // scope 0 at test-binop.rs:3:13: 3:24  | 
67 |  | -        _10 = Not(move _11);             // scope 0 at test-binop.rs:3:5: 3:25  | 
68 |  | -        switchInt(move _10) -> [0: bb4, otherwise: bb3]; // scope 0 at test-binop.rs:3:5: 3:25  | 
 | 41 | +        _9 = Add(_1, _2);  | 
 | 42 | +        _8 = Eq(move _9, const 52_usize);  | 
 | 43 | +        _7 = Not(move _8);  | 
 | 44 | +        switchInt(move _7) -> [0: bb4, otherwise: bb3];  | 
69 | 45 |     }  | 
70 | 46 | 
 
  | 
71 | 47 |     bb3: {  | 
72 |  | -        _15 = core::panicking::panic(const "assertion failed: x + y == 52"); // scope 0 at test-binop.rs:3:5: 3:25  | 
73 |  | -                                         // mir::Constant  | 
74 |  | -                                         // + span: test-binop.rs:3:5: 3:25  | 
75 |  | -                                         // + literal: Const { ty: fn(&'static str) -> ! {core::panicking::panic}, val: Value(<ZST>) }  | 
76 |  | -                                         // mir::Constant  | 
77 |  | -                                         // + span: no-location  | 
78 |  | -                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }  | 
 | 48 | +        _10 = core::panicking::panic(const "assertion failed: x + y == 52");  | 
79 | 49 |     }  | 
80 | 50 | 
 
  | 
81 | 51 |     bb4: {  | 
82 |  | -        _19 = _1;                        // scope 0 at test-binop.rs:4:13: 4:14  | 
83 |  | -        _20 = _2;                        // scope 0 at test-binop.rs:4:17: 4:18  | 
84 |  | -        _18 = Add(move _19, move _20);   // scope 0 at test-binop.rs:4:13: 4:18  | 
85 |  | -        _22 = _2;                        // scope 0 at test-binop.rs:4:22: 4:23  | 
86 |  | -        _23 = _1;                        // scope 0 at test-binop.rs:4:26: 4:27  | 
87 |  | -        _21 = Add(move _22, move _23);   // scope 0 at test-binop.rs:4:22: 4:27  | 
88 |  | -        _17 = Eq(move _18, move _21);    // scope 0 at test-binop.rs:4:13: 4:27  | 
89 |  | -        _16 = Not(move _17);             // scope 0 at test-binop.rs:4:5: 4:28  | 
90 |  | -        switchInt(move _16) -> [0: bb6, otherwise: bb5]; // scope 0 at test-binop.rs:4:5: 4:28  | 
 | 52 | +        _13 = Add(_1, _2);  | 
 | 53 | +        _14 = Add(_2, _1);  | 
 | 54 | +        _12 = Eq(move _13, move _14);  | 
 | 55 | +        _11 = Not(move _12);  | 
 | 56 | +        switchInt(move _11) -> [0: bb6, otherwise: bb5];  | 
91 | 57 |     }  | 
92 | 58 | 
 
  | 
93 | 59 |     bb5: {  | 
94 |  | -        _24 = core::panicking::panic(const "assertion failed: x + y == y + x"); // scope 0 at test-binop.rs:4:5: 4:28  | 
95 |  | -                                         // mir::Constant  | 
96 |  | -                                         // + span: test-binop.rs:4:5: 4:28  | 
97 |  | -                                         // + literal: Const { ty: fn(&'static str) -> ! {core::panicking::panic}, val: Value(<ZST>) }  | 
98 |  | -                                         // mir::Constant  | 
99 |  | -                                         // + span: no-location  | 
100 |  | -                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }  | 
 | 60 | +        _15 = core::panicking::panic(const "assertion failed: x + y == y + x");  | 
101 | 61 |     }  | 
102 | 62 | 
 
  | 
103 | 63 |     bb6: {  | 
104 |  | -        _28 = _1;                        // scope 0 at test-binop.rs:5:13: 5:14  | 
105 |  | -        _29 = _2;                        // scope 0 at test-binop.rs:5:17: 5:18  | 
106 |  | -        _27 = Add(move _28, move _29);   // scope 0 at test-binop.rs:5:13: 5:18  | 
107 |  | -        _26 = Eq(move _27, const 52_usize); // scope 0 at test-binop.rs:5:13: 5:24  | 
108 |  | -        _25 = Not(move _26);             // scope 0 at test-binop.rs:5:5: 5:25  | 
109 |  | -        switchInt(move _25) -> [0: bb8, otherwise: bb7]; // scope 0 at test-binop.rs:5:5: 5:25  | 
 | 64 | +        _18 = Add(_1, _2);  | 
 | 65 | +        _17 = Eq(move _18, const 52_usize);  | 
 | 66 | +        _16 = Not(move _17);  | 
 | 67 | +        switchInt(move _16) -> [0: bb8, otherwise: bb7];  | 
110 | 68 |     }  | 
111 | 69 | 
 
  | 
112 | 70 |     bb7: {  | 
113 |  | -        _30 = core::panicking::panic(const "assertion failed: x + y == 52"); // scope 0 at test-binop.rs:5:5: 5:25  | 
114 |  | -                                         // mir::Constant  | 
115 |  | -                                         // + span: test-binop.rs:5:5: 5:25  | 
116 |  | -                                         // + literal: Const { ty: fn(&'static str) -> ! {core::panicking::panic}, val: Value(<ZST>) }  | 
117 |  | -                                         // mir::Constant  | 
118 |  | -                                         // + span: no-location  | 
119 |  | -                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }  | 
 | 71 | +        _19 = core::panicking::panic(const "assertion failed: x + y == 52");  | 
120 | 72 |     }  | 
121 | 73 | 
 
  | 
122 | 74 |     bb8: {  | 
123 |  | -        _34 = _1;                        // scope 0 at test-binop.rs:6:13: 6:14  | 
124 |  | -        _35 = _2;                        // scope 0 at test-binop.rs:6:17: 6:18  | 
125 |  | -        _33 = Sub(move _34, move _35);   // scope 0 at test-binop.rs:6:13: 6:18  | 
126 |  | -        _32 = Eq(move _33, const 32_usize); // scope 0 at test-binop.rs:6:13: 6:24  | 
127 |  | -        _31 = Not(move _32);             // scope 0 at test-binop.rs:6:5: 6:25  | 
128 |  | -        switchInt(move _31) -> [0: bb10, otherwise: bb9]; // scope 0 at test-binop.rs:6:5: 6:25  | 
 | 75 | +        _22 = Sub(_1, _2);  | 
 | 76 | +        _21 = Eq(move _22, const 32_usize);  | 
 | 77 | +        _20 = Not(move _21);  | 
 | 78 | +        switchInt(move _20) -> [0: bb10, otherwise: bb9];  | 
129 | 79 |     }  | 
130 | 80 | 
 
  | 
131 | 81 |     bb9: {  | 
132 |  | -        _36 = core::panicking::panic(const "assertion failed: x - y == 32"); // scope 0 at test-binop.rs:6:5: 6:25  | 
133 |  | -                                         // mir::Constant  | 
134 |  | -                                         // + span: test-binop.rs:6:5: 6:25  | 
135 |  | -                                         // + literal: Const { ty: fn(&'static str) -> ! {core::panicking::panic}, val: Value(<ZST>) }  | 
136 |  | -                                         // mir::Constant  | 
137 |  | -                                         // + span: no-location  | 
138 |  | -                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }  | 
 | 82 | +        _23 = core::panicking::panic(const "assertion failed: x - y == 32");  | 
139 | 83 |     }  | 
140 | 84 | 
 
  | 
141 | 85 |     bb10: {  | 
142 |  | -        return;                          // scope 0 at test-binop.rs:8:2: 8:2  | 
 | 86 | +        return;  | 
143 | 87 |     }  | 
144 | 88 | }  | 
145 | 89 | 
 
  | 
146 | 90 | fn main() -> () {  | 
147 |  | -    let mut _0: ();                      // return place in scope 0 at test-binop.rs:11:11: 11:11  | 
148 |  | -    let _1: usize;                       // in scope 0 at test-binop.rs:12:7: 12:8  | 
149 |  | -    let _3: ();                          // in scope 0 at test-binop.rs:14:3: 14:19  | 
150 |  | -    let mut _4: usize;                   // in scope 0 at test-binop.rs:14:14: 14:15  | 
151 |  | -    let mut _5: usize;                   // in scope 0 at test-binop.rs:14:17: 14:18  | 
 | 91 | +    let mut _0: ();  | 
 | 92 | +    let _1: usize;  | 
 | 93 | +    let _3: ();  | 
152 | 94 |     scope 1 {  | 
153 |  | -        debug x => _1;                   // in scope 1 at test-binop.rs:12:7: 12:8  | 
154 |  | -        let _2: usize;                   // in scope 1 at test-binop.rs:13:7: 13:8  | 
 | 95 | +        debug x => _1;  | 
 | 96 | +        let _2: usize;  | 
155 | 97 |         scope 2 {  | 
156 |  | -            debug y => _2;               // in scope 2 at test-binop.rs:13:7: 13:8  | 
 | 98 | +            debug y => _2;  | 
157 | 99 |         }  | 
158 | 100 |     }  | 
159 | 101 | 
 
  | 
160 | 102 |     bb0: {  | 
161 |  | -        _1 = const 42_usize;             // scope 0 at test-binop.rs:12:11: 12:13  | 
162 |  | -        _2 = const 10_usize;             // scope 1 at test-binop.rs:13:11: 13:13  | 
163 |  | -        _4 = const 42_usize;             // scope 2 at test-binop.rs:14:14: 14:15  | 
164 |  | -        _5 = const 10_usize;             // scope 2 at test-binop.rs:14:17: 14:18  | 
165 |  | -        _3 = test_binop(move _4, move _5) -> bb1; // scope 2 at test-binop.rs:14:3: 14:19  | 
166 |  | -                                         // mir::Constant  | 
167 |  | -                                         // + span: test-binop.rs:14:3: 14:13  | 
168 |  | -                                         // + literal: Const { ty: fn(usize, usize) {test_binop}, val: Value(<ZST>) }  | 
 | 103 | +        _1 = const 42_usize;  | 
 | 104 | +        _2 = const 10_usize;  | 
 | 105 | +        _3 = test_binop(_1, _2) -> bb1;  | 
169 | 106 |     }  | 
170 | 107 | 
 
  | 
171 | 108 |     bb1: {  | 
172 |  | -        return;                          // scope 0 at test-binop.rs:16:2: 16:2  | 
 | 109 | +        return;  | 
173 | 110 |     }  | 
174 | 111 | }  | 
0 commit comments