Struct Ptr 

pub struct Ptr<T>
where
    T: ArenaObj,
{ /* private fields */ }

Pointer to an IR Object owned by Context.

Implementations

impl<'a, T> Ptr<T>

where T: ArenaObj,

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

Borrow the inner RefCell and return a Ref to the pointee. The borrow is live as long as the returned Ref lives. Panics on dangling Ptr or borrow interior mutability errors. Run cargo with options +nightly -Zbuild-std -Zbuild-std-features="debug_refcell" to enable printing the interior mutability violation locations.

pub fn deref_mut(&self, ctx: &'a Context) -> RefMut<'a, T>

Mutably borrow the inner RefCell and return a RefMut to the pointee. The borrow is live as long as the returned RefMut lives. Panics on dangling Ptr or borrow interior mutability errors. Run cargo with options +nightly -Zbuild-std -Zbuild-std-features="debug_refcell" to enable printing the interior mutability violation locations.

pub fn try_deref(&self, ctx: &'a Context) -> Result<Ref<'a, T>, Error>

Try and borrow the inner RefCell and return a Ref to the pointee. The borrow is live as long as the returned Ref lives. If Ptr is dangling or already mutably borrowed, an Error with DanglingPtrDerefError or BorrowError is returned.

pub fn try_deref_mut(&self, ctx: &'a Context) -> Result<RefMut<'a, T>, Error>

Try and mutably borrow the inner RefCell and return a RefMut to the pointee. The borrow is live as long as the returned RefMut lives. If Ptr is dangling or already borrowed, an Error with DanglingPtrDerefError or BorrowMutError is returned.

impl<T> Ptr<T>

where T: LinkedList,

Linked list operations on Ptr<T: LinkedList> for convenience and safety.

pub fn insert_after(&self, ctx: &Context, mark: Ptr<T>)

Insert self after mark.

pub fn insert_before(&self, ctx: &Context, mark: Ptr<T>)

Insert self before mark.

pub fn insert_at_front( &self, container: Ptr<<T as LinkedList>::ContainerType>, ctx: &Context, )

Insert self as the head of the list.

pub fn insert_at_back( &self, container: Ptr<<T as LinkedList>::ContainerType>, ctx: &Context, )

Insert self as the tail of the list.

pub fn is_linked(&self, ctx: &Context) -> bool

Is this node part of a linked list?

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

Unlink self from list.

impl Ptr<BasicBlock>

pub fn has_pred(&self, ctx: &Context) -> bool

Does this block a predecessor?

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

Is pred a predecessor of this block? Note: O(n) in the number of predecessors of this block.

pub fn num_preds(&self, ctx: &Context) -> usize

Number of predecessors to this block.

pub fn get_pred(&self, ctx: &Context, i: usize) -> Ptr<BasicBlock>

Get the i-th predecessor of this block. Panics if i is out of bounds. Note: 1. The order of predecessors is not guaranteed to be deterministic across different platforms or rust compiler versions. 2. O(n) in the number of predecessors of this block.

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

Get all predecessors of this block. Note: The order of predecessors is not guaranteed to be deterministic across different platforms or rust compiler versions.

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

Get uses (as successor operands in an Operation) of this block.

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

Checks whether self is a successor of pred. O(n) in the number of successors of pred.

pub fn retarget_some_preds_to<P>( &self, ctx: &Context, predicate: P, other: Ptr<BasicBlock>, )

where P: Fn(&Context, Ptr<BasicBlock>) -> bool,

Retarget predecessors (that satisfy pred) to other.

pub fn retarget_all_preds_to(&self, ctx: &Context, other: Ptr<BasicBlock>)

Retarget all predecessors to other.

pub fn retarget_pred_to( &self, ctx: &Context, block_use: Use<Ptr<BasicBlock>>, other: Ptr<BasicBlock>, )

Retarget the given pred (block_use) of this Ptr<BasicBlock> to other.

Trait Implementations

impl BlockPtrExt for Ptr<BasicBlock>

fn arguments(self, ctx: &Context) -> Vec<Value>

fn is_empty(&self, ctx: &Context) -> bool

fn is_entry_block(&self, ctx: &Context) -> bool

fn ops_with_interface<T: OpInterfaceMarker + ?Sized + 'static>( &self, ctx: &Context, ) -> impl Iterator<Item = TraitOp<T>>

impl<T> Clone for Ptr<T>

where T: ArenaObj,

fn clone(&self) -> Ptr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ControlFlowGraph<Context> for Ptr<Region>

type Node = Ptr<BasicBlock>

fn num_successors( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, ) -> usize

Number of successors of node.

fn get_successor( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, i: usize, ) -> <Ptr<Region> as ControlFlowGraph<Context>>::Node

Get the i-th successor of node. Panics if i is out of bounds.

fn successors( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, ) -> Vec<<Ptr<Region> as ControlFlowGraph<Context>>::Node>

Get all successors of node. The default implementation provided may be overridden for better performance.

fn num_predecessors( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, ) -> usize

Number of predecessors of node.

fn get_predecessor( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, i: usize, ) -> <Ptr<Region> as ControlFlowGraph<Context>>::Node

Get the i-th predecessor of node. Panics if i is out of bounds.

fn predecessors( &self, ctx: &Context, node: &<Ptr<Region> as ControlFlowGraph<Context>>::Node, ) -> Vec<<Ptr<Region> as ControlFlowGraph<Context>>::Node>

Get all predecessors of node. The default implementation provided may be overridden for better performance.

fn entry_node( &self, ctx: &Context, ) -> Option<<Ptr<Region> as ControlFlowGraph<Context>>::Node>

Returns the entry node of the graph.

fn nodes<'a>( &'a self, ctx: &'a Context, ) -> Box<dyn Iterator<Item = <Ptr<Region> as ControlFlowGraph<Context>>::Node> + 'a>

Get all nodes in the graph.

impl<T> Copy for Ptr<T>

where T: ArenaObj,

impl<T> Debug for Ptr<T>

where T: ArenaObj,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Eq for Ptr<T>

where T: ArenaObj,

impl From<Ptr<Region>> for RegionSuccessor

fn from(value: Ptr<Region>) -> Self

Converts to this type from the input type.

impl HasLabel<Context> for Ptr<BasicBlock>

fn label(&self, ctx: &Context) -> String

impl<T> Hash for Ptr<T>

where T: ArenaObj + 'static,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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 Named for Ptr<BasicBlock>

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

A (not necessarily unique) name.

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

A Unique (within the context) ID.

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

A unique name; concatenation of name and id.

impl OperationPtrExt for Ptr<Operation>

fn as_op<T: Op>(self, ctx: &Context) -> Option<T>

fn dyn_op(self, ctx: &Context) -> OpObj

fn cast<T: ?Sized + OpInterfaceMarker + 'static>( self, ctx: &Context, ) -> Option<TraitOp<T>>

fn operand(self, ctx: &Context, idx: usize) -> Value

fn operand_as_use(self, ctx: &Context, idx: usize) -> Use<Value>

fn operands(self, ctx: &Context) -> Vec<Value>

fn operands_as_uses(self, ctx: &Context) -> Vec<Use<Value>>

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

fn results(self, ctx: &Context) -> Vec<Value>

fn result_types(self, ctx: &Context) -> Vec<TypeHandle>

fn regions(self, ctx: &Context) -> Vec<Ptr<Region>>

fn result_names(self, ctx: &Context) -> Vec<Option<Identifier>>

fn opt_result(self, ctx: &Context) -> Option<Value>

fn get_attr<'a, T: Attribute>( self, ctx: &'a Context, key: &Identifier, ) -> Option<Ref<'a, T>>

fn set_attr<T: Attribute>(self, ctx: &Context, key: &Identifier, value: T)

fn parent_module(self, ctx: &Context) -> ModuleOp

fn is_ancestor_of(self, ctx: &Context, child: Ptr<Operation>) -> bool

fn is_op<T: Op>(self, ctx: &Context) -> bool

fn is_terminator(self, ctx: &Context) -> bool

fn impls<T: ?Sized + OpInterfaceMarker + 'static>(self, ctx: &Context) -> bool

impl<T> PartialEq for Ptr<T>

where T: ArenaObj,

fn eq(&self, other: &Ptr<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> Printable for Ptr<T>

where T: ArenaObj + Printable,

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

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 RegionPtrExt for Ptr<Region>

fn arguments(self, ctx: &Context) -> Vec<Value>

fn is_empty(&self, ctx: &Context) -> bool

impl<T> Verify for Ptr<T>

where T: ArenaObj + Verify,

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