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. Panics on invalid index.

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

Get an iterator over the results of this operation.

pub fn push_result(this: Ptr<Self>, ctx: &Context, ty: Ptr<TypeObj>) -> usize

Add a result to the end of the result list, returning its index.

pub fn pop_result(this: Ptr<Self>, ctx: &Context)

Remove the last result. Panics if there are no results or if the result has uses. Any Value referring to the removed result is invalidated.

pub fn insert_result( this: Ptr<Self>, ctx: &Context, res_idx: usize, ty: Ptr<TypeObj>, )

Insert a new result at res_idx, shifting existing results, from res_idx, to the right. Panics on invalid index.

pub fn remove_result(this: Ptr<Self>, ctx: &Context, res_idx: usize)

Remove the result at res_idx, shifting existing results, from res_idx + 1, to the left. Panics on invalid index or if the removed result has uses. Any Value referring to the removed result is invalidated.

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 uses(&self) -> impl Iterator<Item = Use<Value>> + '_

Get all uses of all results of this operation.

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

Get type of the idx’th result. Panics on invalid index.

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. Panics on invalid index.

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

Get opd_idx’th operand as a Use<Value>. Panics on invalid index.

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

Get an iterator over the operands of this operation.

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

Get an iterator over the operands of this operation as Use<Value>s.

pub fn push_operand( this: Ptr<Operation>, ctx: &Context, new_opd: Value, ) -> usize

Add a new operand to the end of the operand list, returning its index.

pub fn pop_operand(this: Ptr<Operation>, ctx: &Context) -> Value

Remove the last operand. Panics if there are no operands. Any Use<Value> of the removed operand is invalidated. The removed Value is returned for convenience.

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

Replace opd_idx’th operand of this with other. Panics on invalid index. Any Use<Value> of the replaced operand will be invalidated.

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

Insert a new operand at opd_idx, shifting existing operands, from opd_idx, to the right. Panics on invalid index (i.e., opd_idx > number of operands).

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

Remove the operand at opd_idx, shifting existing operands, from opd_idx + 1, to the left. Panics on invalid index (i.e., opd_idx >= number of operands). Any Use<Value> of the removed operand is invalidated. The removed Value is returned for convenience.

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. Panics on invalid index.

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

Get the opd_idx’th successor as a Use<Ptr<BasicBlock>>. Panics on invalid index.

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

Replace opd_idx’th successor of this with other. Panics on invalid index. Any Use<Ptr<BasicBlock>> of the replaced successor will be invalidated.

pub fn push_successor( this: Ptr<Operation>, ctx: &Context, new_succ: Ptr<BasicBlock>, ) -> usize

Add a new successor to the end of the successor list, returning its index.

pub fn pop_successor(this: Ptr<Operation>, ctx: &Context) -> Ptr<BasicBlock>

Remove the last successor. Panics if there are no successors. Any Use<Ptr<BasicBlock>> of the removed successor is invalidated. The removed Ptr<BasicBlock> is returned for convenience.

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

Insert a new successor at succ_idx, shifting existing successors, from succ_idx, to the right. Panics on invalid index (i.e., succ_idx > number of successors).

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

Remove the successor at succ_idx, shifting existing successors, from succ_idx + 1, to the left. Panics on invalid index (i.e., succ_idx >= number of successors). Any Use<Ptr<BasicBlock>> of the removed successor is invalidated. The removed Ptr<BasicBlock> is returned for convenience.

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

Get an iterator on the successors.

pub fn successors_as_uses( &self, ) -> impl Iterator<Item = Use<Ptr<BasicBlock>>> + '_

Get an iterator over the successors of this operation as Use<Ptr<BasicBlock>>s.

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 is_op<T: Op>(ptr: Ptr<Self>, ctx: &Context) -> bool

Is this operation an instance of the concrete Op T?

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. Panics on invalid index.

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. Panics on invalid index.

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.

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<()>