Enum spirt::qptr::QPtrOp

pub enum QPtrOp {
    FuncLocalVar(MemLayout),
    HandleArrayIndex,
    BufferData,
    BufferDynLen {
        fixed_base_size: u32,
        dyn_unit_stride: NonZeroU32,
    },
    Offset(i32),
    DynOffset {
        stride: NonZeroU32,
        index_bounds: Option<Range<i32>>,
    },
    Load,
    Store,
}

QPtr-specific operations ([DataInstKind::QPtr]).

Variants

FuncLocalVar(MemLayout)

HandleArrayIndex

Adjust a handle array QPtr (inputs[0]), by selecting the handle at the index (inputs[1]) from the handle array (i.e. the resulting QPtr is limited to that one handle and can’t be further “moved around”).

BufferData

Get a memory QPtr pointing at the contents of the buffer whose handle is (implicitly) loaded from a handle QPtr (inputs[0]).

BufferDynLen

Fields

fixed_base_size: u32

dyn_unit_stride: NonZeroU32

Get the length of the buffer whose handle is (implicitly) loaded from a handle QPtr (inputs[0]), converted to a count of “dynamic units” (as per shapes::MaybeDynMemLayout) by subtracting fixed_base_size, then dividing by dyn_unit_stride.

Offset(i32)

Adjust a memory QPtr (inputs[0]), by adding a (signed) immediate amount of bytes to its “address” (whether physical or conceptual).

DynOffset

Fields

stride: NonZeroU32

index_bounds: Option<Range<i32>>

Bounds on the dynamic “index” (inputs[1]).

Adjust a memory QPtr (inputs[0]), by adding a (signed) dynamic “index” (inputs[1]), multiplied by stride (bytes per element), to its “address” (whether physical or conceptual).

Load

Read a single value from a QPtr (inputs[0]).

Store

Write a single value (inputs[1]) to a QPtr (inputs[0]).

Trait Implementations

impl Clone for QPtrOp

fn clone(&self) -> QPtrOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<QPtrOp> for DataInstKind

fn from(original: QPtrOp) -> DataInstKind

Converts to this type from the input type.

impl Hash for QPtrOp

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<QPtrOp> for QPtrOp

fn eq(&self, other: &QPtrOp) -> bool

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

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.

impl Eq for QPtrOp

impl StructuralEq for QPtrOp

impl StructuralPartialEq for QPtrOp