Enum Value 

pub enum Value<D: Dialect> {
    Constant(ConstantValue, Item<D>),
    Value {
        id: Id,
        item: Item<D>,
    },
    Tmp {
        id: Id,
        item: Item<D>,
        is_declared: bool,
        is_ptr: bool,
        is_const: bool,
    },
}

Variants

Constant(ConstantValue, Item<D>)

Value

Fields

id: Id

item: Item<D>

Tmp

Fields

id: Id

item: Item<D>

is_declared: bool

is_ptr: bool

is_const: bool

Implementations

impl<D: Dialect> Value<D>

pub fn is_optimized(&self) -> bool

pub fn tmp(item: Item<D>) -> Self

Create a temporary variable.

Also see Self::tmp_declared for a version that needs custom declaration.

pub fn to_const(&mut self)

pub fn reinterpret_ptr(&self, f: &mut Formatter<'_>, item: Item<D>) -> Self

Create a temporary variable with a reinterpret_cast.

pub fn tmp_ptr(item: Item<D>) -> Self

Create a temporary pointer variable.

Also see Self::tmp_declared for a version that needs custom declaration.

pub fn tmp_declared(item: Item<D>) -> Self

Create a temporary variable with a custom declaration.

Notes

Calling val.fmt_left() will assume the variable already exist.

pub fn optimized_args<const N: usize>(args: [Self; N]) -> OptimizedArgs<N, D>

pub fn optimized(&self) -> Self

pub fn index(&self, index: usize) -> IndexedValue<D>

pub fn const_qualifier(&self) -> &str

pub fn id(&self) -> Option<Id>

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

A value-producing op (e.g. Dot/VectorSum, or any arithmetic) whose output was allocated as a fresh mutable local ends up typed as a local pointer. Such an output can’t be declared inline via FmtLeft::fmt_left — that yields T* out = <scalar value>;, which is a type error. Instead it needs backing storage, exactly like super::Instruction::DeclareVariable.

When self is such a local pointer, this emits the backing declaration (T out_store; T* out = &out_store;) and returns true, so the caller writes the result through the pointer (*out = value;). Otherwise it emits nothing and returns false, and the caller declares the output inline.

This is only reached for freshly-created outputs (the op defines out), so it never double-declares an already-declared local.

pub fn fmt_ptr(&self) -> String

Format variable for a pointer argument. Slices and buffers are already pointers, so we just leave them as is to avoid accidental double pointers

pub fn fmt_ref(&self) -> String

Format variable for a reference argument. Dereferences pointers while keeping locals as is.

pub fn fmt_cast_to(&self, item: Item<D>) -> String

Format an item with a specific type, casting if necessary

pub fn ensure_lvalue(&self, f: &mut Formatter<'_>) -> Result<Value<D>, Error>

Ensure a variable is a named lvalue, reassigning to a temporary if necessary. This is required for reinterpreting constants.

Trait Implementations

impl<D: Clone + Dialect> Clone for Value<D>

fn clone(&self) -> Value<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Dialect> Component<D> for Value<D>

fn index(&self, index: usize) -> IndexedValue<D>

fn item(&self) -> Item<D>

fn is_const(&self) -> bool

fn elem(&self) -> Elem<D>

impl<D: Copy + Dialect> Copy for Value<D>

impl<D: Debug + Dialect> Debug for Value<D>

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

Formats the value using the given formatter.

impl<D: Dialect> Display for Value<D>

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

Formats the value using the given formatter.

impl<D: Eq + Dialect> Eq for Value<D>

impl<D: Dialect> FmtLeft for Value<D>

fn fmt_left(&self) -> String

impl<D: Dialect> From<&Value<D>> for AddressSpace

fn from(value: &Value<D>) -> Self

Converts to this type from the input type.

impl<D: Hash + Dialect> Hash for Value<D>

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<D: PartialEq + Dialect> PartialEq for Value<D>

fn eq(&self, other: &Value<D>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<D: PartialEq + Dialect> StructuralPartialEq for Value<D>