fork/rust

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

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

master
3.8 KiB154 linesraw
1// MIR for `range_loop` after PreCodegen
2
3fn 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: bb12];
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 continue];
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: bb12];
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: bb12];
134    }
135
136    bb10: {
137        StorageDead(_18);
138        StorageDead(_17);
139        StorageDead(_9);
140        goto -> bb1;
141    }
142
143    bb11: {
144        unreachable;
145    }
146
147    bb12 (cleanup): {
148        drop(_2) -> [return: bb13, unwind terminate(cleanup)];
149    }
150
151    bb13 (cleanup): {
152        resume;
153    }
154}