| // WARNING: This is highly experimental output it's intended for rustc_public developers only. |
| // If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir. |
| fn operands(_1: u8) -> () { |
| let mut _0: (); |
| let _2: [u8; 10]; |
| let mut _3: u8; |
| let _4: u8; |
| let _5: usize; |
| let mut _6: bool; |
| let _7: u8; |
| let _8: usize; |
| let mut _9: (usize, bool); |
| let mut _10: bool; |
| let _11: (); |
| let mut _12: (&u8, &u8); |
| let mut _13: &u8; |
| let mut _14: &u8; |
| let _15: &u8; |
| let _16: &u8; |
| let mut _17: bool; |
| let mut _18: u8; |
| let mut _19: u8; |
| let mut _20: !; |
| let _21: core::panicking::AssertKind; |
| let _22: !; |
| let mut _23: core::panicking::AssertKind; |
| let mut _24: &u8; |
| let _25: &u8; |
| let mut _26: &u8; |
| let _27: &u8; |
| let mut _28: Option<Arguments<'_>>; |
| let _29: &u8; |
| let _30: u8; |
| let _31: (); |
| let mut _32: (&u8, &u8); |
| let mut _33: &u8; |
| let mut _34: &u8; |
| let _35: &u8; |
| let _36: &u8; |
| let mut _37: bool; |
| let mut _38: u8; |
| let mut _39: u8; |
| let mut _40: !; |
| let _41: core::panicking::AssertKind; |
| let _42: !; |
| let mut _43: core::panicking::AssertKind; |
| let mut _44: &u8; |
| let _45: &u8; |
| let mut _46: &u8; |
| let _47: &u8; |
| let mut _48: Option<Arguments<'_>>; |
| let _49: (u8, u8); |
| let mut _50: u8; |
| let mut _51: u8; |
| let _52: u8; |
| let _53: u8; |
| let _54: (); |
| let mut _55: (&u8, &u8); |
| let mut _56: &u8; |
| let mut _57: &u8; |
| let _58: &u8; |
| let _59: &u8; |
| let mut _60: bool; |
| let mut _61: u8; |
| let mut _62: u8; |
| let mut _63: !; |
| let _64: core::panicking::AssertKind; |
| let _65: !; |
| let mut _66: core::panicking::AssertKind; |
| let mut _67: &u8; |
| let _68: &u8; |
| let mut _69: &u8; |
| let _70: &u8; |
| let mut _71: Option<Arguments<'_>>; |
| let _72: usize; |
| let mut _73: &[u8]; |
| let mut _74: &[u8; 10]; |
| let _75: usize; |
| let mut _76: &usize; |
| let _77: &usize; |
| let _78: (); |
| let mut _79: (&usize, &usize); |
| let mut _80: &usize; |
| let mut _81: &usize; |
| let _82: &usize; |
| let _83: &usize; |
| let mut _84: bool; |
| let mut _85: usize; |
| let mut _86: usize; |
| let mut _87: !; |
| let _88: core::panicking::AssertKind; |
| let _89: !; |
| let mut _90: core::panicking::AssertKind; |
| let mut _91: &usize; |
| let _92: &usize; |
| let mut _93: &usize; |
| let _94: &usize; |
| let mut _95: Option<Arguments<'_>>; |
| debug val => _1; |
| debug array => _2; |
| debug first => _4; |
| debug last => _7; |
| debug left_val => _15; |
| debug right_val => _16; |
| debug kind => _21; |
| debug reference => _29; |
| debug dereferenced => _30; |
| debug left_val => _35; |
| debug right_val => _36; |
| debug kind => _41; |
| debug tuple => _49; |
| debug first_again => _52; |
| debug first_again_again => _53; |
| debug left_val => _58; |
| debug right_val => _59; |
| debug kind => _64; |
| debug length => _72; |
| debug size_of => _75; |
| debug left_val => _82; |
| debug right_val => _83; |
| debug kind => _88; |
| bb0: { |
| StorageLive(_2); |
| StorageLive(_3); |
| _3 = _1; |
| _2 = [move _3; 10]; |
| StorageDead(_3); |
| StorageLive(_4); |
| StorageLive(_5); |
| _5 = 0_usize; |
| _6 = Lt(_5, 10_usize); |
| assert(move _6, "index out of bounds: the length is {} but the index is {}", 10_usize, _5) -> [success: bb1, unwind unreachable]; |
| } |
| bb1: { |
| _4 = _2[_5]; |
| StorageDead(_5); |
| StorageLive(_7); |
| StorageLive(_8); |
| _9 = CheckedSub(10_usize, 1_usize); |
| assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", 10_usize, 1_usize) -> [success: bb2, unwind unreachable]; |
| } |
| bb2: { |
| _8 = move (_9.0: usize); |
| _10 = Lt(_8, 10_usize); |
| assert(move _10, "index out of bounds: the length is {} but the index is {}", 10_usize, _8) -> [success: bb3, unwind unreachable]; |
| } |
| bb3: { |
| _7 = _2[_8]; |
| StorageDead(_8); |
| StorageLive(_11); |
| StorageLive(_12); |
| StorageLive(_13); |
| _13 = &_4; |
| StorageLive(_14); |
| _14 = &_7; |
| _12 = (move _13, move _14); |
| StorageDead(_14); |
| StorageDead(_13); |
| StorageLive(_15); |
| _15 = (_12.0: &u8); |
| StorageLive(_16); |
| _16 = (_12.1: &u8); |
| StorageLive(_17); |
| StorageLive(_18); |
| _18 = (*_15); |
| StorageLive(_19); |
| _19 = (*_16); |
| _17 = Eq(move _18, move _19); |
| switchInt(move _17) -> [0: bb5, otherwise: bb4]; |
| } |
| bb4: { |
| StorageDead(_19); |
| StorageDead(_18); |
| _11 = (); |
| StorageDead(_17); |
| StorageDead(_16); |
| StorageDead(_15); |
| StorageDead(_12); |
| StorageDead(_11); |
| StorageLive(_29); |
| _29 = &_4; |
| StorageLive(_30); |
| _30 = (*_29); |
| StorageLive(_31); |
| StorageLive(_32); |
| StorageLive(_33); |
| _33 = &_30; |
| StorageLive(_34); |
| _34 = &_4; |
| _32 = (move _33, move _34); |
| StorageDead(_34); |
| StorageDead(_33); |
| StorageLive(_35); |
| _35 = (_32.0: &u8); |
| StorageLive(_36); |
| _36 = (_32.1: &u8); |
| StorageLive(_37); |
| StorageLive(_38); |
| _38 = (*_35); |
| StorageLive(_39); |
| _39 = (*_36); |
| _37 = Eq(move _38, move _39); |
| switchInt(move _37) -> [0: bb7, otherwise: bb6]; |
| } |
| bb5: { |
| StorageDead(_19); |
| StorageDead(_18); |
| StorageLive(_21); |
| _21 = core::panicking::AssertKind::Eq; |
| StorageLive(_22); |
| StorageLive(_23); |
| _23 = move _21; |
| StorageLive(_24); |
| StorageLive(_25); |
| _25 = &(*_15); |
| _24 = &(*_25); |
| StorageLive(_26); |
| StorageLive(_27); |
| _27 = &(*_16); |
| _26 = &(*_27); |
| StorageLive(_28); |
| _28 = std::option::Option::None; |
| _22 = core::panicking::assert_failed::<u8, u8>(move _23, move _24, move _26, move _28) -> unwind unreachable; |
| } |
| bb6: { |
| StorageDead(_39); |
| StorageDead(_38); |
| _31 = (); |
| StorageDead(_37); |
| StorageDead(_36); |
| StorageDead(_35); |
| StorageDead(_32); |
| StorageDead(_31); |
| StorageLive(_49); |
| StorageLive(_50); |
| _50 = _4; |
| StorageLive(_51); |
| _51 = _7; |
| _49 = (move _50, move _51); |
| StorageDead(_51); |
| StorageDead(_50); |
| StorageLive(_52); |
| _52 = (_49.0: u8); |
| StorageLive(_53); |
| _53 = (_49.0: u8); |
| StorageLive(_54); |
| StorageLive(_55); |
| StorageLive(_56); |
| _56 = &_52; |
| StorageLive(_57); |
| _57 = &_53; |
| _55 = (move _56, move _57); |
| StorageDead(_57); |
| StorageDead(_56); |
| StorageLive(_58); |
| _58 = (_55.0: &u8); |
| StorageLive(_59); |
| _59 = (_55.1: &u8); |
| StorageLive(_60); |
| StorageLive(_61); |
| _61 = (*_58); |
| StorageLive(_62); |
| _62 = (*_59); |
| _60 = Eq(move _61, move _62); |
| switchInt(move _60) -> [0: bb9, otherwise: bb8]; |
| } |
| bb7: { |
| StorageDead(_39); |
| StorageDead(_38); |
| StorageLive(_41); |
| _41 = core::panicking::AssertKind::Eq; |
| StorageLive(_42); |
| StorageLive(_43); |
| _43 = move _41; |
| StorageLive(_44); |
| StorageLive(_45); |
| _45 = &(*_35); |
| _44 = &(*_45); |
| StorageLive(_46); |
| StorageLive(_47); |
| _47 = &(*_36); |
| _46 = &(*_47); |
| StorageLive(_48); |
| _48 = std::option::Option::None; |
| _42 = core::panicking::assert_failed::<u8, u8>(move _43, move _44, move _46, move _48) -> unwind unreachable; |
| } |
| bb8: { |
| StorageDead(_62); |
| StorageDead(_61); |
| _54 = (); |
| StorageDead(_60); |
| StorageDead(_59); |
| StorageDead(_58); |
| StorageDead(_55); |
| StorageDead(_54); |
| StorageLive(_72); |
| StorageLive(_73); |
| StorageLive(_74); |
| _74 = &_2; |
| _73 = move _74 as &[u8]; |
| StorageDead(_74); |
| _72 = core::slice::<impl [u8]>::len(move _73) -> [return: bb10, unwind unreachable]; |
| } |
| bb9: { |
| StorageDead(_62); |
| StorageDead(_61); |
| StorageLive(_64); |
| _64 = core::panicking::AssertKind::Eq; |
| StorageLive(_65); |
| StorageLive(_66); |
| _66 = move _64; |
| StorageLive(_67); |
| StorageLive(_68); |
| _68 = &(*_58); |
| _67 = &(*_68); |
| StorageLive(_69); |
| StorageLive(_70); |
| _70 = &(*_59); |
| _69 = &(*_70); |
| StorageLive(_71); |
| _71 = std::option::Option::None; |
| _65 = core::panicking::assert_failed::<u8, u8>(move _66, move _67, move _69, move _71) -> unwind unreachable; |
| } |
| bb10: { |
| StorageDead(_73); |
| StorageLive(_75); |
| StorageLive(_76); |
| StorageLive(_77); |
| _77 = &_72; |
| _76 = &(*_77); |
| _75 = std::mem::size_of_val::<usize>(move _76) -> [return: bb11, unwind unreachable]; |
| } |
| bb11: { |
| StorageDead(_76); |
| StorageDead(_77); |
| StorageLive(_78); |
| StorageLive(_79); |
| StorageLive(_80); |
| _80 = &_72; |
| StorageLive(_81); |
| _81 = &_75; |
| _79 = (move _80, move _81); |
| StorageDead(_81); |
| StorageDead(_80); |
| StorageLive(_82); |
| _82 = (_79.0: &usize); |
| StorageLive(_83); |
| _83 = (_79.1: &usize); |
| StorageLive(_84); |
| StorageLive(_85); |
| _85 = (*_82); |
| StorageLive(_86); |
| _86 = (*_83); |
| _84 = Eq(move _85, move _86); |
| switchInt(move _84) -> [0: bb13, otherwise: bb12]; |
| } |
| bb12: { |
| StorageDead(_86); |
| StorageDead(_85); |
| _78 = (); |
| StorageDead(_84); |
| StorageDead(_83); |
| StorageDead(_82); |
| StorageDead(_79); |
| StorageDead(_78); |
| _0 = (); |
| StorageDead(_75); |
| StorageDead(_72); |
| StorageDead(_53); |
| StorageDead(_52); |
| StorageDead(_49); |
| StorageDead(_30); |
| StorageDead(_29); |
| StorageDead(_7); |
| StorageDead(_4); |
| StorageDead(_2); |
| return; |
| } |
| bb13: { |
| StorageDead(_86); |
| StorageDead(_85); |
| StorageLive(_88); |
| _88 = core::panicking::AssertKind::Eq; |
| StorageLive(_89); |
| StorageLive(_90); |
| _90 = move _88; |
| StorageLive(_91); |
| StorageLive(_92); |
| _92 = &(*_82); |
| _91 = &(*_92); |
| StorageLive(_93); |
| StorageLive(_94); |
| _94 = &(*_83); |
| _93 = &(*_94); |
| StorageLive(_95); |
| _95 = std::option::Option::None; |
| _89 = core::panicking::assert_failed::<usize, usize>(move _90, move _91, move _93, move _95) -> unwind unreachable; |
| } |
| } |
| fn operands::{constant#0}() -> usize { |
| let mut _0: usize; |
| bb0: { |
| _0 = 10_usize; |
| return; |
| } |
| } |
| fn more_operands() -> [Ctors; 3] { |
| let mut _0: [Ctors; 3]; |
| let _1: Dummy; |
| let _2: Ctors; |
| let _3: Ctors; |
| let mut _4: Dummy; |
| let _5: Ctors; |
| let mut _6: Ctors; |
| let mut _7: Ctors; |
| let mut _8: Ctors; |
| debug dummy => _1; |
| debug unit => _2; |
| debug struct_like => _3; |
| debug tup_like => _5; |
| bb0: { |
| StorageLive(_1); |
| _1 = Dummy('a', core::num::<impl i32>::MIN); |
| StorageLive(_2); |
| _2 = Ctors::Unit; |
| StorageLive(_3); |
| StorageLive(_4); |
| _4 = move _1; |
| _3 = Ctors::StructLike(move _4); |
| StorageDead(_4); |
| StorageLive(_5); |
| _5 = Ctors::TupLike(false); |
| StorageLive(_6); |
| _6 = move _2; |
| StorageLive(_7); |
| _7 = move _3; |
| StorageLive(_8); |
| _8 = move _5; |
| _0 = [move _6, move _7, move _8]; |
| StorageDead(_8); |
| StorageDead(_7); |
| StorageDead(_6); |
| StorageDead(_5); |
| StorageDead(_3); |
| StorageDead(_2); |
| StorageDead(_1); |
| return; |
| } |
| } |
| fn more_operands::{constant#0}() -> usize { |
| let mut _0: usize; |
| bb0: { |
| _0 = 3_usize; |
| return; |
| } |
| } |
| fn closures(_1: bool, _2: bool) -> {closure@$DIR/operands.rs:47:5: 47:19} { |
| let mut _0: {closure@$DIR/operands.rs:47:5: 47:19}; |
| debug x => _1; |
| debug z => _2; |
| bb0: { |
| _0 = {closure@$DIR/operands.rs:47:5: 47:19}(_1, _2); |
| return; |
| } |
| } |
| fn closures::{closure#0}(_1: {closure@$DIR/operands.rs:47:5: 47:19}, _2: bool) -> bool { |
| let mut _0: bool; |
| let mut _3: bool; |
| let mut _4: bool; |
| let mut _5: bool; |
| debug y => _2; |
| debug x => (_1.0: bool); |
| debug z => (_1.1: bool); |
| bb0: { |
| StorageLive(_3); |
| StorageLive(_4); |
| _4 = (_1.0: bool); |
| StorageLive(_5); |
| _5 = _2; |
| _3 = BitXor(move _4, move _5); |
| switchInt(move _3) -> [0: bb2, otherwise: bb1]; |
| } |
| bb1: { |
| StorageDead(_5); |
| StorageDead(_4); |
| _0 = true; |
| goto -> bb3; |
| } |
| bb2: { |
| StorageDead(_5); |
| StorageDead(_4); |
| _0 = (_1.1: bool); |
| goto -> bb3; |
| } |
| bb3: { |
| StorageDead(_3); |
| return; |
| } |
| } |
| fn Ctors::TupLike(_1: bool) -> Ctors { |
| let mut _0: Ctors; |
| bb0: { |
| _0 = Ctors::TupLike(move _1); |
| return; |
| } |
| } |
