tests/mir-opt/building/shifts.shift_signed.built.after.mir

   1 // MIR for `shift_signed` after built
   2
   3 fn 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 }