mirror of https://github.com/rust-lang/rust.git
136 lines
3.6 KiB
Rust
136 lines
3.6 KiB
Rust
// MIR for `shift_unsigned` after built
|
|
|
|
fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i128; 3]) {
|
|
debug small => _1;
|
|
debug big => _2;
|
|
debug a => _3;
|
|
debug b => _4;
|
|
debug c => _5;
|
|
let mut _0: ([u8; 3], [i128; 3]);
|
|
let mut _6: [u8; 3];
|
|
let mut _7: u8;
|
|
let mut _8: u8;
|
|
let mut _9: u8;
|
|
let mut _10: bool;
|
|
let mut _11: u8;
|
|
let mut _12: u8;
|
|
let mut _13: u32;
|
|
let mut _14: bool;
|
|
let mut _15: u8;
|
|
let mut _16: u8;
|
|
let mut _17: u128;
|
|
let mut _18: bool;
|
|
let mut _19: [i128; 3];
|
|
let mut _20: i128;
|
|
let mut _21: i128;
|
|
let mut _22: u8;
|
|
let mut _23: bool;
|
|
let mut _24: i128;
|
|
let mut _25: i128;
|
|
let mut _26: u32;
|
|
let mut _27: bool;
|
|
let mut _28: i128;
|
|
let mut _29: i128;
|
|
let mut _30: u128;
|
|
let mut _31: bool;
|
|
|
|
bb0: {
|
|
StorageLive(_6);
|
|
StorageLive(_7);
|
|
StorageLive(_8);
|
|
_8 = copy _1;
|
|
StorageLive(_9);
|
|
_9 = copy _3;
|
|
_10 = Lt(copy _9, const 8_u8);
|
|
assert(move _10, "attempt to shift right by `{}`, which would overflow", copy _9) -> [success: bb1, unwind: bb7];
|
|
}
|
|
|
|
bb1: {
|
|
_7 = Shr(move _8, move _9);
|
|
StorageDead(_9);
|
|
StorageDead(_8);
|
|
StorageLive(_11);
|
|
StorageLive(_12);
|
|
_12 = copy _1;
|
|
StorageLive(_13);
|
|
_13 = copy _4;
|
|
_14 = Lt(copy _13, const 8_u32);
|
|
assert(move _14, "attempt to shift right by `{}`, which would overflow", copy _13) -> [success: bb2, unwind: bb7];
|
|
}
|
|
|
|
bb2: {
|
|
_11 = Shr(move _12, move _13);
|
|
StorageDead(_13);
|
|
StorageDead(_12);
|
|
StorageLive(_15);
|
|
StorageLive(_16);
|
|
_16 = copy _1;
|
|
StorageLive(_17);
|
|
_17 = copy _5;
|
|
_18 = Lt(copy _17, const 8_u128);
|
|
assert(move _18, "attempt to shift right by `{}`, which would overflow", copy _17) -> [success: bb3, unwind: bb7];
|
|
}
|
|
|
|
bb3: {
|
|
_15 = Shr(move _16, move _17);
|
|
StorageDead(_17);
|
|
StorageDead(_16);
|
|
_6 = [move _7, move _11, move _15];
|
|
StorageDead(_15);
|
|
StorageDead(_11);
|
|
StorageDead(_7);
|
|
StorageLive(_19);
|
|
StorageLive(_20);
|
|
StorageLive(_21);
|
|
_21 = copy _2;
|
|
StorageLive(_22);
|
|
_22 = copy _3;
|
|
_23 = Lt(copy _22, const 128_u8);
|
|
assert(move _23, "attempt to shift left by `{}`, which would overflow", copy _22) -> [success: bb4, unwind: bb7];
|
|
}
|
|
|
|
bb4: {
|
|
_20 = Shl(move _21, move _22);
|
|
StorageDead(_22);
|
|
StorageDead(_21);
|
|
StorageLive(_24);
|
|
StorageLive(_25);
|
|
_25 = copy _2;
|
|
StorageLive(_26);
|
|
_26 = copy _4;
|
|
_27 = Lt(copy _26, const 128_u32);
|
|
assert(move _27, "attempt to shift left by `{}`, which would overflow", copy _26) -> [success: bb5, unwind: bb7];
|
|
}
|
|
|
|
bb5: {
|
|
_24 = Shl(move _25, move _26);
|
|
StorageDead(_26);
|
|
StorageDead(_25);
|
|
StorageLive(_28);
|
|
StorageLive(_29);
|
|
_29 = copy _2;
|
|
StorageLive(_30);
|
|
_30 = copy _5;
|
|
_31 = Lt(copy _30, const 128_u128);
|
|
assert(move _31, "attempt to shift left by `{}`, which would overflow", copy _30) -> [success: bb6, unwind: bb7];
|
|
}
|
|
|
|
bb6: {
|
|
_28 = Shl(move _29, move _30);
|
|
StorageDead(_30);
|
|
StorageDead(_29);
|
|
_19 = [move _20, move _24, move _28];
|
|
StorageDead(_28);
|
|
StorageDead(_24);
|
|
StorageDead(_20);
|
|
_0 = (move _6, move _19);
|
|
StorageDead(_19);
|
|
StorageDead(_6);
|
|
return;
|
|
}
|
|
|
|
bb7 (cleanup): {
|
|
resume;
|
|
}
|
|
}
|