Struct DeclareVariableOp 

pub struct DeclareVariableOp { /* private fields */ }

Attribute(s):

Note: Only attributes defined directly as part of this operation are listed here. There may be others, not listed here, defined by interface implementations.

Name	Static Name Identifier	Type
memory_declare_variable_value_ty	ATTR_KEY_MEMORY_DECLARE_VARIABLE_VALUE_TY	TypeAttr
memory_declare_variable_addr_space	ATTR_KEY_MEMORY_DECLARE_VARIABLE_ADDR_SPACE	AddressSpaceAttr
memory_declare_variable_alignment	ATTR_KEY_MEMORY_DECLARE_VARIABLE_ALIGNMENT	IndexAttr
memory_declare_variable_initializer	ATTR_KEY_MEMORY_DECLARE_VARIABLE_INITIALIZER	Any

Implementations

impl DeclareVariableOp

pub fn get_attr_memory_declare_variable_value_ty<'a>( &self, ctx: &'a Context, ) -> Option<Ref<'a, TypeAttr>>

Get a Ref to the value of the attribute named memory_declare_variable_value_ty. The Ref is a borrow of the containing Operation object.

pub fn set_attr_memory_declare_variable_value_ty( &self, ctx: &Context, value: TypeAttr, )

Set the value of the attribute named memory_declare_variable_value_ty.

pub fn get_attr_memory_declare_variable_addr_space<'a>( &self, ctx: &'a Context, ) -> Option<Ref<'a, AddressSpaceAttr>>

Get a Ref to the value of the attribute named memory_declare_variable_addr_space. The Ref is a borrow of the containing Operation object.

pub fn set_attr_memory_declare_variable_addr_space( &self, ctx: &Context, value: AddressSpaceAttr, )

Set the value of the attribute named memory_declare_variable_addr_space.

pub fn get_attr_memory_declare_variable_alignment<'a>( &self, ctx: &'a Context, ) -> Option<Ref<'a, IndexAttr>>

Get a Ref to the value of the attribute named memory_declare_variable_alignment. The Ref is a borrow of the containing Operation object.

pub fn set_attr_memory_declare_variable_alignment( &self, ctx: &Context, value: IndexAttr, )

Set the value of the attribute named memory_declare_variable_alignment.

pub fn get_attr_memory_declare_variable_initializer<'a>( &self, ctx: &'a Context, ) -> Option<Ref<'a, AttrObj>>

Get a Ref to the value of the attribute named memory_declare_variable_initializer. The Ref is a borrow of the containing Operation object.

pub fn set_attr_memory_declare_variable_initializer( &self, ctx: &Context, value: AttrObj, )

Set the value of the attribute named memory_declare_variable_initializer.

impl DeclareVariableOp

pub fn new( ctx: &mut Context, value_ty: impl Into<TypeAttr>, addr_space: impl Into<AddressSpaceAttr>, alignment: impl Into<IndexAttr>, initializer: Option<AttrObj>, ) -> Self

pub fn value_ty<'a>(&self, ctx: &'a Context) -> Ref<'a, TypeAttr>

pub fn addr_space<'a>(&self, ctx: &'a Context) -> Ref<'a, AddressSpaceAttr>

pub fn alignment<'a>(&self, ctx: &'a Context) -> Ref<'a, IndexAttr>

pub fn initializer<'a>(&self, ctx: &'a Context) -> Option<Ref<'a, AttrObj>>

pub fn set_value_ty(&self, ctx: &Context, value: impl Into<TypeAttr>)

pub fn set_addr_space(&self, ctx: &Context, value: impl Into<AddressSpaceAttr>)

pub fn set_alignment(&self, ctx: &Context, value: impl Into<IndexAttr>)

pub fn set_initializer(&self, ctx: &Context, value: impl Into<AttrObj>)

pub fn remove_initializer(&self, ctx: &Context)

Trait Implementations

impl AtLeastNResultsInterface<1> for DeclareVariableOp

impl AtMostNOpdsInterface<0> for DeclareVariableOp

impl AtMostNResultsInterface<1> for DeclareVariableOp

impl Clone for DeclareVariableOp

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DeclareVariableOp

impl DestructurableConstructorOpInterface for DeclareVariableOp

fn destructurable_values(&self, ctx: &Context) -> Vec<DestructurableValueSlot>

Returns the list of value for which destructuring should be attempted, specifying in which way the value should be destructured into subvalues. This computes the type of the value for each subvalue to be generated. The type of the value must implement DestructurableTypeInterface.

fn destructure( &self, ctx: &mut Context, _value: &DestructurableValueSlot, used_indices: &SmallSet<AttrObj, 8>, rewriter: &mut PassRewriter, new_constructors: &mut Vec<TraitOp<dyn DestructurableConstructorOpInterface>>, ) -> HMap<AttrObj, ValueSlot>

Destructures this value into multiple subvalues. The original value must still exist at the end of this call. Only generates subvalues for the indices found in used_indices since all other subvalues are unused.

fn handle_destructuring_complete( &self, ctx: &mut Context, value: &DestructurableValueSlot, rewriter: &mut PassRewriter, ) -> Option<TraitOp<dyn DestructurableConstructorOpInterface>>

Hook triggered once the destructuring of a value is complete, meaning the original value is no longer being referred to and could be deleted. This will only be called for values declared by this operation.

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Eq for DeclareVariableOp

impl Hash for DeclareVariableOp

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 MaterializableOp for DeclareVariableOp

fn materialize( &self, ctx: &mut Context, result_ty: Vec<TypeHandle>, operands: Vec<Value>, attributes: AttributeDict, ) -> Ptr<Operation>

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl NOpdsInterface<0> for DeclareVariableOp

fn get_operand_i(&self, ctx: &Context, i: LessThanN<N>) -> Value

Get the i’th operand.

fn operand_type_i(&self, ctx: &Context, i: LessThanN<N>) -> TypeHandle

Get the type of the i’th operand.

impl NResultsInterface<1> for DeclareVariableOp

fn get_result_i(&self, ctx: &Context, i: LessThanN<N>) -> Value

Get the i’th result.

fn result_type_i(&self, ctx: &Context, i: LessThanN<N>) -> TypeHandle

Get the type of the i’th result.

impl OneResultInterface for DeclareVariableOp

fn get_result(&self, ctx: &Context) -> Value

Get the single result defined by this Op.

fn result_type(&self, ctx: &Context) -> TypeHandle

Get the type of the single result defined by this Op.

impl Op for DeclareVariableOp

fn get_operation(&self) -> Ptr<Operation>

Get the underlying IR Operation

fn get_opid(&self) -> OpId

Get this Op’s OpId

fn get_opid_static() -> OpId

Get this Op’s OpId, without self reference.

fn get_concrete_op_info() -> (fn(Ptr<Operation>) -> OpBox, TypeId)

where Self: Sized,

Get details about the concrete Op type.

fn register(ctx: &mut Context)

where Self: Sized + Parsable<Arg = Vec<(Identifier, Location)>, Parsed = OpBox>,

Register Op in Context and add it to its dialect.

fn loc(&self, ctx: &Context) -> Location

Get Op’s location

impl Parsable for DeclareVariableOp

type Arg = Vec<(Identifier, Location)>

Type of the argument that must be passed to the parser.

type Parsed = OpBox

The type of the parsed entity.

fn parse<'a>( input: &mut StateStream<'a>, arg: Self::Arg, ) -> ParseResult<'a, Self::Parsed>

Define a parser using existing combinators and call into on Parser::parse_stream to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, Output = Self::Parsed, PartialState = ()> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for DeclareVariableOp

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for DeclareVariableOp

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

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl PromotableAllocationInterface for DeclareVariableOp

fn alloc_info(&self, ctx: &Context) -> Vec<AllocInfo>

Get the allocation info(s) for this operation.

fn default_value( &self, ctx: &mut Context, inserter: &mut dyn Inserter, alloc_info: &AllocInfo, ) -> Result<Value>

Get the default value for an allocation. This is used when there’s no reaching definition for a use. The alloc_info passed is guaranteed to be one of the entries returned by alloc_info. The inserter is positioned in the entry block. If the allocation is in the entry block, the inserter position will be before it.

fn promote( &self, ctx: &mut Context, rewriter: &mut dyn Rewriter, alloc_infos: &[AllocInfo], ) -> Result<()>

Promote allocations. This is called after all uses have been promoted, and should remove the allocation (not necessary the operation itself) from the IR. The alloc_infos passed are guaranteed to be from the entries returned by alloc_info. The rewriter is set to insert before this alloc op.

impl SameResultsType for DeclareVariableOp

fn common_result_type(&self, ctx: &Context) -> Option<TypeHandle>

Get the common type of the results.

impl SideEffects for DeclareVariableOp

fn has_side_effects(&self, _ctx: &Context) -> bool

Returns true if the operation has side effects, and false otherwise.

impl StructuralPartialEq for DeclareVariableOp

impl UniformOpInterface for DeclareVariableOp

fn uniformity(&self, ctx: &Context, _operands: &[Uniformity]) -> Uniformity

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Verify for DeclareVariableOp

fn verify(&self, _ctx: &Context) -> Result<()>