Struct SwitchOp 

pub struct SwitchOp { /* private fields */ }

Equivalent to LLVM’s Switch opcode.

Operands

operand	description
condition	1-bit signless integer
default_dest_opds	variadic of any type
case_dest_opds	variadic of any type

Successors:

Successor	description
default_dest	any successor
case_dests	any successor(s)

Attribute(s):

Note: Only attributes defined directly as part of this operation are listed here. There may be others, not listed here, defined by interface implementations.

Name	Static Name Identifier	Type
switch_case_values	ATTR_KEY_SWITCH_CASE_VALUES	CaseValuesAttr

Implementations

impl SwitchOp

pub fn get_attr_switch_case_values<'a>( &self, ctx: &'a Context, ) -> Option<Ref<'a, CaseValuesAttr>>

Get a Ref to the value of the attribute named switch_case_values. The Ref is a borrow of the containing Operation object.

pub fn set_attr_switch_case_values(&self, ctx: &Context, value: CaseValuesAttr)

Set the value of the attribute named switch_case_values.

impl SwitchOp

pub fn new( ctx: &mut Context, condition: Value, default_dest: Ptr<BasicBlock>, default_dest_opds: Vec<Value>, cases: Vec<SwitchCase>, ) -> Self

Create a new SwitchOp.

pub fn cases(&self, ctx: &Context) -> Vec<SwitchCase>

Get the cases of this switch operation. (The default case cannot be / isn’t included here).

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

Get the condition value for the switch.

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

Get the default destination of this switch operation.

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

Get the operands to pass to the default destination.

Trait Implementations

impl BranchOpInterface for SwitchOp

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

Get a list of Values that are forwarded to the target block.

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, opd_idx: usize, ) -> Value

Remove and return the operand at opd_idx among the operands forwarded to successor succ_idx. Panics if succ_idx or opd_idx is invalid.

impl Clone for SwitchOp

fn clone(&self) -> SwitchOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Hash for SwitchOp

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 Op for SwitchOp

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() -> (fn(Ptr<Operation>) -> OpBox, TypeId)

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 SwitchOp

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 get_segment(&self, ctx: &Context, seg_idx: usize) -> Vec<Value>

Get the seg_idxth segment of operands.

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 SwitchOp

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

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

impl PartialEq for SwitchOp

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

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 SwitchOp

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

impl Copy for SwitchOp

impl Eq for SwitchOp

impl IsTerminatorInterface for SwitchOp

impl NResultsInterface<0> for SwitchOp

impl StructuralPartialEq for SwitchOp