reth::core::primitives::revm_primitives::bitvec::store

Trait BitStore

pub trait BitStore: 'static + Debug {
    type Mem: BitRegister + BitStore<Mem = Self::Mem>;
    type Access: BitAccess<Item = Self::Mem> + BitStore<Mem = Self::Mem>;
    type Alias: BitStore<Mem = Self::Mem>;
    type Unalias: BitStore<Mem = Self::Mem>;

    const ZERO: Self;
    const ALIGNED_TO_SIZE: [(); 1];
    const ALIAS_WIDTH: [(); 1];

    // Required methods
    fn new(value: Self::Mem) -> Self;
    fn load_value(&self) -> Self::Mem;
    fn store_value(&mut self, value: Self::Mem);

    // Provided method
    fn get_bit<O>(&self, index: BitIdx<Self::Mem>) -> bool
       where O: BitOrder { ... }
}

Expand description

§Bit Storage

This trait drives bitvec’s ability to view memory as a collection of discrete bits. It combines awareness of storage element width, memory-bus access requirements, element contention, and buffer management, into a type-system graph that the rest of the crate can use to abstract away concerns about memory representation or access rules.

It is responsible for extending the standard Rust &/&mut shared/exclusion rules to apply to individual bits while avoiding violating those rules when operating on real memory so that Rust and LLVM cannot find fault with the object code it produces.

§Implementors

This is implemented on three type families:

all BitRegister raw integer fundamentals
all Cell wrappers of them
all atomic variants of them

The BitSlice region, and all structures composed atop it, can be built out of regions of memory that have this trait implementation.

§Associated Types

The associated types attached to each implementation create a closed graph of type transitions used to manage alias conditions. When a bit-slice region determines that an aliasing or unaliasing event has occurred, it transitions along the type graph in order to maintain correct operations in memory. The methods that cause type transitions can be found in BitSlice and domain.

Required Associated Constants§

const ZERO: Self

The zero constant.

const ALIGNED_TO_SIZE: [(); 1]

All implementors are required to have their alignment match their size.

Use mem::aligned_to_size::<Self>() to prove this.

const ALIAS_WIDTH: [(); 1]

All implementors are required to have Self and Self::Alias be equal in representation. This is true by fiat for all types except the unsigned integers.

Use mem::layout_eq::<Self, Self::Alias>() to prove this.

Required Associated Types§

type Mem: BitRegister + BitStore<Mem = Self::Mem>

The element type used in the memory region underlying a BitSlice. It is always one of the unsigned integer fundamentals.

type Access: BitAccess<Item = Self::Mem> + BitStore<Mem = Self::Mem>

A type that selects the appropriate load/store instructions when accessing the memory bus. It determines what instructions are used when moving a Self::Mem value between the processor and the memory system.

This must be at least able to manage aliasing.

type Alias: BitStore<Mem = Self::Mem>

A sibling BitStore implementor that is known to be alias-safe. It is used when a BitSlice introduces multiple handles that view the same memory location, and at least one of them has write capabilities to it. It must have the same underlying memory type, and can only change access patterns or public-facing usage.

type Unalias: BitStore<Mem = Self::Mem>

The inverse of ::Alias. It is used when a BitSlice removes the conditions that required a T -> T::Alias transition.

Required Methods§

fn new(value: Self::Mem) -> Self

Wraps a raw memory value as a BitStore type.

fn load_value(&self) -> Self::Mem

Loads a value out of the memory system according to the ::Access rules. This may be called when the value is aliased by a write-capable reference.

fn store_value(&mut self, value: Self::Mem)

Stores a value into the memory system. This is only called when there are no other handles to the value, and it may bypass ::Access constraints.

Provided Methods§

fn get_bit<O>(&self, index: BitIdx<Self::Mem>) -> bool
where O: BitOrder,

Reads a single bit out of the memory system according to the ::Access rules. This is lifted from BitAccess so that it can be used elsewhere without additional casts.