# Struct miri::interpret::Allocation

source ·

    pub struct Allocation<Prov = CtfeProvenance, Extra = (), Bytes = Box<[u8]>>where
        Prov: Provenance,{
        bytes: Bytes,
        provenance: ProvenanceMap<Prov>,
        init_mask: InitMask,
        pub align: Align,
        pub mutability: Mutability,
        pub extra: Extra,
    }

Expand description

This type represents an Allocation in the Miri/CTFE core engine.

Its public API is rather low-level, working directly with allocation offsets and a custom error type to account for the lack of an AllocId on this level. The Miri/CTFE core engine `memory` module provides higher-level access.

## Fields§

§`bytes: Bytes`§`provenance: ProvenanceMap<Prov>`§`init_mask: InitMask`§`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§

source§

### impl<Prov, Bytes> Allocation<Prov, (), Bytes>
where Prov: Provenance, Bytes: AllocBytes,

source

#### pub fn from_raw_bytes( bytes: Bytes, align: Align, mutability: Mutability ) -> Allocation<Prov, (), Bytes>

Creates an allocation from an existing `Bytes` value - this is needed for miri FFI support

source

#### pub fn from_bytes<'a>( slice: impl Into<Cow<'a, [u8]>>, align: Align, mutability: Mutability ) -> Allocation<Prov, (), Bytes>

Creates an allocation initialized by the given bytes

source

#### pub fn from_bytes_byte_aligned_immutable<'a>( slice: impl Into<Cow<'a, [u8]>> ) -> Allocation<Prov, (), Bytes>

source

#### pub fn try_uninit<'tcx>( size: Size, align: Align ) -> Result<Allocation<Prov, (), Bytes>, InterpErrorInfo<'tcx>>

Try to create an Allocation of `size` bytes, failing if there is not enough memory available to the compiler to do so.

source

#### pub fn uninit(size: Size, align: Align) -> Allocation<Prov, (), Bytes>

Try to create an Allocation of `size` bytes, panics if there is not enough memory available to the compiler to do so.

Example use case: To obtain an Allocation filled with specific data, first call this function and then call write_scalar to fill in the right data.

source§

### impl<Bytes> Allocation<CtfeProvenance, (), Bytes>
where Bytes: AllocBytes,

source

#### pub fn adjust_from_tcx<Prov, Extra, Err>( self, cx: &impl HasDataLayout, extra: Extra, adjust_ptr: impl FnMut(Pointer) -> Result<Pointer<Prov>, Err> ) -> Result<Allocation<Prov, Extra, Bytes>, Err>
where Prov: Provenance,

Adjust allocation from the ones in `tcx` to a custom Machine instance with a different `Provenance` and `Extra` type.

source§

### impl<Prov, Extra, Bytes> Allocation<Prov, Extra, Bytes>
where Prov: Provenance, Bytes: AllocBytes,

Raw accessors. Provide access to otherwise private bytes.

source

#### pub fn len(&self) -> usize

source

#### pub fn size(&self) -> Size

source

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

Looks at a slice which may contain uninitialized bytes or provenance. This differs from `get_bytes_with_uninit_and_ptr` in that it does no provenance checks (even on the edges) at all. This must not be used for reads affecting the interpreter execution.

source

#### pub fn init_mask(&self) -> &InitMask

Returns the mask indicating which bytes are initialized.

source

#### pub fn provenance(&self) -> &ProvenanceMap<Prov>

Returns the provenance map.

source§

### impl<Prov, Extra, Bytes> Allocation<Prov, Extra, Bytes>
where Prov: Provenance, Bytes: AllocBytes,

Byte accessors.

source

#### pub fn base_addr(&self) -> *const u8

source

#### pub fn get_bytes_unchecked(&self, range: AllocRange) -> &[u8] ⓘ

This is the entirely abstraction-violating way to just grab the raw bytes without caring about provenance or initialization.

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

source

#### pub fn get_bytes_strip_provenance( &self, cx: &impl HasDataLayout, range: AllocRange ) -> Result<&[u8], AllocError>

Checks that these bytes are initialized, and then strip provenance (if possible) and return them.

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.

source

#### pub fn get_bytes_mut( &mut self, cx: &impl HasDataLayout, range: AllocRange ) -> Result<&mut [u8], AllocError>

Just calling this already marks everything as defined and removes provenance, 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.

source

#### pub fn get_bytes_mut_ptr( &mut self, cx: &impl HasDataLayout, range: AllocRange ) -> Result<*mut [u8], AllocError>

A raw pointer variant of `get_bytes_mut` that avoids invalidating existing aliases into this memory.

source§

### impl<Prov, Extra, Bytes> Allocation<Prov, Extra, Bytes>
where Prov: Provenance, Bytes: AllocBytes,

Reading and writing.

source

#### pub fn read_scalar( &self, cx: &impl HasDataLayout, range: AllocRange, read_provenance: bool ) -> Result<Scalar<Prov>, AllocError>

Reads a non-ZST scalar.

If `read_provenance` is `true`, this will also read provenance; otherwise (if the machine supports that) provenance is entirely ignored.

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.

source

#### pub fn write_scalar( &mut self, cx: &impl HasDataLayout, range: AllocRange, val: Scalar<Prov> ) -> Result<(), AllocError>

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.

source

#### pub fn write_uninit( &mut self, cx: &impl HasDataLayout, range: AllocRange ) -> Result<(), AllocError>

Write “uninit” to the given memory range.

source

#### pub fn provenance_apply_copy(&mut self, copy: ProvenanceCopy<Prov>)

Applies a previously prepared provenance copy. The affected range, as defined in the parameters to `provenance().prepare_copy` is expected to be clear of provenance.

This is dangerous to use as it can violate internal `Allocation` invariants! It only exists to support an efficient implementation of `mem_copy_repeatedly`.

source

#### pub fn init_mask_apply_copy( &mut self, copy: InitCopy, range: AllocRange, repeat: u64 )

Applies a previously prepared copy of the init mask.

This is dangerous to use as it can violate internal `Allocation` invariants! It only exists to support an efficient implementation of `mem_copy_repeatedly`.

## Trait Implementations§

source§

### impl<'tcx> ArenaAllocatable<'tcx> for Allocation

source§

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

source§

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

source§

### impl<Prov, Extra, Bytes> Clone for Allocation<Prov, Extra, Bytes>
where Prov: Clone + Provenance, Extra: Clone, Bytes: Clone,

source§

#### fn clone(&self) -> Allocation<Prov, Extra, Bytes>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<Prov, Extra, Bytes, __D> Decodable<__D> for Allocation<Prov, Extra, Bytes>
where Prov: Provenance, __D: TyDecoder, Bytes: Decodable<__D>, ProvenanceMap<Prov>: Decodable<__D>, Extra: Decodable<__D>,

source§

#### fn decode(__decoder: &mut __D) -> Allocation<Prov, Extra, Bytes>

source§

### impl<Prov, Extra, Bytes, __E> Encodable<__E> for Allocation<Prov, Extra, Bytes>
where Prov: Provenance, __E: TyEncoder, Bytes: Encodable<__E>, ProvenanceMap<Prov>: Encodable<__E>, Extra: Encodable<__E>,

source§

#### fn encode(&self, __encoder: &mut __E)

source§

### impl Hash for Allocation

source§

#### fn hash<H>(&self, state: &mut H)
where H: Hasher,

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<'__ctx, Prov, Extra, Bytes> HashStable<StableHashingContext<'__ctx>> for Allocation<Prov, Extra, Bytes>
where Prov: Provenance + HashStable<StableHashingContext<'__ctx>>, Bytes: HashStable<StableHashingContext<'__ctx>>, Extra: HashStable<StableHashingContext<'__ctx>>,

source§

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

source§

### impl<Prov, Extra, Bytes> PartialEq for Allocation<Prov, Extra, Bytes>
where Prov: PartialEq + Provenance, Extra: PartialEq, Bytes: PartialEq,

source§

#### fn eq(&self, other: &Allocation<Prov, Extra, Bytes>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl VisitProvenance for Allocation<Provenance, AllocExtra<'_>>

source§

#### fn visit_provenance(&self, visit: &mut VisitWith<'_>)

source§

### impl<Prov, Extra, Bytes> Eq for Allocation<Prov, Extra, Bytes>
where Prov: Eq + Provenance, Extra: Eq, Bytes: Eq,

source§

### impl<Prov, Extra, Bytes> StructuralPartialEq for Allocation<Prov, Extra, Bytes>
where Prov: Provenance,

## Auto Trait Implementations§

§

### impl<Prov, Extra, Bytes> DynSend for Allocation<Prov, Extra, Bytes>
where Bytes: DynSend, Extra: DynSend, Prov: DynSend,

§

### impl<Prov, Extra, Bytes> DynSync for Allocation<Prov, Extra, Bytes>
where Bytes: DynSync, Extra: DynSync, Prov: DynSync,

§

### impl<Prov, Extra, Bytes> Freeze for Allocation<Prov, Extra, Bytes>
where Bytes: Freeze, Extra: Freeze,

§

### impl<Prov, Extra, Bytes> RefUnwindSafe for Allocation<Prov, Extra, Bytes>
where Bytes: RefUnwindSafe, Extra: RefUnwindSafe, Prov: RefUnwindSafe,

§

### impl<Prov, Extra, Bytes> Send for Allocation<Prov, Extra, Bytes>
where Bytes: Send, Extra: Send, Prov: Send,

§

### impl<Prov, Extra, Bytes> Sync for Allocation<Prov, Extra, Bytes>
where Bytes: Sync, Extra: Sync, Prov: Sync,

§

### impl<Prov, Extra, Bytes> Unpin for Allocation<Prov, Extra, Bytes>
where Bytes: Unpin, Extra: Unpin, Prov: Unpin,

§

### impl<Prov, Extra, Bytes> UnwindSafe for Allocation<Prov, Extra, Bytes>
where Bytes: UnwindSafe, Extra: UnwindSafe, Prov: UnwindSafe,

## Blanket Implementations§

source§

### impl<T> Aligned for T

source§

#### const ALIGN: Alignment = _

Alignment of `Self`.
source§

### impl<T> Any for T
where T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T> AnyEq for T
where T: Any + PartialEq,

§

#### fn equals(&self, other: &(dyn Any + 'static)) -> bool

§

#### fn as_any(&self) -> &(dyn Any + 'static)

source§

### impl<T> Borrow<T> for T
where T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T, R> CollectAndApply<T, R> for T

source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
§

### impl<T> Filterable for T

§

#### fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T> Instrument for T

source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for T
where U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<P> IntoQueryParam<P> for P

source§

#### fn into_query_param(self) -> P

source§

### impl<T> MaybeResult<T> for T

§

#### type Error = !

source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

§

### impl<T> Pointable for T

§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T> ToOwned for T
where T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<'tcx, T> ToPredicate<'tcx, T> for T

source§

#### fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

source§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

source§

### impl<T> WithSubscriber for T

source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

§

### impl<T> ErasedDestructor for T
where T: 'static,

§

### impl<T> MaybeSendSync for T
where T: Send + Sync,

## Layout§

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.