fork/rust

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

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

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