Auto merge of #89030 - nbdd0121:box2, r=jonas-schievink

Introduce `Rvalue::ShallowInitBox` Polished version of #88700. Implements MCP rust-lang/compiler-team#460, and should allow #43596 to go forward. In short, creating an empty box is split from a nullary-op `NullOp::Box` into two steps, first a call to `exchange_malloc`, then a `Rvalue::ShallowInitBox` which transmutes `*mut u8` to a shallow-initialized `Box<T>`. This allows the `exchange_malloc` call to unwind. Details can be found in the MCP. `NullOp::Box` is not yet removed, purely to make reverting easier in case anything goes wrong as the result of this PR. If revert is needed a reversion of "Use Rvalue::ShallowInitBox for box expression" commit followed by a test bless should be sufficient. Experiments in #88700 showed a very slight compile-time perf regression due to (supposedly) slightly more time spent in LLVM. We could omit unwind edge generation (in non-`oom=panic` case) in box expression MIR construction to restore perf; but I don't think it's necessary since runtime perf isn't affected and perf difference is rather small.

Author: bors

compiler/rustc_borrowck/src/invalidation.rs

@@ -316,7 +316,8 @@ impl<'cx, 'tcx> InvalidationGenerator<'cx, 'tcx> {
  Rvalue::Use(ref operand)
  | Rvalue::Repeat(ref operand, _)
  | Rvalue::UnaryOp(_ /*un_op*/, ref operand)
- | Rvalue::Cast(_ /*cast_kind*/, ref operand, _ /*ty*/) => {
+ | Rvalue::Cast(_ /*cast_kind*/, ref operand, _ /*ty*/)
+ | Rvalue::ShallowInitBox(ref operand, _ /*ty*/) => {
  self.consume_operand(location, operand)
  }
 

compiler/rustc_borrowck/src/lib.rs

@@ -1361,7 +1361,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  Rvalue::Use(ref operand)
  | Rvalue::Repeat(ref operand, _)
  | Rvalue::UnaryOp(_ /*un_op*/, ref operand)
- | Rvalue::Cast(_ /*cast_kind*/, ref operand, _ /*ty*/) => {
+ | Rvalue::Cast(_ /*cast_kind*/, ref operand, _ /*ty*/)
+ | Rvalue::ShallowInitBox(ref operand, _ /*ty*/) => {
  self.consume_operand(location, (operand, span), flow_state)
  }
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2024,13 +2024,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  }
  }
 
- Rvalue::NullaryOp(_, ty) => {
- // Even with unsized locals cannot box an unsized value.
- if self.unsized_feature_enabled() {
- let span = body.source_info(location).span;
- self.ensure_place_sized(ty, span);
- }
-
+ Rvalue::NullaryOp(_, ty) | Rvalue::ShallowInitBox(_, ty) => {
  let trait_ref = ty::TraitRef {
  def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
  substs: tcx.mk_substs_trait(ty, &[]),
@@ -2363,6 +2357,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  | Rvalue::AddressOf(..)
  | Rvalue::Len(..)
  | Rvalue::Cast(..)
+ | Rvalue::ShallowInitBox(..)
  | Rvalue::BinaryOp(..)
  | Rvalue::CheckedBinaryOp(..)
  | Rvalue::NullaryOp(..)

compiler/rustc_codegen_cranelift/src/base.rs

@@ -701,6 +701,13 @@ fn codegen_stmt<'tcx>(
  let len = codegen_array_len(fx, place);
  lval.write_cvalue(fx, CValue::by_val(len, usize_layout));
  }
+ Rvalue::ShallowInitBox(ref operand, content_ty) => {
+ let content_ty = fx.monomorphize(content_ty);
+ let box_layout = fx.layout_of(fx.tcx.mk_box(content_ty));
+ let operand = codegen_operand(fx, operand);
+ let operand = operand.load_scalar(fx);
+ lval.write_cvalue(fx, CValue::by_val(operand, box_layout));
+ }
  Rvalue::NullaryOp(NullOp::Box, content_ty) => {
  let usize_type = fx.clif_type(fx.tcx.types.usize).unwrap();
  let content_ty = fx.monomorphize(content_ty);

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -550,6 +550,18 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  OperandRef::new_zst(&mut bx, self.cx.layout_of(self.monomorphize(ty)));
  (bx, operand)
  }
+ mir::Rvalue::ShallowInitBox(ref operand, content_ty) => {
+ let operand = self.codegen_operand(&mut bx, operand);
+ let lloperand = operand.immediate();
+
+ let content_ty = self.monomorphize(content_ty);
+ let box_layout = bx.cx().layout_of(bx.tcx().mk_box(content_ty));
+ let llty_ptr = bx.cx().backend_type(box_layout);
+
+ let val = bx.pointercast(lloperand, llty_ptr);
+ let operand = OperandRef { val: OperandValue::Immediate(val), layout: box_layout };
+ (bx, operand)
+ }
  }
  }
 
@@ -763,6 +775,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  mir::Rvalue::AddressOf(..) |
  mir::Rvalue::Len(..) |
  mir::Rvalue::Cast(..) | // (*)
+ mir::Rvalue::ShallowInitBox(..) | // (*)
  mir::Rvalue::BinaryOp(..) |
  mir::Rvalue::CheckedBinaryOp(..) |
  mir::Rvalue::UnaryOp(..) |

compiler/rustc_const_eval/src/interpret/step.rs

@@ -289,6 +289,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  self.write_scalar(Scalar::from_machine_usize(val, self), &dest)?;
  }
 
+ ShallowInitBox(ref operand, _) => {
+ let src = self.eval_operand(operand, None)?;
+ let v = self.read_immediate(&src)?;
+ self.write_immediate(*v, &dest)?;
+ }
+
  Cast(cast_kind, ref operand, cast_ty) => {
  let src = self.eval_operand(operand, None)?;
  let cast_ty = self.subst_from_current_frame_and_normalize_erasing_regions(cast_ty);

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -650,6 +650,7 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
 
  Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, _) => {}
  Rvalue::NullaryOp(NullOp::Box, _) => self.check_op(ops::HeapAllocation),
+ Rvalue::ShallowInitBox(_, _) => {}
 
  Rvalue::UnaryOp(_, ref operand) => {
  let ty = operand.ty(self.body, self.tcx);
@@ -912,6 +913,11 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
  return;
  }
 
+ if Some(callee) == tcx.lang_items().exchange_malloc_fn() {
+ self.check_op(ops::HeapAllocation);
+ return;
+ }
+
  // `async` blocks get lowered to `std::future::from_generator(/* a closure */)`.
  let is_async_block = Some(callee) == tcx.lang_items().from_generator_fn();
  if is_async_block {

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -206,7 +206,8 @@ where
  Rvalue::Use(operand)
  | Rvalue::Repeat(operand, _)
  | Rvalue::UnaryOp(_, operand)
- | Rvalue::Cast(_, operand, _) => in_operand::<Q, _>(cx, in_local, operand),
+ | Rvalue::Cast(_, operand, _)
+ | Rvalue::ShallowInitBox(operand, _) => in_operand::<Q, _>(cx, in_local, operand),
 
  Rvalue::BinaryOp(_, box (lhs, rhs)) | Rvalue::CheckedBinaryOp(_, box (lhs, rhs)) => {
  in_operand::<Q, _>(cx, in_local, lhs) || in_operand::<Q, _>(cx, in_local, rhs)

compiler/rustc_const_eval/src/transform/promote_consts.rs

@@ -523,6 +523,8 @@ impl<'tcx> Validator<'_, 'tcx> {
  NullOp::AlignOf => {}
  },
 
+ Rvalue::ShallowInitBox(_, _) => return Err(Unpromotable),
+
  Rvalue::UnaryOp(op, operand) => {
  match op {
  // These operations can never fail.

compiler/rustc_middle/src/mir/mod.rs

@@ -2200,6 +2200,12 @@ pub enum Rvalue<'tcx> {
  /// that `Foo` has a destructor. These rvalues can be optimized
  /// away after type-checking and before lowering.
  Aggregate(Box<AggregateKind<'tcx>>, Vec<Operand<'tcx>>),
+
+ /// Transmutes a `*mut u8` into shallow-initialized `Box<T>`.
+ ///
+ /// This is different a normal transmute because dataflow analysis will treat the box
+ /// as initialized but its content as uninitialized.
+ ShallowInitBox(Operand<'tcx>, Ty<'tcx>),
 }
 
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
@@ -2450,6 +2456,10 @@ impl<'tcx> Debug for Rvalue<'tcx> {
  }),
  }
  }
+
+ ShallowInitBox(ref place, ref ty) => {
+ write!(fmt, "ShallowInitBox({:?}, {:?})", place, ty)
+ }
  }
  }
 }