llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-mlir Author: Sergio Afonso (skatrak) <details> <summary>Changes</summary> This patch adds a new tablegen file for the OpenMP dialect containing the list of clauses currently supported. --- Patch is 44.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/92521.diff 1 Files Affected: - (added) mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td (+1183) ``````````diff diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td new file mode 100644 index 0000000000000..8b3a53a5842f3 --- /dev/null +++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td @@ -0,0 +1,1183 @@ +//=== OpenMPClauses.td - OpenMP dialect clause definitions -*- tablegen -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains clause definitions for the OpenMP dialect. +// +// For each "Xyz" clause, there is an "OpenMP_XyzClauseSkip" class and an +// "OpenMP_XyzClause" definition. The latter is an instantiation of the former +// where all "skip" template parameters are set to `false` and should be the +// preferred variant to used whenever possible when defining `OpenMP_Op` +// instances. +// +//===----------------------------------------------------------------------===// + +#ifndef OPENMP_CLAUSES +#define OPENMP_CLAUSES + +include "mlir/Dialect/OpenMP/OpenMPOpBase.td" + +//===----------------------------------------------------------------------===// +// V5.2: [5.11] `aligned` clause +//===----------------------------------------------------------------------===// + +class OpenMP_AlignedClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<OpenMP_PointerLikeType>:$aligned_vars, + OptionalAttr<I64ArrayAttr>:$alignment_values + ); + + let assemblyFormat = [{ + `aligned` `(` custom<AlignedClause>($aligned_vars, type($aligned_vars), + $alignment_values) `)` + }]; + + let description = [{ + The `alignment_values` attribute additionally specifies alignment of each + corresponding aligned operand. Note that `aligned_vars` and + `alignment_values` should contain the same number of elements. + }]; +} + +def OpenMP_AlignedClause : OpenMP_AlignedClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [6.6] `allocate` clause +//===----------------------------------------------------------------------===// + +class OpenMP_AllocateClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<AnyType>:$allocate_vars, + Variadic<AnyType>:$allocators_vars + ); + + let assemblyFormat = [{ + `allocate` `(` + custom<AllocateAndAllocator>($allocate_vars, type($allocate_vars), + $allocators_vars, type($allocators_vars)) `)` + }]; + + let description = [{ + 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. + }]; +} + +def OpenMP_AllocateClause : OpenMP_AllocateClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [16.1, 16.2] `cancel-directive-name` clause set +//===----------------------------------------------------------------------===// + +class OpenMP_CancelDirectiveNameClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + CancellationConstructTypeAttr:$cancellation_construct_type_val + ); + + let assemblyFormat = [{ + `cancellation_construct_type` `(` + custom<ClauseAttr>($cancellation_construct_type_val) `)` + }]; + + // TODO: Add description. +} + +def OpenMP_CancelDirectiveNameClause : OpenMP_CancelDirectiveNameClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [4.4.3] `collapse` clause +//===----------------------------------------------------------------------===// + +class OpenMP_CollapseClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let traits = [ + AllTypesMatch<["lowerBound", "upperBound", "step"]> + ]; + + let arguments = (ins + Variadic<IntLikeType>:$lowerBound, + Variadic<IntLikeType>:$upperBound, + Variadic<IntLikeType>:$step + ); + + let extraClassDeclaration = [{ + /// Returns the number of loops in the loop nest. + unsigned getNumLoops() { return getLowerBound().size(); } + }]; + + // Description and formatting integrated in the `omp.loop_nest` operation, + // which is the only one currently accepting this clause. +} + +def OpenMP_CollapseClause : OpenMP_CollapseClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.7.2] `copyprivate` clause +//===----------------------------------------------------------------------===// + +class OpenMP_CopyprivateClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<OpenMP_PointerLikeType>:$copyprivate_vars, + OptionalAttr<SymbolRefArrayAttr>:$copyprivate_funcs + ); + + let assemblyFormat = [{ + `copyprivate` `(` + custom<CopyPrivateVarList>($copyprivate_vars, type($copyprivate_vars), + $copyprivate_funcs) `)` + }]; + + let description = [{ + If `copyprivate` variables and functions are specified, then each thread + variable is updated with the variable value of the thread that executed + the single region, using the specified copy functions. + }]; +} + +def OpenMP_CopyprivateClause : OpenMP_CopyprivateClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [15.2] `critical` `name` argument +//===----------------------------------------------------------------------===// + +class OpenMP_CriticalNameClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + SymbolNameAttr:$sym_name + ); + + let assemblyFormat = "$sym_name"; + + let description = [{ + The `sym_name` can be used in `omp.critical` constructs in the dialect. + }]; +} + +def OpenMP_CriticalNameClause : OpenMP_CriticalNameClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [15.9.5] `depend` clause +//===----------------------------------------------------------------------===// + +class OpenMP_DependClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + OptionalAttr<TaskDependArrayAttr>:$depends, + Variadic<OpenMP_PointerLikeType>:$depend_vars + ); + + let assemblyFormat = [{ + `depend` `(` + custom<DependVarList>($depend_vars, type($depend_vars), $depends) `)` + }]; + + let description = [{ + The `depends` and `depend_vars` arguments are variadic lists of values that + specify the dependencies of this particular task in relation to other tasks. + }]; +} + +def OpenMP_DependClause : OpenMP_DependClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [13.2] `device` clause +//===----------------------------------------------------------------------===// + +class OpenMP_DeviceClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Optional<AnyInteger>:$device + ); + + let assemblyFormat = [{ + `device` `(` $device `:` type($device) `)` + }]; + + let description = [{ + The optional `device` parameter specifies the device number for the target + region. + }]; +} + +def OpenMP_DeviceClause : OpenMP_DeviceClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [11.6.1] `dist_schedule` clause +//===----------------------------------------------------------------------===// + +class OpenMP_DistScheduleClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + UnitAttr:$dist_schedule_static, + Optional<IntLikeType>:$chunk_size + ); + + let assemblyFormat = [{ + `dist_schedule_static` $dist_schedule_static + | `chunk_size` `(` $chunk_size `:` type($chunk_size) `)` + }]; + + let description = [{ + The `dist_schedule_static` attribute specifies the schedule for this loop, + determining how the loop is distributed across the various teams. The + optional `chunk_size` associated with this determines further controls this + distribution. + }]; +} + +def OpenMP_DistScheduleClause : OpenMP_DistScheduleClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [15.9.6] `doacross` clause +//===----------------------------------------------------------------------===// + +class OpenMP_DoacrossClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + OptionalAttr<ClauseDependAttr>:$depend_type_val, + ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val, + Variadic<AnyType>:$depend_vec_vars + ); + + let assemblyFormat = [{ + ( `depend_type` `` $depend_type_val^ )? + ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )? + }]; + + let description = [{ + 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. + }]; +} + +def OpenMP_DoacrossClause : OpenMP_DoacrossClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [12.3] `final` clause +//===----------------------------------------------------------------------===// + +class OpenMP_FinalClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Optional<I1>:$final_expr + ); + + let assemblyFormat = [{ + `final` `(` $final_expr `)` + }]; + + let description = [{ + When a `final` clause is present and the `final` clause expression evaluates + to `true`, the generated tasks will be final tasks. All task constructs + encountered during execution of a final task will generate final and + included tasks. The use of a variable in a `final` clause expression causes + an implicit reference to the variable in all enclosing constructs. + }]; +} + +def OpenMP_FinalClause : OpenMP_FinalClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [12.6.1] `grainsize` clause +//===----------------------------------------------------------------------===// + +class OpenMP_GrainsizeClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Optional<IntLikeType>:$grain_size + ); + + let assemblyFormat = [{ + `grain_size` `(` $grain_size `:` type($grain_size) `)` + }]; + + let description = [{ + If a `grainsize` clause is present, the number of logical loop iterations + assigned to each generated task is greater than or equal to the minimum of + the value of the grain-size expression and the number of logical loop + iterations, but less than two times the value of the grain-size expression. + }]; +} + +def OpenMP_GrainsizeClause : OpenMP_GrainsizeClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.4.9] `has_device_addr` clause +//===----------------------------------------------------------------------===// + +class OpenMP_HasDeviceAddrClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<OpenMP_PointerLikeType>:$has_device_addr + ); + + let assemblyFormat = [{ + `has_device_addr` `(` $has_device_addr `:` type($has_device_addr) `)` + }]; + + let description = [{ + The optional `has_device_addr` indicates that list items already have device + addresses, so they may be directly accessed from the target device. This + includes array sections. + }]; +} + +def OpenMP_HasDeviceAddrClause : OpenMP_HasDeviceAddrClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [15.1.2] `hint` clause +//===----------------------------------------------------------------------===// + +class OpenMP_HintClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + DefaultValuedOptionalAttr<I64Attr, "0">:$hint_val + ); + + let assemblyFormat = [{ + `hint` `(` custom<SynchronizationHint>($hint_val) `)` + }]; + + let description = [{ + `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. + }]; +} + +def OpenMP_HintClause : OpenMP_HintClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [3.4] `if` clause +//===----------------------------------------------------------------------===// + +class OpenMP_IfClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Optional<I1>:$if_expr + ); + + let assemblyFormat = [{ + `if` `(` $if_expr `)` + }]; + + // Description varies depending on the operation. +} + +def OpenMP_IfClause : OpenMP_IfClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.5.10] `in_reduction` clause +//===----------------------------------------------------------------------===// + +class OpenMP_InReductionClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let traits = [ + ReductionClauseInterface + ]; + + let arguments = (ins + Variadic<OpenMP_PointerLikeType>:$in_reduction_vars, + OptionalAttr<SymbolRefArrayAttr>:$in_reductions + ); + + let assemblyFormat = [{ + `in_reduction` `(` + custom<ReductionVarList>($in_reduction_vars, type($in_reduction_vars), + $in_reductions) `)` + }]; + + let extraClassDeclaration = [{ + /// Returns the reduction variables. + SmallVector<Value> getReductionVars() { + return SmallVector<Value>(getInReductionVars().begin(), + getInReductionVars().end()); + } + }]; + + // Description varies depending on the operation. +} + +def OpenMP_InReductionClause : OpenMP_InReductionClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.4.7] `is_device_ptr` clause +//===----------------------------------------------------------------------===// + +class OpenMP_IsDevicePtrClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<OpenMP_PointerLikeType>:$is_device_ptr + ); + + let assemblyFormat = [{ + `is_device_ptr` `(` $is_device_ptr `:` type($is_device_ptr) `)` + }]; + + let description = [{ + The optional `is_device_ptr` indicates list items are device pointers. + }]; +} + +def OpenMP_IsDevicePtrClause : OpenMP_IsDevicePtrClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.4.6] `linear` clause +//===----------------------------------------------------------------------===// + +class OpenMP_LinearClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat = false, + bit description = false, bit extraClassDeclaration = false + > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat, + description, extraClassDeclaration> { + let arguments = (ins + Variadic<AnyType>:$linear_vars, + Variadic<I32>:$linear_step_vars + ); + + let assemblyFormat = [{ + `linear` `(` + custom<LinearClause>($linear_vars, type($linear_vars), + $linear_step_vars) `)` + }]; + + let description = [{ + 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. + }]; +} + +def OpenMP_LinearClause : OpenMP_LinearClauseSkip<>; + +//===----------------------------------------------------------------------===// +// V5.2: [5.8.3] `map` clause +//===----------------------------------------------------------------------===// + +class OpenMP_MapClauseSkip< + bit traits = false, bit arguments = false, bit assemblyFormat =... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/92521 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
