Struct Operation 

pub struct Operation {
    pub attributes: AttributeDict,
    /* private fields */
}

Basic unit of execution. May or may not be in a BasicBlock.

Fields

attributes: AttributeDict

A dictionary of attributes.

Implementations

impl Operation

pub fn new( ctx: &mut Context, concrete_op: (fn(Ptr<Operation>) -> OpObj, TypeId), result_types: Vec<Ptr<TypeObj>>, operands: Vec<Value>, successors: Vec<Ptr<BasicBlock>>, num_regions: usize, ) -> Ptr<Operation>

Create a new, unlinked (i.e., not in a basic block) operation.

pub fn get_parent_block(&self) -> Option<Ptr<BasicBlock>>

Get parent block.

pub fn get_parent_region(&self, ctx: &Context) -> Option<Ptr<Region>>

Get parent region.

pub fn get_parent_op(&self, ctx: &Context) -> Option<Ptr<Operation>>

Get parent operation.

pub fn get_num_results(&self) -> usize

Number of results this operation has.

pub fn get_result(&self, idx: usize) -> Value

Get idx’th result as a Value.

pub fn results(&self) -> impl Iterator<Item = Value> + Clone + '_

Get an iterator over the results of this operation.

pub fn has_use(&self) -> bool

Does any result of this operation have a use?

pub fn num_uses(&self) -> usize

Total number of uses (across all results).

pub fn get_type(&self, idx: usize) -> Ptr<TypeObj>

Get type of the idx’th result.

pub fn result_types(&self) -> impl Iterator<Item = Ptr<TypeObj>> + Clone + '_

Get an iterator over the result types of this operation.

pub fn get_num_operands(&self) -> usize

Get number of operands.

pub fn get_operand(&self, opd_idx: usize) -> Value

Get opd_idx’th operand of this Operation

pub fn get_operand_as_use(&self, opd_idx: usize) -> Use<Value>

Get opd_idx’th operand as a Use<Value>.

pub fn operands(&self) -> impl Iterator<Item = Value> + Clone + '_

Get an iterator over the results of this operation.

pub fn replace_operand( this: Ptr<Operation>, ctx: &Context, opd_idx: usize, other: Value, )

Replace opd_idx’th operand of this with other.

pub fn get_num_successors(&self) -> usize

Get number of successors

pub fn get_successor(&self, succ_idx: usize) -> Ptr<BasicBlock>

Get the opd_idx’th successor of this Operation

pub fn get_successor_as_use(&self, succ_idx: usize) -> Use<Ptr<BasicBlock>>

Get the opd_idx’th successor as a Use<Ptr<BasicBlock>>.

pub fn replace_successor( this: Ptr<Operation>, ctx: &Context, succ_idx: usize, other: Ptr<BasicBlock>, )

Replace opd_idx’th successor of this with other.

pub fn successors(&self) -> impl Iterator<Item = Ptr<BasicBlock>> + Clone + '_

Get an iterator on the successors.

pub fn get_op_dyn(ptr: Ptr<Self>, ctx: &Context) -> OpObj

Create an OpObj corresponding to self. get_op is more efficient if the concrete type is known.

pub fn get_op<T: Op>(ptr: Ptr<Self>, ctx: &Context) -> Option<T>

Creates the concrete Op corresponding to self.

pub fn get_opid(ptr: Ptr<Self>, ctx: &Context) -> OpId

Get the OpId this Operation. Builds an intermediate OpObj.

pub fn get_region(&self, reg_idx: usize) -> Ptr<Region>

Get a Ptr to the reg_idxth region.

pub fn num_regions(&self) -> usize

Number of regions.

pub fn add_region(ptr: Ptr<Self>, ctx: &mut Context) -> Ptr<Region>

Add a new empty region to the operation and return its Ptr.

pub fn erase_region(ptr: Ptr<Self>, ctx: &mut Context, reg_idx: usize)

Erase reg_idx’th region. Affects the index of all regions after it.

pub fn regions(&self) -> impl Iterator<Item = Ptr<Region>> + Clone + '_

Get an iterator on the regions.

pub fn drop_all_uses(ptr: Ptr<Self>, ctx: &Context)

Drop all uses that this operation holds.

pub fn erase(ptr: Ptr<Self>, ctx: &mut Context)

Unlink and deallocate this operation and everything that it contains. There must not be any uses.

pub fn top_level_parse<'a>( state_stream: &mut StateStream<'a>, ) -> ParseResult<'a, Ptr<Self>>

Parse a top level operation from a StateStream. Top level parser looks for outlined attributes.

pub fn top_level_parser<'a>() -> impl Parser<StateStream<'a>, Output = Ptr<Self>, PartialState = ()> + 'a

A parser combinator to parse a top level operation. Top level parser looks for outlined attributes.

Trait Implementations

impl ContainsLinkedList<Operation> for BasicBlock

fn get_head(&self) -> Option<Ptr<Operation>>

Simply get the head of the list.

fn get_tail(&self) -> Option<Ptr<Operation>>

Simply get the tail of the list.

fn iter<'a>(&self, ctx: &'a Context) -> Iter<'a, T>

Get an iterator over the items. Context is borrowed throughout.

impl LinkedList for Operation

fn get_next(&self) -> Option<Ptr<Self>>

Simple getter for the item previous to this in the list.

fn get_prev(&self) -> Option<Ptr<Self>>

Simple getter for the item previous to this in the list.

fn get_container(&self) -> Option<Ptr<BasicBlock>>

Get a reference to the object that contains this linked list.

impl Located for Operation

fn loc(&self) -> Location

fn set_loc(&mut self, loc: Location)

impl Parsable for Operation

type Arg = OperationParserConfig

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

type Parsed = Ptr<Operation>

The type of the parsed entity.

fn parse<'a>( state_stream: &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<StateStream<'a>, Output = Self::Parsed, PartialState = ()> + 'a>

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

fn parser_fn<'a>( _: &'a (), arg: Self::Arg, ) -> Box<dyn Parser<StateStream<'a>, Output = Self::Parsed, PartialState = ()> + 'a>

Same as Self::parser but takes a unit reference for use as ParserFn

impl PartialEq for Operation

fn eq(&self, other: &Self) -> 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 Operation

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 Verify for Operation

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