1//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines constans and helpers used when dealing with OpenMP.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
15#define LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
16
17#include "llvm/ADT/BitmaskEnum.h"
18
19#include "llvm/ADT/StringRef.h"
20#include "llvm/Frontend/OpenMP/OMP.h.inc"
21
22namespace llvm {
23namespace omp {
24LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
25
26/// IDs for all Internal Control Variables (ICVs).
27enum class InternalControlVar {
28#define ICV_DATA_ENV(Enum, ...) Enum,
29#include "llvm/Frontend/OpenMP/OMPKinds.def"
30};
31
32#define ICV_DATA_ENV(Enum, ...)                                                \
33  constexpr auto Enum = omp::InternalControlVar::Enum;
34#include "llvm/Frontend/OpenMP/OMPKinds.def"
35
36enum class ICVInitValue {
37#define ICV_INIT_VALUE(Enum, Name) Enum,
38#include "llvm/Frontend/OpenMP/OMPKinds.def"
39};
40
41#define ICV_INIT_VALUE(Enum, Name)                                             \
42  constexpr auto Enum = omp::ICVInitValue::Enum;
43#include "llvm/Frontend/OpenMP/OMPKinds.def"
44
45/// IDs for all omp runtime library (RTL) functions.
46enum class RuntimeFunction {
47#define OMP_RTL(Enum, ...) Enum,
48#include "llvm/Frontend/OpenMP/OMPKinds.def"
49};
50
51#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum;
52#include "llvm/Frontend/OpenMP/OMPKinds.def"
53
54/// IDs for the different default kinds.
55enum class DefaultKind {
56#define OMP_DEFAULT_KIND(Enum, Str) Enum,
57#include "llvm/Frontend/OpenMP/OMPKinds.def"
58};
59
60#define OMP_DEFAULT_KIND(Enum, ...)                                            \
61  constexpr auto Enum = omp::DefaultKind::Enum;
62#include "llvm/Frontend/OpenMP/OMPKinds.def"
63
64/// IDs for all omp runtime library ident_t flag encodings (see
65/// their defintion in openmp/runtime/src/kmp.h).
66enum class IdentFlag {
67#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
68#include "llvm/Frontend/OpenMP/OMPKinds.def"
69  LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
70};
71
72#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
73#include "llvm/Frontend/OpenMP/OMPKinds.def"
74
75// Version of the kernel argument format used by the omp runtime.
76#define OMP_KERNEL_ARG_VERSION 2
77
78/// \note This needs to be kept in sync with kmp.h enum sched_type.
79/// Todo: Update kmp.h to include this file, and remove the enums in kmp.h
80enum class OMPScheduleType {
81  // For typed comparisons, not a valid schedule
82  None = 0,
83
84  // Schedule algorithms
85  BaseStaticChunked = 1,
86  BaseStatic = 2,
87  BaseDynamicChunked = 3,
88  BaseGuidedChunked = 4,
89  BaseRuntime = 5,
90  BaseAuto = 6,
91  BaseTrapezoidal = 7,
92  BaseGreedy = 8,
93  BaseBalanced = 9,
94  BaseGuidedIterativeChunked = 10,
95  BaseGuidedAnalyticalChunked = 11,
96  BaseSteal = 12,
97
98  // with chunk adjustment (e.g., simd)
99  BaseStaticBalancedChunked = 13,
100  BaseGuidedSimd = 14,
101  BaseRuntimeSimd = 15,
102
103  // static schedules algorithims for distribute
104  BaseDistributeChunked = 27,
105  BaseDistribute = 28,
106
107  // Modifier flags to be combined with schedule algorithms
108  ModifierUnordered = (1 << 5),
109  ModifierOrdered = (1 << 6),
110  ModifierNomerge = (1 << 7),
111  ModifierMonotonic = (1 << 29),
112  ModifierNonmonotonic = (1 << 30),
113
114  // Masks combining multiple flags
115  OrderingMask = ModifierUnordered | ModifierOrdered | ModifierNomerge,
116  MonotonicityMask = ModifierMonotonic | ModifierNonmonotonic,
117  ModifierMask = OrderingMask | MonotonicityMask,
118
119  // valid schedule type values, without monotonicity flags
120  UnorderedStaticChunked = BaseStaticChunked | ModifierUnordered,        //  33
121  UnorderedStatic = BaseStatic | ModifierUnordered,                      //  34
122  UnorderedDynamicChunked = BaseDynamicChunked | ModifierUnordered,      //  35
123  UnorderedGuidedChunked = BaseGuidedChunked | ModifierUnordered,        //  36
124  UnorderedRuntime = BaseRuntime | ModifierUnordered,                    //  37
125  UnorderedAuto = BaseAuto | ModifierUnordered,                          //  38
126  UnorderedTrapezoidal = BaseTrapezoidal | ModifierUnordered,            //  39
127  UnorderedGreedy = BaseGreedy | ModifierUnordered,                      //  40
128  UnorderedBalanced = BaseBalanced | ModifierUnordered,                  //  41
129  UnorderedGuidedIterativeChunked =
130      BaseGuidedIterativeChunked | ModifierUnordered,                    //  42
131  UnorderedGuidedAnalyticalChunked =
132      BaseGuidedAnalyticalChunked | ModifierUnordered,                   //  43
133  UnorderedSteal = BaseSteal | ModifierUnordered,                        //  44
134
135  UnorderedStaticBalancedChunked =
136      BaseStaticBalancedChunked | ModifierUnordered,                     //  45
137  UnorderedGuidedSimd = BaseGuidedSimd | ModifierUnordered,              //  46
138  UnorderedRuntimeSimd = BaseRuntimeSimd | ModifierUnordered,            //  47
139
140  OrderedStaticChunked = BaseStaticChunked | ModifierOrdered,            //  65
141  OrderedStatic = BaseStatic | ModifierOrdered,                          //  66
142  OrderedDynamicChunked = BaseDynamicChunked | ModifierOrdered,          //  67
143  OrderedGuidedChunked = BaseGuidedChunked | ModifierOrdered,            //  68
144  OrderedRuntime = BaseRuntime | ModifierOrdered,                        //  69
145  OrderedAuto = BaseAuto | ModifierOrdered,                              //  70
146  OrderdTrapezoidal = BaseTrapezoidal | ModifierOrdered,                 //  71
147
148  OrderedDistributeChunked = BaseDistributeChunked | ModifierOrdered,    //  91
149  OrderedDistribute = BaseDistribute | ModifierOrdered,                  //  92
150
151  NomergeUnorderedStaticChunked =
152      BaseStaticChunked | ModifierUnordered | ModifierNomerge,           // 161
153  NomergeUnorderedStatic =
154      BaseStatic | ModifierUnordered | ModifierNomerge,                  // 162
155  NomergeUnorderedDynamicChunked =
156      BaseDynamicChunked | ModifierUnordered | ModifierNomerge,          // 163
157  NomergeUnorderedGuidedChunked =
158      BaseGuidedChunked | ModifierUnordered | ModifierNomerge,           // 164
159  NomergeUnorderedRuntime =
160      BaseRuntime | ModifierUnordered | ModifierNomerge,                 // 165
161  NomergeUnorderedAuto = BaseAuto | ModifierUnordered | ModifierNomerge, // 166
162  NomergeUnorderedTrapezoidal =
163      BaseTrapezoidal | ModifierUnordered | ModifierNomerge,             // 167
164  NomergeUnorderedGreedy =
165      BaseGreedy | ModifierUnordered | ModifierNomerge,                  // 168
166  NomergeUnorderedBalanced =
167      BaseBalanced | ModifierUnordered | ModifierNomerge,                // 169
168  NomergeUnorderedGuidedIterativeChunked =
169      BaseGuidedIterativeChunked | ModifierUnordered | ModifierNomerge,  // 170
170  NomergeUnorderedGuidedAnalyticalChunked =
171      BaseGuidedAnalyticalChunked | ModifierUnordered | ModifierNomerge, // 171
172  NomergeUnorderedSteal =
173      BaseSteal | ModifierUnordered | ModifierNomerge,                   // 172
174
175  NomergeOrderedStaticChunked =
176      BaseStaticChunked | ModifierOrdered | ModifierNomerge,             // 193
177  NomergeOrderedStatic = BaseStatic | ModifierOrdered | ModifierNomerge, // 194
178  NomergeOrderedDynamicChunked =
179      BaseDynamicChunked | ModifierOrdered | ModifierNomerge,            // 195
180  NomergeOrderedGuidedChunked =
181      BaseGuidedChunked | ModifierOrdered | ModifierNomerge,             // 196
182  NomergeOrderedRuntime =
183      BaseRuntime | ModifierOrdered | ModifierNomerge,                   // 197
184  NomergeOrderedAuto = BaseAuto | ModifierOrdered | ModifierNomerge,     // 198
185  NomergeOrderedTrapezoidal =
186      BaseTrapezoidal | ModifierOrdered | ModifierNomerge,               // 199
187
188  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue */ ModifierMask)
189};
190
191/// Values for bit flags used to specify the mapping type for
192/// offloading.
193enum class OpenMPOffloadMappingFlags : uint64_t {
194  /// No flags
195  OMP_MAP_NONE = 0x0,
196  /// Allocate memory on the device and move data from host to device.
197  OMP_MAP_TO = 0x01,
198  /// Allocate memory on the device and move data from device to host.
199  OMP_MAP_FROM = 0x02,
200  /// Always perform the requested mapping action on the element, even
201  /// if it was already mapped before.
202  OMP_MAP_ALWAYS = 0x04,
203  /// Delete the element from the device environment, ignoring the
204  /// current reference count associated with the element.
205  OMP_MAP_DELETE = 0x08,
206  /// The element being mapped is a pointer-pointee pair; both the
207  /// pointer and the pointee should be mapped.
208  OMP_MAP_PTR_AND_OBJ = 0x10,
209  /// This flags signals that the base address of an entry should be
210  /// passed to the target kernel as an argument.
211  OMP_MAP_TARGET_PARAM = 0x20,
212  /// Signal that the runtime library has to return the device pointer
213  /// in the current position for the data being mapped. Used when we have the
214  /// use_device_ptr or use_device_addr clause.
215  OMP_MAP_RETURN_PARAM = 0x40,
216  /// This flag signals that the reference being passed is a pointer to
217  /// private data.
218  OMP_MAP_PRIVATE = 0x80,
219  /// Pass the element to the device by value.
220  OMP_MAP_LITERAL = 0x100,
221  /// Implicit map
222  OMP_MAP_IMPLICIT = 0x200,
223  /// Close is a hint to the runtime to allocate memory close to
224  /// the target device.
225  OMP_MAP_CLOSE = 0x400,
226  /// 0x800 is reserved for compatibility with XLC.
227  /// Produce a runtime error if the data is not already allocated.
228  OMP_MAP_PRESENT = 0x1000,
229  // Increment and decrement a separate reference counter so that the data
230  // cannot be unmapped within the associated region.  Thus, this flag is
231  // intended to be used on 'target' and 'target data' directives because they
232  // are inherently structured.  It is not intended to be used on 'target
233  // enter data' and 'target exit data' directives because they are inherently
234  // dynamic.
235  // This is an OpenMP extension for the sake of OpenACC support.
236  OMP_MAP_OMPX_HOLD = 0x2000,
237  /// Signal that the runtime library should use args as an array of
238  /// descriptor_dim pointers and use args_size as dims. Used when we have
239  /// non-contiguous list items in target update directive
240  OMP_MAP_NON_CONTIG = 0x100000000000,
241  /// The 16 MSBs of the flags indicate whether the entry is member of some
242  /// struct/class.
243  OMP_MAP_MEMBER_OF = 0xffff000000000000,
244  LLVM_MARK_AS_BITMASK_ENUM(/* LargestFlag = */ OMP_MAP_MEMBER_OF)
245};
246
247enum OpenMPOffloadingReservedDeviceIDs {
248  /// Device ID if the device was not defined, runtime should get it
249  /// from environment variables in the spec.
250  OMP_DEVICEID_UNDEF = -1
251};
252
253enum class AddressSpace : unsigned {
254  Generic = 0,
255  Global = 1,
256  Shared = 3,
257  Constant = 4,
258  Local = 5,
259};
260
261/// \note This needs to be kept in sync with interop.h enum kmp_interop_type_t.:
262enum class OMPInteropType { Unknown, Target, TargetSync };
263
264/// Atomic compare operations. Currently OpenMP only supports ==, >, and <.
265enum class OMPAtomicCompareOp : unsigned { EQ, MIN, MAX };
266
267/// Fields ids in kmp_depend_info record.
268enum class RTLDependInfoFields { BaseAddr, Len, Flags };
269
270/// Dependence kind for RTL.
271enum class RTLDependenceKindTy {
272  DepUnknown = 0x0,
273  DepIn = 0x01,
274  DepInOut = 0x3,
275  DepMutexInOutSet = 0x4,
276  DepInOutSet = 0x8,
277  DepOmpAllMem = 0x80,
278};
279
280/// A type of worksharing loop construct
281enum class WorksharingLoopType {
282  // Worksharing `for`-loop
283  ForStaticLoop,
284  // Worksharing `distrbute`-loop
285  DistributeStaticLoop,
286  // Worksharing `distrbute parallel for`-loop
287  DistributeForStaticLoop
288};
289
290} // end namespace omp
291
292} // end namespace llvm
293
294#include "OMPDeviceConstants.h"
295
296#endif // LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
297