Miri: unsized locals and by-value dyn traits

src/librustc_mir/interpret/eval_context.rs

@@ -116,26 +116,57 @@ pub struct LocalState<'tcx, Tag=(), Id=AllocId> {
 /// State of a local variable
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub enum LocalValue<Tag=(), Id=AllocId> {
+ /// This local is not currently alive, and cannot be used at all.
  Dead,
- // Mostly for convenience, we re-use the `Operand` type here.
- // This is an optimization over just always having a pointer here;
- // we can thus avoid doing an allocation when the local just stores
- // immediate values *and* never has its address taken.
+ /// This local is alive but not yet initialized. It can be written to
+ /// but not read from or its address taken. Locals get initialized on
+ /// first write because for unsized locals, we do not know their size
+ /// before that.
+ Uninitialized,
+ /// A normal, live local.
+ /// Mostly for convenience, we re-use the `Operand` type here.
+ /// This is an optimization over just always having a pointer here;
+ /// we can thus avoid doing an allocation when the local just stores
+ /// immediate values *and* never has its address taken.
  Live(Operand<Tag, Id>),
 }
 
-impl<'tcx, Tag> LocalState<'tcx, Tag> {
+impl<Tag: Copy> LocalValue<Tag> {
+ /// The initial value of a local: ZST get "initialized" because they can be read from without
+ /// ever having been written to.
+ fn uninit_local(
+ layout: TyLayout<'_>
+ ) -> LocalValue<Tag> {
+ // FIXME: Can we avoid this ZST special case? That would likely require MIR
+ // generation changes.
+ if layout.is_zst() {
+ LocalValue::Live(Operand::Immediate(Immediate::Scalar(Scalar::zst().into())))
+ } else {
+ LocalValue::Uninitialized
+ }
+ }
+}
+
+impl<'tcx, Tag: Copy> LocalState<'tcx, Tag> {
  pub fn access(&self) -> EvalResult<'tcx, &Operand<Tag>> {
  match self.state {
- LocalValue::Dead => err!(DeadLocal),
+ LocalValue::Dead | LocalValue::Uninitialized => err!(DeadLocal),
  LocalValue::Live(ref val) => Ok(val),
  }
  }
 
- pub fn access_mut(&mut self) -> EvalResult<'tcx, &mut Operand<Tag>> {
+ /// Overwrite the local. If the local can be overwritten in place, return a reference
+ /// to do so; otherwise return the `MemPlace` to consult instead.
+ pub fn access_mut(
+ &mut self,
+ ) -> EvalResult<'tcx, Result<&mut LocalValue<Tag>, MemPlace<Tag>>> {
  match self.state {
  LocalValue::Dead => err!(DeadLocal),
- LocalValue::Live(ref mut val) => Ok(val),
+ LocalValue::Live(Operand::Indirect(mplace)) => Ok(Err(mplace)),
+ ref mut local @ LocalValue::Live(Operand::Immediate(_)) |
+ ref mut local @ LocalValue::Uninitialized => {
+ Ok(Ok(local))
+ }
  }
  }
 }
@@ -327,6 +358,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tc
  let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs);
  self.layout_of(local_ty)
  })?;
+ // Layouts of locals are requested a lot, so we cache them.
  frame.locals[local].layout.set(Some(layout));
  Ok(layout)
  }
@@ -473,13 +505,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tc
 
  // don't allocate at all for trivial constants
  if mir.local_decls.len() > 1 {
- // We put some marker immediate into the locals that we later want to initialize.
- // This can be anything except for LocalValue::Dead -- because *that* is the
- // value we use for things that we know are initially dead.
+ // Locals are initially uninitialized.
  let dummy = LocalState {
- state: LocalValue::Live(Operand::Immediate(Immediate::Scalar(
- ScalarMaybeUndef::Undef,
- ))),
+ state: LocalValue::Uninitialized,
  layout: Cell::new(None),
  };
  let mut locals = IndexVec::from_elem(dummy, &mir.local_decls);
@@ -506,19 +534,21 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tc
  }
  },
  }
- // Finally, properly initialize all those that still have the dummy value
+ // The remaining locals are uninitialized, fill them with `uninit_local`.
+ // (For ZST this is not a NOP.)
  for (idx, local) in locals.iter_enumerated_mut() {
  match local.state {
- LocalValue::Live(_) => {
+ LocalValue::Uninitialized => {
  // This needs to be properly initialized.
  let ty = self.monomorphize(mir.local_decls[idx].ty)?;
  let layout = self.layout_of(ty)?;
- local.state = LocalValue::Live(self.uninit_operand(layout)?);
+ local.state = LocalValue::uninit_local(layout);
  local.layout = Cell::new(Some(layout));
  }
  LocalValue::Dead => {
  // Nothing to do
  }
+ LocalValue::Live(_) => bug!("Locals cannot be live yet"),
  }
  }
  // done
@@ -604,9 +634,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tc
  trace!("{:?} is now live", local);
 
  let layout = self.layout_of_local(self.frame(), local, None)?;
- let init = LocalValue::Live(self.uninit_operand(layout)?);
+ let local_val = LocalValue::uninit_local(layout);
  // StorageLive *always* kills the value that's currently stored
- Ok(mem::replace(&mut self.frame_mut().locals[local].state, init))
+ Ok(mem::replace(&mut self.frame_mut().locals[local].state, local_val))
  }
 
  /// Returns the old value of the local.
@@ -668,31 +698,31 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tc
  }
  write!(msg, ":").unwrap();
 
- match self.stack[frame].locals[local].access() {
- Err(err) => {
- if let InterpError::DeadLocal = err.kind {
- write!(msg, " is dead").unwrap();
- } else {
- panic!("Failed to access local: {:?}", err);
- }
- }
- Ok(Operand::Indirect(mplace)) => {
- let (ptr, align) = mplace.to_scalar_ptr_align();
- match ptr {
+ match self.stack[frame].locals[local].state {
+ LocalValue::Dead => write!(msg, " is dead").unwrap(),
+ LocalValue::Uninitialized => write!(msg, " is uninitialized").unwrap(),
+ LocalValue::Live(Operand::Indirect(mplace)) => {
+ match mplace.ptr {
  Scalar::Ptr(ptr) => {
- write!(msg, " by align({}) ref:", align.bytes()).unwrap();
+ write!(msg, " by align({}){} ref:",
+ mplace.align.bytes(),
+ match mplace.meta {
+ Some(meta) => format!(" meta({:?})", meta),
+ None => String::new()
+ }
+ ).unwrap();
  allocs.push(ptr.alloc_id);
  }
  ptr => write!(msg, " by integral ref: {:?}", ptr).unwrap(),
  }
  }
- Ok(Operand::Immediate(Immediate::Scalar(val))) => {
+ LocalValue::Live(Operand::Immediate(Immediate::Scalar(val))) => {
  write!(msg, " {:?}", val).unwrap();
  if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val {
  allocs.push(ptr.alloc_id);
  }
  }
- Ok(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
+ LocalValue::Live(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
  write!(msg, " ({:?}, {:?})", val1, val2).unwrap();
  if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val1 {
  allocs.push(ptr.alloc_id);

src/librustc_mir/interpret/operand.rs

@@ -14,7 +14,7 @@ use rustc::mir::interpret::{
 };
 use super::{
  InterpretCx, Machine,
- MemPlace, MPlaceTy, PlaceTy, Place, MemoryKind,
+ MemPlace, MPlaceTy, PlaceTy, Place,
 };
 pub use rustc::mir::interpret::ScalarMaybeUndef;
 
@@ -373,33 +373,6 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M>
  Ok(str)
  }
 
- pub fn uninit_operand(
- &mut self,
- layout: TyLayout<'tcx>
- ) -> EvalResult<'tcx, Operand<M::PointerTag>> {
- // This decides which types we will use the Immediate optimization for, and hence should
- // match what `try_read_immediate` and `eval_place_to_op` support.
- if layout.is_zst() {
- return Ok(Operand::Immediate(Immediate::Scalar(Scalar::zst().into())));
- }
-
- Ok(match layout.abi {
- layout::Abi::Scalar(..) =>
- Operand::Immediate(Immediate::Scalar(ScalarMaybeUndef::Undef)),
- layout::Abi::ScalarPair(..) =>
- Operand::Immediate(Immediate::ScalarPair(
- ScalarMaybeUndef::Undef,
- ScalarMaybeUndef::Undef,
- )),
- _ => {
- trace!("Forcing allocation for local of type {:?}", layout.ty);
- Operand::Indirect(
- *self.allocate(layout, MemoryKind::Stack)
- )
- }
- })
- }
-
  /// Projection functions
  pub fn operand_field(
  &self,