Struct ConstantOp 

pub struct ConstantOp { /* private fields */ }

Constant value operation for the LLVM dialect. Similar to MLIR’s llvm.mlir.constant.

The constant value is held as one of the following attributes: [IntegerAttr], dyn FloatAttr, AggregateAttr SplatAttr, BytesAttr, SymbolAddrAttr.

Results:

result	description
result	the type of the value attribute

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
llvm_constant_value	ATTR_KEY_LLVM_CONSTANT_VALUE	Any

Implementations

impl ConstantOp

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

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

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

Set the value of the attribute named llvm_constant_value.

impl ConstantOp

pub fn get_value<'a>(&self, ctx: &'a Context) -> Ref<'a, dyn TypedAttrInterface>

Get the constant value that this Op defines. The Ref is a borrow of the containing [Operation] object.

Use pliron::dyn_clone::clone_box to clone the value if required.

pub fn new(ctx: &mut Context, value: Box<dyn TypedAttrInterface>) -> Self

Create a new ConstantOp holding value.

Trait Implementations

impl Clone for ConstantOp

fn clone(&self) -> ConstantOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstFoldInterface for ConstantOp

fn check_fold( &self, ctx: &Context, _operand_attrs: &[Option<AttrObj>], ) -> Vec<Option<AttrObj>>

Given a slice operand_attrs corresponding to each operand, indicating a known compile time constant value for that operand (if any), returns a vector corresponding to each result, indicating the folded (inferred constant) value, if any.

fn fold_in_place( &self, _ctx: &mut Context, _operand_attrs: &[Option<AttrObj>], _rewriter: &mut dyn Rewriter, ) -> IRStatus

Given a slice operand_attrs corresponding to each operand, indicating a known compile time constant value for that operand (if any), attempts to fold the op in place using the provided rewriter. Assumes that rewriter is positioned just before the op to be folded.

fn fold_with_materialization( &self, ctx: &mut Context, operand_attrs: &[Option<Box<dyn Attribute>>], rewriter: &mut dyn Rewriter, ) -> IRStatus

A helper for implementing fold_in_place by materializing the constants inferred by check_fold.

impl Copy for ConstantOp

impl Eq for ConstantOp

impl Hash for ConstantOp

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 NOpdsInterface<0> for ConstantOp

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 OneResultInterface for ConstantOp

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 ConstantOp

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 ConstantOp

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<'__pliron_parse>( state_stream: &mut StateStream<'__pliron_parse>, arg: Self::Arg, ) -> ParseResult<'__pliron_parse, 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>>, PartialState = (), Output = Self::Parsed> + 'a>

where Self::Parsed: 'a,

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

impl PartialEq for ConstantOp

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Printable for ConstantOp

fn fmt(&self, ctx: &Context, state: &State, fmt: &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 SideEffects for ConstantOp

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

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

impl StructuralPartialEq for ConstantOp

impl Verify for ConstantOp

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