Struct ForOp 

pub struct ForOp { /* private fields */ }

Implementations

impl ForOp

pub fn new( ctx: &mut Context, results: Vec<TypeHandle>, start: Value, end: Value, step: Value, carried_values_init: Vec<Value>, ) -> Self

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

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

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

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

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

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

pub fn remove_initial_carried_value( &self, ctx: &mut Context, opd_idx: usize, ) -> Value

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

pub fn get_carried_value(&self, ctx: &Context, arg_idx: usize) -> Value

pub fn push_carried_value(&self, ctx: &mut Context, ty: TypeHandle) -> usize

pub fn remove_carried_value(&self, ctx: &Context, arg_idx: usize)

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

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

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

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

Trait Implementations

impl CanonicalizeInterface for ForOp

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

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

where Self: Sized,

impl Clone for ForOp

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ForOp

impl Eq for ForOp

impl Hash for ForOp

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 ForOp

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 ForOp

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 OneRegionInterface for ForOp

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

Get the single region that this Op has.

impl Op for ForOp

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 ForOp

fn expected_num_segments(&self, _: &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 ForOp

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

where Self::Parsed: 'a,

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

impl PartialEq for ForOp

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for ForOp

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 PromotableRegionOpInterface for ForOp

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, alloc: &AllocInfo, reaching_def: Value, has_value_stores: 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, entry_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 ForOp

fn entry_successor_operands( &self, ctx: &Context, _: 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 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 verify(_op: &dyn Op, _ctx: &Context) -> Result<()>

where Self: Sized,

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

Returns all potential region successors when first executing the op.

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 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 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 ForOp

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

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

impl SingleBlockRegionInterface for ForOp

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 ForOp

impl UniformRegionOpInterface for ForOp

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 ForOp

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