Struct While

pub struct While { /* private fields */ }

A while is a loop structure composed of two regions: a “before” region, and an “after” region.

The “before” region’s entry block parameters correspond to the operands expected by the operation, and can be used to compute the condition that determines whether the “after” body is executed or not, or simply forwarded to the “after” region. The “before” region must terminate with a Condition operation, which will be evaluated to determine whether or not to continue the loop.

The “after” region corresponds to the loop body, and must terminate with a Yield operation, whose operands must be of the same arity and type as the “before” region’s argument list. In this way, the “after” body can feed back input to the “before” body to determine whether to continue the loop.

Implementations

impl While

Construction

pub fn create<B: ?Sized + Builder, TInits: IntoIterator<Item = ValueRef>>( builder: &mut B, span: SourceSpan, inits: TInits, ) -> Result<UnsafeIntrusiveEntityRef<Self>, Report>

Manually construct a new [#op_ident]

It is generally preferable to use [::midenc_hir::Builder::create] instead.

impl While

This impl block contains no items.

User-defined Fields

impl While

This impl block contains no items.

Attributes

impl While

This impl block contains no items.

Symbols

impl While

Operands

pub fn inits(&self) -> OpOperandRange<'_>

Get a reference to the inits operand group.

pub fn inits_mut(&mut self) -> OpOperandRangeMut<'_>

Get a mutable reference to the inits operand group.

impl While

This impl block contains no items.

Results

impl While

Regions

pub fn before(&self) -> EntityRef<'_, Region>

Get a reference to the before region.

pub fn before_mut(&mut self) -> EntityMut<'_, Region>

Get a mutable reference to the before region.

pub fn after(&self) -> EntityRef<'_, Region>

Get a reference to the after region.

pub fn after_mut(&mut self) -> EntityMut<'_, Region>

Get a mutable reference to the after region.

impl While

This impl block contains no items.

Successors

impl While

pub fn condition_op(&self) -> UnsafeIntrusiveEntityRef<Condition>

pub fn yield_op(&self) -> UnsafeIntrusiveEntityRef<Yield>

Trait Implementations

impl AsMut<Operation> for While

fn as_mut(&mut self) -> &mut Operation

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Operation> for While

fn as_ref(&self) -> &Operation

Converts this type into a shared reference of the (usually inferred) input type.

impl<TInits: IntoIterator<Item = ValueRef>> BuildableOp<(TInits,)> for While

type Builder<'a, T: ?Sized + Builder + 'a> = WhileBuilder<'a, T>

fn builder<'b, B>(builder: &'b mut B, span: SourceSpan) -> Self::Builder<'b, B>

where B: ?Sized + Builder + 'b,

impl Canonicalizable for While

fn get_canonicalization_patterns( rewrites: &mut RewritePatternSet, context: Rc<Context>, )

Populate rewrites with the set of rewrite patterns that should be applied to canonicalize this operation.

impl LoopLikeOpInterface for While

fn get_region_iter_args(&self) -> Option<EntityRef<'_, [BlockArgumentRef]>>

Return the region “iter_args” (block arguments) that correspond to the “init” operands.

fn get_loop_header_region(&self) -> RegionRef

Returns the entry region for this loop, which is expected to also play the role of loop header.

fn get_loop_regions(&self) -> SmallVec<[RegionRef; 2]>

Returns the regions that make up the body of the loop, and should be inspected for loop- invariant operations.

fn get_inits_mut(&mut self) -> OpOperandRangeMut<'_>

Return the mutable “init” operands that are used as initialization values for the region “iter_args” of this loop.

fn get_yielded_values_mut( &mut self, ) -> Option<EntityProjectionMut<'_, OpOperandRangeMut<'_>>>

Return the mutable operand range of values that are yielded to the next iteration by the loop terminator.

fn is_defined_outside_of_loop( &self, value: RawEntityRef<dyn Value<Use = OpOperandImpl, Id = ValueId>>, ) -> bool

Returns true if the given value is defined outside of the loop.

fn move_out_of_loop(&mut self, op: RawEntityRef<Operation, IntrusiveLink>)

Moves the given loop-invariant operation out of the loop.

fn promote_if_single_iteration( &mut self, rewriter: &mut dyn Rewriter, ) -> Result<(), ()>

Promotes the loop body to its containing block if the loop is known to have a single iteration.

fn get_loop_induction_vars( &self, ) -> Option<SmallVec<[RawEntityRef<dyn Value<Use = OpOperandImpl, Id = ValueId>>; 2]>>

Return all induction variables, if they exist.

fn get_loop_lower_bounds(&self) -> Option<SmallVec<[OpFoldResult; 2]>>

Return all lower bounds, if they exist.

fn get_loop_upper_bounds(&self) -> Option<SmallVec<[OpFoldResult; 2]>>

Return all upper bounds, if they exist.

fn get_loop_steps(&self) -> Option<SmallVec<[OpFoldResult; 2]>>

Return all steps, if they exist.

fn get_loop_results(&self) -> Option<EntityRange<'_, RawEntityRef<OpResult>>>

Return the range of results that are return from this loop and correspond to the “init” operands.

impl Op for While

fn name(&self) -> OperationName

The name of this operation’s opcode

fn as_operation(&self) -> &Operation

fn as_operation_mut(&mut self) -> &mut Operation

fn print(&self, flags: &OpPrintingFlags) -> Document

fn as_operation_ref(&self) -> RawEntityRef<Operation, IntrusiveLink>

fn set_span(&mut self, span: SourceSpan)

fn parent(&self) -> Option<RawEntityRef<Block, IntrusiveLink>>

fn parent_region(&self) -> Option<RawEntityRef<Region, IntrusiveLink>>

fn parent_op(&self) -> Option<RawEntityRef<Operation, IntrusiveLink>>

fn num_regions(&self) -> usize

fn regions(&self) -> &EntityList<Region>

fn regions_mut(&mut self) -> &mut EntityList<Region>

fn region(&self, index: usize) -> EntityRef<'_, Region>

fn region_mut(&mut self, index: usize) -> EntityMut<'_, Region>

fn has_successors(&self) -> bool

fn num_successors(&self) -> usize

fn has_operands(&self) -> bool

fn num_operands(&self) -> usize

fn operands(&self) -> &EntityStorage<RawEntityRef<OpOperandImpl, IntrusiveLink>>

fn operands_mut( &mut self, ) -> &mut EntityStorage<RawEntityRef<OpOperandImpl, IntrusiveLink>>

fn has_results(&self) -> bool

fn num_results(&self) -> usize

fn results(&self) -> &EntityStorage<RawEntityRef<OpResult>>

fn results_mut(&mut self) -> &mut EntityStorage<RawEntityRef<OpResult>>

fn successors(&self) -> &EntityStorage<SuccessorInfo, 0>

fn successors_mut(&mut self) -> &mut EntityStorage<SuccessorInfo, 0>

impl OpPrinter for While

fn print(&self, flags: &OpPrintingFlags, _context: &Context) -> Document

impl OpRegistration for While

fn dialect_name() -> Symbol

The name of the dialect this op is declared part of

fn name() -> Symbol

The name of the operation (i.e. its opcode)

fn traits() -> Box<[TraitInfo]>

The set of statically known traits for this op

fn full_name() -> Symbol

The fully-qualified name of the operation (i.e. <dialect>.<opcode>)

impl OpVerifier for While

Generated verifier implementation via #[operation] attribute

Traits verified by this implementation:

• SingleBlock
• HasRecursiveMemoryEffects
• RegionBranchOpInterface
• LoopLikeOpInterface
• OpPrinter

Use cargo-expand to view the generated code if you suspect verification is broken.

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

impl RegionBranchOpInterface for While

fn get_entry_successor_operands( &self, _point: RegionBranchPoint, ) -> SuccessorOperandRange<'_>

Returns the operands of this operation that are forwarded to the region successor’s block arguments or this operation’s results when branching to point. point is guaranteed to be among the successors that are returned by get_entry_succcessor_regions or get_successor_regions(parent_op()).

fn get_successor_regions( &self, point: RegionBranchPoint, ) -> RegionSuccessorIter<'_>

Returns the potential region successors when branching from point.

fn get_region_invocation_bounds( &self, _operands: &[Option<Box<dyn AttributeValue>>], ) -> SmallVec<[InvocationBounds; 1]>

Returns a set of invocation bounds, representing the minimum and maximum number of times this operation will invoke each attached region (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::unknown].

fn is_repetitive_region(&self, _index: usize) -> bool

Returns true if control flow originating from the region at index may eventually branch back to the same region, either from itself, or after passing through other regions first.

fn has_loop(&self) -> bool

Returns true if there is a loop in the region branching graph.

fn get_entry_successor_regions( &self, operands: &[Option<Box<dyn AttributeValue>>], ) -> RegionSuccessorIter<'_>

Returns the potential region successors when first executing the op.

fn are_types_compatible(&self, lhs: &Type, rhs: &Type) -> bool

This function is called to compare types along control-flow edges.

impl Spanned for While

fn span(&self) -> SourceSpan

impl HasRecursiveMemoryEffects for While

impl SingleBlock for While