fork/rust

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

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

master
3.9 KiB147 linesraw
1// MIR for `shift_signed` after built
2
3fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; 3]) {
4    debug small => _1;
5    debug big => _2;
6    debug a => _3;
7    debug b => _4;
8    debug c => _5;
9    let mut _0: ([i8; 3], [u128; 3]);
10    let mut _6: [i8; 3];
11    let mut _7: i8;
12    let mut _8: i8;
13    let mut _9: i8;
14    let mut _10: u8;
15    let mut _11: bool;
16    let mut _12: i8;
17    let mut _13: i8;
18    let mut _14: i32;
19    let mut _15: u32;
20    let mut _16: bool;
21    let mut _17: i8;
22    let mut _18: i8;
23    let mut _19: i128;
24    let mut _20: u128;
25    let mut _21: bool;
26    let mut _22: [u128; 3];
27    let mut _23: u128;
28    let mut _24: u128;
29    let mut _25: i8;
30    let mut _26: u8;
31    let mut _27: bool;
32    let mut _28: u128;
33    let mut _29: u128;
34    let mut _30: i32;
35    let mut _31: u32;
36    let mut _32: bool;
37    let mut _33: u128;
38    let mut _34: u128;
39    let mut _35: i128;
40    let mut _36: u128;
41    let mut _37: bool;
42
43    bb0: {
44        StorageLive(_6);
45        StorageLive(_7);
46        StorageLive(_8);
47        _8 = _1;
48        StorageLive(_9);
49        _9 = _3;
50        _10 = _9 as u8 (IntToInt);
51        _11 = Lt(move _10, const 8_u8);
52        assert(move _11, "attempt to shift right by `{}`, which would overflow", _9) -> [success: bb1, unwind: bb7];
53    }
54
55    bb1: {
56        _7 = Shr(move _8, move _9);
57        StorageDead(_9);
58        StorageDead(_8);
59        StorageLive(_12);
60        StorageLive(_13);
61        _13 = _1;
62        StorageLive(_14);
63        _14 = _4;
64        _15 = _14 as u32 (IntToInt);
65        _16 = Lt(move _15, const 8_u32);
66        assert(move _16, "attempt to shift right by `{}`, which would overflow", _14) -> [success: bb2, unwind: bb7];
67    }
68
69    bb2: {
70        _12 = Shr(move _13, move _14);
71        StorageDead(_14);
72        StorageDead(_13);
73        StorageLive(_17);
74        StorageLive(_18);
75        _18 = _1;
76        StorageLive(_19);
77        _19 = _5;
78        _20 = _19 as u128 (IntToInt);
79        _21 = Lt(move _20, const 8_u128);
80        assert(move _21, "attempt to shift right by `{}`, which would overflow", _19) -> [success: bb3, unwind: bb7];
81    }
82
83    bb3: {
84        _17 = Shr(move _18, move _19);
85        StorageDead(_19);
86        StorageDead(_18);
87        _6 = [move _7, move _12, move _17];
88        StorageDead(_17);
89        StorageDead(_12);
90        StorageDead(_7);
91        StorageLive(_22);
92        StorageLive(_23);
93        StorageLive(_24);
94        _24 = _2;
95        StorageLive(_25);
96        _25 = _3;
97        _26 = _25 as u8 (IntToInt);
98        _27 = Lt(move _26, const 128_u8);
99        assert(move _27, "attempt to shift left by `{}`, which would overflow", _25) -> [success: bb4, unwind: bb7];
100    }
101
102    bb4: {
103        _23 = Shl(move _24, move _25);
104        StorageDead(_25);
105        StorageDead(_24);
106        StorageLive(_28);
107        StorageLive(_29);
108        _29 = _2;
109        StorageLive(_30);
110        _30 = _4;
111        _31 = _30 as u32 (IntToInt);
112        _32 = Lt(move _31, const 128_u32);
113        assert(move _32, "attempt to shift left by `{}`, which would overflow", _30) -> [success: bb5, unwind: bb7];
114    }
115
116    bb5: {
117        _28 = Shl(move _29, move _30);
118        StorageDead(_30);
119        StorageDead(_29);
120        StorageLive(_33);
121        StorageLive(_34);
122        _34 = _2;
123        StorageLive(_35);
124        _35 = _5;
125        _36 = _35 as u128 (IntToInt);
126        _37 = Lt(move _36, const 128_u128);
127        assert(move _37, "attempt to shift left by `{}`, which would overflow", _35) -> [success: bb6, unwind: bb7];
128    }
129
130    bb6: {
131        _33 = Shl(move _34, move _35);
132        StorageDead(_35);
133        StorageDead(_34);
134        _22 = [move _23, move _28, move _33];
135        StorageDead(_33);
136        StorageDead(_28);
137        StorageDead(_23);
138        _0 = (move _6, move _22);
139        StorageDead(_22);
140        StorageDead(_6);
141        return;
142    }
143
144    bb7 (cleanup): {
145        resume;
146    }
147}