tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir

   1 // MIR for `range_loop` after PreCodegen
   2
   3 fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
   4     debug slice => _1;
   5     debug f => _2;
   6     let mut _0: ();
   7     let mut _3: usize;
   8     let mut _4: std::ops::Range<usize>;
   9     let mut _5: std::ops::Range<usize>;
  10     let mut _9: std::option::Option<usize>;
  11     let mut _12: isize;
  12     let mut _14: usize;
  13     let mut _15: bool;
  14     let mut _17: &impl Fn(usize, &T);
  15     let mut _18: (usize, &T);
  16     let _19: ();
  17     let mut _20: &mut std::ops::Range<usize>;
  18     scope 1 {
  19         debug iter => _5;
  20         let _13: usize;
  21         scope 2 {
  22             debug i => _13;
  23             let _16: &T;
  24             scope 3 {
  25                 debug x => _16;
  26             }
  27         }
  28         scope 5 (inlined iter::range::<impl Iterator for std::ops::Range<usize>>::next) {
  29             debug self => _20;
  30             scope 6 (inlined <std::ops::Range<usize> as iter::range::RangeIteratorImpl>::spec_next) {
  31                 debug self => _20;
  32                 let mut _8: bool;
  33                 let _10: usize;
  34                 let mut _11: usize;
  35                 let mut _21: &usize;
  36                 let mut _22: &usize;
  37                 scope 7 {
  38                     debug old => _10;
  39                     scope 8 {
  40                     }
  41                 }
  42                 scope 9 (inlined cmp::impls::<impl PartialOrd for usize>::lt) {
  43                     debug self => _21;
  44                     debug other => _22;
  45                     let mut _6: usize;
  46                     let mut _7: usize;
  47                 }
  48             }
  49         }
  50     }
  51     scope 4 (inlined <std::ops::Range<usize> as IntoIterator>::into_iter) {
  52         debug self => _4;
  53     }
  54
  55     bb0: {
  56         StorageLive(_3);
  57         _3 = Len((*_1));
  58         _4 = std::ops::Range::<usize> { start: const 0_usize, end: move _3 };
  59         StorageDead(_3);
  60         StorageLive(_5);
  61         _5 = move _4;
  62         goto -> bb1;
  63     }
  64
  65     bb1: {
  66         StorageLive(_9);
  67         StorageLive(_10);
  68         StorageLive(_8);
  69         StorageLive(_21);
  70         StorageLive(_22);
  71         StorageLive(_6);
  72         _6 = (_5.0: usize);
  73         StorageLive(_7);
  74         _7 = (_5.1: usize);
  75         _8 = Lt(move _6, move _7);
  76         StorageDead(_7);
  77         StorageDead(_6);
  78         switchInt(move _8) -> [0: bb2, otherwise: bb3];
  79     }
  80
  81     bb2: {
  82         StorageDead(_22);
  83         StorageDead(_21);
  84         _9 = Option::<usize>::None;
  85         goto -> bb5;
  86     }
  87
  88     bb3: {
  89         StorageDead(_22);
  90         StorageDead(_21);
  91         _10 = (_5.0: usize);
  92         StorageLive(_11);
  93         _11 = <usize as Step>::forward_unchecked(_10, const 1_usize) -> [return: bb4, unwind unreachable];
  94     }
  95
  96     bb4: {
  97         (_5.0: usize) = move _11;
  98         StorageDead(_11);
  99         _9 = Option::<usize>::Some(_10);
 100         goto -> bb5;
 101     }
 102
 103     bb5: {
 104         StorageDead(_8);
 105         StorageDead(_10);
 106         _12 = discriminant(_9);
 107         switchInt(move _12) -> [0: bb6, 1: bb8, otherwise: bb11];
 108     }
 109
 110     bb6: {
 111         StorageDead(_9);
 112         StorageDead(_5);
 113         drop(_2) -> [return: bb7, unwind unreachable];
 114     }
 115
 116     bb7: {
 117         return;
 118     }
 119
 120     bb8: {
 121         _13 = ((_9 as Some).0: usize);
 122         _14 = Len((*_1));
 123         _15 = Lt(_13, _14);
 124         assert(move _15, "index out of bounds: the length is {} but the index is {}", move _14, _13) -> [success: bb9, unwind unreachable];
 125     }
 126
 127     bb9: {
 128         _16 = &(*_1)[_13];
 129         StorageLive(_17);
 130         _17 = &_2;
 131         StorageLive(_18);
 132         _18 = (_13, _16);
 133         _19 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _17, move _18) -> [return: bb10, unwind unreachable];
 134     }
 135
 136     bb10: {
 137         StorageDead(_18);
 138         StorageDead(_17);
 139         StorageDead(_9);
 140         goto -> bb1;
 141     }
 142
 143     bb11: {
 144         unreachable;
 145     }
 146 }