# MLIR

Multi-Level IR Compiler Framework

# 'omp' Dialect

## Attribute definition ¶

### ClauseCancellationConstructTypeAttr ¶

CancellationConstructType Clause

Syntax:

!omp.cancellationconstructtype<
::mlir::omp::ClauseCancellationConstructType   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseCancellationConstructTypean enum of type ClauseCancellationConstructType

### ClauseDependAttr ¶

depend clause

Syntax:

!omp.clause_depend<
::mlir::omp::ClauseDepend   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseDependan enum of type ClauseDepend

### ClauseMemoryOrderKindAttr ¶

MemoryOrderKind Clause

Syntax:

!omp.memoryorderkind<
::mlir::omp::ClauseMemoryOrderKind   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseMemoryOrderKindan enum of type ClauseMemoryOrderKind

### ClauseOrderKindAttr ¶

OrderKind Clause

Syntax:

!omp.orderkind<
::mlir::omp::ClauseOrderKind   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseOrderKindan enum of type ClauseOrderKind

### ClauseProcBindKindAttr ¶

ProcBindKind Clause

Syntax:

!omp.procbindkind<
::mlir::omp::ClauseProcBindKind   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseProcBindKindan enum of type ClauseProcBindKind

### ClauseScheduleKindAttr ¶

ScheduleKind Clause

Syntax:

!omp.schedulekind<
::mlir::omp::ClauseScheduleKind   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ClauseScheduleKindan enum of type ClauseScheduleKind

### ScheduleModifierAttr ¶

OpenMP Schedule Modifier

Syntax:

!omp.sched_mod<
::mlir::omp::ScheduleModifier   # value
>


#### Parameters: ¶

ParameterC++ typeDescription
value::mlir::omp::ScheduleModifieran enum of type ScheduleModifier

## Operation definition ¶

### omp.atomic.capture (::mlir::omp::AtomicCaptureOp) ¶

performs an atomic capture

Syntax:

operation ::= omp.atomic.capture oilist(memory_order ( custom<ClauseAttr>($memory_order_val) ) |hint ( custom<SynchronizationHint>($hint_val) ))
$region attr-dict  This operation performs an atomic capture. hint is the value of hint (as used in the hint clause). It is a compile time constant. As the name suggests, this is just a hint for optimization. memory_order indicates the memory ordering behavior of the construct. It can be one of seq_cst, acq_rel, release, acquire or relaxed. The region has the following allowed forms:  omp.atomic.capture { omp.atomic.update ... omp.atomic.read ... omp.terminator } omp.atomic.capture { omp.atomic.read ... omp.atomic.update ... omp.terminator } omp.atomic.capture { omp.atomic.read ... omp.atomic.write ... omp.terminator }  Traits: SingleBlockImplicitTerminator #### Attributes: ¶ AttributeMLIR TypeDescription hint_val::mlir::IntegerAttr64-bit signless integer attribute memory_order_val::mlir::omp::ClauseMemoryOrderKindAttrMemoryOrderKind Clause ### omp.atomic.read (::mlir::omp::AtomicReadOp) ¶ performs an atomic read Syntax: operation ::= omp.atomic.read$v = $x oilist( memory_order ( custom<ClauseAttr>($memory_order_val) )
| hint ( custom<SynchronizationHint>($hint_val) )) : type($x) attr-dict


This operation performs an atomic read.

The operand x is the address from where the value is atomically read. The operand v is the address where the value is stored after reading.

hint is the value of hint (as specified in the hint clause). It is a compile time constant. As the name suggests, this is just a hint for optimization.

memory_order indicates the memory ordering behavior of the construct. It can be one of seq_cst, acquire or relaxed.

#### Attributes: ¶

AttributeMLIR TypeDescription
hint_val::mlir::IntegerAttr64-bit signless integer attribute
memory_order_val::mlir::omp::ClauseMemoryOrderKindAttrMemoryOrderKind Clause

#### Operands: ¶

OperandDescription
xOpenMP-compatible variable type
vOpenMP-compatible variable type

### omp.atomic.update (::mlir::omp::AtomicUpdateOp) ¶

performs an atomic update

Syntax:

operation ::= omp.atomic.update oilist( memory_order ( custom<ClauseAttr>($memory_order_val) ) | hint ( custom<SynchronizationHint>($hint_val) ))
( if ( $if_expr^ ) )? attr-dict  The cancel construct activates cancellation of the innermost enclosing region of the type specified. #### Attributes: ¶ AttributeMLIR TypeDescription cancellation_construct_type_val::mlir::omp::ClauseCancellationConstructTypeAttrCancellationConstructType Clause #### Operands: ¶ OperandDescription if_expr1-bit signless integer ### omp.cancellationpoint (::mlir::omp::CancellationPointOp) ¶ cancellation point directive Syntax: operation ::= omp.cancellationpoint cancellation_construct_type ( custom<ClauseAttr>($cancellation_construct_type_val) )
attr-dict


The cancellation point construct introduces a user-defined cancellation point at which implicit or explicit tasks check if cancellation of the innermost enclosing region of the type specified has been activated.

#### Attributes: ¶

AttributeMLIR TypeDescription
cancellation_construct_type_val::mlir::omp::ClauseCancellationConstructTypeAttrCancellationConstructType Clause

### omp.critical.declare (::mlir::omp::CriticalDeclareOp) ¶

declares a named critical section.

Syntax:

operation ::= omp.critical.declare $sym_name oilist(hint ( custom<SynchronizationHint>($hint_val) ))
attr-dict


Declares a named critical section.

The name can be used in critical constructs in the dialect.

Interfaces: Symbol

#### Attributes: ¶

AttributeMLIR TypeDescription
sym_name::mlir::StringAttrstring attribute
hint_val::mlir::IntegerAttr64-bit signless integer attribute

### omp.critical (::mlir::omp::CriticalOp) ¶

critical construct

Syntax:

operation ::= omp.critical (( $name^ ))?$region attr-dict


The critical construct imposes a restriction on the associated structured block (region) to be executed by only a single thread at a time.

Interfaces: SymbolUserOpInterface

#### Attributes: ¶

AttributeMLIR TypeDescription
name::mlir::FlatSymbolRefAttrflat symbol reference attribute

### omp.flush (::mlir::omp::FlushOp) ¶

flush construct

Syntax:

operation ::= omp.flush ( ( $varList^ : type($varList) ) )? attr-dict


The flush construct executes the OpenMP flush operation. This operation makes a thread’s temporary view of memory consistent with memory and enforces an order on the memory operations of the variables explicitly specified or implied.

#### Operands: ¶

OperandDescription
varListany type

master construct

Syntax:

operation ::= omp.master $region attr-dict  The master construct specifies a structured block that is executed by the master thread of the team. ### omp.ordered (::mlir::omp::OrderedOp) ¶ ordered construct without region Syntax: operation ::= omp.ordered ( depend_type $depend_type_val^ )?
( depend_vec ( $depend_vec_vars^ : type($depend_vec_vars) ) )?
attr-dict


The ordered construct without region is a stand-alone directive that specifies cross-iteration dependences in a doacross loop nest.

The depend_type_val attribute refers to either the DEPEND(SOURCE) clause or the DEPEND(SINK: vec) clause.

The num_loops_val attribute specifies the number of loops in the doacross nest.

The depend_vec_vars is a variadic list of operands that specifies the index of the loop iterator in the doacross nest for the DEPEND(SOURCE) clause or the index of the element of “vec” for the DEPEND(SINK: vec) clause. It contains the operands in multiple “vec” when multiple DEPEND(SINK: vec) clauses exist in one ORDERED directive.

#### Attributes: ¶

AttributeMLIR TypeDescription
depend_type_val::mlir::omp::ClauseDependAttrdepend clause
num_loops_val::mlir::IntegerAttr64-bit signless integer attribute whose minimum value is 0

#### Operands: ¶

OperandDescription
depend_vec_varsany type

### omp.ordered_region (::mlir::omp::OrderedRegionOp) ¶

ordered construct with region

Syntax:

operation ::= omp.ordered_region ( simd $simd^ )?$region attr-dict


The ordered construct with region specifies a structured block in a worksharing-loop, SIMD, or worksharing-loop SIMD region that is executed in the order of the loop iterations.

The simd attribute corresponds to the SIMD clause specified. If it is not present, it behaves as if the THREADS clause is specified or no clause is specified.

#### Attributes: ¶

AttributeMLIR TypeDescription
simd::mlir::UnitAttrunit attribute

### omp.parallel (::mlir::omp::ParallelOp) ¶

parallel construct

Syntax:

operation ::= omp.parallel oilist( reduction (
custom<ReductionVarList>(
$reduction_vars, type($reduction_vars), $reductions ) ) | if ($if_expr_var : type($if_expr_var) ) | num_threads ($num_threads_var : type($num_threads_var) ) | allocate ( custom<AllocateAndAllocator>($allocate_vars, type($allocate_vars),$allocators_vars, type($allocators_vars) ) ) | proc_bind ( custom<ClauseAttr>($proc_bind_val) )
) $region attr-dict  The parallel construct includes a region of code which is to be executed by a team of threads. The optional$if_expr_var parameter specifies a boolean result of a conditional check. If this value is 1 or is not provided then the parallel region runs as normal, if it is 0 then the parallel region is executed with one thread.

The optional $num_threads_var parameter specifies the number of threads which should be used to execute the parallel region. The$allocators_vars and $allocate_vars parameters are a variadic list of values that specify the memory allocator to be used to obtain storage for private values. Reductions can be performed in a parallel construct by specifying reduction accumulator variables in reduction_vars and symbols referring to reduction declarations in the reductions attribute. Each reduction is identified by the accumulator it uses and accumulators must not be repeated in the same reduction. The omp.reduction operation accepts the accumulator and a partial value which is considered to be produced by the thread for the given reduction. If multiple values are produced for the same accumulator, i.e. there are multiple omp.reductions, the last value is taken. The reduction declaration specifies how to combine the values from each thread into the final value, which is available in the accumulator after all the threads complete. The optional$proc_bind_val attribute controls the thread affinity for the execution of the parallel region.

Traits: AttrSizedOperandSegments, AutomaticAllocationScope, RecursiveSideEffects

Interfaces: OutlineableOpenMPOpInterface, ReductionClauseInterface

#### Attributes: ¶

AttributeMLIR TypeDescription
reductions::mlir::ArrayAttrsymbol ref array attribute
proc_bind_val::mlir::omp::ClauseProcBindKindAttrProcBindKind Clause

#### Operands: ¶

OperandDescription
if_expr_var1-bit signless integer
num_threads_varinteger or index
allocate_varsany type
allocators_varsany type
reduction_varsOpenMP-compatible variable type

### omp.reduction.declare (::mlir::omp::ReductionDeclareOp) ¶

declares a reduction kind

Syntax:

operation ::= omp.reduction.declare $sym_name :$type attr-dict-with-keyword init $initializerRegion combiner$reductionRegion custom<AtomicReductionRegion>($atomicReductionRegion)  Declares an OpenMP reduction kind. This requires two mandatory and one optional region. 1. The initializer region specifies how to initialize the thread-local reduction value. This is usually the neutral element of the reduction. For convenience, the region has an argument that contains the value of the reduction accumulator at the start of the reduction. It is expected to omp.yield the new value on all control flow paths. 2. The reduction region specifies how to combine two values into one, i.e. the reduction operator. It accepts the two values as arguments and is expected to omp.yield the combined value on all control flow paths. 3. The atomic reduction region is optional and specifies how two values can be combined atomically given local accumulator variables. It is expected to store the combined value in the first accumulator variable. Note that the MLIR type system does not allow for type-polymorphic reductions. Separate reduction declarations should be created for different element and accumulator types. For initializer and reduction regions, the operand to omp.yield must match the parent operation’s results. Interfaces: Symbol #### Attributes: ¶ AttributeMLIR TypeDescription sym_name::mlir::StringAttrstring attribute type::mlir::TypeAttrany type attribute ### omp.reduction (::mlir::omp::ReductionOp) ¶ reduction construct Syntax: operation ::= omp.reduction$operand , $accumulator attr-dict : type($accumulator)


Indicates the value that is produced by the current reduction-participating entity for a reduction requested in some ancestor. The reduction is identified by the accumulator, but the value of the accumulator may not be updated immediately.

#### Operands: ¶

OperandDescription
operandany type
accumulatorOpenMP-compatible variable type

### omp.section (::mlir::omp::SectionOp) ¶

section directive

Syntax:

operation ::= omp.section $region attr-dict  A section operation encloses a region which represents one section in a sections construct. A section op should always be surrounded by an omp.sections operation. Traits: HasParent ### omp.sections (::mlir::omp::SectionsOp) ¶ sections construct Syntax: operation ::= omp.sections oilist( reduction ( custom<ReductionVarList>($reduction_vars, type($reduction_vars),$reductions
) )
| allocate (
custom<AllocateAndAllocator>(
$allocate_vars, type($allocate_vars),
$allocators_vars, type($allocators_vars)
) )
| nowait $nowait )$region attr-dict


The sections construct is a non-iterative worksharing construct that contains omp.section operations. The omp.section operations are to be distributed among and executed by the threads in a team. Each omp.section is executed once by one of the threads in the team in the context of its implicit task.

Reductions can be performed in a sections construct by specifying reduction accumulator variables in reduction_vars and symbols referring to reduction declarations in the reductions attribute. Each reduction is identified by the accumulator it uses and accumulators must not be repeated in the same reduction. The omp.reduction operation accepts the accumulator and a partial value which is considered to be produced by the section for the given reduction. If multiple values are produced for the same accumulator, i.e. there are multiple omp.reductions, the last value is taken. The reduction declaration specifies how to combine the values from each section into the final value, which is available in the accumulator after all the sections complete.

The $allocators_vars and$allocate_vars parameters are a variadic list of values that specify the memory allocator to be used to obtain storage for private values.

The nowait attribute, when present, signifies that there should be no implicit barrier at the end of the construct.

Traits: AttrSizedOperandSegments

Interfaces: ReductionClauseInterface

#### Attributes: ¶

AttributeMLIR TypeDescription
reductions::mlir::ArrayAttrsymbol ref array attribute
nowait::mlir::UnitAttrunit attribute

#### Operands: ¶

OperandDescription
reduction_varsOpenMP-compatible variable type
allocate_varsany type
allocators_varsany type

### omp.simdloop (::mlir::omp::SimdLoopOp) ¶

simd loop construct

The simd construct can be applied to a loop to indicate that the loop can be transformed into a SIMD loop (that is, multiple iterations of the loop can be executed concurrently using SIMD instructions).. The lower and upper bounds specify a half-open range: the range includes the lower bound but does not include the upper bound.

The body region can contain any number of blocks. The region is terminated by “omp.yield” instruction without operands.

omp.simdloop (%i1, %i2) : index = (%c0, %c0) to (%c10, %c10)
step (%c1, %c1) {
// block operations
omp.yield
}


Traits: AttrSizedOperandSegments

#### Operands: ¶

OperandDescription
lowerBoundinteger or index
upperBoundinteger or index
stepinteger or index

### omp.single (::mlir::omp::SingleOp) ¶

single directive

Syntax:

operation ::= omp.single oilist(allocate (
custom<AllocateAndAllocator>(
$allocate_vars, type($allocate_vars),
$allocators_vars, type($allocators_vars)
) )
|nowait $nowait )$region attr-dict


The single construct specifies that the associated structured block is executed by only one of the threads in the team (not necessarily the master thread), in the context of its implicit task. The other threads in the team, which do not execute the block, wait at an implicit barrier at the end of the single construct unless a nowait clause is specified.

Traits: AttrSizedOperandSegments

#### Attributes: ¶

AttributeMLIR TypeDescription
nowait::mlir::UnitAttrunit attribute

#### Operands: ¶

OperandDescription
allocate_varsany type
allocators_varsany type

### omp.target (::mlir::omp::TargetOp) ¶

target construct

Syntax:

operation ::= omp.target oilist( if ( $if_expr ) | device ($device : type($device) ) | thread_limit ($thread_limit : type($thread_limit) ) | nowait$nowait
) $region attr-dict  The target construct includes a region of code which is to be executed on a device. The optional$if_expr parameter specifies a boolean result of a conditional check. If this value is 1 or is not provided then the target region runs on a device, if it is 0 then the target region is executed on the host device.

The optional $device parameter specifies the device number for the target region. The optional$thread_limit specifies the limit on the number of threads

The optional $nowait elliminates the implicit barrier so the parent task can make progress even if the target task is not yet completed. TODO: map, is_device_ptr, depend, defaultmap, in_reduction Traits: AttrSizedOperandSegments #### Attributes: ¶ AttributeMLIR TypeDescription nowait::mlir::UnitAttrunit attribute #### Operands: ¶ OperandDescription if_expr1-bit signless integer deviceinteger thread_limitinteger ### omp.task (::mlir::omp::TaskOp) ¶ task construct Syntax: operation ::= omp.task oilist(if ($if_expr )
|final ( $final_expr ) |untied$untied
|mergeable $mergeable |in_reduction ( custom<ReductionVarList>($in_reduction_vars, type($in_reduction_vars),$in_reductions
) )
|priority ( $priority ) |allocate ( custom<AllocateAndAllocator>($allocate_vars, type($allocate_vars),$allocators_vars, type($allocators_vars) ) ) )$region attr-dict


When an if clause is present on a task construct, and the value of if_expr evaluates to false, an “undeferred task” is generated, and the encountering thread must suspend the current task region, for which execution cannot be resumed until execution of the structured block that is associated with the generated task is completed.

When a final clause is present on a task construct and the final_expr evaluates to true, the generated task will be a “final task”. All task constructs encountered during execution of a final task will generate final and included tasks.

If the untied clause is present on a task construct, any thread in the team can resume the task region after a suspension. The untied clause is ignored if a final clause is present on the same task construct and the final_expr evaluates to true, or if a task is an included task.

When the mergeable clause is present on a task construct, the generated task is a “mergeable task”.

The in_reduction clause specifies that this particular task (among all the tasks in current taskgroup, if any) participates in a reduction.

The priority clause is a hint for the priority of the generated task. The priority is a non-negative integer expression that provides a hint for task execution order. Among all tasks ready to be executed, higher priority tasks (those with a higher numerical value in the priority clause expression) are recommended to execute before lower priority ones. The default priority-value when no priority clause is specified should be assumed to be zero (the lowest priority).

The allocators_vars and allocate_vars parameters are a variadic list of values that specify the memory allocator to be used to obtain storage for private values.

Traits: AttrSizedOperandSegments, AutomaticAllocationScope

Interfaces: OutlineableOpenMPOpInterface, ReductionClauseInterface

#### Attributes: ¶

AttributeMLIR TypeDescription
untied::mlir::UnitAttrunit attribute
mergeable::mlir::UnitAttrunit attribute
in_reductions::mlir::ArrayAttrsymbol ref array attribute

#### Operands: ¶

OperandDescription
if_expr1-bit signless integer
final_expr1-bit signless integer
in_reduction_varsOpenMP-compatible variable type
priority32-bit signless integer
allocate_varsany type
allocators_varsany type

### omp.taskwait (::mlir::omp::TaskwaitOp) ¶

Syntax:

operation ::= omp.taskwait attr-dict


### omp.taskyield (::mlir::omp::TaskyieldOp) ¶

Syntax:

operation ::= omp.taskyield attr-dict


The taskyield construct specifies that the current task can be suspended in favor of execution of a different task.

### omp.terminator (::mlir::omp::TerminatorOp) ¶

terminator for OpenMP regions

Syntax:

operation ::= omp.terminator attr-dict


A terminator operation for regions that appear in the body of OpenMP operation. These regions are not expected to return any value so the terminator takes no operands. The terminator op returns control to the enclosing op.

Traits: Terminator

### omp.threadprivate (::mlir::omp::ThreadprivateOp) ¶

Syntax:

operation ::= omp.threadprivate $sym_addr : type($sym_addr) -> type($tls_addr) attr-dict  The threadprivate directive specifies that variables are replicated, with each thread having its own copy. The current implementation uses the OpenMP runtime to provide thread-local storage (TLS). Using the TLS feature of the LLVM IR will be supported in future. This operation takes in the address of a symbol that represents the original variable and returns the address of its TLS. All occurrences of threadprivate variables in a parallel region should use the TLS returned by this operation. The sym_addr refers to the address of the symbol, which is a pointer to the original variable. #### Operands: ¶ OperandDescription sym_addrOpenMP-compatible variable type #### Results: ¶ ResultDescription tls_addrOpenMP-compatible variable type ### omp.wsloop (::mlir::omp::WsLoopOp) ¶ worksharing-loop construct Syntax: operation ::= omp.wsloop oilist(linear ( custom<LinearClause>($linear_vars, type($linear_vars),$linear_step_vars) )
|schedule (
custom<ScheduleClause>(
$schedule_val,$schedule_modifier, $simd_modifier,$schedule_chunk_var, type($schedule_chunk_var)) ) |collapse ($collapse_val )
|nowait $nowait |ordered ($ordered_val )
|order ( custom<ClauseAttr>($order_val) ) |reduction ( custom<ReductionVarList>($reduction_vars, type($reduction_vars),$reductions
) )
) for custom<WsLoopControl>($region,$lowerBound, $upperBound,$step,
type($step),$inclusive) attr-dict


The worksharing-loop construct specifies that the iterations of the loop(s) will be executed in parallel by threads in the current context. These iterations are spread across threads that already exist in the enclosing parallel region. The lower and upper bounds specify a half-open range: the range includes the lower bound but does not include the upper bound. If the inclusive attribute is specified then the upper bound is also included.

The body region can contain any number of blocks. The region is terminated by “omp.yield” instruction without operands.

omp.wsloop <clauses>
for (%i1, %i2) : index = (%c0, %c0) to (%c10, %c10) step (%c1, %c1) {
%a = load %arrA[%i1, %i2] : memref<?x?xf32>
%b = load %arrB[%i1, %i2] : memref<?x?xf32>
%sum = arith.addf %a, %b : f32
store %sum, %arrC[%i1, %i2] : memref<?x?xf32>
omp.yield
}


The linear_step_vars operand additionally specifies the step for each associated linear operand. Note that the linear_vars and linear_step_vars variadic lists should contain the same number of elements.

Reductions can be performed in a workshare loop by specifying reduction accumulator variables in reduction_vars and symbols referring to reduction declarations in the reductions attribute. Each reduction is identified by the accumulator it uses and accumulators must not be repeated in the same reduction. The omp.reduction operation accepts the accumulator and a partial value which is considered to be produced by the current loop iteration for the given reduction. If multiple values are produced for the same accumulator, i.e. there are multiple omp.reductions, the last value is taken. The reduction declaration specifies how to combine the values from each iteration into the final value, which is available in the accumulator after the loop completes.

The optional schedule_val attribute specifies the loop schedule for this loop, determining how the loop is distributed across the parallel threads. The optional schedule_chunk_var associated with this determines further controls this distribution.

The optional collapse_val attribute specifies the number of loops which are collapsed to form the worksharing loop.

The nowait attribute, when present, signifies that there should be no implicit barrier at the end of the loop.

The optional ordered_val attribute specifies how many loops are associated with the worksharing-loop construct. The value of zero refers to the ordered clause specified without parameter.

The optional order attribute specifies which order the iterations of the associate loops are executed in. Currently the only option for this attribute is “concurrent”.

Traits: AttrSizedOperandSegments, RecursiveSideEffects

Interfaces: ReductionClauseInterface

#### Attributes: ¶

AttributeMLIR TypeDescription
reductions::mlir::ArrayAttrsymbol ref array attribute
schedule_val::mlir::omp::ClauseScheduleKindAttrScheduleKind Clause
schedule_modifier::mlir::omp::ScheduleModifierAttrOpenMP Schedule Modifier
simd_modifier::mlir::UnitAttrunit attribute
collapse_val::mlir::IntegerAttr64-bit signless integer attribute whose minimum value is 0
nowait::mlir::UnitAttrunit attribute
ordered_val::mlir::IntegerAttr64-bit signless integer attribute whose minimum value is 0
order_val::mlir::omp::ClauseOrderKindAttrOrderKind Clause
inclusive::mlir::UnitAttrunit attribute

#### Operands: ¶

OperandDescription
lowerBoundinteger or index
upperBoundinteger or index
stepinteger or index
linear_varsany type
linear_step_vars32-bit signless integer
reduction_varsOpenMP-compatible variable type
schedule_chunk_varany type

### omp.yield (::mlir::omp::YieldOp) ¶

loop yield and termination operation

Syntax:

operation ::= omp.yield ( ( $results^ : type($results) ) )? attr-dict


“omp.yield” yields SSA values from the OpenMP dialect op region and terminates the region. The semantics of how the values are yielded is defined by the parent operation.

Traits: HasParent<WsLoopOp, ReductionDeclareOp, AtomicUpdateOp, SimdLoopOp>, ReturnLike, Terminator

Interfaces: NoSideEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

#### Operands: ¶

OperandDescription
resultsany type