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 
22 namespace llvm {
23 namespace omp {
24 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
25 
26 /// IDs for all Internal Control Variables (ICVs).
27 enum 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 
36 enum 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.
46 enum 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.
55 enum 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).
66 enum 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
80 enum 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.
193 enum 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 
247 enum 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 
253 enum 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.:
262 enum class OMPInteropType { Unknown, Target, TargetSync };
263 
264 /// Atomic compare operations. Currently OpenMP only supports ==, >, and <.
265 enum class OMPAtomicCompareOp : unsigned { EQ, MIN, MAX };
266 
267 /// Fields ids in kmp_depend_info record.
268 enum class RTLDependInfoFields { BaseAddr, Len, Flags };
269 
270 /// Dependence kind for RTL.
271 enum 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
281 enum 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