# Struct miri::borrow_tracker::stacked_borrows::stack::Stack

source ·

    pub struct Stack {
        borrows: Vec<Item>,
        unknown_bottom: Option<BorTag>,
        cache: StackCache,
        unique_range: Range<usize>,
    }

Expand description

Extra per-location state.

## Fields§

§`borrows: Vec<Item>`

Used mostly as a stack; never empty. Invariants:

- Above a `SharedReadOnly` there can only be more `SharedReadOnly`.
- Except for `Untagged`, no tag occurs in the stack more than once.

§`unknown_bottom: Option<BorTag>`

If this is `Some(id)`, then the actual current stack is unknown. This can happen when wildcard pointers are used to access this location. What we do know is that `borrows` are at the top of the stack, and below it are arbitrarily many items whose `tag` is strictly less than `id`. When the bottom is unknown, `borrows` always has a `SharedReadOnly` or `Unique` at the bottom; we never have the unknown-to-known boundary in an SRW group.

§`cache: StackCache`

A small LRU cache of searches of the borrow stack.

§`unique_range: Range<usize>`

On a read, we need to disable all `Unique` above the granting item. We can avoid most of this scan by keeping track of the region of the borrow stack that may contain `Unique`s.

## Implementations§

source§

### impl Stack

source

#### pub fn retain(&mut self, tags: &FxHashSet<BorTag>)

source§

### impl<'tcx> Stack

source

#### pub(super) fn find_granting( &mut self, access: AccessKind, tag: ProvenanceExtra, exposed_tags: &FxHashSet<BorTag>, ) -> Result<Option<usize>, ()>

Find the item granting the given kind of access to the given tag, and return where it is on the stack. For wildcard tags, the given index is approximate, but if no index is given it means the match was not in the known part of the stack. `Ok(None)` indicates it matched the “unknown” part of the stack. `Err` indicates it was not found.

source

#### fn find_granting_tagged( &mut self, access: AccessKind, tag: BorTag, ) -> Option<usize>

source

#### fn find_granting_cache( &mut self, access: AccessKind, tag: BorTag, ) -> Option<usize>

source

#### pub fn insert(&mut self, new_idx: usize, new: Item)

source

#### fn insert_cache(&mut self, new_idx: usize, new: Item)

source

#### pub fn new(item: Item) -> Self

Construct a new `Stack` using the passed `Item` as the root tag.

source

#### pub fn get(&self, idx: usize) -> Option<Item>

source

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

source

#### pub fn unknown_bottom(&self) -> Option<BorTag>

source

#### pub fn set_unknown_bottom(&mut self, tag: BorTag)

source

#### pub fn disable_uniques_starting_at( &mut self, disable_start: usize, visitor: impl FnMut(Item) -> InterpResult<'tcx>, ) -> InterpResult<'tcx>

Find all `Unique` elements in this borrow stack above `granting_idx`, pass a copy of them to the `visitor`, then set their `Permission` to `Disabled`.

source

#### pub fn pop_items_after<V: FnMut(Item) -> InterpResult<'tcx>>( &mut self, start: usize, visitor: V, ) -> InterpResult<'tcx>

Produces an iterator which iterates over `range` in reverse, and when dropped removes that range of `Item`s from this `Stack`.

source§

### impl<'tcx> Stack

Core per-location operations: access, dealloc, reborrow.

source

#### fn find_first_write_incompatible(&self, granting: usize) -> usize

Find the first write-incompatible item above the given one – i.e, find the height to which the stack will be truncated when writing to `granting`.

source

#### fn item_invalidated( item: &Item, global: &GlobalStateInner, dcx: &DiagnosticCx<'_, '_, 'tcx>, cause: ItemInvalidationCause, ) -> InterpResult<'tcx>

The given item was invalidated – check its protectors for whether that will cause UB.

source

#### fn access( &mut self, access: AccessKind, tag: ProvenanceExtra, global: &GlobalStateInner, dcx: &mut DiagnosticCx<'_, '_, 'tcx>, exposed_tags: &FxHashSet<BorTag>, ) -> InterpResult<'tcx>

Test if a memory `access` using pointer tagged `tag` is granted. If yes, return the index of the item that granted it. `range` refers the entire operation, and `offset` refers to the specific offset into the allocation that we are currently checking.

source

#### fn dealloc( &mut self, tag: ProvenanceExtra, global: &GlobalStateInner, dcx: &mut DiagnosticCx<'_, '_, 'tcx>, exposed_tags: &FxHashSet<BorTag>, ) -> InterpResult<'tcx>

Deallocate a location: Like a write access, but also there must be no active protectors at all because we will remove all items.

source

#### fn grant( &mut self, derived_from: ProvenanceExtra, new: Item, access: Option<AccessKind>, global: &GlobalStateInner, dcx: &mut DiagnosticCx<'_, '_, 'tcx>, exposed_tags: &FxHashSet<BorTag>, ) -> InterpResult<'tcx>

Derive a new pointer from one with the given tag.

`access` indicates which kind of memory access this retag itself should correspond to.

## Trait Implementations§

source§

### impl Clone for Stack

source§

#### fn clone(&self) -> Stack

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 Debug for Stack

source§

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

Formats the value using the given formatter. Read more
source§

### impl PartialEq for Stack

source§

#### fn eq(&self, other: &Self) -> 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 Eq for Stack

## Auto Trait Implementations§

§

### impl Freeze for Stack

§

### impl RefUnwindSafe for Stack

§

### impl Send for Stack

§

### impl Sync for Stack

§

### impl Unpin for Stack

§

### impl UnwindSafe for Stack

## Blanket Implementations§

source§

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

source§

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

Gets the `TypeId` of `self`. Read more
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> CloneToUninit for T
where T: Clone,

source§

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dst`. Read more
source§

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

source§

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

Returns the argument unchanged.

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<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<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

## Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain `repr(...)` attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 560 bytes