Struct rustc_middle::mir::interpret::Allocation

pub struct Allocation<Tag = (), Extra = ()> {
    bytes: Vec<u8>,
    relocations: Relocations<Tag>,
    init_mask: InitMask,
    pub size: Size,
    pub align: Align,
    pub mutability: Mutability,
    pub extra: Extra,
}

Fields

bytes: Vec<u8>

The actual bytes of the allocation. Note that the bytes of a pointer represent the offset of the pointer.

relocations: Relocations<Tag>

Maps from byte addresses to extra data for each pointer. Only the first byte of a pointer is inserted into the map; i.e., every entry in this map applies to pointer_size consecutive bytes starting at the given offset.

init_mask: InitMask

Denotes which part of this allocation is initialized.

size: Size

The size of the allocation. Currently, must always equal bytes.len().

align: Align

The alignment of the allocation to detect unaligned reads. (Align guarantees that this is a power of two.)

mutability: Mutability

true if the allocation is mutable. Also used by codegen to determine if a static should be put into mutable memory, which happens for static mut and static with interior mutability.

extra: Extra

Extra state for the machine.

Implementations

impl<Tag> Allocation<Tag>

pub fn from_bytes<'a>(slice: impl Into<Cow<'a, [u8]>>, align: Align) -> Self

Creates a read-only allocation initialized by the given bytes

pub fn from_byte_aligned_bytes<'a>(slice: impl Into<Cow<'a, [u8]>>) -> Self

pub fn uninit(size: Size, align: Align) -> Self

impl Allocation<(), ()>

pub fn with_tags_and_extra<T, E>(
    self,
    tagger: impl FnMut(AllocId) -> T,
    extra: E
) -> Allocation<T, E>

Add Tag and Extra fields

impl<Tag, Extra> Allocation<Tag, Extra>

Raw accessors. Provide access to otherwise private bytes.

pub fn len(&self) -> usize

pub fn inspect_with_uninit_and_ptr_outside_interpreter(
    &self,
    range: Range<usize>
) -> &[u8]

Looks at a slice which may describe uninitialized bytes or describe a relocation. This differs from get_bytes_with_uninit_and_ptr in that it does no relocation checks (even on the edges) at all. It further ignores AllocationExtra callbacks. This must not be used for reads affecting the interpreter execution.

pub fn init_mask(&self) -> &InitMask

Returns the mask indicating which bytes are initialized.

pub fn relocations(&self) -> &Relocations<Tag>

Returns the relocation list.

impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra>

Byte accessors.

pub(in mir::interpret::allocation) fn check_bounds(
    &self,
    offset: Size,
    size: Size
) -> Range<usize>

Just a small local helper function to avoid a bit of code repetition. Returns the range of this allocation that was meant.

pub(in mir::interpret::allocation) fn get_bytes_internal(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size,
    check_init_and_ptr: bool
) -> InterpResult<'tcx, &[u8]>

The last argument controls whether we error out when there are uninitialized or pointer bytes. You should never call this, call get_bytes or get_bytes_with_uninit_and_ptr instead,

This function also guarantees that the resulting pointer will remain stable even when new allocations are pushed to the HashMap. copy_repeatedly relies on that.

It is the caller's responsibility to check bounds and alignment beforehand.

pub fn get_bytes(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx, &[u8]>

Checks that these bytes are initialized and not pointer bytes, and then return them as a slice.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to use the PlaceTy and OperandTy-based methods on InterpCx instead.

pub fn get_bytes_with_uninit_and_ptr(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx, &[u8]>

It is the caller's responsibility to handle uninitialized and pointer bytes. However, this still checks that there are no relocations on the edges.

It is the caller's responsibility to check bounds and alignment beforehand.

pub fn get_bytes_mut(
    &mut self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx, &mut [u8]>

Just calling this already marks everything as defined and removes relocations, so be sure to actually put data there!

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to use the PlaceTy and OperandTy-based methods on InterpCx instead.

impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra>

Reading and writing.

pub fn read_c_str(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>
) -> InterpResult<'tcx, &[u8]>

Reads bytes until a 0 is encountered. Will error if the end of the allocation is reached before a 0 is found.

Most likely, you want to call Memory::read_c_str instead of this method.

pub fn check_bytes(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size,
    allow_uninit_and_ptr: bool
) -> InterpResult<'tcx>

Validates that ptr.offset and ptr.offset + size do not point to the middle of a relocation. If allow_uninit_and_ptr is false, also enforces that the memory in the given range contains neither relocations nor uninitialized bytes.

pub fn write_bytes(
    &mut self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    src: impl IntoIterator<Item = u8>
) -> InterpResult<'tcx>

Writes src to the memory starting at ptr.offset.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to call Memory::write_bytes instead of this method.

pub fn read_scalar(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>>

Reads a non-ZST scalar.

ZSTs can't be read because in order to obtain a Pointer, we need to check for ZSTness anyway due to integer pointers being valid for ZSTs.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to call InterpCx::read_scalar instead of this method.

pub fn read_ptr_sized(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>
) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>>

Reads a pointer-sized scalar.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to call InterpCx::read_scalar instead of this method.

pub fn write_scalar(
    &mut self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    val: ScalarMaybeUninit<Tag>,
    type_size: Size
) -> InterpResult<'tcx>

Writes a non-ZST scalar.

ZSTs can't be read because in order to obtain a Pointer, we need to check for ZSTness anyway due to integer pointers being valid for ZSTs.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to call InterpCx::write_scalar instead of this method.

pub fn write_ptr_sized(
    &mut self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    val: ScalarMaybeUninit<Tag>
) -> InterpResult<'tcx>

Writes a pointer-sized scalar.

It is the caller's responsibility to check bounds and alignment beforehand. Most likely, you want to call InterpCx::write_scalar instead of this method.

impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra>

Relocations.

pub fn get_relocations(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> &[(Size, (Tag, AllocId))]

Returns all relocations overlapping with the given pointer-offset pair.

pub(in mir::interpret::allocation) fn check_relocations(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx>

Checks that there are no relocations overlapping with the given range.

pub(in mir::interpret::allocation) fn clear_relocations(
    &mut self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx>

Removes all relocations inside the given range. If there are relocations overlapping with the edges, they are removed as well and the bytes they cover are marked as uninitialized. This is a somewhat odd "spooky action at a distance", but it allows strictly more code to run than if we would just error immediately in that case.

pub(in mir::interpret::allocation) fn check_relocation_edges(
    &self,
    cx: &impl HasDataLayout,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx>

Errors if there are relocations overlapping with the edges of the given memory range.

impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra>

Uninitialized bytes.

pub(in mir::interpret::allocation) fn is_init(
    &self,
    ptr: Pointer<Tag>,
    size: Size
) -> Result<(), Range<Size>>

Checks whether the given range is entirely initialized.

Returns Ok(()) if it's initialized. Otherwise returns the range of byte indexes of the first contiguous uninitialized access.

pub(in mir::interpret::allocation) fn check_init(
    &self,
    ptr: Pointer<Tag>,
    size: Size
) -> InterpResult<'tcx>

Checks that a range of bytes is initialized. If not, returns the InvalidUninitBytes error which will report the first range of bytes which is uninitialized.

pub fn mark_init(&mut self, ptr: Pointer<Tag>, size: Size, is_init: bool)

impl<Tag, Extra> Allocation<Tag, Extra>

Transferring the initialization mask to other allocations.

pub fn compress_uninit_range(
    &self,
    src: Pointer<Tag>,
    size: Size
) -> InitMaskCompressed

Creates a run-length encoding of the initialization mask.

pub fn mark_compressed_init_range(
    &mut self,
    defined: &InitMaskCompressed,
    dest: Pointer<Tag>,
    size: Size,
    repeat: u64
)

Applies multiple instances of the run-length encoding to the initialization mask.

impl<Tag: Copy, Extra> Allocation<Tag, Extra>

pub fn prepare_relocation_copy(
    &self,
    cx: &impl HasDataLayout,
    src: Pointer<Tag>,
    size: Size,
    dest: Pointer<Tag>,
    length: u64
) -> AllocationRelocations<Tag>

pub fn mark_relocation_range(&mut self, relocations: AllocationRelocations<Tag>)

Applies a relocation copy. The affected range, as defined in the parameters to prepare_relocation_copy is expected to be clear of relocations.

Trait Implementations

impl<'tcx> ArenaAllocatable<'tcx, Allocation<(), ()>> for Allocation

pub fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self

pub fn allocate_from_iter<'a>(
    arena: &'a Arena<'tcx>,
    iter: impl IntoIterator<Item = Self>
) -> &'a mut [Self]

impl<Tag: Clone, Extra: Clone> Clone for Allocation<Tag, Extra>

pub fn clone(&self) -> Allocation<Tag, Extra>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Tag: Debug, Extra: Debug> Debug for Allocation<Tag, Extra>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for &'tcx Allocation

pub fn decode(decoder: &mut D) -> Result<Self, D::Error>

impl<'tcx, Tag, Extra, __D: TyDecoder<'tcx>> Decodable<__D> for Allocation<Tag, Extra> where
    Tag: Decodable<__D>,
    Extra: Decodable<__D>, 

pub fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<'tcx, Tag, Extra, __E: TyEncoder<'tcx>> Encodable<__E> for Allocation<Tag, Extra> where
    Tag: Encodable<__E>,
    Extra: Encodable<__E>, 

pub fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl<Tag: Eq, Extra: Eq> Eq for Allocation<Tag, Extra>

impl<Tag: Hash, Extra: Hash> Hash for Allocation<Tag, Extra>

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'__ctx, Tag, Extra> HashStable<StableHashingContext<'__ctx>> for Allocation<Tag, Extra> where
    Tag: HashStable<StableHashingContext<'__ctx>>,
    Extra: HashStable<StableHashingContext<'__ctx>>, 

pub fn hash_stable(
    &self,
    __hcx: &mut StableHashingContext<'__ctx>,
    __hasher: &mut StableHasher
)

impl<Tag: Ord, Extra: Ord> Ord for Allocation<Tag, Extra>

pub fn cmp(&self, other: &Allocation<Tag, Extra>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Tag: PartialEq, Extra: PartialEq> PartialEq<Allocation<Tag, Extra>> for Allocation<Tag, Extra>

pub fn eq(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests for !=.

impl<Tag: PartialOrd, Extra: PartialOrd> PartialOrd<Allocation<Tag, Extra>> for Allocation<Tag, Extra>

pub fn partial_cmp(&self, other: &Allocation<Tag, Extra>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Allocation<Tag, Extra>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for Allocation

pub fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error>

impl<Tag, Extra> StructuralEq for Allocation<Tag, Extra>

impl<Tag, Extra> StructuralPartialEq for Allocation<Tag, Extra>