Struct SwitchOp 

pub struct SwitchOp { /* private fields */ }

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
scf_switch_cases	ATTR_KEY_SCF_SWITCH_CASES	IntegerVecAttr

Implementations

impl SwitchOp

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

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

pub fn set_attr_scf_switch_cases(&self, ctx: &Context, value: IntegerVecAttr)

Set the value of the attribute named scf_switch_cases.

impl SwitchOp

pub fn new(ctx: &mut Context, results: Vec<TypeHandle>, value: Value) -> Self

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

pub fn default_region(&self, ctx: &Context) -> Ptr<Region>

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

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

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

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

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

pub fn cases_regions(&self, ctx: &Context) -> Vec<(IntegerAttr, Ptr<Region>)>

pub fn cases_values(&self, ctx: &Context) -> Vec<IntegerAttr>

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

pub fn set_attr_cases( &self, ctx: &Context, cases: impl IntoIterator<Item = IntegerAttr>, )

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

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

Trait Implementations

impl CanonicalizeInterface for SwitchOp

fn canonicalize( &self, ctx: &mut Context, rewriter: &mut MatchRewriter, ) -> Result<()>

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Clone for SwitchOp

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionallySpeculatable for SwitchOp

fn speculatability(&self, _ctx: &Context) -> Speculatability

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Copy for SwitchOp

impl Eq for SwitchOp

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

fn memory_effects(&self, ctx: &Context) -> Vec<MemoryEffect>

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

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

impl MemorySSARegionOpInterface for SwitchOp

fn setup_memory_ssa( &self, ctx: &Context, _state: &mut MemorySSAContext, reaching_def: MemoryValue, _has_memory_defs: bool, regions_to_process: &mut SmallMap<Ptr<Region>, MemoryValue, 2>, )

Called before descending into nested regions. reaching_def is the state of the memory on entry to this op. Populate regions_to_process with the reaching def each region starts with.

fn finalize_memory_ssa( &self, ctx: &Context, _state: &mut MemorySSAContext, entry_reaching_def: MemoryValue, has_memory_defs: bool, _reaching_at_region_entry: &HMap<Ptr<Region>, MemoryValue>, reaching_at_block_end: &HMap<Ptr<BasicBlock>, MemoryValue>, _region_phis: &mut SmallMap<Ptr<Region>, RegionMemoryPhiInputs, 2>, ) -> RegionMemoryValue

Called after reaching defs are computed for all regions. Returns the new reaching def at the op’s exit. If values need to be merged at the start of a nested region, the input values must be added to region_phis. This will insert a memory phi at the beginning of the region’s entry block, with the result value being the one added to regions_to_process in setup_memory_ssa.

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl NOpdsInterface<1> for SwitchOp

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

Get the i’th operand.

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

Get the type of the i’th operand.

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 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<'__pliron_parse>( state_stream: &mut StateStream<'__pliron_parse>, arg: Self::Arg, ) -> ParseResult<'__pliron_parse, 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>

where Self::Parsed: 'a,

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

impl PartialEq for SwitchOp

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for SwitchOp

fn fmt(&self, ctx: &Context, state: &State, fmt: &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 PromotableRegionOpInterface for SwitchOp

fn is_region_promotable( &self, _: &Context, _: &AllocInfo, _: Ptr<Region>, _: bool, ) -> bool

Returns true if region (a child of this op) can be analysed for promotion with respect to alloc. has_value_stores is a hint: true when the region contains stores to alloc.

fn setup_promotion( &self, ctx: &mut Context, _: &AllocInfo, reaching_def: Value, _: bool, regions_to_process: &mut SmallMap<Ptr<Region>, Value, 2>, )

Called before descending into nested regions. reaching_def is the value in slot on entry to this op. Populate regions_to_process with the reaching def each region starts with. You may mutate the op in place, but do NOT delete ops or touch terminators.

fn finalize_promotion( &self, ctx: &mut Context, alloc: &AllocInfo, reaching_def: Value, has_value_stores: bool, reaching_at_block_end: &HMap<Ptr<BasicBlock>, Value>, ) -> Value

Called after reaching defs are computed for all regions, but before blocking uses are removed. Returns the new reaching def at the op’s exit. Mutation is allowed, but you must not change control flow or add ops that interact with the slot’s value.

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl RegionBranchOpInterface for SwitchOp

fn entry_successor_regions( &self, ctx: &Context, operands: &[Option<AttrObj>], ) -> Vec<RegionSuccessor>

Returns all potential region successors when first executing the op.

fn successor_regions( &self, ctx: &Context, pred: RegionPredecessor, ) -> Vec<RegionSuccessor>

Returns all potential region successors when branching from predecessor. These are the regions that may be selected during the flow of control.

fn successor_inputs( &self, ctx: &Context, successor: RegionSuccessor, ) -> Vec<Value>

Return all successor inputs for the given region successor. If the given region successor is a region, then the returned values are block arguments. Otherwise, if the given region successor is an operation, the returned values are op results.

fn region_invocation_bounds( &self, ctx: &Context, operands: &[Option<AttrObj>], ) -> Vec<InvocationBounds>

Populates invocationBounds with the minimum and maximum number of times this operation will invoke the attached regions (assuming the regions yield normally, i.e. do not abort or invoke an infinite loop). The minimum number of invocations is at least 0. If the maximum number of invocations cannot be statically determined, then it will be set to InvocationBounds::getUnknown().

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

fn entry_successor_operands( &self, ctx: &Context, successor: RegionSuccessor, ) -> Vec<Use<Value>>

Returns the operands of this operation that are forwarded to the successor inputs when branching to successor. successor is guaranteed to be among the successors that are returned by entry_successor_regions/successor_regions(parent()).

fn all_successor_regions_of_region( &self, ctx: &Context, region: Ptr<Region>, ) -> Vec<RegionSuccessor>

Returns all potential region successors when branching from any terminator in region.

fn predecessors( &self, ctx: &Context, successor: RegionSuccessor, ) -> Vec<RegionPredecessor>

Returns all potential branching points (predecessors) for a given region successor.

fn predecessor_values( &self, ctx: &Context, successor: RegionSuccessor, index: usize, ) -> Vec<Use<Value>>

Returns all potential values across all (predecessors) for a given successor input.

fn are_types_compatible( &self, ctx: &Context, lhs: TypeHandle, rhs: TypeHandle, ) -> bool

This method is called to compare types along control-flow edges. By default, the types are checked as equal.

impl SideEffects for SwitchOp

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

Returns true if the operation has side effects, and false otherwise.

impl SingleBlockRegionInterface for SwitchOp

fn get_body(&self, ctx: &Context, region_idx: usize) -> Ptr<BasicBlock>

Get the single body block in region_idx.

fn append_operation( &self, ctx: &mut Context, op: Ptr<Operation>, region_idx: usize, )

Insert an operation at the end of the single block in region_idx.

impl StructuralPartialEq for SwitchOp

impl UniformRegionOpInterface for SwitchOp

fn result_uniformity( &self, _ctx: &Context, operands: &[Uniformity], ) -> Uniformity

fn entry_successor_region_uniformity( &self, ctx: &Context, operands: &[Uniformity], ) -> Vec<Uniformity>

fn verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Verify for SwitchOp

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