[AMDGPU][AsmParser][NFC] Get rid of custom default operand handlers.
[llvm-project.git] / clang / lib / CodeGen / CGOpenMPRuntime.h
blobbd27642867719ce168b0058013a1bb85030bf7cc
1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- 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 //
9 // This provides a class for OpenMP runtime code generation.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
14 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
16 #include "CGValue.h"
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/AST/GlobalDecl.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/OpenMPKinds.h"
21 #include "clang/Basic/SourceLocation.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/SmallPtrSet.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/StringSet.h"
27 #include "llvm/Frontend/OpenMP/OMPConstants.h"
28 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/ValueHandle.h"
31 #include "llvm/Support/AtomicOrdering.h"
33 namespace llvm {
34 class ArrayType;
35 class Constant;
36 class FunctionType;
37 class GlobalVariable;
38 class Type;
39 class Value;
40 class OpenMPIRBuilder;
41 } // namespace llvm
43 namespace clang {
44 class Expr;
45 class OMPDependClause;
46 class OMPExecutableDirective;
47 class OMPLoopDirective;
48 class VarDecl;
49 class OMPDeclareReductionDecl;
51 namespace CodeGen {
52 class Address;
53 class CodeGenFunction;
54 class CodeGenModule;
56 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
57 /// region.
58 class PrePostActionTy {
59 public:
60 explicit PrePostActionTy() {}
61 virtual void Enter(CodeGenFunction &CGF) {}
62 virtual void Exit(CodeGenFunction &CGF) {}
63 virtual ~PrePostActionTy() {}
66 /// Class provides a way to call simple version of codegen for OpenMP region, or
67 /// an advanced with possible pre|post-actions in codegen.
68 class RegionCodeGenTy final {
69 intptr_t CodeGen;
70 typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
71 CodeGenTy Callback;
72 mutable PrePostActionTy *PrePostAction;
73 RegionCodeGenTy() = delete;
74 template <typename Callable>
75 static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
76 PrePostActionTy &Action) {
77 return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
80 public:
81 template <typename Callable>
82 RegionCodeGenTy(
83 Callable &&CodeGen,
84 std::enable_if_t<!std::is_same<std::remove_reference_t<Callable>,
85 RegionCodeGenTy>::value> * = nullptr)
86 : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
87 Callback(CallbackFn<std::remove_reference_t<Callable>>),
88 PrePostAction(nullptr) {}
89 void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
90 void operator()(CodeGenFunction &CGF) const;
93 struct OMPTaskDataTy final {
94 SmallVector<const Expr *, 4> PrivateVars;
95 SmallVector<const Expr *, 4> PrivateCopies;
96 SmallVector<const Expr *, 4> FirstprivateVars;
97 SmallVector<const Expr *, 4> FirstprivateCopies;
98 SmallVector<const Expr *, 4> FirstprivateInits;
99 SmallVector<const Expr *, 4> LastprivateVars;
100 SmallVector<const Expr *, 4> LastprivateCopies;
101 SmallVector<const Expr *, 4> ReductionVars;
102 SmallVector<const Expr *, 4> ReductionOrigs;
103 SmallVector<const Expr *, 4> ReductionCopies;
104 SmallVector<const Expr *, 4> ReductionOps;
105 SmallVector<CanonicalDeclPtr<const VarDecl>, 4> PrivateLocals;
106 struct DependData {
107 OpenMPDependClauseKind DepKind = OMPC_DEPEND_unknown;
108 const Expr *IteratorExpr = nullptr;
109 SmallVector<const Expr *, 4> DepExprs;
110 explicit DependData() = default;
111 DependData(OpenMPDependClauseKind DepKind, const Expr *IteratorExpr)
112 : DepKind(DepKind), IteratorExpr(IteratorExpr) {}
114 SmallVector<DependData, 4> Dependences;
115 llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
116 llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
117 llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
118 llvm::Value *Reductions = nullptr;
119 unsigned NumberOfParts = 0;
120 bool Tied = true;
121 bool Nogroup = false;
122 bool IsReductionWithTaskMod = false;
123 bool IsWorksharingReduction = false;
124 bool HasNowaitClause = false;
127 /// Class intended to support codegen of all kind of the reduction clauses.
128 class ReductionCodeGen {
129 private:
130 /// Data required for codegen of reduction clauses.
131 struct ReductionData {
132 /// Reference to the item shared between tasks to reduce into.
133 const Expr *Shared = nullptr;
134 /// Reference to the original item.
135 const Expr *Ref = nullptr;
136 /// Helper expression for generation of private copy.
137 const Expr *Private = nullptr;
138 /// Helper expression for generation reduction operation.
139 const Expr *ReductionOp = nullptr;
140 ReductionData(const Expr *Shared, const Expr *Ref, const Expr *Private,
141 const Expr *ReductionOp)
142 : Shared(Shared), Ref(Ref), Private(Private), ReductionOp(ReductionOp) {
145 /// List of reduction-based clauses.
146 SmallVector<ReductionData, 4> ClausesData;
148 /// List of addresses of shared variables/expressions.
149 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
150 /// List of addresses of original variables/expressions.
151 SmallVector<std::pair<LValue, LValue>, 4> OrigAddresses;
152 /// Sizes of the reduction items in chars.
153 SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes;
154 /// Base declarations for the reduction items.
155 SmallVector<const VarDecl *, 4> BaseDecls;
157 /// Emits lvalue for shared expression.
158 LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
159 /// Emits upper bound for shared expression (if array section).
160 LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
161 /// Performs aggregate initialization.
162 /// \param N Number of reduction item in the common list.
163 /// \param PrivateAddr Address of the corresponding private item.
164 /// \param SharedAddr Address of the original shared variable.
165 /// \param DRD Declare reduction construct used for reduction item.
166 void emitAggregateInitialization(CodeGenFunction &CGF, unsigned N,
167 Address PrivateAddr, Address SharedAddr,
168 const OMPDeclareReductionDecl *DRD);
170 public:
171 ReductionCodeGen(ArrayRef<const Expr *> Shareds, ArrayRef<const Expr *> Origs,
172 ArrayRef<const Expr *> Privates,
173 ArrayRef<const Expr *> ReductionOps);
174 /// Emits lvalue for the shared and original reduction item.
175 /// \param N Number of the reduction item.
176 void emitSharedOrigLValue(CodeGenFunction &CGF, unsigned N);
177 /// Emits the code for the variable-modified type, if required.
178 /// \param N Number of the reduction item.
179 void emitAggregateType(CodeGenFunction &CGF, unsigned N);
180 /// Emits the code for the variable-modified type, if required.
181 /// \param N Number of the reduction item.
182 /// \param Size Size of the type in chars.
183 void emitAggregateType(CodeGenFunction &CGF, unsigned N, llvm::Value *Size);
184 /// Performs initialization of the private copy for the reduction item.
185 /// \param N Number of the reduction item.
186 /// \param PrivateAddr Address of the corresponding private item.
187 /// \param DefaultInit Default initialization sequence that should be
188 /// performed if no reduction specific initialization is found.
189 /// \param SharedAddr Address of the original shared variable.
190 void
191 emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
192 Address SharedAddr,
193 llvm::function_ref<bool(CodeGenFunction &)> DefaultInit);
194 /// Returns true if the private copy requires cleanups.
195 bool needCleanups(unsigned N);
196 /// Emits cleanup code for the reduction item.
197 /// \param N Number of the reduction item.
198 /// \param PrivateAddr Address of the corresponding private item.
199 void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr);
200 /// Adjusts \p PrivatedAddr for using instead of the original variable
201 /// address in normal operations.
202 /// \param N Number of the reduction item.
203 /// \param PrivateAddr Address of the corresponding private item.
204 Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N,
205 Address PrivateAddr);
206 /// Returns LValue for the reduction item.
207 LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
208 /// Returns LValue for the original reduction item.
209 LValue getOrigLValue(unsigned N) const { return OrigAddresses[N].first; }
210 /// Returns the size of the reduction item (in chars and total number of
211 /// elements in the item), or nullptr, if the size is a constant.
212 std::pair<llvm::Value *, llvm::Value *> getSizes(unsigned N) const {
213 return Sizes[N];
215 /// Returns the base declaration of the reduction item.
216 const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; }
217 /// Returns the base declaration of the reduction item.
218 const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
219 /// Returns true if the initialization of the reduction item uses initializer
220 /// from declare reduction construct.
221 bool usesReductionInitializer(unsigned N) const;
222 /// Return the type of the private item.
223 QualType getPrivateType(unsigned N) const {
224 return cast<VarDecl>(cast<DeclRefExpr>(ClausesData[N].Private)->getDecl())
225 ->getType();
229 class CGOpenMPRuntime {
230 public:
231 /// Allows to disable automatic handling of functions used in target regions
232 /// as those marked as `omp declare target`.
233 class DisableAutoDeclareTargetRAII {
234 CodeGenModule &CGM;
235 bool SavedShouldMarkAsGlobal;
237 public:
238 DisableAutoDeclareTargetRAII(CodeGenModule &CGM);
239 ~DisableAutoDeclareTargetRAII();
242 /// Manages list of nontemporal decls for the specified directive.
243 class NontemporalDeclsRAII {
244 CodeGenModule &CGM;
245 const bool NeedToPush;
247 public:
248 NontemporalDeclsRAII(CodeGenModule &CGM, const OMPLoopDirective &S);
249 ~NontemporalDeclsRAII();
252 /// Manages list of nontemporal decls for the specified directive.
253 class UntiedTaskLocalDeclsRAII {
254 CodeGenModule &CGM;
255 const bool NeedToPush;
257 public:
258 UntiedTaskLocalDeclsRAII(
259 CodeGenFunction &CGF,
260 const llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
261 std::pair<Address, Address>> &LocalVars);
262 ~UntiedTaskLocalDeclsRAII();
265 /// Maps the expression for the lastprivate variable to the global copy used
266 /// to store new value because original variables are not mapped in inner
267 /// parallel regions. Only private copies are captured but we need also to
268 /// store private copy in shared address.
269 /// Also, stores the expression for the private loop counter and it
270 /// threaprivate name.
271 struct LastprivateConditionalData {
272 llvm::MapVector<CanonicalDeclPtr<const Decl>, SmallString<16>>
273 DeclToUniqueName;
274 LValue IVLVal;
275 llvm::Function *Fn = nullptr;
276 bool Disabled = false;
278 /// Manages list of lastprivate conditional decls for the specified directive.
279 class LastprivateConditionalRAII {
280 enum class ActionToDo {
281 DoNotPush,
282 PushAsLastprivateConditional,
283 DisableLastprivateConditional,
285 CodeGenModule &CGM;
286 ActionToDo Action = ActionToDo::DoNotPush;
288 /// Check and try to disable analysis of inner regions for changes in
289 /// lastprivate conditional.
290 void tryToDisableInnerAnalysis(const OMPExecutableDirective &S,
291 llvm::DenseSet<CanonicalDeclPtr<const Decl>>
292 &NeedToAddForLPCsAsDisabled) const;
294 LastprivateConditionalRAII(CodeGenFunction &CGF,
295 const OMPExecutableDirective &S);
297 public:
298 explicit LastprivateConditionalRAII(CodeGenFunction &CGF,
299 const OMPExecutableDirective &S,
300 LValue IVLVal);
301 static LastprivateConditionalRAII disable(CodeGenFunction &CGF,
302 const OMPExecutableDirective &S);
303 ~LastprivateConditionalRAII();
306 llvm::OpenMPIRBuilder &getOMPBuilder() { return OMPBuilder; }
308 protected:
309 CodeGenModule &CGM;
311 /// An OpenMP-IR-Builder instance.
312 llvm::OpenMPIRBuilder OMPBuilder;
314 /// Helper to emit outlined function for 'target' directive.
315 /// \param D Directive to emit.
316 /// \param ParentName Name of the function that encloses the target region.
317 /// \param OutlinedFn Outlined function value to be defined by this call.
318 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
319 /// \param IsOffloadEntry True if the outlined function is an offload entry.
320 /// \param CodeGen Lambda codegen specific to an accelerator device.
321 /// An outlined function may not be an entry if, e.g. the if clause always
322 /// evaluates to false.
323 virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D,
324 StringRef ParentName,
325 llvm::Function *&OutlinedFn,
326 llvm::Constant *&OutlinedFnID,
327 bool IsOffloadEntry,
328 const RegionCodeGenTy &CodeGen);
330 /// Emits object of ident_t type with info for source location.
331 /// \param Flags Flags for OpenMP location.
332 /// \param EmitLoc emit source location with debug-info is off.
334 llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
335 unsigned Flags = 0, bool EmitLoc = false);
337 /// Emit the number of teams for a target directive. Inspect the num_teams
338 /// clause associated with a teams construct combined or closely nested
339 /// with the target directive.
341 /// Emit a team of size one for directives such as 'target parallel' that
342 /// have no associated teams construct.
344 /// Otherwise, return nullptr.
345 const Expr *getNumTeamsExprForTargetDirective(CodeGenFunction &CGF,
346 const OMPExecutableDirective &D,
347 int32_t &DefaultVal);
348 llvm::Value *emitNumTeamsForTargetDirective(CodeGenFunction &CGF,
349 const OMPExecutableDirective &D);
350 /// Emit the number of threads for a target directive. Inspect the
351 /// thread_limit clause associated with a teams construct combined or closely
352 /// nested with the target directive.
354 /// Emit the num_threads clause for directives such as 'target parallel' that
355 /// have no associated teams construct.
357 /// Otherwise, return nullptr.
358 const Expr *
359 getNumThreadsExprForTargetDirective(CodeGenFunction &CGF,
360 const OMPExecutableDirective &D,
361 int32_t &DefaultVal);
362 llvm::Value *
363 emitNumThreadsForTargetDirective(CodeGenFunction &CGF,
364 const OMPExecutableDirective &D);
366 /// Returns pointer to ident_t type.
367 llvm::Type *getIdentTyPointerTy();
369 /// Gets thread id value for the current thread.
371 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
373 /// Get the function name of an outlined region.
374 std::string getOutlinedHelperName(StringRef Name) const;
375 std::string getOutlinedHelperName(CodeGenFunction &CGF) const;
377 /// Get the function name of a reduction function.
378 std::string getReductionFuncName(StringRef Name) const;
380 /// Emits \p Callee function call with arguments \p Args with location \p Loc.
381 void emitCall(CodeGenFunction &CGF, SourceLocation Loc,
382 llvm::FunctionCallee Callee,
383 ArrayRef<llvm::Value *> Args = std::nullopt) const;
385 /// Emits address of the word in a memory where current thread id is
386 /// stored.
387 virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
389 void setLocThreadIdInsertPt(CodeGenFunction &CGF,
390 bool AtCurrentPoint = false);
391 void clearLocThreadIdInsertPt(CodeGenFunction &CGF);
393 /// Check if the default location must be constant.
394 /// Default is false to support OMPT/OMPD.
395 virtual bool isDefaultLocationConstant() const { return false; }
397 /// Returns additional flags that can be stored in reserved_2 field of the
398 /// default location.
399 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
401 /// Returns default flags for the barriers depending on the directive, for
402 /// which this barier is going to be emitted.
403 static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind);
405 /// Get the LLVM type for the critical name.
406 llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
408 /// Returns corresponding lock object for the specified critical region
409 /// name. If the lock object does not exist it is created, otherwise the
410 /// reference to the existing copy is returned.
411 /// \param CriticalName Name of the critical region.
413 llvm::Value *getCriticalRegionLock(StringRef CriticalName);
415 protected:
416 /// Map for SourceLocation and OpenMP runtime library debug locations.
417 typedef llvm::DenseMap<SourceLocation, llvm::Value *> OpenMPDebugLocMapTy;
418 OpenMPDebugLocMapTy OpenMPDebugLocMap;
419 /// The type for a microtask which gets passed to __kmpc_fork_call().
420 /// Original representation is:
421 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
422 llvm::FunctionType *Kmpc_MicroTy = nullptr;
423 /// Stores debug location and ThreadID for the function.
424 struct DebugLocThreadIdTy {
425 llvm::Value *DebugLoc;
426 llvm::Value *ThreadID;
427 /// Insert point for the service instructions.
428 llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
430 /// Map of local debug location, ThreadId and functions.
431 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
432 OpenMPLocThreadIDMapTy;
433 OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
434 /// Map of UDRs and corresponding combiner/initializer.
435 typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
436 std::pair<llvm::Function *, llvm::Function *>>
437 UDRMapTy;
438 UDRMapTy UDRMap;
439 /// Map of functions and locally defined UDRs.
440 typedef llvm::DenseMap<llvm::Function *,
441 SmallVector<const OMPDeclareReductionDecl *, 4>>
442 FunctionUDRMapTy;
443 FunctionUDRMapTy FunctionUDRMap;
444 /// Map from the user-defined mapper declaration to its corresponding
445 /// functions.
446 llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
447 /// Map of functions and their local user-defined mappers.
448 using FunctionUDMMapTy =
449 llvm::DenseMap<llvm::Function *,
450 SmallVector<const OMPDeclareMapperDecl *, 4>>;
451 FunctionUDMMapTy FunctionUDMMap;
452 /// Maps local variables marked as lastprivate conditional to their internal
453 /// types.
454 llvm::DenseMap<llvm::Function *,
455 llvm::DenseMap<CanonicalDeclPtr<const Decl>,
456 std::tuple<QualType, const FieldDecl *,
457 const FieldDecl *, LValue>>>
458 LastprivateConditionalToTypes;
459 /// Maps function to the position of the untied task locals stack.
460 llvm::DenseMap<llvm::Function *, unsigned> FunctionToUntiedTaskStackMap;
461 /// Type kmp_critical_name, originally defined as typedef kmp_int32
462 /// kmp_critical_name[8];
463 llvm::ArrayType *KmpCriticalNameTy;
464 /// An ordered map of auto-generated variables to their unique names.
465 /// It stores variables with the following names: 1) ".gomp_critical_user_" +
466 /// <critical_section_name> + ".var" for "omp critical" directives; 2)
467 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
468 /// variables.
469 llvm::StringMap<llvm::AssertingVH<llvm::GlobalVariable>,
470 llvm::BumpPtrAllocator> InternalVars;
471 /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
472 llvm::Type *KmpRoutineEntryPtrTy = nullptr;
473 QualType KmpRoutineEntryPtrQTy;
474 /// Type typedef struct kmp_task {
475 /// void * shareds; /**< pointer to block of pointers to
476 /// shared vars */
477 /// kmp_routine_entry_t routine; /**< pointer to routine to call for
478 /// executing task */
479 /// kmp_int32 part_id; /**< part id for the task */
480 /// kmp_routine_entry_t destructors; /* pointer to function to invoke
481 /// deconstructors of firstprivate C++ objects */
482 /// } kmp_task_t;
483 QualType KmpTaskTQTy;
484 /// Saved kmp_task_t for task directive.
485 QualType SavedKmpTaskTQTy;
486 /// Saved kmp_task_t for taskloop-based directive.
487 QualType SavedKmpTaskloopTQTy;
488 /// Type typedef struct kmp_depend_info {
489 /// kmp_intptr_t base_addr;
490 /// size_t len;
491 /// struct {
492 /// bool in:1;
493 /// bool out:1;
494 /// } flags;
495 /// } kmp_depend_info_t;
496 QualType KmpDependInfoTy;
497 /// Type typedef struct kmp_task_affinity_info {
498 /// kmp_intptr_t base_addr;
499 /// size_t len;
500 /// struct {
501 /// bool flag1 : 1;
502 /// bool flag2 : 1;
503 /// kmp_int32 reserved : 30;
504 /// } flags;
505 /// } kmp_task_affinity_info_t;
506 QualType KmpTaskAffinityInfoTy;
507 /// struct kmp_dim { // loop bounds info casted to kmp_int64
508 /// kmp_int64 lo; // lower
509 /// kmp_int64 up; // upper
510 /// kmp_int64 st; // stride
511 /// };
512 QualType KmpDimTy;
514 bool ShouldMarkAsGlobal = true;
515 /// List of the emitted declarations.
516 llvm::DenseSet<CanonicalDeclPtr<const Decl>> AlreadyEmittedTargetDecls;
517 /// List of the global variables with their addresses that should not be
518 /// emitted for the target.
519 llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
521 /// List of variables that can become declare target implicitly and, thus,
522 /// must be emitted.
523 llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
525 using NontemporalDeclsSet = llvm::SmallDenseSet<CanonicalDeclPtr<const Decl>>;
526 /// Stack for list of declarations in current context marked as nontemporal.
527 /// The set is the union of all current stack elements.
528 llvm::SmallVector<NontemporalDeclsSet, 4> NontemporalDeclsStack;
530 using UntiedLocalVarsAddressesMap =
531 llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
532 std::pair<Address, Address>>;
533 llvm::SmallVector<UntiedLocalVarsAddressesMap, 4> UntiedLocalVarsStack;
535 /// Stack for list of addresses of declarations in current context marked as
536 /// lastprivate conditional. The set is the union of all current stack
537 /// elements.
538 llvm::SmallVector<LastprivateConditionalData, 4> LastprivateConditionalStack;
540 /// Flag for keeping track of weather a requires unified_shared_memory
541 /// directive is present.
542 bool HasRequiresUnifiedSharedMemory = false;
544 /// Atomic ordering from the omp requires directive.
545 llvm::AtomicOrdering RequiresAtomicOrdering = llvm::AtomicOrdering::Monotonic;
547 /// Flag for keeping track of weather a target region has been emitted.
548 bool HasEmittedTargetRegion = false;
550 /// Flag for keeping track of weather a device routine has been emitted.
551 /// Device routines are specific to the
552 bool HasEmittedDeclareTargetRegion = false;
554 /// Start scanning from statement \a S and emit all target regions
555 /// found along the way.
556 /// \param S Starting statement.
557 /// \param ParentName Name of the function declaration that is being scanned.
558 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
560 /// Build type kmp_routine_entry_t (if not built yet).
561 void emitKmpRoutineEntryT(QualType KmpInt32Ty);
563 /// Returns pointer to kmpc_micro type.
564 llvm::Type *getKmpc_MicroPointerTy();
566 /// Returns __kmpc_for_static_init_* runtime function for the specified
567 /// size \a IVSize and sign \a IVSigned. Will create a distribute call
568 /// __kmpc_distribute_static_init* if \a IsGPUDistribute is set.
569 llvm::FunctionCallee createForStaticInitFunction(unsigned IVSize,
570 bool IVSigned,
571 bool IsGPUDistribute);
573 /// Returns __kmpc_dispatch_init_* runtime function for the specified
574 /// size \a IVSize and sign \a IVSigned.
575 llvm::FunctionCallee createDispatchInitFunction(unsigned IVSize,
576 bool IVSigned);
578 /// Returns __kmpc_dispatch_next_* runtime function for the specified
579 /// size \a IVSize and sign \a IVSigned.
580 llvm::FunctionCallee createDispatchNextFunction(unsigned IVSize,
581 bool IVSigned);
583 /// Returns __kmpc_dispatch_fini_* runtime function for the specified
584 /// size \a IVSize and sign \a IVSigned.
585 llvm::FunctionCallee createDispatchFiniFunction(unsigned IVSize,
586 bool IVSigned);
588 /// If the specified mangled name is not in the module, create and
589 /// return threadprivate cache object. This object is a pointer's worth of
590 /// storage that's reserved for use by the OpenMP runtime.
591 /// \param VD Threadprivate variable.
592 /// \return Cache variable for the specified threadprivate.
593 llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
595 /// Set of threadprivate variables with the generated initializer.
596 llvm::StringSet<> ThreadPrivateWithDefinition;
598 /// Set of declare target variables with the generated initializer.
599 llvm::StringSet<> DeclareTargetWithDefinition;
601 /// Emits initialization code for the threadprivate variables.
602 /// \param VDAddr Address of the global variable \a VD.
603 /// \param Ctor Pointer to a global init function for \a VD.
604 /// \param CopyCtor Pointer to a global copy function for \a VD.
605 /// \param Dtor Pointer to a global destructor function for \a VD.
606 /// \param Loc Location of threadprivate declaration.
607 void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
608 llvm::Value *Ctor, llvm::Value *CopyCtor,
609 llvm::Value *Dtor, SourceLocation Loc);
611 /// Emit the array initialization or deletion portion for user-defined mapper
612 /// code generation.
613 void emitUDMapperArrayInitOrDel(CodeGenFunction &MapperCGF,
614 llvm::Value *Handle, llvm::Value *BasePtr,
615 llvm::Value *Ptr, llvm::Value *Size,
616 llvm::Value *MapType, llvm::Value *MapName,
617 CharUnits ElementSize,
618 llvm::BasicBlock *ExitBB, bool IsInit);
620 struct TaskResultTy {
621 llvm::Value *NewTask = nullptr;
622 llvm::Function *TaskEntry = nullptr;
623 llvm::Value *NewTaskNewTaskTTy = nullptr;
624 LValue TDBase;
625 const RecordDecl *KmpTaskTQTyRD = nullptr;
626 llvm::Value *TaskDupFn = nullptr;
628 /// Emit task region for the task directive. The task region is emitted in
629 /// several steps:
630 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
631 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
632 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
633 /// function:
634 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
635 /// TaskFunction(gtid, tt->part_id, tt->shareds);
636 /// return 0;
637 /// }
638 /// 2. Copy a list of shared variables to field shareds of the resulting
639 /// structure kmp_task_t returned by the previous call (if any).
640 /// 3. Copy a pointer to destructions function to field destructions of the
641 /// resulting structure kmp_task_t.
642 /// \param D Current task directive.
643 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
644 /// /*part_id*/, captured_struct */*__context*/);
645 /// \param SharedsTy A type which contains references the shared variables.
646 /// \param Shareds Context with the list of shared variables from the \p
647 /// TaskFunction.
648 /// \param Data Additional data for task generation like tiednsee, final
649 /// state, list of privates etc.
650 TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
651 const OMPExecutableDirective &D,
652 llvm::Function *TaskFunction, QualType SharedsTy,
653 Address Shareds, const OMPTaskDataTy &Data);
655 /// Return the trip count of loops associated with constructs / 'target teams
656 /// distribute' and 'teams distribute parallel for'. \param SizeEmitter Emits
657 /// the int64 value for the number of iterations of the associated loop.
658 llvm::Value *emitTargetNumIterationsCall(
659 CodeGenFunction &CGF, const OMPExecutableDirective &D,
660 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
661 const OMPLoopDirective &D)>
662 SizeEmitter);
664 /// Emit update for lastprivate conditional data.
665 void emitLastprivateConditionalUpdate(CodeGenFunction &CGF, LValue IVLVal,
666 StringRef UniqueDeclName, LValue LVal,
667 SourceLocation Loc);
669 /// Returns the number of the elements and the address of the depobj
670 /// dependency array.
671 /// \return Number of elements in depobj array and the pointer to the array of
672 /// dependencies.
673 std::pair<llvm::Value *, LValue> getDepobjElements(CodeGenFunction &CGF,
674 LValue DepobjLVal,
675 SourceLocation Loc);
677 SmallVector<llvm::Value *, 4>
678 emitDepobjElementsSizes(CodeGenFunction &CGF, QualType &KmpDependInfoTy,
679 const OMPTaskDataTy::DependData &Data);
681 void emitDepobjElements(CodeGenFunction &CGF, QualType &KmpDependInfoTy,
682 LValue PosLVal, const OMPTaskDataTy::DependData &Data,
683 Address DependenciesArray);
685 public:
686 explicit CGOpenMPRuntime(CodeGenModule &CGM);
687 virtual ~CGOpenMPRuntime() {}
688 virtual void clear();
690 /// Returns true if the current target is a GPU.
691 virtual bool isTargetCodegen() const { return false; }
693 /// Emits code for OpenMP 'if' clause using specified \a CodeGen
694 /// function. Here is the logic:
695 /// if (Cond) {
696 /// ThenGen();
697 /// } else {
698 /// ElseGen();
699 /// }
700 void emitIfClause(CodeGenFunction &CGF, const Expr *Cond,
701 const RegionCodeGenTy &ThenGen,
702 const RegionCodeGenTy &ElseGen);
704 /// Checks if the \p Body is the \a CompoundStmt and returns its child
705 /// statement iff there is only one that is not evaluatable at the compile
706 /// time.
707 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
709 /// Get the platform-specific name separator.
710 std::string getName(ArrayRef<StringRef> Parts) const;
712 /// Emit code for the specified user defined reduction construct.
713 virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
714 const OMPDeclareReductionDecl *D);
715 /// Get combiner/initializer for the specified user-defined reduction, if any.
716 virtual std::pair<llvm::Function *, llvm::Function *>
717 getUserDefinedReduction(const OMPDeclareReductionDecl *D);
719 /// Emit the function for the user defined mapper construct.
720 void emitUserDefinedMapper(const OMPDeclareMapperDecl *D,
721 CodeGenFunction *CGF = nullptr);
722 /// Get the function for the specified user-defined mapper. If it does not
723 /// exist, create one.
724 llvm::Function *
725 getOrCreateUserDefinedMapperFunc(const OMPDeclareMapperDecl *D);
727 /// Emits outlined function for the specified OpenMP parallel directive
728 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
729 /// kmp_int32 BoundID, struct context_vars*).
730 /// \param CGF Reference to current CodeGenFunction.
731 /// \param D OpenMP directive.
732 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
733 /// \param InnermostKind Kind of innermost directive (for simple directives it
734 /// is a directive itself, for combined - its innermost directive).
735 /// \param CodeGen Code generation sequence for the \a D directive.
736 virtual llvm::Function *emitParallelOutlinedFunction(
737 CodeGenFunction &CGF, const OMPExecutableDirective &D,
738 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
739 const RegionCodeGenTy &CodeGen);
741 /// Emits outlined function for the specified OpenMP teams directive
742 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
743 /// kmp_int32 BoundID, struct context_vars*).
744 /// \param CGF Reference to current CodeGenFunction.
745 /// \param D OpenMP directive.
746 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
747 /// \param InnermostKind Kind of innermost directive (for simple directives it
748 /// is a directive itself, for combined - its innermost directive).
749 /// \param CodeGen Code generation sequence for the \a D directive.
750 virtual llvm::Function *emitTeamsOutlinedFunction(
751 CodeGenFunction &CGF, const OMPExecutableDirective &D,
752 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
753 const RegionCodeGenTy &CodeGen);
755 /// Emits outlined function for the OpenMP task directive \a D. This
756 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
757 /// TaskT).
758 /// \param D OpenMP directive.
759 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
760 /// \param PartIDVar Variable for partition id in the current OpenMP untied
761 /// task region.
762 /// \param TaskTVar Variable for task_t argument.
763 /// \param InnermostKind Kind of innermost directive (for simple directives it
764 /// is a directive itself, for combined - its innermost directive).
765 /// \param CodeGen Code generation sequence for the \a D directive.
766 /// \param Tied true if task is generated for tied task, false otherwise.
767 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
768 /// tasks.
770 virtual llvm::Function *emitTaskOutlinedFunction(
771 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
772 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
773 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
774 bool Tied, unsigned &NumberOfParts);
776 /// Cleans up references to the objects in finished function.
778 virtual void functionFinished(CodeGenFunction &CGF);
780 /// Emits code for parallel or serial call of the \a OutlinedFn with
781 /// variables captured in a record which address is stored in \a
782 /// CapturedStruct.
783 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
784 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
785 /// \param CapturedVars A pointer to the record with the references to
786 /// variables used in \a OutlinedFn function.
787 /// \param IfCond Condition in the associated 'if' clause, if it was
788 /// specified, nullptr otherwise.
789 /// \param NumThreads The value corresponding to the num_threads clause, if
790 /// any, or nullptr.
792 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
793 llvm::Function *OutlinedFn,
794 ArrayRef<llvm::Value *> CapturedVars,
795 const Expr *IfCond, llvm::Value *NumThreads);
797 /// Emits a critical region.
798 /// \param CriticalName Name of the critical region.
799 /// \param CriticalOpGen Generator for the statement associated with the given
800 /// critical region.
801 /// \param Hint Value of the 'hint' clause (optional).
802 virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
803 const RegionCodeGenTy &CriticalOpGen,
804 SourceLocation Loc,
805 const Expr *Hint = nullptr);
807 /// Emits a master region.
808 /// \param MasterOpGen Generator for the statement associated with the given
809 /// master region.
810 virtual void emitMasterRegion(CodeGenFunction &CGF,
811 const RegionCodeGenTy &MasterOpGen,
812 SourceLocation Loc);
814 /// Emits a masked region.
815 /// \param MaskedOpGen Generator for the statement associated with the given
816 /// masked region.
817 virtual void emitMaskedRegion(CodeGenFunction &CGF,
818 const RegionCodeGenTy &MaskedOpGen,
819 SourceLocation Loc,
820 const Expr *Filter = nullptr);
822 /// Emits code for a taskyield directive.
823 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
825 /// Emit __kmpc_error call for error directive
826 /// extern void __kmpc_error(ident_t *loc, int severity, const char *message);
827 virtual void emitErrorCall(CodeGenFunction &CGF, SourceLocation Loc, Expr *ME,
828 bool IsFatal);
830 /// Emit a taskgroup region.
831 /// \param TaskgroupOpGen Generator for the statement associated with the
832 /// given taskgroup region.
833 virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
834 const RegionCodeGenTy &TaskgroupOpGen,
835 SourceLocation Loc);
837 /// Emits a single region.
838 /// \param SingleOpGen Generator for the statement associated with the given
839 /// single region.
840 virtual void emitSingleRegion(CodeGenFunction &CGF,
841 const RegionCodeGenTy &SingleOpGen,
842 SourceLocation Loc,
843 ArrayRef<const Expr *> CopyprivateVars,
844 ArrayRef<const Expr *> DestExprs,
845 ArrayRef<const Expr *> SrcExprs,
846 ArrayRef<const Expr *> AssignmentOps);
848 /// Emit an ordered region.
849 /// \param OrderedOpGen Generator for the statement associated with the given
850 /// ordered region.
851 virtual void emitOrderedRegion(CodeGenFunction &CGF,
852 const RegionCodeGenTy &OrderedOpGen,
853 SourceLocation Loc, bool IsThreads);
855 /// Emit an implicit/explicit barrier for OpenMP threads.
856 /// \param Kind Directive for which this implicit barrier call must be
857 /// generated. Must be OMPD_barrier for explicit barrier generation.
858 /// \param EmitChecks true if need to emit checks for cancellation barriers.
859 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
860 /// runtime class decides which one to emit (simple or with cancellation
861 /// checks).
863 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
864 OpenMPDirectiveKind Kind,
865 bool EmitChecks = true,
866 bool ForceSimpleCall = false);
868 /// Check if the specified \a ScheduleKind is static non-chunked.
869 /// This kind of worksharing directive is emitted without outer loop.
870 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
871 /// \param Chunked True if chunk is specified in the clause.
873 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
874 bool Chunked) const;
876 /// Check if the specified \a ScheduleKind is static non-chunked.
877 /// This kind of distribute directive is emitted without outer loop.
878 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
879 /// \param Chunked True if chunk is specified in the clause.
881 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
882 bool Chunked) const;
884 /// Check if the specified \a ScheduleKind is static chunked.
885 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
886 /// \param Chunked True if chunk is specified in the clause.
888 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
889 bool Chunked) const;
891 /// Check if the specified \a ScheduleKind is static non-chunked.
892 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
893 /// \param Chunked True if chunk is specified in the clause.
895 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
896 bool Chunked) const;
898 /// Check if the specified \a ScheduleKind is dynamic.
899 /// This kind of worksharing directive is emitted without outer loop.
900 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
902 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
904 /// struct with the values to be passed to the dispatch runtime function
905 struct DispatchRTInput {
906 /// Loop lower bound
907 llvm::Value *LB = nullptr;
908 /// Loop upper bound
909 llvm::Value *UB = nullptr;
910 /// Chunk size specified using 'schedule' clause (nullptr if chunk
911 /// was not specified)
912 llvm::Value *Chunk = nullptr;
913 DispatchRTInput() = default;
914 DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
915 : LB(LB), UB(UB), Chunk(Chunk) {}
918 /// Call the appropriate runtime routine to initialize it before start
919 /// of loop.
921 /// This is used for non static scheduled types and when the ordered
922 /// clause is present on the loop construct.
923 /// Depending on the loop schedule, it is necessary to call some runtime
924 /// routine before start of the OpenMP loop to get the loop upper / lower
925 /// bounds \a LB and \a UB and stride \a ST.
927 /// \param CGF Reference to current CodeGenFunction.
928 /// \param Loc Clang source location.
929 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
930 /// \param IVSize Size of the iteration variable in bits.
931 /// \param IVSigned Sign of the iteration variable.
932 /// \param Ordered true if loop is ordered, false otherwise.
933 /// \param DispatchValues struct containing llvm values for lower bound, upper
934 /// bound, and chunk expression.
935 /// For the default (nullptr) value, the chunk 1 will be used.
937 virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
938 const OpenMPScheduleTy &ScheduleKind,
939 unsigned IVSize, bool IVSigned, bool Ordered,
940 const DispatchRTInput &DispatchValues);
942 /// Struct with the values to be passed to the static runtime function
943 struct StaticRTInput {
944 /// Size of the iteration variable in bits.
945 unsigned IVSize = 0;
946 /// Sign of the iteration variable.
947 bool IVSigned = false;
948 /// true if loop is ordered, false otherwise.
949 bool Ordered = false;
950 /// Address of the output variable in which the flag of the last iteration
951 /// is returned.
952 Address IL = Address::invalid();
953 /// Address of the output variable in which the lower iteration number is
954 /// returned.
955 Address LB = Address::invalid();
956 /// Address of the output variable in which the upper iteration number is
957 /// returned.
958 Address UB = Address::invalid();
959 /// Address of the output variable in which the stride value is returned
960 /// necessary to generated the static_chunked scheduled loop.
961 Address ST = Address::invalid();
962 /// Value of the chunk for the static_chunked scheduled loop. For the
963 /// default (nullptr) value, the chunk 1 will be used.
964 llvm::Value *Chunk = nullptr;
965 StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL,
966 Address LB, Address UB, Address ST,
967 llvm::Value *Chunk = nullptr)
968 : IVSize(IVSize), IVSigned(IVSigned), Ordered(Ordered), IL(IL), LB(LB),
969 UB(UB), ST(ST), Chunk(Chunk) {}
971 /// Call the appropriate runtime routine to initialize it before start
972 /// of loop.
974 /// This is used only in case of static schedule, when the user did not
975 /// specify a ordered clause on the loop construct.
976 /// Depending on the loop schedule, it is necessary to call some runtime
977 /// routine before start of the OpenMP loop to get the loop upper / lower
978 /// bounds LB and UB and stride ST.
980 /// \param CGF Reference to current CodeGenFunction.
981 /// \param Loc Clang source location.
982 /// \param DKind Kind of the directive.
983 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
984 /// \param Values Input arguments for the construct.
986 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
987 OpenMPDirectiveKind DKind,
988 const OpenMPScheduleTy &ScheduleKind,
989 const StaticRTInput &Values);
992 /// \param CGF Reference to current CodeGenFunction.
993 /// \param Loc Clang source location.
994 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
995 /// \param Values Input arguments for the construct.
997 virtual void emitDistributeStaticInit(CodeGenFunction &CGF,
998 SourceLocation Loc,
999 OpenMPDistScheduleClauseKind SchedKind,
1000 const StaticRTInput &Values);
1002 /// Call the appropriate runtime routine to notify that we finished
1003 /// iteration of the ordered loop with the dynamic scheduling.
1005 /// \param CGF Reference to current CodeGenFunction.
1006 /// \param Loc Clang source location.
1007 /// \param IVSize Size of the iteration variable in bits.
1008 /// \param IVSigned Sign of the iteration variable.
1010 virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
1011 SourceLocation Loc, unsigned IVSize,
1012 bool IVSigned);
1014 /// Call the appropriate runtime routine to notify that we finished
1015 /// all the work with current loop.
1017 /// \param CGF Reference to current CodeGenFunction.
1018 /// \param Loc Clang source location.
1019 /// \param DKind Kind of the directive for which the static finish is emitted.
1021 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1022 OpenMPDirectiveKind DKind);
1024 /// Call __kmpc_dispatch_next(
1025 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1026 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1027 /// kmp_int[32|64] *p_stride);
1028 /// \param IVSize Size of the iteration variable in bits.
1029 /// \param IVSigned Sign of the iteration variable.
1030 /// \param IL Address of the output variable in which the flag of the
1031 /// last iteration is returned.
1032 /// \param LB Address of the output variable in which the lower iteration
1033 /// number is returned.
1034 /// \param UB Address of the output variable in which the upper iteration
1035 /// number is returned.
1036 /// \param ST Address of the output variable in which the stride value is
1037 /// returned.
1038 virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1039 unsigned IVSize, bool IVSigned,
1040 Address IL, Address LB,
1041 Address UB, Address ST);
1043 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1044 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1045 /// clause.
1046 /// \param NumThreads An integer value of threads.
1047 virtual void emitNumThreadsClause(CodeGenFunction &CGF,
1048 llvm::Value *NumThreads,
1049 SourceLocation Loc);
1051 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1052 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1053 virtual void emitProcBindClause(CodeGenFunction &CGF,
1054 llvm::omp::ProcBindKind ProcBind,
1055 SourceLocation Loc);
1057 /// Returns address of the threadprivate variable for the current
1058 /// thread.
1059 /// \param VD Threadprivate variable.
1060 /// \param VDAddr Address of the global variable \a VD.
1061 /// \param Loc Location of the reference to threadprivate var.
1062 /// \return Address of the threadprivate variable for the current thread.
1063 virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
1064 const VarDecl *VD,
1065 Address VDAddr,
1066 SourceLocation Loc);
1068 /// Returns the address of the variable marked as declare target with link
1069 /// clause OR as declare target with to clause and unified memory.
1070 virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD);
1072 /// Emit a code for initialization of threadprivate variable. It emits
1073 /// a call to runtime library which adds initial value to the newly created
1074 /// threadprivate variable (if it is not constant) and registers destructor
1075 /// for the variable (if any).
1076 /// \param VD Threadprivate variable.
1077 /// \param VDAddr Address of the global variable \a VD.
1078 /// \param Loc Location of threadprivate declaration.
1079 /// \param PerformInit true if initialization expression is not constant.
1080 virtual llvm::Function *
1081 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1082 SourceLocation Loc, bool PerformInit,
1083 CodeGenFunction *CGF = nullptr);
1085 /// Emit a code for initialization of declare target variable.
1086 /// \param VD Declare target variable.
1087 /// \param Addr Address of the global variable \a VD.
1088 /// \param PerformInit true if initialization expression is not constant.
1089 virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD,
1090 llvm::GlobalVariable *Addr,
1091 bool PerformInit);
1093 /// Creates artificial threadprivate variable with name \p Name and type \p
1094 /// VarType.
1095 /// \param VarType Type of the artificial threadprivate variable.
1096 /// \param Name Name of the artificial threadprivate variable.
1097 virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1098 QualType VarType,
1099 StringRef Name);
1101 /// Emit flush of the variables specified in 'omp flush' directive.
1102 /// \param Vars List of variables to flush.
1103 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1104 SourceLocation Loc, llvm::AtomicOrdering AO);
1106 /// Emit task region for the task directive. The task region is
1107 /// emitted in several steps:
1108 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1109 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1110 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1111 /// function:
1112 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1113 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1114 /// return 0;
1115 /// }
1116 /// 2. Copy a list of shared variables to field shareds of the resulting
1117 /// structure kmp_task_t returned by the previous call (if any).
1118 /// 3. Copy a pointer to destructions function to field destructions of the
1119 /// resulting structure kmp_task_t.
1120 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1121 /// kmp_task_t *new_task), where new_task is a resulting structure from
1122 /// previous items.
1123 /// \param D Current task directive.
1124 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1125 /// /*part_id*/, captured_struct */*__context*/);
1126 /// \param SharedsTy A type which contains references the shared variables.
1127 /// \param Shareds Context with the list of shared variables from the \p
1128 /// TaskFunction.
1129 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1130 /// otherwise.
1131 /// \param Data Additional data for task generation like tiednsee, final
1132 /// state, list of privates etc.
1133 virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1134 const OMPExecutableDirective &D,
1135 llvm::Function *TaskFunction, QualType SharedsTy,
1136 Address Shareds, const Expr *IfCond,
1137 const OMPTaskDataTy &Data);
1139 /// Emit task region for the taskloop directive. The taskloop region is
1140 /// emitted in several steps:
1141 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1142 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1143 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1144 /// function:
1145 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1146 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1147 /// return 0;
1148 /// }
1149 /// 2. Copy a list of shared variables to field shareds of the resulting
1150 /// structure kmp_task_t returned by the previous call (if any).
1151 /// 3. Copy a pointer to destructions function to field destructions of the
1152 /// resulting structure kmp_task_t.
1153 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1154 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1155 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1156 /// is a resulting structure from
1157 /// previous items.
1158 /// \param D Current task directive.
1159 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1160 /// /*part_id*/, captured_struct */*__context*/);
1161 /// \param SharedsTy A type which contains references the shared variables.
1162 /// \param Shareds Context with the list of shared variables from the \p
1163 /// TaskFunction.
1164 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1165 /// otherwise.
1166 /// \param Data Additional data for task generation like tiednsee, final
1167 /// state, list of privates etc.
1168 virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1169 const OMPLoopDirective &D,
1170 llvm::Function *TaskFunction,
1171 QualType SharedsTy, Address Shareds,
1172 const Expr *IfCond, const OMPTaskDataTy &Data);
1174 /// Emit code for the directive that does not require outlining.
1176 /// \param InnermostKind Kind of innermost directive (for simple directives it
1177 /// is a directive itself, for combined - its innermost directive).
1178 /// \param CodeGen Code generation sequence for the \a D directive.
1179 /// \param HasCancel true if region has inner cancel directive, false
1180 /// otherwise.
1181 virtual void emitInlinedDirective(CodeGenFunction &CGF,
1182 OpenMPDirectiveKind InnermostKind,
1183 const RegionCodeGenTy &CodeGen,
1184 bool HasCancel = false);
1186 /// Emits reduction function.
1187 /// \param ReducerName Name of the function calling the reduction.
1188 /// \param ArgsElemType Array type containing pointers to reduction variables.
1189 /// \param Privates List of private copies for original reduction arguments.
1190 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1191 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1192 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1193 /// or 'operator binop(LHS, RHS)'.
1194 llvm::Function *emitReductionFunction(
1195 StringRef ReducerName, SourceLocation Loc, llvm::Type *ArgsElemType,
1196 ArrayRef<const Expr *> Privates, ArrayRef<const Expr *> LHSExprs,
1197 ArrayRef<const Expr *> RHSExprs, ArrayRef<const Expr *> ReductionOps);
1199 /// Emits single reduction combiner
1200 void emitSingleReductionCombiner(CodeGenFunction &CGF,
1201 const Expr *ReductionOp,
1202 const Expr *PrivateRef,
1203 const DeclRefExpr *LHS,
1204 const DeclRefExpr *RHS);
1206 struct ReductionOptionsTy {
1207 bool WithNowait;
1208 bool SimpleReduction;
1209 OpenMPDirectiveKind ReductionKind;
1211 /// Emit a code for reduction clause. Next code should be emitted for
1212 /// reduction:
1213 /// \code
1215 /// static kmp_critical_name lock = { 0 };
1217 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1218 /// ...
1219 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1220 /// ...
1221 /// }
1223 /// ...
1224 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1225 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1226 /// RedList, reduce_func, &<lock>)) {
1227 /// case 1:
1228 /// ...
1229 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1230 /// ...
1231 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1232 /// break;
1233 /// case 2:
1234 /// ...
1235 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1236 /// ...
1237 /// break;
1238 /// default:;
1239 /// }
1240 /// \endcode
1242 /// \param Privates List of private copies for original reduction arguments.
1243 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1244 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1245 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1246 /// or 'operator binop(LHS, RHS)'.
1247 /// \param Options List of options for reduction codegen:
1248 /// WithNowait true if parent directive has also nowait clause, false
1249 /// otherwise.
1250 /// SimpleReduction Emit reduction operation only. Used for omp simd
1251 /// directive on the host.
1252 /// ReductionKind The kind of reduction to perform.
1253 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1254 ArrayRef<const Expr *> Privates,
1255 ArrayRef<const Expr *> LHSExprs,
1256 ArrayRef<const Expr *> RHSExprs,
1257 ArrayRef<const Expr *> ReductionOps,
1258 ReductionOptionsTy Options);
1260 /// Emit a code for initialization of task reduction clause. Next code
1261 /// should be emitted for reduction:
1262 /// \code
1264 /// _taskred_item_t red_data[n];
1265 /// ...
1266 /// red_data[i].shar = &shareds[i];
1267 /// red_data[i].orig = &origs[i];
1268 /// red_data[i].size = sizeof(origs[i]);
1269 /// red_data[i].f_init = (void*)RedInit<i>;
1270 /// red_data[i].f_fini = (void*)RedDest<i>;
1271 /// red_data[i].f_comb = (void*)RedOp<i>;
1272 /// red_data[i].flags = <Flag_i>;
1273 /// ...
1274 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
1275 /// \endcode
1276 /// For reduction clause with task modifier it emits the next call:
1277 /// \code
1279 /// _taskred_item_t red_data[n];
1280 /// ...
1281 /// red_data[i].shar = &shareds[i];
1282 /// red_data[i].orig = &origs[i];
1283 /// red_data[i].size = sizeof(origs[i]);
1284 /// red_data[i].f_init = (void*)RedInit<i>;
1285 /// red_data[i].f_fini = (void*)RedDest<i>;
1286 /// red_data[i].f_comb = (void*)RedOp<i>;
1287 /// red_data[i].flags = <Flag_i>;
1288 /// ...
1289 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
1290 /// red_data);
1291 /// \endcode
1292 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1293 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1294 /// \param Data Additional data for task generation like tiedness, final
1295 /// state, list of privates, reductions etc.
1296 virtual llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF,
1297 SourceLocation Loc,
1298 ArrayRef<const Expr *> LHSExprs,
1299 ArrayRef<const Expr *> RHSExprs,
1300 const OMPTaskDataTy &Data);
1302 /// Emits the following code for reduction clause with task modifier:
1303 /// \code
1304 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
1305 /// \endcode
1306 virtual void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc,
1307 bool IsWorksharingReduction);
1309 /// Required to resolve existing problems in the runtime. Emits threadprivate
1310 /// variables to store the size of the VLAs/array sections for
1311 /// initializer/combiner/finalizer functions.
1312 /// \param RCG Allows to reuse an existing data for the reductions.
1313 /// \param N Reduction item for which fixups must be emitted.
1314 virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc,
1315 ReductionCodeGen &RCG, unsigned N);
1317 /// Get the address of `void *` type of the privatue copy of the reduction
1318 /// item specified by the \p SharedLVal.
1319 /// \param ReductionsPtr Pointer to the reduction data returned by the
1320 /// emitTaskReductionInit function.
1321 /// \param SharedLVal Address of the original reduction item.
1322 virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
1323 llvm::Value *ReductionsPtr,
1324 LValue SharedLVal);
1326 /// Emit code for 'taskwait' directive.
1327 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc,
1328 const OMPTaskDataTy &Data);
1330 /// Emit code for 'cancellation point' construct.
1331 /// \param CancelRegion Region kind for which the cancellation point must be
1332 /// emitted.
1334 virtual void emitCancellationPointCall(CodeGenFunction &CGF,
1335 SourceLocation Loc,
1336 OpenMPDirectiveKind CancelRegion);
1338 /// Emit code for 'cancel' construct.
1339 /// \param IfCond Condition in the associated 'if' clause, if it was
1340 /// specified, nullptr otherwise.
1341 /// \param CancelRegion Region kind for which the cancel must be emitted.
1343 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1344 const Expr *IfCond,
1345 OpenMPDirectiveKind CancelRegion);
1347 /// Emit outilined function for 'target' directive.
1348 /// \param D Directive to emit.
1349 /// \param ParentName Name of the function that encloses the target region.
1350 /// \param OutlinedFn Outlined function value to be defined by this call.
1351 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1352 /// \param IsOffloadEntry True if the outlined function is an offload entry.
1353 /// \param CodeGen Code generation sequence for the \a D directive.
1354 /// An outlined function may not be an entry if, e.g. the if clause always
1355 /// evaluates to false.
1356 virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
1357 StringRef ParentName,
1358 llvm::Function *&OutlinedFn,
1359 llvm::Constant *&OutlinedFnID,
1360 bool IsOffloadEntry,
1361 const RegionCodeGenTy &CodeGen);
1363 /// Emit the target offloading code associated with \a D. The emitted
1364 /// code attempts offloading the execution to the device, an the event of
1365 /// a failure it executes the host version outlined in \a OutlinedFn.
1366 /// \param D Directive to emit.
1367 /// \param OutlinedFn Host version of the code to be offloaded.
1368 /// \param OutlinedFnID ID of host version of the code to be offloaded.
1369 /// \param IfCond Expression evaluated in if clause associated with the target
1370 /// directive, or null if no if clause is used.
1371 /// \param Device Expression evaluated in device clause associated with the
1372 /// target directive, or null if no device clause is used and device modifier.
1373 /// \param SizeEmitter Callback to emit number of iterations for loop-based
1374 /// directives.
1375 virtual void emitTargetCall(
1376 CodeGenFunction &CGF, const OMPExecutableDirective &D,
1377 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
1378 llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
1379 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
1380 const OMPLoopDirective &D)>
1381 SizeEmitter);
1383 /// Emit the target regions enclosed in \a GD function definition or
1384 /// the function itself in case it is a valid device function. Returns true if
1385 /// \a GD was dealt with successfully.
1386 /// \param GD Function to scan.
1387 virtual bool emitTargetFunctions(GlobalDecl GD);
1389 /// Emit the global variable if it is a valid device global variable.
1390 /// Returns true if \a GD was dealt with successfully.
1391 /// \param GD Variable declaration to emit.
1392 virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1394 /// Checks if the provided global decl \a GD is a declare target variable and
1395 /// registers it when emitting code for the host.
1396 virtual void registerTargetGlobalVariable(const VarDecl *VD,
1397 llvm::Constant *Addr);
1399 /// Emit the global \a GD if it is meaningful for the target. Returns
1400 /// if it was emitted successfully.
1401 /// \param GD Global to scan.
1402 virtual bool emitTargetGlobal(GlobalDecl GD);
1404 /// Creates and returns a registration function for when at least one
1405 /// requires directives was used in the current module.
1406 llvm::Function *emitRequiresDirectiveRegFun();
1408 /// Creates all the offload entries in the current compilation unit
1409 /// along with the associated metadata.
1410 void createOffloadEntriesAndInfoMetadata();
1412 /// Emits code for teams call of the \a OutlinedFn with
1413 /// variables captured in a record which address is stored in \a
1414 /// CapturedStruct.
1415 /// \param OutlinedFn Outlined function to be run by team masters. Type of
1416 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1417 /// \param CapturedVars A pointer to the record with the references to
1418 /// variables used in \a OutlinedFn function.
1420 virtual void emitTeamsCall(CodeGenFunction &CGF,
1421 const OMPExecutableDirective &D,
1422 SourceLocation Loc, llvm::Function *OutlinedFn,
1423 ArrayRef<llvm::Value *> CapturedVars);
1425 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1426 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1427 /// for num_teams clause.
1428 /// \param NumTeams An integer expression of teams.
1429 /// \param ThreadLimit An integer expression of threads.
1430 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1431 const Expr *ThreadLimit, SourceLocation Loc);
1433 /// Struct that keeps all the relevant information that should be kept
1434 /// throughout a 'target data' region.
1435 class TargetDataInfo : public llvm::OpenMPIRBuilder::TargetDataInfo {
1436 public:
1437 explicit TargetDataInfo() : llvm::OpenMPIRBuilder::TargetDataInfo() {}
1438 explicit TargetDataInfo(bool RequiresDevicePointerInfo,
1439 bool SeparateBeginEndCalls)
1440 : llvm::OpenMPIRBuilder::TargetDataInfo(RequiresDevicePointerInfo,
1441 SeparateBeginEndCalls) {}
1442 /// Map between the a declaration of a capture and the corresponding base
1443 /// pointer address where the runtime returns the device pointers.
1444 llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1447 /// Emit the target data mapping code associated with \a D.
1448 /// \param D Directive to emit.
1449 /// \param IfCond Expression evaluated in if clause associated with the
1450 /// target directive, or null if no device clause is used.
1451 /// \param Device Expression evaluated in device clause associated with the
1452 /// target directive, or null if no device clause is used.
1453 /// \param Info A record used to store information that needs to be preserved
1454 /// until the region is closed.
1455 virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1456 const OMPExecutableDirective &D,
1457 const Expr *IfCond, const Expr *Device,
1458 const RegionCodeGenTy &CodeGen,
1459 CGOpenMPRuntime::TargetDataInfo &Info);
1461 /// Emit the data mapping/movement code associated with the directive
1462 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1463 /// \param D Directive to emit.
1464 /// \param IfCond Expression evaluated in if clause associated with the target
1465 /// directive, or null if no if clause is used.
1466 /// \param Device Expression evaluated in device clause associated with the
1467 /// target directive, or null if no device clause is used.
1468 virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
1469 const OMPExecutableDirective &D,
1470 const Expr *IfCond,
1471 const Expr *Device);
1473 /// Marks function \a Fn with properly mangled versions of vector functions.
1474 /// \param FD Function marked as 'declare simd'.
1475 /// \param Fn LLVM function that must be marked with 'declare simd'
1476 /// attributes.
1477 virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1478 llvm::Function *Fn);
1480 /// Emit initialization for doacross loop nesting support.
1481 /// \param D Loop-based construct used in doacross nesting construct.
1482 virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
1483 ArrayRef<Expr *> NumIterations);
1485 /// Emit code for doacross ordered directive with 'depend' clause.
1486 /// \param C 'depend' clause with 'sink|source' dependency kind.
1487 virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1488 const OMPDependClause *C);
1490 /// Translates the native parameter of outlined function if this is required
1491 /// for target.
1492 /// \param FD Field decl from captured record for the parameter.
1493 /// \param NativeParam Parameter itself.
1494 virtual const VarDecl *translateParameter(const FieldDecl *FD,
1495 const VarDecl *NativeParam) const {
1496 return NativeParam;
1499 /// Gets the address of the native argument basing on the address of the
1500 /// target-specific parameter.
1501 /// \param NativeParam Parameter itself.
1502 /// \param TargetParam Corresponding target-specific parameter.
1503 virtual Address getParameterAddress(CodeGenFunction &CGF,
1504 const VarDecl *NativeParam,
1505 const VarDecl *TargetParam) const;
1507 /// Choose default schedule type and chunk value for the
1508 /// dist_schedule clause.
1509 virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF,
1510 const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1511 llvm::Value *&Chunk) const {}
1513 /// Choose default schedule type and chunk value for the
1514 /// schedule clause.
1515 virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF,
1516 const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1517 const Expr *&ChunkExpr) const;
1519 /// Emits call of the outlined function with the provided arguments,
1520 /// translating these arguments to correct target-specific arguments.
1521 virtual void
1522 emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc,
1523 llvm::FunctionCallee OutlinedFn,
1524 ArrayRef<llvm::Value *> Args = std::nullopt) const;
1526 /// Emits OpenMP-specific function prolog.
1527 /// Required for device constructs.
1528 virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D);
1530 /// Gets the OpenMP-specific address of the local variable.
1531 virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF,
1532 const VarDecl *VD);
1534 /// Marks the declaration as already emitted for the device code and returns
1535 /// true, if it was marked already, and false, otherwise.
1536 bool markAsGlobalTarget(GlobalDecl GD);
1538 /// Emit deferred declare target variables marked for deferred emission.
1539 void emitDeferredTargetDecls() const;
1541 /// Adjust some parameters for the target-based directives, like addresses of
1542 /// the variables captured by reference in lambdas.
1543 virtual void
1544 adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF,
1545 const OMPExecutableDirective &D) const;
1547 /// Perform check on requires decl to ensure that target architecture
1548 /// supports unified addressing
1549 virtual void processRequiresDirective(const OMPRequiresDecl *D);
1551 /// Gets default memory ordering as specified in requires directive.
1552 llvm::AtomicOrdering getDefaultMemoryOrdering() const;
1554 /// Checks if the variable has associated OMPAllocateDeclAttr attribute with
1555 /// the predefined allocator and translates it into the corresponding address
1556 /// space.
1557 virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS);
1559 /// Return whether the unified_shared_memory has been specified.
1560 bool hasRequiresUnifiedSharedMemory() const;
1562 /// Checks if the \p VD variable is marked as nontemporal declaration in
1563 /// current context.
1564 bool isNontemporalDecl(const ValueDecl *VD) const;
1566 /// Create specialized alloca to handle lastprivate conditionals.
1567 Address emitLastprivateConditionalInit(CodeGenFunction &CGF,
1568 const VarDecl *VD);
1570 /// Checks if the provided \p LVal is lastprivate conditional and emits the
1571 /// code to update the value of the original variable.
1572 /// \code
1573 /// lastprivate(conditional: a)
1574 /// ...
1575 /// <type> a;
1576 /// lp_a = ...;
1577 /// #pragma omp critical(a)
1578 /// if (last_iv_a <= iv) {
1579 /// last_iv_a = iv;
1580 /// global_a = lp_a;
1581 /// }
1582 /// \endcode
1583 virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF,
1584 const Expr *LHS);
1586 /// Checks if the lastprivate conditional was updated in inner region and
1587 /// writes the value.
1588 /// \code
1589 /// lastprivate(conditional: a)
1590 /// ...
1591 /// <type> a;bool Fired = false;
1592 /// #pragma omp ... shared(a)
1593 /// {
1594 /// lp_a = ...;
1595 /// Fired = true;
1596 /// }
1597 /// if (Fired) {
1598 /// #pragma omp critical(a)
1599 /// if (last_iv_a <= iv) {
1600 /// last_iv_a = iv;
1601 /// global_a = lp_a;
1602 /// }
1603 /// Fired = false;
1604 /// }
1605 /// \endcode
1606 virtual void checkAndEmitSharedLastprivateConditional(
1607 CodeGenFunction &CGF, const OMPExecutableDirective &D,
1608 const llvm::DenseSet<CanonicalDeclPtr<const VarDecl>> &IgnoredDecls);
1610 /// Gets the address of the global copy used for lastprivate conditional
1611 /// update, if any.
1612 /// \param PrivLVal LValue for the private copy.
1613 /// \param VD Original lastprivate declaration.
1614 virtual void emitLastprivateConditionalFinalUpdate(CodeGenFunction &CGF,
1615 LValue PrivLVal,
1616 const VarDecl *VD,
1617 SourceLocation Loc);
1619 /// Emits list of dependecies based on the provided data (array of
1620 /// dependence/expression pairs).
1621 /// \returns Pointer to the first element of the array casted to VoidPtr type.
1622 std::pair<llvm::Value *, Address>
1623 emitDependClause(CodeGenFunction &CGF,
1624 ArrayRef<OMPTaskDataTy::DependData> Dependencies,
1625 SourceLocation Loc);
1627 /// Emits list of dependecies based on the provided data (array of
1628 /// dependence/expression pairs) for depobj construct. In this case, the
1629 /// variable is allocated in dynamically. \returns Pointer to the first
1630 /// element of the array casted to VoidPtr type.
1631 Address emitDepobjDependClause(CodeGenFunction &CGF,
1632 const OMPTaskDataTy::DependData &Dependencies,
1633 SourceLocation Loc);
1635 /// Emits the code to destroy the dependency object provided in depobj
1636 /// directive.
1637 void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal,
1638 SourceLocation Loc);
1640 /// Updates the dependency kind in the specified depobj object.
1641 /// \param DepobjLVal LValue for the main depobj object.
1642 /// \param NewDepKind New dependency kind.
1643 void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal,
1644 OpenMPDependClauseKind NewDepKind, SourceLocation Loc);
1646 /// Initializes user defined allocators specified in the uses_allocators
1647 /// clauses.
1648 void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator,
1649 const Expr *AllocatorTraits);
1651 /// Destroys user defined allocators specified in the uses_allocators clause.
1652 void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator);
1654 /// Returns true if the variable is a local variable in untied task.
1655 bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const;
1658 /// Class supports emissionof SIMD-only code.
1659 class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime {
1660 public:
1661 explicit CGOpenMPSIMDRuntime(CodeGenModule &CGM) : CGOpenMPRuntime(CGM) {}
1662 ~CGOpenMPSIMDRuntime() override {}
1664 /// Emits outlined function for the specified OpenMP parallel directive
1665 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1666 /// kmp_int32 BoundID, struct context_vars*).
1667 /// \param CGF Reference to current CodeGenFunction.
1668 /// \param D OpenMP directive.
1669 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1670 /// \param InnermostKind Kind of innermost directive (for simple directives it
1671 /// is a directive itself, for combined - its innermost directive).
1672 /// \param CodeGen Code generation sequence for the \a D directive.
1673 llvm::Function *emitParallelOutlinedFunction(
1674 CodeGenFunction &CGF, const OMPExecutableDirective &D,
1675 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1676 const RegionCodeGenTy &CodeGen) override;
1678 /// Emits outlined function for the specified OpenMP teams directive
1679 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1680 /// kmp_int32 BoundID, struct context_vars*).
1681 /// \param CGF Reference to current CodeGenFunction.
1682 /// \param D OpenMP directive.
1683 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1684 /// \param InnermostKind Kind of innermost directive (for simple directives it
1685 /// is a directive itself, for combined - its innermost directive).
1686 /// \param CodeGen Code generation sequence for the \a D directive.
1687 llvm::Function *emitTeamsOutlinedFunction(
1688 CodeGenFunction &CGF, const OMPExecutableDirective &D,
1689 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1690 const RegionCodeGenTy &CodeGen) override;
1692 /// Emits outlined function for the OpenMP task directive \a D. This
1693 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1694 /// TaskT).
1695 /// \param D OpenMP directive.
1696 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1697 /// \param PartIDVar Variable for partition id in the current OpenMP untied
1698 /// task region.
1699 /// \param TaskTVar Variable for task_t argument.
1700 /// \param InnermostKind Kind of innermost directive (for simple directives it
1701 /// is a directive itself, for combined - its innermost directive).
1702 /// \param CodeGen Code generation sequence for the \a D directive.
1703 /// \param Tied true if task is generated for tied task, false otherwise.
1704 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1705 /// tasks.
1707 llvm::Function *emitTaskOutlinedFunction(
1708 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
1709 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
1710 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1711 bool Tied, unsigned &NumberOfParts) override;
1713 /// Emits code for parallel or serial call of the \a OutlinedFn with
1714 /// variables captured in a record which address is stored in \a
1715 /// CapturedStruct.
1716 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1717 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1718 /// \param CapturedVars A pointer to the record with the references to
1719 /// variables used in \a OutlinedFn function.
1720 /// \param IfCond Condition in the associated 'if' clause, if it was
1721 /// specified, nullptr otherwise.
1722 /// \param NumThreads The value corresponding to the num_threads clause, if
1723 /// any, or nullptr.
1725 void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
1726 llvm::Function *OutlinedFn,
1727 ArrayRef<llvm::Value *> CapturedVars,
1728 const Expr *IfCond, llvm::Value *NumThreads) override;
1730 /// Emits a critical region.
1731 /// \param CriticalName Name of the critical region.
1732 /// \param CriticalOpGen Generator for the statement associated with the given
1733 /// critical region.
1734 /// \param Hint Value of the 'hint' clause (optional).
1735 void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
1736 const RegionCodeGenTy &CriticalOpGen,
1737 SourceLocation Loc,
1738 const Expr *Hint = nullptr) override;
1740 /// Emits a master region.
1741 /// \param MasterOpGen Generator for the statement associated with the given
1742 /// master region.
1743 void emitMasterRegion(CodeGenFunction &CGF,
1744 const RegionCodeGenTy &MasterOpGen,
1745 SourceLocation Loc) override;
1747 /// Emits a masked region.
1748 /// \param MaskedOpGen Generator for the statement associated with the given
1749 /// masked region.
1750 void emitMaskedRegion(CodeGenFunction &CGF,
1751 const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc,
1752 const Expr *Filter = nullptr) override;
1754 /// Emits a masked region.
1755 /// \param MaskedOpGen Generator for the statement associated with the given
1756 /// masked region.
1758 /// Emits code for a taskyield directive.
1759 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
1761 /// Emit a taskgroup region.
1762 /// \param TaskgroupOpGen Generator for the statement associated with the
1763 /// given taskgroup region.
1764 void emitTaskgroupRegion(CodeGenFunction &CGF,
1765 const RegionCodeGenTy &TaskgroupOpGen,
1766 SourceLocation Loc) override;
1768 /// Emits a single region.
1769 /// \param SingleOpGen Generator for the statement associated with the given
1770 /// single region.
1771 void emitSingleRegion(CodeGenFunction &CGF,
1772 const RegionCodeGenTy &SingleOpGen, SourceLocation Loc,
1773 ArrayRef<const Expr *> CopyprivateVars,
1774 ArrayRef<const Expr *> DestExprs,
1775 ArrayRef<const Expr *> SrcExprs,
1776 ArrayRef<const Expr *> AssignmentOps) override;
1778 /// Emit an ordered region.
1779 /// \param OrderedOpGen Generator for the statement associated with the given
1780 /// ordered region.
1781 void emitOrderedRegion(CodeGenFunction &CGF,
1782 const RegionCodeGenTy &OrderedOpGen,
1783 SourceLocation Loc, bool IsThreads) override;
1785 /// Emit an implicit/explicit barrier for OpenMP threads.
1786 /// \param Kind Directive for which this implicit barrier call must be
1787 /// generated. Must be OMPD_barrier for explicit barrier generation.
1788 /// \param EmitChecks true if need to emit checks for cancellation barriers.
1789 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1790 /// runtime class decides which one to emit (simple or with cancellation
1791 /// checks).
1793 void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
1794 OpenMPDirectiveKind Kind, bool EmitChecks = true,
1795 bool ForceSimpleCall = false) override;
1797 /// This is used for non static scheduled types and when the ordered
1798 /// clause is present on the loop construct.
1799 /// Depending on the loop schedule, it is necessary to call some runtime
1800 /// routine before start of the OpenMP loop to get the loop upper / lower
1801 /// bounds \a LB and \a UB and stride \a ST.
1803 /// \param CGF Reference to current CodeGenFunction.
1804 /// \param Loc Clang source location.
1805 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1806 /// \param IVSize Size of the iteration variable in bits.
1807 /// \param IVSigned Sign of the iteration variable.
1808 /// \param Ordered true if loop is ordered, false otherwise.
1809 /// \param DispatchValues struct containing llvm values for lower bound, upper
1810 /// bound, and chunk expression.
1811 /// For the default (nullptr) value, the chunk 1 will be used.
1813 void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
1814 const OpenMPScheduleTy &ScheduleKind,
1815 unsigned IVSize, bool IVSigned, bool Ordered,
1816 const DispatchRTInput &DispatchValues) override;
1818 /// Call the appropriate runtime routine to initialize it before start
1819 /// of loop.
1821 /// This is used only in case of static schedule, when the user did not
1822 /// specify a ordered clause on the loop construct.
1823 /// Depending on the loop schedule, it is necessary to call some runtime
1824 /// routine before start of the OpenMP loop to get the loop upper / lower
1825 /// bounds LB and UB and stride ST.
1827 /// \param CGF Reference to current CodeGenFunction.
1828 /// \param Loc Clang source location.
1829 /// \param DKind Kind of the directive.
1830 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1831 /// \param Values Input arguments for the construct.
1833 void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1834 OpenMPDirectiveKind DKind,
1835 const OpenMPScheduleTy &ScheduleKind,
1836 const StaticRTInput &Values) override;
1839 /// \param CGF Reference to current CodeGenFunction.
1840 /// \param Loc Clang source location.
1841 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1842 /// \param Values Input arguments for the construct.
1844 void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1845 OpenMPDistScheduleClauseKind SchedKind,
1846 const StaticRTInput &Values) override;
1848 /// Call the appropriate runtime routine to notify that we finished
1849 /// iteration of the ordered loop with the dynamic scheduling.
1851 /// \param CGF Reference to current CodeGenFunction.
1852 /// \param Loc Clang source location.
1853 /// \param IVSize Size of the iteration variable in bits.
1854 /// \param IVSigned Sign of the iteration variable.
1856 void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc,
1857 unsigned IVSize, bool IVSigned) override;
1859 /// Call the appropriate runtime routine to notify that we finished
1860 /// all the work with current loop.
1862 /// \param CGF Reference to current CodeGenFunction.
1863 /// \param Loc Clang source location.
1864 /// \param DKind Kind of the directive for which the static finish is emitted.
1866 void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1867 OpenMPDirectiveKind DKind) override;
1869 /// Call __kmpc_dispatch_next(
1870 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1871 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1872 /// kmp_int[32|64] *p_stride);
1873 /// \param IVSize Size of the iteration variable in bits.
1874 /// \param IVSigned Sign of the iteration variable.
1875 /// \param IL Address of the output variable in which the flag of the
1876 /// last iteration is returned.
1877 /// \param LB Address of the output variable in which the lower iteration
1878 /// number is returned.
1879 /// \param UB Address of the output variable in which the upper iteration
1880 /// number is returned.
1881 /// \param ST Address of the output variable in which the stride value is
1882 /// returned.
1883 llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1884 unsigned IVSize, bool IVSigned, Address IL,
1885 Address LB, Address UB, Address ST) override;
1887 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1888 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1889 /// clause.
1890 /// \param NumThreads An integer value of threads.
1891 void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads,
1892 SourceLocation Loc) override;
1894 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1895 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1896 void emitProcBindClause(CodeGenFunction &CGF,
1897 llvm::omp::ProcBindKind ProcBind,
1898 SourceLocation Loc) override;
1900 /// Returns address of the threadprivate variable for the current
1901 /// thread.
1902 /// \param VD Threadprivate variable.
1903 /// \param VDAddr Address of the global variable \a VD.
1904 /// \param Loc Location of the reference to threadprivate var.
1905 /// \return Address of the threadprivate variable for the current thread.
1906 Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD,
1907 Address VDAddr, SourceLocation Loc) override;
1909 /// Emit a code for initialization of threadprivate variable. It emits
1910 /// a call to runtime library which adds initial value to the newly created
1911 /// threadprivate variable (if it is not constant) and registers destructor
1912 /// for the variable (if any).
1913 /// \param VD Threadprivate variable.
1914 /// \param VDAddr Address of the global variable \a VD.
1915 /// \param Loc Location of threadprivate declaration.
1916 /// \param PerformInit true if initialization expression is not constant.
1917 llvm::Function *
1918 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1919 SourceLocation Loc, bool PerformInit,
1920 CodeGenFunction *CGF = nullptr) override;
1922 /// Creates artificial threadprivate variable with name \p Name and type \p
1923 /// VarType.
1924 /// \param VarType Type of the artificial threadprivate variable.
1925 /// \param Name Name of the artificial threadprivate variable.
1926 Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1927 QualType VarType,
1928 StringRef Name) override;
1930 /// Emit flush of the variables specified in 'omp flush' directive.
1931 /// \param Vars List of variables to flush.
1932 void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1933 SourceLocation Loc, llvm::AtomicOrdering AO) override;
1935 /// Emit task region for the task directive. The task region is
1936 /// emitted in several steps:
1937 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1938 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1939 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1940 /// function:
1941 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1942 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1943 /// return 0;
1944 /// }
1945 /// 2. Copy a list of shared variables to field shareds of the resulting
1946 /// structure kmp_task_t returned by the previous call (if any).
1947 /// 3. Copy a pointer to destructions function to field destructions of the
1948 /// resulting structure kmp_task_t.
1949 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1950 /// kmp_task_t *new_task), where new_task is a resulting structure from
1951 /// previous items.
1952 /// \param D Current task directive.
1953 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1954 /// /*part_id*/, captured_struct */*__context*/);
1955 /// \param SharedsTy A type which contains references the shared variables.
1956 /// \param Shareds Context with the list of shared variables from the \p
1957 /// TaskFunction.
1958 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1959 /// otherwise.
1960 /// \param Data Additional data for task generation like tiednsee, final
1961 /// state, list of privates etc.
1962 void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1963 const OMPExecutableDirective &D,
1964 llvm::Function *TaskFunction, QualType SharedsTy,
1965 Address Shareds, const Expr *IfCond,
1966 const OMPTaskDataTy &Data) override;
1968 /// Emit task region for the taskloop directive. The taskloop region is
1969 /// emitted in several steps:
1970 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1971 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1972 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1973 /// function:
1974 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1975 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1976 /// return 0;
1977 /// }
1978 /// 2. Copy a list of shared variables to field shareds of the resulting
1979 /// structure kmp_task_t returned by the previous call (if any).
1980 /// 3. Copy a pointer to destructions function to field destructions of the
1981 /// resulting structure kmp_task_t.
1982 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1983 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1984 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1985 /// is a resulting structure from
1986 /// previous items.
1987 /// \param D Current task directive.
1988 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1989 /// /*part_id*/, captured_struct */*__context*/);
1990 /// \param SharedsTy A type which contains references the shared variables.
1991 /// \param Shareds Context with the list of shared variables from the \p
1992 /// TaskFunction.
1993 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1994 /// otherwise.
1995 /// \param Data Additional data for task generation like tiednsee, final
1996 /// state, list of privates etc.
1997 void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1998 const OMPLoopDirective &D, llvm::Function *TaskFunction,
1999 QualType SharedsTy, Address Shareds, const Expr *IfCond,
2000 const OMPTaskDataTy &Data) override;
2002 /// Emit a code for reduction clause. Next code should be emitted for
2003 /// reduction:
2004 /// \code
2006 /// static kmp_critical_name lock = { 0 };
2008 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
2009 /// ...
2010 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
2011 /// ...
2012 /// }
2014 /// ...
2015 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
2016 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
2017 /// RedList, reduce_func, &<lock>)) {
2018 /// case 1:
2019 /// ...
2020 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
2021 /// ...
2022 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
2023 /// break;
2024 /// case 2:
2025 /// ...
2026 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
2027 /// ...
2028 /// break;
2029 /// default:;
2030 /// }
2031 /// \endcode
2033 /// \param Privates List of private copies for original reduction arguments.
2034 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
2035 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
2036 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
2037 /// or 'operator binop(LHS, RHS)'.
2038 /// \param Options List of options for reduction codegen:
2039 /// WithNowait true if parent directive has also nowait clause, false
2040 /// otherwise.
2041 /// SimpleReduction Emit reduction operation only. Used for omp simd
2042 /// directive on the host.
2043 /// ReductionKind The kind of reduction to perform.
2044 void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
2045 ArrayRef<const Expr *> Privates,
2046 ArrayRef<const Expr *> LHSExprs,
2047 ArrayRef<const Expr *> RHSExprs,
2048 ArrayRef<const Expr *> ReductionOps,
2049 ReductionOptionsTy Options) override;
2051 /// Emit a code for initialization of task reduction clause. Next code
2052 /// should be emitted for reduction:
2053 /// \code
2055 /// _taskred_item_t red_data[n];
2056 /// ...
2057 /// red_data[i].shar = &shareds[i];
2058 /// red_data[i].orig = &origs[i];
2059 /// red_data[i].size = sizeof(origs[i]);
2060 /// red_data[i].f_init = (void*)RedInit<i>;
2061 /// red_data[i].f_fini = (void*)RedDest<i>;
2062 /// red_data[i].f_comb = (void*)RedOp<i>;
2063 /// red_data[i].flags = <Flag_i>;
2064 /// ...
2065 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
2066 /// \endcode
2067 /// For reduction clause with task modifier it emits the next call:
2068 /// \code
2070 /// _taskred_item_t red_data[n];
2071 /// ...
2072 /// red_data[i].shar = &shareds[i];
2073 /// red_data[i].orig = &origs[i];
2074 /// red_data[i].size = sizeof(origs[i]);
2075 /// red_data[i].f_init = (void*)RedInit<i>;
2076 /// red_data[i].f_fini = (void*)RedDest<i>;
2077 /// red_data[i].f_comb = (void*)RedOp<i>;
2078 /// red_data[i].flags = <Flag_i>;
2079 /// ...
2080 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
2081 /// red_data);
2082 /// \endcode
2083 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
2084 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
2085 /// \param Data Additional data for task generation like tiedness, final
2086 /// state, list of privates, reductions etc.
2087 llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc,
2088 ArrayRef<const Expr *> LHSExprs,
2089 ArrayRef<const Expr *> RHSExprs,
2090 const OMPTaskDataTy &Data) override;
2092 /// Emits the following code for reduction clause with task modifier:
2093 /// \code
2094 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
2095 /// \endcode
2096 void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc,
2097 bool IsWorksharingReduction) override;
2099 /// Required to resolve existing problems in the runtime. Emits threadprivate
2100 /// variables to store the size of the VLAs/array sections for
2101 /// initializer/combiner/finalizer functions + emits threadprivate variable to
2102 /// store the pointer to the original reduction item for the custom
2103 /// initializer defined by declare reduction construct.
2104 /// \param RCG Allows to reuse an existing data for the reductions.
2105 /// \param N Reduction item for which fixups must be emitted.
2106 void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc,
2107 ReductionCodeGen &RCG, unsigned N) override;
2109 /// Get the address of `void *` type of the privatue copy of the reduction
2110 /// item specified by the \p SharedLVal.
2111 /// \param ReductionsPtr Pointer to the reduction data returned by the
2112 /// emitTaskReductionInit function.
2113 /// \param SharedLVal Address of the original reduction item.
2114 Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
2115 llvm::Value *ReductionsPtr,
2116 LValue SharedLVal) override;
2118 /// Emit code for 'taskwait' directive.
2119 void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc,
2120 const OMPTaskDataTy &Data) override;
2122 /// Emit code for 'cancellation point' construct.
2123 /// \param CancelRegion Region kind for which the cancellation point must be
2124 /// emitted.
2126 void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc,
2127 OpenMPDirectiveKind CancelRegion) override;
2129 /// Emit code for 'cancel' construct.
2130 /// \param IfCond Condition in the associated 'if' clause, if it was
2131 /// specified, nullptr otherwise.
2132 /// \param CancelRegion Region kind for which the cancel must be emitted.
2134 void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
2135 const Expr *IfCond,
2136 OpenMPDirectiveKind CancelRegion) override;
2138 /// Emit outilined function for 'target' directive.
2139 /// \param D Directive to emit.
2140 /// \param ParentName Name of the function that encloses the target region.
2141 /// \param OutlinedFn Outlined function value to be defined by this call.
2142 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2143 /// \param IsOffloadEntry True if the outlined function is an offload entry.
2144 /// \param CodeGen Code generation sequence for the \a D directive.
2145 /// An outlined function may not be an entry if, e.g. the if clause always
2146 /// evaluates to false.
2147 void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
2148 StringRef ParentName,
2149 llvm::Function *&OutlinedFn,
2150 llvm::Constant *&OutlinedFnID,
2151 bool IsOffloadEntry,
2152 const RegionCodeGenTy &CodeGen) override;
2154 /// Emit the target offloading code associated with \a D. The emitted
2155 /// code attempts offloading the execution to the device, an the event of
2156 /// a failure it executes the host version outlined in \a OutlinedFn.
2157 /// \param D Directive to emit.
2158 /// \param OutlinedFn Host version of the code to be offloaded.
2159 /// \param OutlinedFnID ID of host version of the code to be offloaded.
2160 /// \param IfCond Expression evaluated in if clause associated with the target
2161 /// directive, or null if no if clause is used.
2162 /// \param Device Expression evaluated in device clause associated with the
2163 /// target directive, or null if no device clause is used and device modifier.
2164 void emitTargetCall(
2165 CodeGenFunction &CGF, const OMPExecutableDirective &D,
2166 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
2167 llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
2168 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
2169 const OMPLoopDirective &D)>
2170 SizeEmitter) override;
2172 /// Emit the target regions enclosed in \a GD function definition or
2173 /// the function itself in case it is a valid device function. Returns true if
2174 /// \a GD was dealt with successfully.
2175 /// \param GD Function to scan.
2176 bool emitTargetFunctions(GlobalDecl GD) override;
2178 /// Emit the global variable if it is a valid device global variable.
2179 /// Returns true if \a GD was dealt with successfully.
2180 /// \param GD Variable declaration to emit.
2181 bool emitTargetGlobalVariable(GlobalDecl GD) override;
2183 /// Emit the global \a GD if it is meaningful for the target. Returns
2184 /// if it was emitted successfully.
2185 /// \param GD Global to scan.
2186 bool emitTargetGlobal(GlobalDecl GD) override;
2188 /// Emits code for teams call of the \a OutlinedFn with
2189 /// variables captured in a record which address is stored in \a
2190 /// CapturedStruct.
2191 /// \param OutlinedFn Outlined function to be run by team masters. Type of
2192 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2193 /// \param CapturedVars A pointer to the record with the references to
2194 /// variables used in \a OutlinedFn function.
2196 void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
2197 SourceLocation Loc, llvm::Function *OutlinedFn,
2198 ArrayRef<llvm::Value *> CapturedVars) override;
2200 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2201 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2202 /// for num_teams clause.
2203 /// \param NumTeams An integer expression of teams.
2204 /// \param ThreadLimit An integer expression of threads.
2205 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2206 const Expr *ThreadLimit, SourceLocation Loc) override;
2208 /// Emit the target data mapping code associated with \a D.
2209 /// \param D Directive to emit.
2210 /// \param IfCond Expression evaluated in if clause associated with the
2211 /// target directive, or null if no device clause is used.
2212 /// \param Device Expression evaluated in device clause associated with the
2213 /// target directive, or null if no device clause is used.
2214 /// \param Info A record used to store information that needs to be preserved
2215 /// until the region is closed.
2216 void emitTargetDataCalls(CodeGenFunction &CGF,
2217 const OMPExecutableDirective &D, const Expr *IfCond,
2218 const Expr *Device, const RegionCodeGenTy &CodeGen,
2219 CGOpenMPRuntime::TargetDataInfo &Info) override;
2221 /// Emit the data mapping/movement code associated with the directive
2222 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2223 /// \param D Directive to emit.
2224 /// \param IfCond Expression evaluated in if clause associated with the target
2225 /// directive, or null if no if clause is used.
2226 /// \param Device Expression evaluated in device clause associated with the
2227 /// target directive, or null if no device clause is used.
2228 void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
2229 const OMPExecutableDirective &D,
2230 const Expr *IfCond,
2231 const Expr *Device) override;
2233 /// Emit initialization for doacross loop nesting support.
2234 /// \param D Loop-based construct used in doacross nesting construct.
2235 void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
2236 ArrayRef<Expr *> NumIterations) override;
2238 /// Emit code for doacross ordered directive with 'depend' clause.
2239 /// \param C 'depend' clause with 'sink|source' dependency kind.
2240 void emitDoacrossOrdered(CodeGenFunction &CGF,
2241 const OMPDependClause *C) override;
2243 /// Translates the native parameter of outlined function if this is required
2244 /// for target.
2245 /// \param FD Field decl from captured record for the parameter.
2246 /// \param NativeParam Parameter itself.
2247 const VarDecl *translateParameter(const FieldDecl *FD,
2248 const VarDecl *NativeParam) const override;
2250 /// Gets the address of the native argument basing on the address of the
2251 /// target-specific parameter.
2252 /// \param NativeParam Parameter itself.
2253 /// \param TargetParam Corresponding target-specific parameter.
2254 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2255 const VarDecl *TargetParam) const override;
2257 /// Gets the OpenMP-specific address of the local variable.
2258 Address getAddressOfLocalVariable(CodeGenFunction &CGF,
2259 const VarDecl *VD) override {
2260 return Address::invalid();
2264 } // namespace CodeGen
2265 } // namespace clang
2267 #endif