use std::fmt::Debug;
use std::hash::Hash;
+use rustc_ast::Mutability;
use rustc_macros::HashStable;
use rustc_middle::mir;
use rustc_middle::ty::layout::{PrimitiveExt, TyAndLayout};
use rustc_target::abi::{HasDataLayout, LayoutOf, Size, VariantIdx, Variants};
use super::{
- mir_assign_valid_types, AllocId, AllocMap, Allocation, AllocationExtra, ConstAlloc, ImmTy,
- Immediate, InterpCx, InterpResult, LocalValue, Machine, MemoryKind, OpTy, Operand, Pointer,
+ alloc_range, mir_assign_valid_types, AllocRef, AllocRefMut, ConstAlloc, ImmTy, Immediate,
+ InterpCx, InterpResult, LocalValue, Machine, MemoryKind, OpTy, Operand, Pointer,
PointerArithmetic, Scalar, ScalarMaybeUninit,
};
// FIXME: Working around https://github.com/rust-lang/rust/issues/54385
Tag: Debug + Copy + Eq + Hash + 'static,
M: Machine<'mir, 'tcx, PointerTag = Tag>,
- // FIXME: Working around https://github.com/rust-lang/rust/issues/24159
- M::MemoryMap: AllocMap<AllocId, (MemoryKind<M::MemoryKind>, Allocation<Tag, M::AllocExtra>)>,
- M::AllocExtra: AllocationExtra<Tag>,
{
/// Take a value, which represents a (thin or wide) reference, and make it a place.
/// Alignment is just based on the type. This is the inverse of `MemPlace::to_ref()`.
self.mplace_access_checked(place, None)
}
- /// Check if the given place is good for memory access with the given
- /// size, falling back to the layout's size if `None` (in the latter case,
- /// this must be a statically sized type).
- ///
- /// On success, returns `None` for zero-sized accesses (where nothing else is
- /// left to do) and a `Pointer` to use for the actual access otherwise.
#[inline]
- pub(super) fn check_mplace_access(
+ pub(super) fn get_alloc(
&self,
place: &MPlaceTy<'tcx, M::PointerTag>,
- size: Option<Size>,
- ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
- let size = size.unwrap_or_else(|| {
- assert!(!place.layout.is_unsized());
- assert!(!place.meta.has_meta());
- place.layout.size
- });
- self.memory.check_ptr_access(place.ptr, size, place.align)
+ ) -> InterpResult<'tcx, Option<AllocRef<'_, 'tcx, M::PointerTag, M::AllocExtra>>> {
+ assert!(!place.layout.is_unsized());
+ assert!(!place.meta.has_meta());
+ let size = place.layout.size;
+ self.memory.get(place.ptr, size, place.align)
+ }
+
+ #[inline]
+ pub(super) fn get_alloc_mut(
+ &mut self,
+ place: &MPlaceTy<'tcx, M::PointerTag>,
+ ) -> InterpResult<'tcx, Option<AllocRefMut<'_, 'tcx, M::PointerTag, M::AllocExtra>>> {
+ assert!(!place.layout.is_unsized());
+ assert!(!place.meta.has_meta());
+ let size = place.layout.size;
+ self.memory.get_mut(place.ptr, size, place.align)
}
/// Return the "access-checked" version of this `MPlace`, where for non-ZST
.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))? {
+ let align = force_align.unwrap_or(align);
+ // Record new (stricter, unless forced) alignment requirement in place.
+ place.mplace.align = align;
+ // When dereferencing a pointer, it must be non-null, aligned, and live.
+ if let Some(ptr) = self.memory.check_ptr_access(place.ptr, size, align)? {
place.mplace.ptr = ptr.into();
}
Ok(place)
// wrong type.
// Invalid places are a thing: the return place of a diverging function
- let ptr = match self.check_mplace_access(dest, None)? {
- Some(ptr) => ptr,
+ let tcx = *self.tcx;
+ let mut alloc = match self.get_alloc_mut(dest)? {
+ Some(a) => a,
None => return Ok(()), // zero-sized access
};
- let tcx = *self.tcx;
// FIXME: We should check that there are dest.layout.size many bytes available in
// memory. The code below is not sufficient, with enough padding it might not
// cover all the bytes!
dest.layout
),
}
- self.memory.get_raw_mut(ptr.alloc_id)?.write_scalar(
- &tcx,
- ptr,
- scalar,
- dest.layout.size,
- )
+ alloc.write_scalar(alloc_range(Size::ZERO, dest.layout.size), scalar)
}
Immediate::ScalarPair(a_val, b_val) => {
// We checked `ptr_align` above, so all fields will have the alignment they need.
dest.layout
),
};
- let (a_size, b_size) = (a.size(self), b.size(self));
- let b_offset = a_size.align_to(b.align(self).abi);
- let b_ptr = ptr.offset(b_offset, self)?;
+ let (a_size, b_size) = (a.size(&tcx), b.size(&tcx));
+ let b_offset = a_size.align_to(b.align(&tcx).abi);
// It is tempting to verify `b_offset` against `layout.fields.offset(1)`,
// but that does not work: We could be a newtype around a pair, then the
// fields do not match the `ScalarPair` components.
- self.memory.get_raw_mut(ptr.alloc_id)?.write_scalar(&tcx, ptr, a_val, a_size)?;
- self.memory.get_raw_mut(b_ptr.alloc_id)?.write_scalar(&tcx, b_ptr, b_val, b_size)
+ alloc.write_scalar(alloc_range(Size::ZERO, a_size), a_val)?;
+ alloc.write_scalar(alloc_range(b_offset, b_size), b_val)
}
}
}
});
assert_eq!(src.meta, dest.meta, "Can only copy between equally-sized instances");
- let src = self
- .check_mplace_access(&src, Some(size))
- .expect("places should be checked on creation");
- let dest = self
- .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),
- (None, None) => return Ok(()), // zero-sized copy
- _ => bug!("The pointers should both be Some or both None"),
- };
-
- self.memory.copy(src_ptr, dest_ptr, size, /*nonoverlapping*/ true)
+ self.memory
+ .copy(src.ptr, src.align, dest.ptr, dest.align, size, /*nonoverlapping*/ true)
}
/// Copies the data from an operand to a place. The layouts may disagree, but they must
MPlaceTy::from_aligned_ptr(ptr, layout)
}
- /// Returns a wide MPlace.
+ /// Returns a wide MPlace of type `&'static [mut] str` to a new 1-aligned allocation.
pub fn allocate_str(
&mut self,
str: &str,
kind: MemoryKind<M::MemoryKind>,
+ mutbl: Mutability,
) -> MPlaceTy<'tcx, M::PointerTag> {
- let ptr = self.memory.allocate_bytes(str.as_bytes(), kind);
+ let ptr = self.memory.allocate_bytes(str.as_bytes(), Align::ONE, kind, mutbl);
let meta = Scalar::from_machine_usize(u64::try_from(str.len()).unwrap(), self);
- let mplace = MemPlace {
- ptr: ptr.into(),
- align: Align::from_bytes(1).unwrap(),
- meta: MemPlaceMeta::Meta(meta),
- };
+ let mplace =
+ MemPlace { ptr: ptr.into(), align: Align::ONE, meta: MemPlaceMeta::Meta(meta) };
- let layout = self.layout_of(self.tcx.mk_static_str()).unwrap();
+ let ty = self.tcx.mk_ref(
+ self.tcx.lifetimes.re_static,
+ ty::TypeAndMut { ty: self.tcx.types.str_, mutbl },
+ );
+ let layout = self.layout_of(ty).unwrap();
MPlaceTy { mplace, layout }
}
projects / rustc.git / blobdiff