tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff

- // MIR for `main` before Inline
+ // MIR for `main` after Inline
  
  fn main() -> () {
      let mut _0: ();
      let _1: std::boxed::Box<std::vec::Vec<u32>>;
      let mut _2: std::vec::Vec<u32>;
      scope 1 {
          debug _x => _1;
      }
+     scope 2 (inlined Vec::<u32>::new) {
+         let mut _3: alloc::raw_vec::RawVec<u32>;
+     }
+     scope 3 (inlined Box::<Vec<u32>>::new) {
+         debug x => _2;
+         let mut _4: usize;
+         let mut _5: usize;
+         let mut _6: *mut u8;
+         let mut _7: *const std::vec::Vec<u32>;
+         scope 4 {
+             scope 5 (inlined alloc::alloc::exchange_malloc) {
+                 debug size => _4;
+                 debug align => _5;
+                 let _8: std::alloc::Layout;
+                 let mut _9: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
+                 let mut _10: isize;
+                 let mut _12: !;
+                 scope 6 {
+                     debug layout => _8;
+                     let _11: std::ptr::NonNull<[u8]>;
+                     let mut _13: &std::alloc::Global;
+                     scope 8 {
+                         debug ptr => _11;
+                         scope 18 (inlined NonNull::<[u8]>::as_mut_ptr) {
+                             debug self => _11;
+                             let mut _15: std::ptr::NonNull<u8>;
+                             scope 19 (inlined NonNull::<[u8]>::as_non_null_ptr) {
+                                 debug self => _11;
+                                 let mut _16: *mut u8;
+                                 let mut _17: *mut [u8];
+                                 scope 20 {
+                                     scope 21 (inlined NonNull::<[u8]>::as_ptr) {
+                                         debug self => _11;
+                                         let mut _18: *const [u8];
+                                     }
+                                     scope 22 (inlined ptr::mut_ptr::<impl *mut [u8]>::as_mut_ptr) {
+                                         debug self => _17;
+                                     }
+                                     scope 23 (inlined NonNull::<u8>::new_unchecked) {
+                                         debug ptr => _16;
+                                         let mut _19: *const u8;
+                                         scope 24 {
+                                             scope 25 (inlined NonNull::<T>::new_unchecked::runtime::<u8>) {
+                                                 debug ptr => _16;
+                                                 scope 26 (inlined ptr::mut_ptr::<impl *mut u8>::is_null) {
+                                                     debug self => _16;
+                                                     let mut _20: *mut u8;
+                                                     scope 27 {
+                                                         scope 28 (inlined ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) {
+                                                             debug ptr => _20;
+                                                             scope 29 (inlined ptr::mut_ptr::<impl *mut u8>::addr) {
+                                                                 debug self => _20;
+                                                                 scope 30 {
+                                                                     scope 31 (inlined ptr::mut_ptr::<impl *mut u8>::cast::<()>) {
+                                                                         debug self => _20;
+                                                                     }
+                                                                 }
+                                                             }
+                                                         }
+                                                     }
+                                                 }
+                                             }
+                                         }
+                                     }
+                                 }
+                             }
+                             scope 32 (inlined NonNull::<u8>::as_ptr) {
+                                 debug self => _15;
+                                 let mut _21: *const u8;
+                             }
+                         }
+                     }
+                     scope 17 (inlined <std::alloc::Global as Allocator>::allocate) {
+                         debug self => const _;
+                         debug layout => _8;
+                     }
+                 }
+                 scope 7 {
+                     scope 9 (inlined Layout::from_size_align_unchecked) {
+                         debug size => _4;
+                         debug align => _5;
+                         let mut _14: std::ptr::Alignment;
+                         scope 10 {
+                             scope 11 (inlined std::ptr::Alignment::new_unchecked) {
+                                 debug align => _5;
+                                 scope 12 {
+                                     scope 14 (inlined std::ptr::Alignment::new_unchecked::runtime) {
+                                         debug align => _5;
+                                         scope 15 (inlined core::num::<impl usize>::is_power_of_two) {
+                                             debug self => _5;
+                                             scope 16 (inlined core::num::<impl usize>::count_ones) {
+                                                 debug self => _5;
+                                             }
+                                         }
+                                     }
+                                 }
+                                 scope 13 {
+                                 }
+                             }
+                         }
+                     }
+                 }
+             }
+         }
+     }
  
      bb0: {
          StorageLive(_1);
          StorageLive(_2);
-         _2 = Vec::<u32>::new() -> [return: bb1, unwind unreachable];
+         StorageLive(_3);
+         _3 = const _;
+         _2 = Vec::<u32> { buf: move _3, len: const 0_usize };
+         StorageDead(_3);
+         _4 = SizeOf(std::vec::Vec<u32>);
+         _5 = AlignOf(std::vec::Vec<u32>);
+         StorageLive(_8);
+         StorageLive(_11);
+         StorageLive(_12);
+         StorageLive(_13);
+         StorageLive(_14);
+         _14 = _5 as std::ptr::Alignment (Transmute);
+         _8 = Layout { size: _4, align: move _14 };
+         StorageDead(_14);
+         StorageLive(_9);
+         _13 = const _;
+         _9 = std::alloc::Global::alloc_impl(move _13, _8, const false) -> [return: bb5, unwind unreachable];
      }
  
      bb1: {
-         _1 = Box::<Vec<u32>>::new(move _2) -> [return: bb2, unwind unreachable];
+         StorageDead(_1);
+         return;
      }
  
      bb2: {
+         _12 = handle_alloc_error(move _8) -> unwind unreachable;
+     }
+ 
+     bb3: {
+         unreachable;
+     }
+ 
+     bb4: {
+         _11 = ((_9 as Ok).0: std::ptr::NonNull<[u8]>);
+         StorageLive(_15);
+         StorageLive(_16);
+         StorageLive(_17);
+         StorageLive(_18);
+         _18 = (_11.0: *const [u8]);
+         _17 = move _18 as *mut [u8] (PtrToPtr);
+         StorageDead(_18);
+         _16 = _17 as *mut u8 (PtrToPtr);
+         StorageDead(_17);
+         StorageLive(_19);
+         StorageLive(_20);
+         _19 = _16 as *const u8 (PointerCoercion(MutToConstPointer));
+         _15 = NonNull::<u8> { pointer: _19 };
+         StorageDead(_20);
+         StorageDead(_19);
+         StorageDead(_16);
+         StorageLive(_21);
+         _21 = (_15.0: *const u8);
+         _6 = move _21 as *mut u8 (PtrToPtr);
+         StorageDead(_21);
+         StorageDead(_15);
+         StorageDead(_9);
+         StorageDead(_13);
+         StorageDead(_12);
+         StorageDead(_11);
+         StorageDead(_8);
+         _1 = ShallowInitBox(move _6, std::vec::Vec<u32>);
+         _7 = (((_1.0: std::ptr::Unique<std::vec::Vec<u32>>).0: std::ptr::NonNull<std::vec::Vec<u32>>).0: *const std::vec::Vec<u32>);
+         (*_7) = move _2;
          StorageDead(_2);
          _0 = const ();
-         drop(_1) -> [return: bb3, unwind unreachable];
+         drop(_1) -> [return: bb1, unwind unreachable];
      }
  
-     bb3: {
-         StorageDead(_1);
-         return;
+     bb5: {
+         _10 = discriminant(_9);
+         switchInt(move _10) -> [0: bb4, 1: bb2, otherwise: bb3];
      }
  }