Struct BasicBlock 

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

A basic block contains a list of Operations. It may have arguments.

Fields

attributes: AttributeDict

A dictionary of attributes.

Implementations

impl BasicBlock

pub fn new( ctx: &mut Context, label: Option<Identifier>, arg_types: Vec<Ptr<TypeObj>>, ) -> Ptr<BasicBlock>

Create a new Basic Block.

pub fn get_parent_region(&self) -> Option<Ptr<Region>>

Get parent region.

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

Get parent operation.

pub fn get_parent_block(&self, ctx: &Context) -> Option<Ptr<BasicBlock>>

Get parent block.

pub fn get_argument(&self, arg_idx: usize) -> Value

Get idx’th argument as a Value. Panics on invalid index.

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

Get an iterator over the arguments

pub fn push_argument( block: Ptr<BasicBlock>, ctx: &Context, ty: Ptr<TypeObj>, ) -> usize

Add an argument to the end of the argument list, returning its index.

pub fn pop_argument(block: Ptr<BasicBlock>, ctx: &Context)

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

pub fn insert_argument( block: Ptr<BasicBlock>, ctx: &Context, arg_idx: usize, ty: Ptr<TypeObj>, )

Insert a new argument at arg_idx, shifting existing arguments, from arg_idx, to the right. Panics on invalid index.

pub fn remove_argument(block: Ptr<BasicBlock>, ctx: &Context, arg_idx: usize)

Remove the argument at arg_idx, shifting subsequent arguments to the left. Panics on invalid index or if the argument has uses. Any Value referring to the removed argument is invalidated.

pub fn get_num_arguments(&self) -> usize

Get the number of arguments.

pub fn succs(&self, ctx: &Context) -> Vec<Ptr<BasicBlock>>

Get all successors of this block.

pub fn has_succ(&self, ctx: &Context, succ: Ptr<BasicBlock>) -> bool

Is succ a successor of this block?

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

Get the block terminator, if one exists.

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

Drop all uses that this block holds.

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

Unlink and deallocate this block and everything that it contains. There must not be any uses outside the block.

Trait Implementations

impl ContainsLinkedList<BasicBlock> for Region

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

Simply get the head of the list.

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

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 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 BasicBlock

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<Self::ContainerType>>

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

impl Located for BasicBlock

fn loc(&self) -> Location

fn set_loc(&mut self, loc: Location)

impl Named for BasicBlock

fn given_name(&self, _ctx: &Context) -> Option<Identifier>

fn id(&self, _ctx: &Context) -> Identifier

fn unique_name(&self, ctx: &Context) -> Identifier

impl Parsable for BasicBlock

type Arg = ()

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

type Parsed = Ptr<BasicBlock>

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 BasicBlock

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 BasicBlock

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 BasicBlock

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