Struct CondBrOp 

pub struct CondBrOp { /* private fields */ }

Equivalent to LLVM’s Conditional Branch.

Operands

operand	description
condition	1-bit signless integer
true_dest_opds	Any number of operands with any LLVM type
false_dest_opds	Any number of operands with any LLVM type

Successors:

Successor	description
true_dest	Any successor
false_dest	Any successor

Implementations

impl CondBrOp

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

impl CondBrOp

pub fn new( ctx: &mut Context, condition: Value, true_dest: Ptr<BasicBlock>, true_dest_opds: Vec<Value>, false_dest: Ptr<BasicBlock>, false_dest_opds: Vec<Value>, ) -> Self

Create a new CondBrOp.

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

Get the operands forwarded to the true destination.

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

Get the operands forwarded to the false destination.

Trait Implementations

impl BranchOpFoldInterface for CondBrOp

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

Return the list of possible successor blocks given that operands contains Some(attr) for each operand known to be constant, where attr contains the known constant value.

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.

impl BranchOpInterface for CondBrOp

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

Verify that

fn successor_operand_range( &self, ctx: &Context, succ_idx: usize, ) -> Range<usize>

Return the index range of operands forwarded to successor succ_idx. The ith returned index identifies the operand for the target block’s ith argument. Panics if succ_idx is invalid.

fn add_successor_operand( &self, ctx: &mut Context, succ_idx: usize, operand: Value, ) -> usize

Add a new operand to be forwarded to the given successor. The operand is appended after existing operands for the specified successor. Returns the index of the newly added operand among the operands forwarded to the successor. The returned index can be used to determine the corresponding target block argument index. Panics if succ_idx is invalid.

fn remove_successor_operand( &self, ctx: &mut Context, succ_idx: usize, arg_idx: usize, ) -> Value

Remove and return the operand forwarded to argument arg_idx of successor succ_idx. Panics if succ_idx or arg_idx is invalid.

fn successor_operands(&self, ctx: &Context, succ_idx: usize) -> Vec<Value>

Get the list of Values forwarded to successor succ_idx. Panics if succ_idx is invalid.

fn set_successor_operand( &self, ctx: &Context, succ_idx: usize, arg_idx: usize, operand: Value, )

Replace the operand forwarded to argument arg_idx of successor succ_idx with operand. Panics if succ_idx or arg_idx is invalid.

impl Clone for CondBrOp

fn clone(&self) -> CondBrOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CondBrOp

impl Eq for CondBrOp

impl Hash for CondBrOp

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 IsTerminatorInterface for CondBrOp

impl NResultsInterface<0> for CondBrOp

fn get_result_i(&self, ctx: &Context, i: LessThanN<N>) -> Value

Get the i’th result.

fn result_type_i(&self, ctx: &Context, i: LessThanN<N>) -> TypeHandle

Get the type of the i’th result.

impl NSuccsInterface<2> for CondBrOp

fn get_successor_i(&self, ctx: &Context, i: LessThanN<N>) -> Ptr<BasicBlock>

Get the i’th successor block.

impl Op for CondBrOp

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

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 OperandSegmentInterface for CondBrOp

fn expected_num_segments(&self, _ctx: &Context) -> Option<usize>

The number of operand segments that this Op must have, or None if any number of segments is valid.

fn compute_segment_sizes( operands: Vec<Vec<Value>>, ) -> (Vec<Value>, OperandSegmentSizesAttr)

where Self: Sized,

Given a list of segmented operands, compute the segment sizes and flatten the operands (ready for use in constructing an operation). Call set_operand_segment_sizes with the computed segment sizes to set the attribute.

fn segment_range(&self, ctx: &Context, seg_idx: usize) -> Range<usize>

Return the index range of operands in segment seg_idx of this Op. Panics if seg_idx is out of bounds.

fn get_segment(&self, ctx: &Context, seg_idx: usize) -> Vec<Value>

Get the seg_idxth segment of operands. Panics if seg_idx is out of bounds.

fn segment_size(&self, ctx: &Context, seg_idx: usize) -> u32

Get the length of the seg_idxth segment.

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

Get the number of segments.

fn set_operand_segment_sizes( &self, ctx: &Context, sizes: OperandSegmentSizesAttr, )

Set the operand_segment_sizes attribute for this operation.

fn get_operand_segment_sizes(&self, ctx: &Context) -> OperandSegmentSizesAttr

Get the operand_segment_sizes attribute for this operation.

fn push_to_segment( &self, ctx: &mut Context, seg_idx: usize, operand: Value, ) -> usize

Push a new operand at the end of the seg_idxth segment. Returns the index of the inserted operand within that segment.

fn pop_from_segment(&self, ctx: &mut Context, seg_idx: usize) -> Value

Pop and return the last operand in the seg_idxth segment.

fn insert_into_segment( &self, ctx: &mut Context, seg_idx: usize, seg_opd_idx: usize, operand: Value, )

Insert an operand at seg_opd_idx within the seg_idxth segment.

fn remove_from_segment( &self, ctx: &mut Context, seg_idx: usize, seg_opd_idx: usize, ) -> Value

Remove and return the operand at seg_opd_idx in the seg_idxth segment.

impl Parsable for CondBrOp

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<'a>( state_stream: &mut StateStream<'a>, results: 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<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, Output = Self::Parsed, PartialState = ()> + 'a>

where Self::Parsed: 'a,

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

impl PartialEq for CondBrOp

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for CondBrOp

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 StructuralPartialEq for CondBrOp

impl Verify for CondBrOp

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