dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rust/tests/mir-opt/gvn.slices.GVN.panic-abort....

318 lines
9.0 KiB
Diff
Raw Permalink Blame History

- // MIR for `slices` before GVN
+ // MIR for `slices` after GVN
fn slices() -> () {
let mut _0: ();
let _1: &str;
let _2: ();
let mut _3: &str;
let _5: ();
let mut _6: &str;
let _7: ();
let mut _8: (&*const u8, &*const u8);
let mut _9: &*const u8;
let _10: *const u8;
let mut _11: &str;
let mut _12: &*const u8;
let _13: *const u8;
let mut _14: &str;
let mut _17: bool;
let mut _18: *const u8;
let mut _19: *const u8;
let mut _20: !;
let _22: !;
let mut _23: core::panicking::AssertKind;
let mut _24: &*const u8;
let _25: &*const u8;
let mut _26: &*const u8;
let _27: &*const u8;
let mut _28: std::option::Option<std::fmt::Arguments<'_>>;
let mut _30: &str;
let _31: ();
let mut _32: &[u8];
let _33: ();
let mut _34: (&*const u8, &*const u8);
let mut _35: &*const u8;
let _36: *const u8;
let mut _37: &str;
let mut _38: &*const u8;
let _39: *const u8;
let mut _40: &[u8];
let mut _43: bool;
let mut _44: *const u8;
let mut _45: *const u8;
let mut _46: !;
let _48: !;
let mut _49: core::panicking::AssertKind;
let mut _50: &*const u8;
let _51: &*const u8;
let mut _52: &*const u8;
let _53: &*const u8;
let mut _54: std::option::Option<std::fmt::Arguments<'_>>;
scope 1 {
debug s => _1;
let _4: &str;
scope 2 {
debug t => _4;
let _15: &*const u8;
let _16: &*const u8;
let _29: &[u8];
scope 3 {
debug left_val => _15;
debug right_val => _16;
let _21: core::panicking::AssertKind;
scope 4 {
debug kind => _21;
}
}
scope 5 {
debug u => _29;
let _41: &*const u8;
let _42: &*const u8;
scope 6 {
debug left_val => _41;
debug right_val => _42;
let _47: core::panicking::AssertKind;
scope 7 {
debug kind => _47;
}
}
}
}
}
bb0: {
- StorageLive(_1);
+ nop;
_1 = const "my favourite slice";
StorageLive(_2);
StorageLive(_3);
_3 = copy _1;
- _2 = opaque::<&str>(move _3) -> [return: bb1, unwind unreachable];
+ _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_3);
StorageDead(_2);
StorageLive(_4);
_4 = copy _1;
StorageLive(_5);
StorageLive(_6);
- _6 = copy _4;
- _5 = opaque::<&str>(move _6) -> [return: bb2, unwind unreachable];
+ _6 = copy _1;
+ _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_6);
StorageDead(_5);
StorageLive(_7);
StorageLive(_8);
- StorageLive(_9);
- StorageLive(_10);
+ nop;
+ nop;
StorageLive(_11);
_11 = &(*_1);
_10 = core::str::<impl str>::as_ptr(move _11) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_11);
_9 = &_10;
- StorageLive(_12);
- StorageLive(_13);
+ nop;
+ nop;
StorageLive(_14);
- _14 = &(*_4);
+ _14 = &(*_1);
_13 = core::str::<impl str>::as_ptr(move _14) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_14);
_12 = &_13;
- _8 = (move _9, move _12);
- StorageDead(_12);
- StorageDead(_9);
+ _8 = (copy _9, copy _12);
+ nop;
+ nop;
StorageLive(_15);
- _15 = copy (_8.0: &*const u8);
+ _15 = copy _9;
StorageLive(_16);
- _16 = copy (_8.1: &*const u8);
+ _16 = copy _12;
StorageLive(_17);
StorageLive(_18);
- _18 = copy (*_15);
+ _18 = copy _10;
StorageLive(_19);
- _19 = copy (*_16);
- _17 = Eq(move _18, move _19);
+ _19 = copy _13;
+ _17 = Eq(copy _10, copy _13);
switchInt(move _17) -> [0: bb6, otherwise: bb5];
}
bb5: {
StorageDead(_19);
StorageDead(_18);
_7 = const ();
StorageDead(_17);
StorageDead(_16);
StorageDead(_15);
- StorageDead(_13);
- StorageDead(_10);
+ nop;
+ nop;
StorageDead(_8);
StorageDead(_7);
- StorageLive(_29);
+ nop;
StorageLive(_30);
_30 = &(*_1);
_29 = move _30 as &[u8] (Transmute);
StorageDead(_30);
StorageLive(_31);
StorageLive(_32);
_32 = copy _29;
- _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind unreachable];
+ _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind unreachable];
}
bb6: {
StorageDead(_19);
StorageDead(_18);
- StorageLive(_21);
- _21 = core::panicking::AssertKind::Eq;
+ nop;
+ _21 = const core::panicking::AssertKind::Eq;
StorageLive(_22);
StorageLive(_23);
- _23 = move _21;
+ _23 = const core::panicking::AssertKind::Eq;
StorageLive(_24);
StorageLive(_25);
- _25 = &(*_15);
+ _25 = &(*_9);
_24 = &(*_25);
StorageLive(_26);
StorageLive(_27);
- _27 = &(*_16);
+ _27 = &(*_12);
_26 = &(*_27);
StorageLive(_28);
_28 = Option::<Arguments<'_>>::None;
- _22 = assert_failed::<*const u8, *const u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
+ _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind unreachable;
}
bb7: {
StorageDead(_32);
StorageDead(_31);
StorageLive(_33);
StorageLive(_34);
- StorageLive(_35);
- StorageLive(_36);
+ nop;
+ nop;
StorageLive(_37);
_37 = &(*_1);
_36 = core::str::<impl str>::as_ptr(move _37) -> [return: bb8, unwind unreachable];
}
bb8: {
StorageDead(_37);
_35 = &_36;
- StorageLive(_38);
- StorageLive(_39);
+ nop;
+ nop;
StorageLive(_40);
_40 = &(*_29);
_39 = core::slice::<impl [u8]>::as_ptr(move _40) -> [return: bb9, unwind unreachable];
}
bb9: {
StorageDead(_40);
_38 = &_39;
- _34 = (move _35, move _38);
- StorageDead(_38);
- StorageDead(_35);
+ _34 = (copy _35, copy _38);
+ nop;
+ nop;
StorageLive(_41);
- _41 = copy (_34.0: &*const u8);
+ _41 = copy _35;
StorageLive(_42);
- _42 = copy (_34.1: &*const u8);
+ _42 = copy _38;
StorageLive(_43);
StorageLive(_44);
- _44 = copy (*_41);
+ _44 = copy _36;
StorageLive(_45);
- _45 = copy (*_42);
- _43 = Eq(move _44, move _45);
+ _45 = copy _39;
+ _43 = Eq(copy _36, copy _39);
switchInt(move _43) -> [0: bb11, otherwise: bb10];
}
bb10: {
StorageDead(_45);
StorageDead(_44);
_33 = const ();
StorageDead(_43);
StorageDead(_42);
StorageDead(_41);
- StorageDead(_39);
- StorageDead(_36);
+ nop;
+ nop;
StorageDead(_34);
StorageDead(_33);
_0 = const ();
- StorageDead(_29);
+ nop;
StorageDead(_4);
- StorageDead(_1);
+ nop;
return;
}
bb11: {
StorageDead(_45);
StorageDead(_44);
- StorageLive(_47);
- _47 = core::panicking::AssertKind::Eq;
+ nop;
+ _47 = const core::panicking::AssertKind::Eq;
StorageLive(_48);
StorageLive(_49);
- _49 = move _47;
+ _49 = const core::panicking::AssertKind::Eq;
StorageLive(_50);
StorageLive(_51);
- _51 = &(*_41);
+ _51 = &(*_35);
_50 = &(*_51);
StorageLive(_52);
StorageLive(_53);
- _53 = &(*_42);
+ _53 = &(*_38);
_52 = &(*_53);
StorageLive(_54);
_54 = Option::<Arguments<'_>>::None;
- _48 = assert_failed::<*const u8, *const u8>(move _49, move _50, move _52, move _54) -> unwind unreachable;
+ _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind unreachable;
}
}
Reference in New Issue View Git Blame Copy Permalink