From d06a2a368df2d15cd4e9c3e1c3e8c86727307502 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Mi=C4=85sko?= Date: Mon, 15 Feb 2021 00:00:00 +0000 Subject: [PATCH] Pass MPlaceTy by reference not value --- .../rustc_mir/src/const_eval/eval_queries.rs | 8 +-- compiler/rustc_mir/src/const_eval/machine.rs | 2 +- compiler/rustc_mir/src/const_eval/mod.rs | 2 +- .../rustc_mir/src/interpret/eval_context.rs | 10 ++-- compiler/rustc_mir/src/interpret/intern.rs | 8 +-- .../rustc_mir/src/interpret/intrinsics.rs | 2 +- .../interpret/intrinsics/caller_location.rs | 6 +- compiler/rustc_mir/src/interpret/operand.rs | 23 ++++--- compiler/rustc_mir/src/interpret/place.rs | 60 +++++++++---------- compiler/rustc_mir/src/interpret/step.rs | 4 +- .../rustc_mir/src/interpret/terminator.rs | 2 +- compiler/rustc_mir/src/interpret/validity.rs | 2 +- compiler/rustc_mir/src/interpret/visitor.rs | 8 +-- 13 files changed, 72 insertions(+), 65 deletions(-) diff --git a/compiler/rustc_mir/src/const_eval/eval_queries.rs b/compiler/rustc_mir/src/const_eval/eval_queries.rs index 9a2e659678d5..e9a0742d493d 100644 --- a/compiler/rustc_mir/src/const_eval/eval_queries.rs +++ b/compiler/rustc_mir/src/const_eval/eval_queries.rs @@ -72,7 +72,7 @@ fn eval_body_using_ecx<'mir, 'tcx>( None => InternKind::Constant, } }; - intern_const_alloc_recursive(ecx, intern_kind, ret)?; + intern_const_alloc_recursive(ecx, intern_kind, &ret)?; debug!("eval_body_using_ecx done: {:?}", *ret); Ok(ret) @@ -137,7 +137,7 @@ pub(super) fn op_to_const<'tcx>( op.try_as_mplace(ecx) }; - let to_const_value = |mplace: MPlaceTy<'_>| match mplace.ptr { + let to_const_value = |mplace: &MPlaceTy<'_>| match mplace.ptr { Scalar::Ptr(ptr) => { let alloc = ecx.tcx.global_alloc(ptr.alloc_id).unwrap_memory(); ConstValue::ByRef { alloc, offset: ptr.offset } @@ -155,12 +155,12 @@ pub(super) fn op_to_const<'tcx>( } }; match immediate { - Ok(mplace) => to_const_value(mplace), + Ok(ref mplace) => to_const_value(mplace), // see comment on `let try_as_immediate` above Err(imm) => match *imm { Immediate::Scalar(x) => match x { ScalarMaybeUninit::Scalar(s) => ConstValue::Scalar(s), - ScalarMaybeUninit::Uninit => to_const_value(op.assert_mem_place(ecx)), + ScalarMaybeUninit::Uninit => to_const_value(&op.assert_mem_place(ecx)), }, Immediate::ScalarPair(a, b) => { let (data, start) = match a.check_init().unwrap() { diff --git a/compiler/rustc_mir/src/const_eval/machine.rs b/compiler/rustc_mir/src/const_eval/machine.rs index 70548c583d69..14b67fe11941 100644 --- a/compiler/rustc_mir/src/const_eval/machine.rs +++ b/compiler/rustc_mir/src/const_eval/machine.rs @@ -40,7 +40,7 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> { assert!(args.len() == 1); let msg_place = self.deref_operand(&args[0])?; - let msg = Symbol::intern(self.read_str(msg_place)?); + let msg = Symbol::intern(self.read_str(&msg_place)?); let span = self.find_closest_untracked_caller_location(); let (file, line, col) = self.location_triple_for_span(span); Err(ConstEvalErrKind::Panic { msg, file, line, col }.into()) diff --git a/compiler/rustc_mir/src/const_eval/mod.rs b/compiler/rustc_mir/src/const_eval/mod.rs index 480489c9bc0b..a4e1cd2faa3c 100644 --- a/compiler/rustc_mir/src/const_eval/mod.rs +++ b/compiler/rustc_mir/src/const_eval/mod.rs @@ -29,7 +29,7 @@ pub(crate) fn const_caller_location( let mut ecx = mk_eval_cx(tcx, DUMMY_SP, ty::ParamEnv::reveal_all(), false); let loc_place = ecx.alloc_caller_location(file, line, col); - if intern_const_alloc_recursive(&mut ecx, InternKind::Constant, loc_place).is_err() { + if intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &loc_place).is_err() { bug!("intern_const_alloc_recursive should not error in this case") } ConstValue::Scalar(loc_place.ptr) diff --git a/compiler/rustc_mir/src/interpret/eval_context.rs b/compiler/rustc_mir/src/interpret/eval_context.rs index 3d3a4afb5aca..c56f8a40678c 100644 --- a/compiler/rustc_mir/src/interpret/eval_context.rs +++ b/compiler/rustc_mir/src/interpret/eval_context.rs @@ -548,8 +548,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// This can fail to provide an answer for extern types. pub(super) fn size_and_align_of( &self, - metadata: MemPlaceMeta, - layout: TyAndLayout<'tcx>, + metadata: &MemPlaceMeta, + layout: &TyAndLayout<'tcx>, ) -> InterpResult<'tcx, Option<(Size, Align)>> { if !layout.is_unsized() { return Ok(Some((layout.size, layout.align.abi))); @@ -577,7 +577,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // the last field). Can't have foreign types here, how would we // adjust alignment and size for them? let field = layout.field(self, layout.fields.count() - 1)?; - let (unsized_size, unsized_align) = match self.size_and_align_of(metadata, field)? { + let (unsized_size, unsized_align) = match self.size_and_align_of(metadata, &field)? { Some(size_and_align) => size_and_align, None => { // A field with extern type. If this field is at offset 0, we behave @@ -645,9 +645,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { #[inline] pub fn size_and_align_of_mplace( &self, - mplace: MPlaceTy<'tcx, M::PointerTag>, + mplace: &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx, Option<(Size, Align)>> { - self.size_and_align_of(mplace.meta, mplace.layout) + self.size_and_align_of(&mplace.meta, &mplace.layout) } pub fn push_stack_frame( diff --git a/compiler/rustc_mir/src/interpret/intern.rs b/compiler/rustc_mir/src/interpret/intern.rs index 2eba2c4e5338..42601ce2195e 100644 --- a/compiler/rustc_mir/src/interpret/intern.rs +++ b/compiler/rustc_mir/src/interpret/intern.rs @@ -296,7 +296,7 @@ pub enum InternKind { pub fn intern_const_alloc_recursive>( ecx: &mut InterpCx<'mir, 'tcx, M>, intern_kind: InternKind, - ret: MPlaceTy<'tcx>, + ret: &MPlaceTy<'tcx>, ) -> Result<(), ErrorReported> where 'tcx: 'mir, @@ -328,7 +328,7 @@ where Some(ret.layout.ty), ); - ref_tracking.track((ret, base_intern_mode), || ()); + ref_tracking.track((*ret, base_intern_mode), || ()); while let Some(((mplace, mode), _)) = ref_tracking.todo.pop() { let res = InternVisitor { @@ -435,11 +435,11 @@ impl<'mir, 'tcx: 'mir, M: super::intern::CompileTimeMachine<'mir, 'tcx, !>> layout: TyAndLayout<'tcx>, f: impl FnOnce( &mut InterpCx<'mir, 'tcx, M>, - MPlaceTy<'tcx, M::PointerTag>, + &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx, ()>, ) -> InterpResult<'tcx, &'tcx Allocation> { let dest = self.allocate(layout, MemoryKind::Stack); - f(self, dest)?; + f(self, &dest)?; let ptr = dest.ptr.assert_ptr(); assert_eq!(ptr.offset, Size::ZERO); let mut alloc = self.memory.alloc_map.remove(&ptr.alloc_id).unwrap().1; diff --git a/compiler/rustc_mir/src/interpret/intrinsics.rs b/compiler/rustc_mir/src/interpret/intrinsics.rs index ab1ab69c8d51..00f8a3d0ce26 100644 --- a/compiler/rustc_mir/src/interpret/intrinsics.rs +++ b/compiler/rustc_mir/src/interpret/intrinsics.rs @@ -145,7 +145,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // dereferencable! let place = self.ref_to_mplace(&self.read_immediate(&args[0])?)?; let (size, align) = self - .size_and_align_of_mplace(place)? + .size_and_align_of_mplace(&place)? .ok_or_else(|| err_unsup_format!("`extern type` does not have known layout"))?; let result = match intrinsic_name { diff --git a/compiler/rustc_mir/src/interpret/intrinsics/caller_location.rs b/compiler/rustc_mir/src/interpret/intrinsics/caller_location.rs index 72b07d763724..4dfdc08b875c 100644 --- a/compiler/rustc_mir/src/interpret/intrinsics/caller_location.rs +++ b/compiler/rustc_mir/src/interpret/intrinsics/caller_location.rs @@ -92,11 +92,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let location = self.allocate(loc_layout, MemoryKind::CallerLocation); // Initialize fields. - self.write_immediate(file.to_ref(), &self.mplace_field(location, 0).unwrap().into()) + self.write_immediate(file.to_ref(), &self.mplace_field(&location, 0).unwrap().into()) .expect("writing to memory we just allocated cannot fail"); - self.write_scalar(line, &self.mplace_field(location, 1).unwrap().into()) + self.write_scalar(line, &self.mplace_field(&location, 1).unwrap().into()) .expect("writing to memory we just allocated cannot fail"); - self.write_scalar(col, &self.mplace_field(location, 2).unwrap().into()) + self.write_scalar(col, &self.mplace_field(&location, 2).unwrap().into()) .expect("writing to memory we just allocated cannot fail"); location diff --git a/compiler/rustc_mir/src/interpret/operand.rs b/compiler/rustc_mir/src/interpret/operand.rs index 1a0d9ba1d3c5..f85191f459fa 100644 --- a/compiler/rustc_mir/src/interpret/operand.rs +++ b/compiler/rustc_mir/src/interpret/operand.rs @@ -180,6 +180,13 @@ impl<'tcx, Tag: Copy> From> for OpTy<'tcx, Tag> { } } +impl<'tcx, Tag: Copy> From<&'_ MPlaceTy<'tcx, Tag>> for OpTy<'tcx, Tag> { + #[inline(always)] + fn from(mplace: &MPlaceTy<'tcx, Tag>) -> Self { + OpTy { op: Operand::Indirect(**mplace), layout: mplace.layout } + } +} + impl<'tcx, Tag> From> for OpTy<'tcx, Tag> { #[inline(always)] fn from(val: ImmTy<'tcx, Tag>) -> Self { @@ -243,7 +250,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// Returns `None` if the layout does not permit loading this as a value. fn try_read_immediate_from_mplace( &self, - mplace: MPlaceTy<'tcx, M::PointerTag>, + mplace: &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx, Option>> { if mplace.layout.is_unsized() { // Don't touch unsized @@ -307,11 +314,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { src: &OpTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx, Result, MPlaceTy<'tcx, M::PointerTag>>> { Ok(match src.try_as_mplace(self) { - Ok(mplace) => { + Ok(ref mplace) => { if let Some(val) = self.try_read_immediate_from_mplace(mplace)? { Ok(val) } else { - Err(mplace) + Err(*mplace) } } Err(val) => Ok(val), @@ -340,7 +347,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { } // Turn the wide MPlace into a string (must already be dereferenced!) - pub fn read_str(&self, mplace: MPlaceTy<'tcx, M::PointerTag>) -> InterpResult<'tcx, &str> { + pub fn read_str(&self, mplace: &MPlaceTy<'tcx, M::PointerTag>) -> InterpResult<'tcx, &str> { let len = mplace.len(self)?; let bytes = self.memory.read_bytes(mplace.ptr, Size::from_bytes(len))?; let str = std::str::from_utf8(bytes).map_err(|err| err_ub!(InvalidStr(err)))?; @@ -354,7 +361,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { field: usize, ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> { let base = match op.try_as_mplace(self) { - Ok(mplace) => { + Ok(ref mplace) => { // We can reuse the mplace field computation logic for indirect operands. let field = self.mplace_field(mplace, field)?; return Ok(field.into()); @@ -397,7 +404,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { } else { // Indexing into a big array. This must be an mplace. let mplace = op.assert_mem_place(self); - Ok(self.mplace_index(mplace, index)?.into()) + Ok(self.mplace_index(&mplace, index)?.into()) } } @@ -408,7 +415,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> { // Downcasts only change the layout Ok(match op.try_as_mplace(self) { - Ok(mplace) => self.mplace_downcast(mplace, variant)?.into(), + Ok(ref mplace) => self.mplace_downcast(mplace, variant)?.into(), Err(..) => { let layout = op.layout.for_variant(self, variant); OpTy { layout, ..*op } @@ -430,7 +437,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // The rest should only occur as mplace, we do not use Immediates for types // allowing such operations. This matches place_projection forcing an allocation. let mplace = base.assert_mem_place(self); - self.mplace_projection(mplace, proj_elem)?.into() + self.mplace_projection(&mplace, proj_elem)?.into() } }) } diff --git a/compiler/rustc_mir/src/interpret/place.rs b/compiler/rustc_mir/src/interpret/place.rs index f86a87c88f4d..392f739e84fd 100644 --- a/compiler/rustc_mir/src/interpret/place.rs +++ b/compiler/rustc_mir/src/interpret/place.rs @@ -183,7 +183,7 @@ impl MemPlace { } } -impl<'tcx, Tag> MPlaceTy<'tcx, Tag> { +impl<'tcx, Tag: Copy> MPlaceTy<'tcx, Tag> { /// Produces a MemPlace that works for ZST but nothing else #[inline] pub fn dangling(layout: TyAndLayout<'tcx>, cx: &impl HasDataLayout) -> Self { @@ -195,13 +195,13 @@ impl<'tcx, Tag> MPlaceTy<'tcx, Tag> { /// Replace ptr tag, maintain vtable tag (if any) #[inline] - pub fn replace_tag(self, new_tag: Tag) -> Self { + pub fn replace_tag(&self, new_tag: Tag) -> Self { MPlaceTy { mplace: self.mplace.replace_tag(new_tag), layout: self.layout } } #[inline] pub fn offset( - self, + &self, offset: Size, meta: MemPlaceMeta, layout: TyAndLayout<'tcx>, @@ -216,7 +216,7 @@ impl<'tcx, Tag> MPlaceTy<'tcx, Tag> { } #[inline] - pub(super) fn len(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, u64> { + pub(super) fn len(&self, cx: &impl HasDataLayout) -> InterpResult<'tcx, u64> { if self.layout.is_unsized() { // We need to consult `meta` metadata match self.layout.ty.kind() { @@ -234,7 +234,7 @@ impl<'tcx, Tag> MPlaceTy<'tcx, Tag> { } #[inline] - pub(super) fn vtable(self) -> Scalar { + pub(super) fn vtable(&self) -> Scalar { match self.layout.ty.kind() { ty::Dynamic(..) => self.mplace.meta.unwrap_meta(), _ => bug!("vtable not supported on type {:?}", self.layout.ty), @@ -348,7 +348,7 @@ where #[inline] pub(super) fn check_mplace_access( &self, - place: MPlaceTy<'tcx, M::PointerTag>, + place: &MPlaceTy<'tcx, M::PointerTag>, size: Option, ) -> InterpResult<'tcx, Option>> { let size = size.unwrap_or_else(|| { @@ -370,13 +370,13 @@ where force_align: Option, ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> { let (size, align) = self - .size_and_align_of_mplace(place)? + .size_and_align_of_mplace(&place)? .unwrap_or((place.layout.size, place.layout.align.abi)); assert!(place.mplace.align <= align, "dynamic alignment less strict than static one?"); // Check (stricter) dynamic alignment, unless forced otherwise. place.mplace.align = force_align.unwrap_or(align); // When dereferencing a pointer, it must be non-NULL, aligned, and live. - if let Some(ptr) = self.check_mplace_access(place, Some(size))? { + if let Some(ptr) = self.check_mplace_access(&place, Some(size))? { place.mplace.ptr = ptr.into(); } Ok(place) @@ -401,7 +401,7 @@ where #[inline(always)] pub fn mplace_field( &self, - base: MPlaceTy<'tcx, M::PointerTag>, + base: &MPlaceTy<'tcx, M::PointerTag>, field: usize, ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> { let offset = base.layout.fields.offset(field); @@ -412,7 +412,7 @@ where // Re-use parent metadata to determine dynamic field layout. // With custom DSTS, this *will* execute user-defined code, but the same // happens at run-time so that's okay. - let align = match self.size_and_align_of(base.meta, field_layout)? { + let align = match self.size_and_align_of(&base.meta, &field_layout)? { Some((_, align)) => align, None if offset == Size::ZERO => { // An extern type at offset 0, we fall back to its static alignment. @@ -442,7 +442,7 @@ where #[inline(always)] pub fn mplace_index( &self, - base: MPlaceTy<'tcx, M::PointerTag>, + base: &MPlaceTy<'tcx, M::PointerTag>, index: u64, ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> { // Not using the layout method because we want to compute on u64 @@ -472,8 +472,8 @@ where // same by repeatedly calling `mplace_array`. pub(super) fn mplace_array_fields( &self, - base: MPlaceTy<'tcx, Tag>, - ) -> InterpResult<'tcx, impl Iterator>> + 'tcx> + base: &'a MPlaceTy<'tcx, Tag>, + ) -> InterpResult<'tcx, impl Iterator>> + 'a> { let len = base.len(self)?; // also asserts that we have a type where this makes sense let stride = match base.layout.fields { @@ -488,7 +488,7 @@ where fn mplace_subslice( &self, - base: MPlaceTy<'tcx, M::PointerTag>, + base: &MPlaceTy<'tcx, M::PointerTag>, from: u64, to: u64, from_end: bool, @@ -533,18 +533,18 @@ where pub(super) fn mplace_downcast( &self, - base: MPlaceTy<'tcx, M::PointerTag>, + base: &MPlaceTy<'tcx, M::PointerTag>, variant: VariantIdx, ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> { // Downcasts only change the layout assert!(!base.meta.has_meta()); - Ok(MPlaceTy { layout: base.layout.for_variant(self, variant), ..base }) + Ok(MPlaceTy { layout: base.layout.for_variant(self, variant), ..*base }) } /// Project into an mplace pub(super) fn mplace_projection( &self, - base: MPlaceTy<'tcx, M::PointerTag>, + base: &MPlaceTy<'tcx, M::PointerTag>, proj_elem: mir::PlaceElem<'tcx>, ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> { use rustc_middle::mir::ProjectionElem::*; @@ -598,7 +598,7 @@ where // FIXME: We could try to be smarter and avoid allocation for fields that span the // entire place. let mplace = self.force_allocation(base)?; - Ok(self.mplace_field(mplace, field)?.into()) + Ok(self.mplace_field(&mplace, field)?.into()) } pub fn place_index( @@ -607,7 +607,7 @@ where index: u64, ) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>> { let mplace = self.force_allocation(base)?; - Ok(self.mplace_index(mplace, index)?.into()) + Ok(self.mplace_index(&mplace, index)?.into()) } pub fn place_downcast( @@ -618,7 +618,7 @@ where // Downcast just changes the layout Ok(match base.place { Place::Ptr(mplace) => { - self.mplace_downcast(MPlaceTy { mplace, layout: base.layout }, variant)?.into() + self.mplace_downcast(&MPlaceTy { mplace, layout: base.layout }, variant)?.into() } Place::Local { .. } => { let layout = base.layout.for_variant(self, variant); @@ -642,7 +642,7 @@ where // This matches `operand_projection`. Subslice { .. } | ConstantIndex { .. } | Index(_) => { let mplace = self.force_allocation(base)?; - self.mplace_projection(mplace, proj_elem)?.into() + self.mplace_projection(&mplace, proj_elem)?.into() } }) } @@ -708,7 +708,7 @@ where pub fn write_immediate_to_mplace( &mut self, src: Immediate, - dest: MPlaceTy<'tcx, M::PointerTag>, + dest: &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx> { self.write_immediate_to_mplace_no_validate(src, dest)?; @@ -769,7 +769,7 @@ where let dest = MPlaceTy { mplace, layout: dest.layout }; // This is already in memory, write there. - self.write_immediate_to_mplace_no_validate(src, dest) + self.write_immediate_to_mplace_no_validate(src, &dest) } /// Write an immediate to memory. @@ -778,7 +778,7 @@ where fn write_immediate_to_mplace_no_validate( &mut self, value: Immediate, - dest: MPlaceTy<'tcx, M::PointerTag>, + dest: &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx> { // Note that it is really important that the type here is the right one, and matches the // type things are read at. In case `src_val` is a `ScalarPair`, we don't do any magic here @@ -903,10 +903,10 @@ where assert_eq!(src.meta, dest.meta, "Can only copy between equally-sized instances"); let src = self - .check_mplace_access(src, Some(size)) + .check_mplace_access(&src, Some(size)) .expect("places should be checked on creation"); let dest = self - .check_mplace_access(dest, Some(size)) + .check_mplace_access(&dest, Some(size)) .expect("places should be checked on creation"); let (src_ptr, dest_ptr) = match (src, dest) { (Some(src_ptr), Some(dest_ptr)) => (src_ptr, dest_ptr), @@ -996,7 +996,7 @@ where self.layout_of_local(&self.stack()[frame], local, None)?; // We also need to support unsized types, and hence cannot use `allocate`. let (size, align) = self - .size_and_align_of(meta, local_layout)? + .size_and_align_of(&meta, &local_layout)? .expect("Cannot allocate for non-dyn-sized type"); let ptr = self.memory.allocate(size, align, MemoryKind::Stack); let mplace = MemPlace { ptr: ptr.into(), align, meta }; @@ -1005,7 +1005,7 @@ where // We don't have to validate as we can assume the local // was already valid for its type. let mplace = MPlaceTy { mplace, layout: local_layout }; - self.write_immediate_to_mplace_no_validate(value, mplace)?; + self.write_immediate_to_mplace_no_validate(value, &mplace)?; } // Now we can call `access_mut` again, asserting it goes well, // and actually overwrite things. @@ -1146,7 +1146,7 @@ where /// Also return some more information so drop doesn't have to run the same code twice. pub(super) fn unpack_dyn_trait( &self, - mplace: MPlaceTy<'tcx, M::PointerTag>, + mplace: &MPlaceTy<'tcx, M::PointerTag>, ) -> InterpResult<'tcx, (ty::Instance<'tcx>, MPlaceTy<'tcx, M::PointerTag>)> { let vtable = mplace.vtable(); // also sanity checks the type let (instance, ty) = self.read_drop_type_from_vtable(vtable)?; @@ -1160,7 +1160,7 @@ where assert_eq!(align, layout.align.abi); } - let mplace = MPlaceTy { mplace: MemPlace { meta: MemPlaceMeta::None, ..*mplace }, layout }; + let mplace = MPlaceTy { mplace: MemPlace { meta: MemPlaceMeta::None, ..**mplace }, layout }; Ok((instance, mplace)) } } diff --git a/compiler/rustc_mir/src/interpret/step.rs b/compiler/rustc_mir/src/interpret/step.rs index bb58b9d2f2a9..64d7c8ef2c71 100644 --- a/compiler/rustc_mir/src/interpret/step.rs +++ b/compiler/rustc_mir/src/interpret/step.rs @@ -218,9 +218,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let dest = self.force_allocation(&dest)?; let length = dest.len(self)?; - if let Some(first_ptr) = self.check_mplace_access(dest, None)? { + if let Some(first_ptr) = self.check_mplace_access(&dest, None)? { // Write the first. - let first = self.mplace_field(dest, 0)?; + let first = self.mplace_field(&dest, 0)?; self.copy_op(&op, &first.into())?; if length > 1 { diff --git a/compiler/rustc_mir/src/interpret/terminator.rs b/compiler/rustc_mir/src/interpret/terminator.rs index db2766bb7e26..e4325d6d1e95 100644 --- a/compiler/rustc_mir/src/interpret/terminator.rs +++ b/compiler/rustc_mir/src/interpret/terminator.rs @@ -444,7 +444,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let (instance, place) = match place.layout.ty.kind() { ty::Dynamic(..) => { // Dropping a trait object. - self.unpack_dyn_trait(place)? + self.unpack_dyn_trait(&place)? } _ => (instance, place), }; diff --git a/compiler/rustc_mir/src/interpret/validity.rs b/compiler/rustc_mir/src/interpret/validity.rs index 766c7a299e8f..f33859f3f863 100644 --- a/compiler/rustc_mir/src/interpret/validity.rs +++ b/compiler/rustc_mir/src/interpret/validity.rs @@ -395,7 +395,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, ' } // Make sure this is dereferenceable and all. let size_and_align = try_validation!( - self.ecx.size_and_align_of_mplace(place), + self.ecx.size_and_align_of_mplace(&place), self.path, err_ub!(InvalidMeta(msg)) => { "invalid {} metadata: {}", kind, msg }, ); diff --git a/compiler/rustc_mir/src/interpret/visitor.rs b/compiler/rustc_mir/src/interpret/visitor.rs index 7efed1936268..e05a1c0e0b2e 100644 --- a/compiler/rustc_mir/src/interpret/visitor.rs +++ b/compiler/rustc_mir/src/interpret/visitor.rs @@ -102,7 +102,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> Value<'mir, 'tcx, M> ecx: &InterpCx<'mir, 'tcx, M>, variant: VariantIdx, ) -> InterpResult<'tcx, Self> { - ecx.mplace_downcast(*self, variant) + ecx.mplace_downcast(self, variant) } #[inline(always)] @@ -111,7 +111,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> Value<'mir, 'tcx, M> ecx: &InterpCx<'mir, 'tcx, M>, field: usize, ) -> InterpResult<'tcx, Self> { - ecx.mplace_field(*self, field) + ecx.mplace_field(self, field) } } @@ -208,7 +208,7 @@ macro_rules! make_value_visitor { ty::Dynamic(..) => { // immediate trait objects are not a thing let dest = v.to_op(self.ecx())?.assert_mem_place(self.ecx()); - let inner = self.ecx().unpack_dyn_trait(dest)?.1; + let inner = self.ecx().unpack_dyn_trait(&dest)?.1; trace!("walk_value: dyn object layout: {:#?}", inner.layout); // recurse with the inner type return self.visit_field(&v, 0, &Value::from_mem_place(inner)); @@ -241,7 +241,7 @@ macro_rules! make_value_visitor { // Now we can go over all the fields. // This uses the *run-time length*, i.e., if we are a slice, // the dynamic info from the metadata is used. - let iter = self.ecx().mplace_array_fields(mplace)? + let iter = self.ecx().mplace_array_fields(&mplace)? .map(|f| f.and_then(|f| { Ok(Value::from_mem_place(f)) }));