Struct IfOp 

pub struct IfOp { /* private fields */ }

Implementations

impl IfOp

pub fn new(ctx: &mut Context, cond: Value) -> Self

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

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

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

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

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

Trait Implementations

impl CanonicalizeInterface for IfOp

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

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

where Self: Sized,

impl Clone for IfOp

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 IfOp

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

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

where Self: Sized,

impl Copy for IfOp

impl Eq for IfOp

impl Hash for IfOp

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 IfOp

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 IfOp

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 IfOp

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 NRegionsInterface<2> for IfOp

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

Get the i’th region.

impl NResultsInterface<0> for IfOp

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

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 OperandNOfType<0, BoolType> for IfOp

impl Parsable for IfOp

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

where Self::Parsed: 'a,

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

impl PartialEq for IfOp

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for IfOp

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 RegionBranchOpInterface for IfOp

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 IfOp

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

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

impl SingleBlockRegionInterface for IfOp

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 IfOp

impl Verify for IfOp

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