mirror
/
rust
mirror of https://github.com/rust-lang/rust
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rust/tests/mir-opt/inline_coroutine_body.run2-...

330 lines
11 KiB
Diff
Raw Permalink Blame History

- // MIR for `run2::{closure#0}` before Inline
+ // MIR for `run2::{closure#0}` after Inline
fn run2::{closure#0}(_1: {closure@$DIR/inline_coroutine_body.rs:13:9: 13:11}) -> () {
debug permit => (_1.0: ActionPermit<'_, T>);
debug ctx => (*(_1.1: &mut std::task::Context<'_>));
let mut _0: ();
let mut _2: {async fn body of ActionPermit<'_, T>::perform()};
let mut _3: ActionPermit<'_, T>;
let mut _5: &mut {async fn body of ActionPermit<'_, T>::perform()};
let _6: ();
let mut _7: std::task::Poll<()>;
let mut _8: std::pin::Pin<&mut {async fn body of ActionPermit<'_, T>::perform()}>;
let mut _9: &mut std::task::Context<'_>;
let mut _10: &mut std::task::Context<'_>;
scope 1 {
debug fut => _2;
let _4: std::pin::Pin<&mut {async fn body of ActionPermit<'_, T>::perform()}>;
scope 2 {
debug fut => _4;
scope 3 {
}
+ scope 6 (inlined ActionPermit::<'_, T>::perform::{closure#0}) {
+ let _11: ActionPermit<'_, T>;
+ let mut _12: std::future::Ready<()>;
+ let mut _13: std::future::Ready<()>;
+ let mut _14: ();
+ let mut _16: ();
+ let _17: ();
+ let mut _18: std::task::Poll<()>;
+ let mut _19: std::pin::Pin<&mut std::future::Ready<()>>;
+ let mut _20: &mut std::future::Ready<()>;
+ let mut _21: &mut std::future::Ready<()>;
+ let mut _22: &mut std::task::Context<'_>;
+ let mut _23: &mut std::task::Context<'_>;
+ let mut _24: &mut std::task::Context<'_>;
+ let mut _25: isize;
+ let mut _27: !;
+ let mut _28: &mut std::task::Context<'_>;
+ let mut _29: ();
+ let mut _30: ();
+ let mut _31: &mut std::task::Context<'_>;
+ let mut _32: u32;
+ let mut _33: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _34: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _35: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _36: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _37: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _38: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _39: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _40: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _41: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ let mut _42: &mut {async fn body of ActionPermit<'_, T>::perform()};
+ scope 7 {
+ let mut _15: std::future::Ready<()>;
+ scope 8 {
+ let _26: ();
+ scope 9 {
+ }
+ }
+ scope 10 (inlined ready::<()>) {
+ let mut _43: std::option::Option<()>;
+ }
+ }
+ }
}
+ scope 5 (inlined Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}>::new_unchecked) {
+ }
}
+ scope 4 (inlined ActionPermit::<'_, T>::perform) {
+ }
bb0: {
StorageLive(_2);
StorageLive(_3);
_3 = move (_1.0: ActionPermit<'_, T>);
- _2 = ActionPermit::<'_, T>::perform(move _3) -> [return: bb1, unwind: bb6];
- }
-
- bb1: {
+ _2 = {coroutine@$DIR/inline_coroutine_body.rs:25:28: 27:6 (#0)} { self: move _3 };
StorageDead(_3);
StorageLive(_4);
StorageLive(_5);
_5 = &mut _2;
- _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}>::new_unchecked(move _5) -> [return: bb2, unwind: bb5];
- }
-
- bb2: {
+ _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: _5 };
StorageDead(_5);
StorageLive(_6);
StorageLive(_7);
StorageLive(_8);
_8 = move _4;
StorageLive(_9);
_10 = deref_copy (_1.1: &mut std::task::Context<'_>);
_9 = &mut (*_10);
- _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5];
+ StorageLive(_11);
+ StorageLive(_15);
+ StorageLive(_16);
+ StorageLive(_25);
+ StorageLive(_27);
+ StorageLive(_30);
+ StorageLive(_31);
+ StorageLive(_32);
+ StorageLive(_33);
+ StorageLive(_34);
+ StorageLive(_35);
+ StorageLive(_36);
+ StorageLive(_37);
+ StorageLive(_38);
+ StorageLive(_39);
+ StorageLive(_40);
+ StorageLive(_41);
+ StorageLive(_42);
+ _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ _32 = discriminant((*_33));
+ switchInt(move _32) -> [0: bb5, 1: bb22, 2: bb21, 3: bb20, otherwise: bb10];
}
- bb3: {
+ bb1: {
+ StorageDead(_2);
+ return;
+ }
+
+ bb2 (cleanup): {
+ drop(_2) -> [return: bb3, unwind terminate(cleanup)];
+ }
+
+ bb3 (cleanup): {
+ resume;
+ }
+
+ bb4: {
+ StorageDead(_42);
+ StorageDead(_41);
+ StorageDead(_40);
+ StorageDead(_39);
+ StorageDead(_38);
+ StorageDead(_37);
+ StorageDead(_36);
+ StorageDead(_35);
+ StorageDead(_34);
+ StorageDead(_33);
+ StorageDead(_32);
+ StorageDead(_31);
+ StorageDead(_30);
+ StorageDead(_27);
+ StorageDead(_25);
+ StorageDead(_16);
+ StorageDead(_15);
+ StorageDead(_11);
StorageDead(_9);
StorageDead(_8);
StorageDead(_7);
_6 = const ();
StorageDead(_6);
_0 = const ();
StorageDead(_4);
- drop(_2) -> [return: bb4, unwind: bb6];
+ drop(_2) -> [return: bb1, unwind: bb3];
}
- bb4: {
- StorageDead(_2);
- return;
+ bb5: {
+ _31 = move _9;
+ _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
+ StorageLive(_12);
+ StorageLive(_13);
+ StorageLive(_14);
+ _14 = ();
+ StorageLive(_43);
+ _43 = Option::<()>::Some(_14);
+ _13 = std::future::Ready::<()>(move _43);
+ StorageDead(_43);
+ StorageDead(_14);
+ _12 = <std::future::Ready<()> as IntoFuture>::into_future(move _13) -> [return: bb6, unwind: bb17];
}
- bb5 (cleanup): {
- drop(_2) -> [return: bb6, unwind terminate(cleanup)];
+ bb6: {
+ StorageDead(_13);
+ _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
+ goto -> bb7;
}
- bb6 (cleanup): {
- resume;
+ bb7: {
+ StorageLive(_17);
+ StorageLive(_18);
+ StorageLive(_19);
+ StorageLive(_20);
+ StorageLive(_21);
+ _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
+ _20 = &mut (*_21);
+ _19 = Pin::<&mut std::future::Ready<()>>::new_unchecked(move _20) -> [return: bb8, unwind: bb15];
+ }
+
+ bb8: {
+ StorageDead(_20);
+ StorageLive(_22);
+ StorageLive(_23);
+ StorageLive(_24);
+ _24 = _31;
+ _23 = move _24;
+ _22 = &mut (*_23);
+ StorageDead(_24);
+ _18 = <std::future::Ready<()> as Future>::poll(move _19, move _22) -> [return: bb9, unwind: bb14];
+ }
+
+ bb9: {
+ StorageDead(_22);
+ StorageDead(_19);
+ _25 = discriminant(_18);
+ switchInt(move _25) -> [0: bb12, 1: bb11, otherwise: bb10];
+ }
+
+ bb10: {
+ unreachable;
+ }
+
+ bb11: {
+ _17 = const ();
+ StorageDead(_23);
+ StorageDead(_21);
+ StorageDead(_18);
+ StorageDead(_17);
+ StorageLive(_28);
+ StorageLive(_29);
+ _29 = ();
+ _7 = Poll::<()>::Pending;
+ StorageDead(_12);
+ StorageDead(_28);
+ StorageDead(_29);
+ _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ discriminant((*_38)) = 3;
+ goto -> bb4;
+ }
+
+ bb12: {
+ StorageLive(_26);
+ _26 = ((_18 as Ready).0: ());
+ _30 = _26;
+ StorageDead(_26);
+ StorageDead(_23);
+ StorageDead(_21);
+ StorageDead(_18);
+ StorageDead(_17);
+ StorageDead(_12);
+ _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb13, unwind: bb19];
+ }
+
+ bb13: {
+ _7 = Poll::<()>::Ready(move _30);
+ _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ discriminant((*_40)) = 1;
+ goto -> bb4;
+ }
+
+ bb14 (cleanup): {
+ StorageDead(_22);
+ StorageDead(_19);
+ StorageDead(_23);
+ goto -> bb16;
+ }
+
+ bb15 (cleanup): {
+ StorageDead(_20);
+ StorageDead(_19);
+ goto -> bb16;
+ }
+
+ bb16 (cleanup): {
+ StorageDead(_21);
+ StorageDead(_18);
+ StorageDead(_17);
+ goto -> bb18;
+ }
+
+ bb17 (cleanup): {
+ StorageDead(_13);
+ goto -> bb18;
+ }
+
+ bb18 (cleanup): {
+ StorageDead(_12);
+ _41 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ drop((((*_41) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb19, unwind terminate(cleanup)];
+ }
+
+ bb19 (cleanup): {
+ _42 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+ discriminant((*_42)) = 2;
+ goto -> bb2;
+ }
+
+ bb20: {
+ StorageLive(_12);
+ StorageLive(_28);
+ StorageLive(_29);
+ _28 = move _9;
+ StorageDead(_29);
+ _31 = move _28;
+ StorageDead(_28);
+ _16 = const ();
+ goto -> bb7;
+ }
+
+ bb21: {
+ assert(const false, "`async fn` resumed after panicking") -> [success: bb21, unwind: bb2];
+ }
+
+ bb22: {
+ assert(const false, "`async fn` resumed after completion") -> [success: bb22, unwind: bb2];
}
}
Reference in New Issue View Git Blame Copy Permalink