clang 17.0.0git
CGOpenMPRuntime.h
Go to the documentation of this file.
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.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
14#define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
15
16#include "CGValue.h"
19#include "clang/AST/Type.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"
32
33namespace llvm {
34class ArrayType;
35class Constant;
36class FunctionType;
37class GlobalVariable;
38class Type;
39class Value;
40class OpenMPIRBuilder;
41} // namespace llvm
42
43namespace clang {
44class Expr;
45class OMPDependClause;
46class OMPExecutableDirective;
47class OMPLoopDirective;
48class VarDecl;
49class OMPDeclareReductionDecl;
50
51namespace CodeGen {
52class Address;
53class CodeGenFunction;
54class CodeGenModule;
55
56/// A basic class for pre|post-action for advanced codegen sequence for OpenMP
57/// region.
59public:
60 explicit PrePostActionTy() {}
61 virtual void Enter(CodeGenFunction &CGF) {}
62 virtual void Exit(CodeGenFunction &CGF) {}
63 virtual ~PrePostActionTy() {}
64};
65
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.
68class 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);
78 }
79
80public:
81 template <typename Callable>
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;
91};
92
93struct OMPTaskDataTy final {
106 struct DependData {
108 const Expr *IteratorExpr = nullptr;
110 explicit DependData() = default;
113 };
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;
124 bool HasNowaitClause = false;
125};
126
127/// Class intended to support codegen of all kind of the reduction clauses.
129private:
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) {
143 }
144 };
145 /// List of reduction-based clauses.
147
148 /// List of addresses of shared variables/expressions.
149 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
150 /// List of addresses of original variables/expressions.
152 /// Sizes of the reduction items in chars.
154 /// Base declarations for the reduction items.
156
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);
169
170public:
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.
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];
214 }
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();
226 }
227};
228
230public:
231 /// Allows to disable automatic handling of functions used in target regions
232 /// as those marked as `omp declare target`.
234 CodeGenModule &CGM;
235 bool SavedShouldMarkAsGlobal;
236
237 public:
240 };
241
242 /// Manages list of nontemporal decls for the specified directive.
244 CodeGenModule &CGM;
245 const bool NeedToPush;
246
247 public:
250 };
251
252 /// Manages list of nontemporal decls for the specified directive.
254 CodeGenModule &CGM;
255 const bool NeedToPush;
256
257 public:
259 CodeGenFunction &CGF,
260 const llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
261 std::pair<Address, Address>> &LocalVars);
263 };
264
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.
272 llvm::MapVector<CanonicalDeclPtr<const Decl>, SmallString<16>>
275 llvm::Function *Fn = nullptr;
276 bool Disabled = false;
277 };
278 /// Manages list of lastprivate conditional decls for the specified directive.
280 enum class ActionToDo {
281 DoNotPush,
282 PushAsLastprivateConditional,
283 DisableLastprivateConditional,
284 };
285 CodeGenModule &CGM;
286 ActionToDo Action = ActionToDo::DoNotPush;
287
288 /// Check and try to disable analysis of inner regions for changes in
289 /// lastprivate conditional.
290 void tryToDisableInnerAnalysis(const OMPExecutableDirective &S,
292 &NeedToAddForLPCsAsDisabled) const;
293
295 const OMPExecutableDirective &S);
296
297 public:
299 const OMPExecutableDirective &S,
300 LValue IVLVal);
302 const OMPExecutableDirective &S);
304 };
305
306 llvm::OpenMPIRBuilder &getOMPBuilder() { return OMPBuilder; }
307
308protected:
310
311 /// An OpenMP-IR-Builder instance.
312 llvm::OpenMPIRBuilder OMPBuilder;
313
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.
324 StringRef ParentName,
325 llvm::Function *&OutlinedFn,
326 llvm::Constant *&OutlinedFnID,
327 bool IsOffloadEntry,
328 const RegionCodeGenTy &CodeGen);
329
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.
333 ///
335 unsigned Flags = 0, bool EmitLoc = false);
336
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.
340 ///
341 /// Emit a team of size one for directives such as 'target parallel' that
342 /// have no associated teams construct.
343 ///
344 /// Otherwise, return nullptr.
346 const OMPExecutableDirective &D,
347 int32_t &DefaultVal);
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.
353 ///
354 /// Emit the num_threads clause for directives such as 'target parallel' that
355 /// have no associated teams construct.
356 ///
357 /// Otherwise, return nullptr.
358 const Expr *
360 const OMPExecutableDirective &D,
361 int32_t &DefaultVal);
362 llvm::Value *
364 const OMPExecutableDirective &D);
365
366 /// Returns pointer to ident_t type.
367 llvm::Type *getIdentTyPointerTy();
368
369 /// Gets thread id value for the current thread.
370 ///
371 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
372
373 /// Get the function name of an outlined region.
374 std::string getOutlinedHelperName(StringRef Name) const;
375 std::string getOutlinedHelperName(CodeGenFunction &CGF) const;
376
377 /// Get the function name of a reduction function.
378 std::string getReductionFuncName(StringRef Name) const;
379
380 /// Emits \p Callee function call with arguments \p Args with location \p Loc.
382 llvm::FunctionCallee Callee,
383 ArrayRef<llvm::Value *> Args = std::nullopt) const;
384
385 /// Emits address of the word in a memory where current thread id is
386 /// stored.
388
390 bool AtCurrentPoint = false);
392
393 /// Check if the default location must be constant.
394 /// Default is false to support OMPT/OMPD.
395 virtual bool isDefaultLocationConstant() const { return false; }
396
397 /// Returns additional flags that can be stored in reserved_2 field of the
398 /// default location.
399 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
400
401 /// Returns default flags for the barriers depending on the directive, for
402 /// which this barier is going to be emitted.
404
405 /// Get the LLVM type for the critical name.
406 llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
407
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.
412 ///
413 llvm::Value *getCriticalRegionLock(StringRef CriticalName);
414
415protected:
416 /// Map for SourceLocation and OpenMP runtime library debug locations.
417 typedef llvm::DenseMap<SourceLocation, llvm::Value *> OpenMPDebugLocMapTy;
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.
425 llvm::Value *DebugLoc;
426 llvm::Value *ThreadID;
427 /// Insert point for the service instructions.
428 llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
429 };
430 /// Map of local debug location, ThreadId and functions.
431 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
434 /// Map of UDRs and corresponding combiner/initializer.
435 typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
436 std::pair<llvm::Function *, llvm::Function *>>
439 /// Map of functions and locally defined UDRs.
440 typedef llvm::DenseMap<llvm::Function *,
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.
449 llvm::DenseMap<llvm::Function *,
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>>>
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;
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;
484 /// Saved kmp_task_t for task directive.
486 /// Saved kmp_task_t for taskloop-based directive.
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;
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;
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 /// };
513
515 /// List of the emitted declarations.
517 /// List of the global variables with their addresses that should not be
518 /// emitted for the target.
519 llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
520
521 /// List of variables that can become declare target implicitly and, thus,
522 /// must be emitted.
523 llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
524
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.
529
531 llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
532 std::pair<Address, Address>>;
534
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.
539
540 /// Flag for keeping track of weather a requires unified_shared_memory
541 /// directive is present.
543
544 /// Atomic ordering from the omp requires directive.
545 llvm::AtomicOrdering RequiresAtomicOrdering = llvm::AtomicOrdering::Monotonic;
546
547 /// Flag for keeping track of weather a target region has been emitted.
549
550 /// Flag for keeping track of weather a device routine has been emitted.
551 /// Device routines are specific to the
553
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);
559
560 /// Build type kmp_routine_entry_t (if not built yet).
561 void emitKmpRoutineEntryT(QualType KmpInt32Ty);
562
563 /// Returns pointer to kmpc_micro type.
564 llvm::Type *getKmpc_MicroPointerTy();
565
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);
572
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);
577
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);
582
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);
587
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);
594
595 /// Set of threadprivate variables with the generated initializer.
597
598 /// Set of declare target variables with the generated initializer.
600
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.
608 llvm::Value *Ctor, llvm::Value *CopyCtor,
609 llvm::Value *Dtor, SourceLocation Loc);
610
611 /// Emit the array initialization or deletion portion for user-defined mapper
612 /// code generation.
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);
619
621 llvm::Value *NewTask = nullptr;
622 llvm::Function *TaskEntry = nullptr;
623 llvm::Value *NewTaskNewTaskTTy = nullptr;
625 const RecordDecl *KmpTaskTQTyRD = nullptr;
626 llvm::Value *TaskDupFn = nullptr;
627 };
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.
651 const OMPExecutableDirective &D,
652 llvm::Function *TaskFunction, QualType SharedsTy,
653 Address Shareds, const OMPTaskDataTy &Data);
654
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(
660 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
661 const OMPLoopDirective &D)>
662 SizeEmitter);
663
664 /// Emit update for lastprivate conditional data.
666 StringRef UniqueDeclName, LValue LVal,
667 SourceLocation Loc);
668
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);
676
680
682 LValue PosLVal, const OMPTaskDataTy::DependData &Data,
683 Address DependenciesArray);
684
685public:
687 virtual ~CGOpenMPRuntime() {}
688 virtual void clear();
689
690 /// Returns true if the current target is a GPU.
691 virtual bool isTargetCodegen() const { return false; }
692
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);
703
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);
708
709 /// Get the platform-specific name separator.
710 std::string getName(ArrayRef<StringRef> Parts) const;
711
712 /// Emit code for the specified user defined reduction construct.
714 const OMPDeclareReductionDecl *D);
715 /// Get combiner/initializer for the specified user-defined reduction, if any.
716 virtual std::pair<llvm::Function *, llvm::Function *>
718
719 /// Emit the function for the user defined mapper construct.
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 *
726
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(
738 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
739 const RegionCodeGenTy &CodeGen);
740
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(
752 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
753 const RegionCodeGenTy &CodeGen);
754
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.
769 ///
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);
775
776 /// Cleans up references to the objects in finished function.
777 ///
778 virtual void functionFinished(CodeGenFunction &CGF);
779
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.
791 ///
792 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
793 llvm::Function *OutlinedFn,
794 ArrayRef<llvm::Value *> CapturedVars,
795 const Expr *IfCond, llvm::Value *NumThreads);
796
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);
806
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);
813
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);
821
822 /// Emits code for a taskyield directive.
823 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
824
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);
829
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);
836
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);
847
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);
854
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).
862 ///
863 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
865 bool EmitChecks = true,
866 bool ForceSimpleCall = false);
867
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.
872 ///
873 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
874 bool Chunked) const;
875
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.
880 ///
881 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
882 bool Chunked) const;
883
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.
887 ///
888 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
889 bool Chunked) const;
890
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.
894 ///
895 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
896 bool Chunked) const;
897
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.
901 ///
902 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
903
904 /// struct with the values to be passed to the dispatch runtime function
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) {}
916 };
917
918 /// Call the appropriate runtime routine to initialize it before start
919 /// of loop.
920
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.
926 ///
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.
936 ///
938 const OpenMPScheduleTy &ScheduleKind,
939 unsigned IVSize, bool IVSigned, bool Ordered,
940 const DispatchRTInput &DispatchValues);
941
942 /// Struct with the values to be passed to the static runtime function
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.
953 /// Address of the output variable in which the lower iteration number is
954 /// returned.
956 /// Address of the output variable in which the upper iteration number is
957 /// returned.
959 /// Address of the output variable in which the stride value is returned
960 /// necessary to generated the static_chunked scheduled loop.
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;
967 llvm::Value *Chunk = nullptr)
969 UB(UB), ST(ST), Chunk(Chunk) {}
970 };
971 /// Call the appropriate runtime routine to initialize it before start
972 /// of loop.
973 ///
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.
979 ///
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.
985 ///
986 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
988 const OpenMPScheduleTy &ScheduleKind,
989 const StaticRTInput &Values);
990
991 ///
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.
996 ///
998 SourceLocation Loc,
1000 const StaticRTInput &Values);
1001
1002 /// Call the appropriate runtime routine to notify that we finished
1003 /// iteration of the ordered loop with the dynamic scheduling.
1004 ///
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.
1009 ///
1011 SourceLocation Loc, unsigned IVSize,
1012 bool IVSigned);
1013
1014 /// Call the appropriate runtime routine to notify that we finished
1015 /// all the work with current loop.
1016 ///
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.
1020 ///
1021 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1022 OpenMPDirectiveKind DKind);
1023
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);
1042
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);
1050
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);
1056
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.
1064 const VarDecl *VD,
1065 Address VDAddr,
1066 SourceLocation Loc);
1067
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);
1071
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 *
1082 SourceLocation Loc, bool PerformInit,
1083 CodeGenFunction *CGF = nullptr);
1084
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);
1092
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.
1098 QualType VarType,
1099 StringRef Name);
1100
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);
1105
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);
1138
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);
1173
1174 /// Emit code for the directive that does not require outlining.
1175 ///
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);
1185
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,
1197 ArrayRef<const Expr *> RHSExprs, ArrayRef<const Expr *> ReductionOps);
1198
1199 /// Emits single reduction combiner
1201 const Expr *ReductionOp,
1202 const Expr *PrivateRef,
1203 const DeclRefExpr *LHS,
1204 const DeclRefExpr *RHS);
1205
1210 };
1211 /// Emit a code for reduction clause. Next code should be emitted for
1212 /// reduction:
1213 /// \code
1214 ///
1215 /// static kmp_critical_name lock = { 0 };
1216 ///
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 /// }
1222 ///
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
1241 ///
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);
1259
1260 /// Emit a code for initialization of task reduction clause. Next code
1261 /// should be emitted for reduction:
1262 /// \code
1263 ///
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
1278 ///
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);
1301
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
1307 bool IsWorksharingReduction);
1308
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.
1315 ReductionCodeGen &RCG, unsigned N);
1316
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.
1323 llvm::Value *ReductionsPtr,
1324 LValue SharedLVal);
1325
1326 /// Emit code for 'taskwait' directive.
1327 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc,
1328 const OMPTaskDataTy &Data);
1329
1330 /// Emit code for 'cancellation point' construct.
1331 /// \param CancelRegion Region kind for which the cancellation point must be
1332 /// emitted.
1333 ///
1335 SourceLocation Loc,
1336 OpenMPDirectiveKind CancelRegion);
1337
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.
1342 ///
1343 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1344 const Expr *IfCond,
1345 OpenMPDirectiveKind CancelRegion);
1346
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.
1357 StringRef ParentName,
1358 llvm::Function *&OutlinedFn,
1359 llvm::Constant *&OutlinedFnID,
1360 bool IsOffloadEntry,
1361 const RegionCodeGenTy &CodeGen);
1362
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(
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);
1382
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);
1388
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);
1393
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);
1398
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);
1403
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();
1407
1408 /// Creates all the offload entries in the current compilation unit
1409 /// along with the associated metadata.
1411
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.
1419 ///
1420 virtual void emitTeamsCall(CodeGenFunction &CGF,
1421 const OMPExecutableDirective &D,
1422 SourceLocation Loc, llvm::Function *OutlinedFn,
1423 ArrayRef<llvm::Value *> CapturedVars);
1424
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);
1432
1433 /// Struct that keeps all the relevant information that should be kept
1434 /// throughout a 'target data' region.
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;
1445 };
1446
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,
1460
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.
1469 const OMPExecutableDirective &D,
1470 const Expr *IfCond,
1471 const Expr *Device);
1472
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);
1479
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);
1484
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);
1489
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;
1497 }
1498
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.
1504 const VarDecl *NativeParam,
1505 const VarDecl *TargetParam) const;
1506
1507 /// Choose default schedule type and chunk value for the
1508 /// dist_schedule clause.
1510 const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1511 llvm::Value *&Chunk) const {}
1512
1513 /// Choose default schedule type and chunk value for the
1514 /// schedule clause.
1516 const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1517 const Expr *&ChunkExpr) const;
1518
1519 /// Emits call of the outlined function with the provided arguments,
1520 /// translating these arguments to correct target-specific arguments.
1521 virtual void
1523 llvm::FunctionCallee OutlinedFn,
1524 ArrayRef<llvm::Value *> Args = std::nullopt) const;
1525
1526 /// Emits OpenMP-specific function prolog.
1527 /// Required for device constructs.
1528 virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D);
1529
1530 /// Gets the OpenMP-specific address of the local variable.
1532 const VarDecl *VD);
1533
1534 /// Marks the declaration as already emitted for the device code and returns
1535 /// true, if it was marked already, and false, otherwise.
1537
1538 /// Emit deferred declare target variables marked for deferred emission.
1539 void emitDeferredTargetDecls() const;
1540
1541 /// Adjust some parameters for the target-based directives, like addresses of
1542 /// the variables captured by reference in lambdas.
1543 virtual void
1545 const OMPExecutableDirective &D) const;
1546
1547 /// Perform check on requires decl to ensure that target architecture
1548 /// supports unified addressing
1549 virtual void processRequiresDirective(const OMPRequiresDecl *D);
1550
1551 /// Gets default memory ordering as specified in requires directive.
1552 llvm::AtomicOrdering getDefaultMemoryOrdering() const;
1553
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);
1558
1559 /// Return whether the unified_shared_memory has been specified.
1560 bool hasRequiresUnifiedSharedMemory() const;
1561
1562 /// Checks if the \p VD variable is marked as nontemporal declaration in
1563 /// current context.
1564 bool isNontemporalDecl(const ValueDecl *VD) const;
1565
1566 /// Create specialized alloca to handle lastprivate conditionals.
1568 const VarDecl *VD);
1569
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
1584 const Expr *LHS);
1585
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
1608 const llvm::DenseSet<CanonicalDeclPtr<const VarDecl>> &IgnoredDecls);
1609
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.
1615 LValue PrivLVal,
1616 const VarDecl *VD,
1617 SourceLocation Loc);
1618
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>
1625 SourceLocation Loc);
1626
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.
1632 const OMPTaskDataTy::DependData &Dependencies,
1633 SourceLocation Loc);
1634
1635 /// Emits the code to destroy the dependency object provided in depobj
1636 /// directive.
1637 void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal,
1638 SourceLocation Loc);
1639
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);
1645
1646 /// Initializes user defined allocators specified in the uses_allocators
1647 /// clauses.
1648 void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator,
1649 const Expr *AllocatorTraits);
1650
1651 /// Destroys user defined allocators specified in the uses_allocators clause.
1652 void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator);
1653
1654 /// Returns true if the variable is a local variable in untied task.
1655 bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const;
1656};
1657
1658/// Class supports emissionof SIMD-only code.
1660public:
1663
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(
1675 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1676 const RegionCodeGenTy &CodeGen) override;
1677
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(
1689 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1690 const RegionCodeGenTy &CodeGen) override;
1691
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.
1706 ///
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;
1712
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.
1724 ///
1726 llvm::Function *OutlinedFn,
1727 ArrayRef<llvm::Value *> CapturedVars,
1728 const Expr *IfCond, llvm::Value *NumThreads) override;
1729
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;
1739
1740 /// Emits a master region.
1741 /// \param MasterOpGen Generator for the statement associated with the given
1742 /// master region.
1744 const RegionCodeGenTy &MasterOpGen,
1745 SourceLocation Loc) override;
1746
1747 /// Emits a masked region.
1748 /// \param MaskedOpGen Generator for the statement associated with the given
1749 /// masked region.
1751 const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc,
1752 const Expr *Filter = nullptr) override;
1753
1754 /// Emits a masked region.
1755 /// \param MaskedOpGen Generator for the statement associated with the given
1756 /// masked region.
1757
1758 /// Emits code for a taskyield directive.
1759 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
1760
1761 /// Emit a taskgroup region.
1762 /// \param TaskgroupOpGen Generator for the statement associated with the
1763 /// given taskgroup region.
1765 const RegionCodeGenTy &TaskgroupOpGen,
1766 SourceLocation Loc) override;
1767
1768 /// Emits a single region.
1769 /// \param SingleOpGen Generator for the statement associated with the given
1770 /// single region.
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;
1777
1778 /// Emit an ordered region.
1779 /// \param OrderedOpGen Generator for the statement associated with the given
1780 /// ordered region.
1782 const RegionCodeGenTy &OrderedOpGen,
1783 SourceLocation Loc, bool IsThreads) override;
1784
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).
1792 ///
1794 OpenMPDirectiveKind Kind, bool EmitChecks = true,
1795 bool ForceSimpleCall = false) override;
1796
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.
1802 ///
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.
1812 ///
1814 const OpenMPScheduleTy &ScheduleKind,
1815 unsigned IVSize, bool IVSigned, bool Ordered,
1816 const DispatchRTInput &DispatchValues) override;
1817
1818 /// Call the appropriate runtime routine to initialize it before start
1819 /// of loop.
1820 ///
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.
1826 ///
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.
1832 ///
1834 OpenMPDirectiveKind DKind,
1835 const OpenMPScheduleTy &ScheduleKind,
1836 const StaticRTInput &Values) override;
1837
1838 ///
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.
1843 ///
1846 const StaticRTInput &Values) override;
1847
1848 /// Call the appropriate runtime routine to notify that we finished
1849 /// iteration of the ordered loop with the dynamic scheduling.
1850 ///
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.
1855 ///
1857 unsigned IVSize, bool IVSigned) override;
1858
1859 /// Call the appropriate runtime routine to notify that we finished
1860 /// all the work with current loop.
1861 ///
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.
1865 ///
1867 OpenMPDirectiveKind DKind) override;
1868
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;
1886
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;
1893
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.
1897 llvm::omp::ProcBindKind ProcBind,
1898 SourceLocation Loc) override;
1899
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.
1907 Address VDAddr, SourceLocation Loc) override;
1908
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 *
1919 SourceLocation Loc, bool PerformInit,
1920 CodeGenFunction *CGF = nullptr) override;
1921
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.
1927 QualType VarType,
1928 StringRef Name) override;
1929
1930 /// Emit flush of the variables specified in 'omp flush' directive.
1931 /// \param Vars List of variables to flush.
1933 SourceLocation Loc, llvm::AtomicOrdering AO) override;
1934
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.
1963 const OMPExecutableDirective &D,
1964 llvm::Function *TaskFunction, QualType SharedsTy,
1965 Address Shareds, const Expr *IfCond,
1966 const OMPTaskDataTy &Data) override;
1967
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.
1998 const OMPLoopDirective &D, llvm::Function *TaskFunction,
1999 QualType SharedsTy, Address Shareds, const Expr *IfCond,
2000 const OMPTaskDataTy &Data) override;
2001
2002 /// Emit a code for reduction clause. Next code should be emitted for
2003 /// reduction:
2004 /// \code
2005 ///
2006 /// static kmp_critical_name lock = { 0 };
2007 ///
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 /// }
2013 ///
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
2032 ///
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.
2045 ArrayRef<const Expr *> Privates,
2046 ArrayRef<const Expr *> LHSExprs,
2047 ArrayRef<const Expr *> RHSExprs,
2048 ArrayRef<const Expr *> ReductionOps,
2049 ReductionOptionsTy Options) override;
2050
2051 /// Emit a code for initialization of task reduction clause. Next code
2052 /// should be emitted for reduction:
2053 /// \code
2054 ///
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
2069 ///
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.
2088 ArrayRef<const Expr *> LHSExprs,
2089 ArrayRef<const Expr *> RHSExprs,
2090 const OMPTaskDataTy &Data) override;
2091
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
2097 bool IsWorksharingReduction) override;
2098
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.
2107 ReductionCodeGen &RCG, unsigned N) override;
2108
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.
2115 llvm::Value *ReductionsPtr,
2116 LValue SharedLVal) override;
2117
2118 /// Emit code for 'taskwait' directive.
2120 const OMPTaskDataTy &Data) override;
2121
2122 /// Emit code for 'cancellation point' construct.
2123 /// \param CancelRegion Region kind for which the cancellation point must be
2124 /// emitted.
2125 ///
2127 OpenMPDirectiveKind CancelRegion) override;
2128
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.
2133 ///
2135 const Expr *IfCond,
2136 OpenMPDirectiveKind CancelRegion) override;
2137
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.
2148 StringRef ParentName,
2149 llvm::Function *&OutlinedFn,
2150 llvm::Constant *&OutlinedFnID,
2151 bool IsOffloadEntry,
2152 const RegionCodeGenTy &CodeGen) override;
2153
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(
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;
2171
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;
2177
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;
2182
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;
2187
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.
2195 ///
2197 SourceLocation Loc, llvm::Function *OutlinedFn,
2198 ArrayRef<llvm::Value *> CapturedVars) override;
2199
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;
2207
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.
2217 const OMPExecutableDirective &D, const Expr *IfCond,
2218 const Expr *Device, const RegionCodeGenTy &CodeGen,
2219 CGOpenMPRuntime::TargetDataInfo &Info) override;
2220
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.
2229 const OMPExecutableDirective &D,
2230 const Expr *IfCond,
2231 const Expr *Device) override;
2232
2233 /// Emit initialization for doacross loop nesting support.
2234 /// \param D Loop-based construct used in doacross nesting construct.
2236 ArrayRef<Expr *> NumIterations) override;
2237
2238 /// Emit code for doacross ordered directive with 'depend' clause.
2239 /// \param C 'depend' clause with 'sink|source' dependency kind.
2241 const OMPDependClause *C) override;
2242
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;
2249
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;
2256
2257 /// Gets the OpenMP-specific address of the local variable.
2259 const VarDecl *VD) override {
2260 return Address::invalid();
2261 }
2262};
2263
2264} // namespace CodeGen
2265} // namespace clang
2266
2267#endif
MatchType Type
This file defines OpenMP nodes for declarative directives.
Defines some OpenMP-specific enums and functions.
Defines the clang::SourceLocation class and associated facilities.
const char * Data
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
A wrapper class around a pointer that always points to its canonical declaration.
Definition: Redeclarable.h:349
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
An aligned address.
Definition: Address.h:29
static Address invalid()
Definition: Address.h:49
Allows to disable automatic handling of functions used in target regions as those marked as omp decla...
Manages list of lastprivate conditional decls for the specified directive.
static LastprivateConditionalRAII disable(CodeGenFunction &CGF, const OMPExecutableDirective &S)
Manages list of nontemporal decls for the specified directive.
Struct that keeps all the relevant information that should be kept throughout a 'target data' region.
TargetDataInfo(bool RequiresDevicePointerInfo, bool SeparateBeginEndCalls)
llvm::DenseMap< const ValueDecl *, Address > CaptureDeviceAddrMap
Map between the a declaration of a capture and the corresponding base pointer address where the runti...
Manages list of nontemporal decls for the specified directive.
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
llvm::FunctionType * Kmpc_MicroTy
The type for a microtask which gets passed to __kmpc_fork_call().
llvm::StringSet ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the task directive.
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata.
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST)
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
bool markAsGlobalTarget(GlobalDecl GD)
Marks the declaration as already emitted for the device code and returns true, if it was marked alrea...
llvm::FunctionCallee createDispatchInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_init_* runtime function for the specified size IVSize and sign IVSigned.
virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device)
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
virtual void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc)
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
QualType SavedKmpTaskloopTQTy
Saved kmp_task_t for taskloop-based directive.
virtual void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps)
Emits a single region.
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
void setLocThreadIdInsertPt(CodeGenFunction &CGF, bool AtCurrentPoint=false)
std::string getOutlinedHelperName(StringRef Name) const
Get the function name of an outlined region.
bool HasEmittedDeclareTargetRegion
Flag for keeping track of weather a device routine has been emitted.
llvm::Constant * getOrCreateThreadPrivateCache(const VarDecl *VD)
If the specified mangled name is not in the module, create and return threadprivate cache object.
virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal)
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind, const Expr *&ChunkExpr) const
Choose default schedule type and chunk value for the schedule clause.
virtual std::pair< llvm::Function *, llvm::Function * > getUserDefinedReduction(const OMPDeclareReductionDecl *D)
Get combiner/initializer for the specified user-defined reduction, if any.
static const Stmt * getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body)
Checks if the Body is the CompoundStmt and returns its child statement iff there is only one that is ...
llvm::FunctionCallee createDispatchFiniFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_fini_* runtime function for the specified size IVSize and sign IVSigned.
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
bool HasRequiresUnifiedSharedMemory
Flag for keeping track of weather a requires unified_shared_memory directive is present.
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags=0, bool EmitLoc=false)
Emits object of ident_t type with info for source location.
bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const
Returns true if the variable is a local variable in untied task.
virtual void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars)
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
void emitUDMapperArrayInitOrDel(CodeGenFunction &MapperCGF, llvm::Value *Handle, llvm::Value *BasePtr, llvm::Value *Ptr, llvm::Value *Size, llvm::Value *MapType, llvm::Value *MapName, CharUnits ElementSize, llvm::BasicBlock *ExitBB, bool IsInit)
Emit the array initialization or deletion portion for user-defined mapper code generation.
virtual const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const
Translates the native parameter of outlined function if this is required for target.
virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
llvm::DenseMap< llvm::Function *, SmallVector< const OMPDeclareReductionDecl *, 4 > > FunctionUDRMapTy
Map of functions and locally defined UDRs.
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
virtual bool isDefaultLocationConstant() const
Check if the default location must be constant.
llvm::MapVector< CanonicalDeclPtr< const VarDecl >, std::pair< Address, Address > > UntiedLocalVarsAddressesMap
llvm::Function * getOrCreateUserDefinedMapperFunc(const OMPDeclareMapperDecl *D)
Get the function for the specified user-defined mapper.
OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap
virtual void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
void emitCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args=std::nullopt) const
Emits Callee function call with arguments Args with location Loc.
virtual llvm::Function * emitTeamsOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP teams directive D.
llvm::DenseMap< llvm::Function *, DebugLocThreadIdTy > OpenMPLocThreadIDMapTy
Map of local debug location, ThreadId and functions.
QualType KmpTaskTQTy
Type typedef struct kmp_task { void * shareds; /‍**< pointer to block of pointers to shared vars ‍/ k...
llvm::OpenMPIRBuilder OMPBuilder
An OpenMP-IR-Builder instance.
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations)
Emit initialization for doacross loop nesting support.
virtual void adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF, const OMPExecutableDirective &D) const
Adjust some parameters for the target-based directives, like addresses of the variables captured by r...
virtual void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, CGOpenMPRuntime::TargetDataInfo &Info)
Emit the target data mapping code associated with D.
virtual unsigned getDefaultLocationReserved2Flags() const
Returns additional flags that can be stored in reserved_2 field of the default location.
virtual Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const
Gets the address of the native argument basing on the address of the target-specific parameter.
void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator)
Destroys user defined allocators specified in the uses_allocators clause.
QualType KmpTaskAffinityInfoTy
Type typedef struct kmp_task_affinity_info { kmp_intptr_t base_addr; size_t len; struct { bool flag1 ...
llvm::SmallVector< NontemporalDeclsSet, 4 > NontemporalDeclsStack
Stack for list of declarations in current context marked as nontemporal.
llvm::Value * emitNumTeamsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Helper to emit outlined function for 'target' directive.
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and emit all target regions found along the way.
const Expr * getNumTeamsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &DefaultVal)
Emit the number of teams for a target directive.
SmallVector< llvm::Value *, 4 > emitDepobjElementsSizes(CodeGenFunction &CGF, QualType &KmpDependInfoTy, const OMPTaskDataTy::DependData &Data)
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
llvm::DenseMap< llvm::Function *, SmallVector< const OMPDeclareMapperDecl *, 4 > > FunctionUDMMapTy
Map of functions and their local user-defined mappers.
llvm::DenseMap< llvm::Function *, llvm::DenseMap< CanonicalDeclPtr< const Decl >, std::tuple< QualType, const FieldDecl *, const FieldDecl *, LValue > > > LastprivateConditionalToTypes
Maps local variables marked as lastprivate conditional to their internal types.
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc)
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams,...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name)
Creates artificial threadprivate variable with name Name and type VarType.
void emitUserDefinedMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit the function for the user defined mapper construct.
llvm::DenseMap< SourceLocation, llvm::Value * > OpenMPDebugLocMapTy
Map for SourceLocation and OpenMP runtime library debug locations.
bool HasEmittedTargetRegion
Flag for keeping track of weather a target region has been emitted.
void emitDepobjElements(CodeGenFunction &CGF, QualType &KmpDependInfoTy, LValue PosLVal, const OMPTaskDataTy::DependData &Data, Address DependenciesArray)
std::string getReductionFuncName(StringRef Name) const
Get the function name of a reduction function.
virtual void processRequiresDirective(const OMPRequiresDecl *D)
Perform check on requires decl to ensure that target architecture supports unified addressing.
llvm::DenseSet< CanonicalDeclPtr< const Decl > > AlreadyEmittedTargetDecls
List of the emitted declarations.
virtual llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data)
Emit a code for initialization of task reduction clause.
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal, OpenMPDependClauseKind NewDepKind, SourceLocation Loc)
Updates the dependency kind in the specified depobj object.
virtual void emitLastprivateConditionalFinalUpdate(CodeGenFunction &CGF, LValue PrivLVal, const VarDecl *VD, SourceLocation Loc)
Gets the address of the global copy used for lastprivate conditional update, if any.
virtual void emitErrorCall(CodeGenFunction &CGF, SourceLocation Loc, Expr *ME, bool IsFatal)
Emit __kmpc_error call for error directive extern void __kmpc_error(ident_t *loc, int severity,...
void clearLocThreadIdInsertPt(CodeGenFunction &CGF)
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Addr, bool PerformInit)
Emit a code for initialization of declare target variable.
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO)
Emit flush of the variables specified in 'omp flush' directive.
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data)
Emit code for 'taskwait' directive.
virtual void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc)
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
void emitLastprivateConditionalUpdate(CodeGenFunction &CGF, LValue IVLVal, StringRef UniqueDeclName, LValue LVal, SourceLocation Loc)
Emit update for lastprivate conditional data.
virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the taskloop directive.
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind)
Returns default flags for the barriers depending on the directive, for which this barier is going to ...
llvm::FunctionCallee createDispatchNextFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_next_* runtime function for the specified size IVSize and sign IVSigned.
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
llvm::FunctionCallee createForStaticInitFunction(unsigned IVSize, bool IVSigned, bool IsGPUDistribute)
Returns __kmpc_for_static_init_* runtime function for the specified size IVSize and sign IVSigned.
TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const OMPTaskDataTy &Data)
Emit task region for the task directive.
llvm::Value * emitTargetNumIterationsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter)
Return the trip count of loops associated with constructs / 'target teams distribute' and 'teams dist...
llvm::StringMap< llvm::AssertingVH< llvm::GlobalVariable >, llvm::BumpPtrAllocator > InternalVars
An ordered map of auto-generated variables to their unique names.
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values)
llvm::SmallVector< UntiedLocalVarsAddressesMap, 4 > UntiedLocalVarsStack
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind)
Call the appropriate runtime routine to notify that we finished all the work with current loop.
void emitIfClause(CodeGenFunction &CGF, const Expr *Cond, const RegionCodeGenTy &ThenGen, const RegionCodeGenTy &ElseGen)
Emits code for OpenMP 'if' clause using specified CodeGen function.
Address emitDepobjDependClause(CodeGenFunction &CGF, const OMPTaskDataTy::DependData &Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs) for depob...
bool isNontemporalDecl(const ValueDecl *VD) const
Checks if the VD variable is marked as nontemporal declaration in current context.
virtual llvm::Function * emitParallelOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP parallel directive D.
llvm::SmallVector< LastprivateConditionalData, 4 > LastprivateConditionalStack
Stack for list of addresses of declarations in current context marked as lastprivate conditional.
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values)
Call the appropriate runtime routine to initialize it before start of loop.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
llvm::AtomicOrdering getDefaultMemoryOrdering() const
Gets default memory ordering as specified in requires directive.
llvm::SmallDenseSet< CanonicalDeclPtr< const Decl > > NontemporalDeclsSet
llvm::StringSet DeclareTargetWithDefinition
Set of declare target variables with the generated initializer.
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
QualType SavedKmpTaskTQTy
Saved kmp_task_t for task directive.
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
virtual llvm::Function * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts)
Emits outlined function for the OpenMP task directive D.
OpenMPDebugLocMapTy OpenMPDebugLocMap
llvm::DenseMap< llvm::Function *, unsigned > FunctionToUntiedTaskStackMap
Maps function to the position of the untied task locals stack.
void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal, SourceLocation Loc)
Emits the code to destroy the dependency object provided in depobj directive.
virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N)
Required to resolve existing problems in the runtime.
llvm::ArrayType * KmpCriticalNameTy
Type kmp_critical_name, originally defined as typedef kmp_int32 kmp_critical_name[8];.
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with 'depend' clause.
llvm::DenseMap< const OMPDeclareMapperDecl *, llvm::Function * > UDMMap
Map from the user-defined mapper declaration to its corresponding functions.
virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF, const Expr *LHS)
Checks if the provided LVal is lastprivate conditional and emits the code to update the value of the ...
std::pair< llvm::Value *, LValue > getDepobjElements(CodeGenFunction &CGF, LValue DepobjLVal, SourceLocation Loc)
Returns the number of the elements and the address of the depobj dependency array.
llvm::SmallDenseSet< const VarDecl * > DeferredGlobalVariables
List of variables that can become declare target implicitly and, thus, must be emitted.
void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator, const Expr *AllocatorTraits)
Initializes user defined allocators specified in the uses_allocators clauses.
virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind, llvm::Value *&Chunk) const
Choose default schedule type and chunk value for the dist_schedule clause.
llvm::DenseMap< const OMPDeclareReductionDecl *, std::pair< llvm::Function *, llvm::Function * > > UDRMapTy
Map of UDRs and corresponding combiner/initializer.
llvm::Type * KmpRoutineEntryPtrTy
Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);.
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
void emitSingleReductionCombiner(CodeGenFunction &CGF, const Expr *ReductionOp, const Expr *PrivateRef, const DeclRefExpr *LHS, const DeclRefExpr *RHS)
Emits single reduction combiner.
virtual bool isTargetCodegen() const
Returns true if the current target is a GPU.
llvm::OpenMPIRBuilder & getOMPBuilder()
llvm::Function * emitRequiresDirectiveRegFun()
Creates and returns a registration function for when at least one requires directives was used in the...
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for 'target' directive.
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned)
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
llvm::Value * emitNumThreadsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr, llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc)
Emits initialization code for the threadprivate variables.
virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)
Emit code for the specified user defined reduction construct.
virtual void checkAndEmitSharedLastprivateConditional(CodeGenFunction &CGF, const OMPExecutableDirective &D, const llvm::DenseSet< CanonicalDeclPtr< const VarDecl > > &IgnoredDecls)
Checks if the lastprivate conditional was updated in inner region and writes the value.
QualType KmpDimTy
struct kmp_dim { // loop bounds info casted to kmp_int64 kmp_int64 lo; // lower kmp_int64 up; // uppe...
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D)
Emits OpenMP-specific function prolog.
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static chunked.
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter)
Emit the target offloading code associated with D.
virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS)
Checks if the variable has associated OMPAllocateDeclAttr attribute with the predefined allocator and...
llvm::AtomicOrdering RequiresAtomicOrdering
Atomic ordering from the omp requires directive.
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options)
Emit a code for reduction clause.
std::pair< llvm::Value *, Address > emitDependClause(CodeGenFunction &CGF, ArrayRef< OMPTaskDataTy::DependData > Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs).
llvm::StringMap< llvm::WeakTrackingVH > EmittedNonTargetVariables
List of the global variables with their addresses that should not be emitted for the target.
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
const Expr * getNumThreadsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &DefaultVal)
Emit the number of threads for a target directive.
Address emitLastprivateConditionalInit(CodeGenFunction &CGF, const VarDecl *VD)
Create specialized alloca to handle lastprivate conditionals.
llvm::ArrayType * getKmpCriticalNameTy() const
Get the LLVM type for the critical name.
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
virtual void emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::FunctionCallee OutlinedFn, ArrayRef< llvm::Value * > Args=std::nullopt) const
Emits call of the outlined function with the provided arguments, translating these arguments to corre...
virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)
Gets the OpenMP-specific address of the local variable.
virtual void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction)
Emits the following code for reduction clause with task modifier:
virtual void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr)
Emits a masked region.
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
llvm::Function * emitReductionFunction(StringRef ReducerName, SourceLocation Loc, llvm::Type *ArgsElemType, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps)
Emits reduction function.
virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues)
Call the appropriate runtime routine to initialize it before start of loop.
Class supports emissionof SIMD-only code.
Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal) override
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr) override
Emits a critical region.
void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values) override
void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values) override
Call the appropriate runtime routine to initialize it before start of loop.
bool emitTargetGlobalVariable(GlobalDecl GD) override
Emit the global variable if it is a valid device global variable.
llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST) override
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr) override
Emit a code for initialization of threadprivate variable.
void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device) override
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
llvm::Function * emitTeamsOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP teams directive D.
void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options) override
Emit a code for reduction clause.
void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO) override
Emit flush of the variables specified in 'omp flush' directive.
void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C) override
Emit code for doacross ordered directive with 'depend' clause.
void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override
Emits a masked region.
Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name) override
Creates artificial threadprivate variable with name Name and type VarType.
Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc) override
Returns address of the threadprivate variable for the current thread.
void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps) override
Emits a single region.
void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N) override
Required to resolve existing problems in the runtime.
llvm::Function * emitParallelOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP parallel directive D.
void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancellation point' construct.
void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false) override
Emit an implicit/explicit barrier for OpenMP threads.
Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD) override
Gets the OpenMP-specific address of the local variable.
Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const override
Gets the address of the native argument basing on the address of the target-specific parameter.
void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars) override
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned) override
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
bool emitTargetGlobal(GlobalDecl GD) override
Emit the global GD if it is meaningful for the target.
void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction) override
Emits the following code for reduction clause with task modifier:
void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads) override
Emit an ordered region.
void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind) override
Call the appropriate runtime routine to notify that we finished all the work with current loop.
llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data) override
Emit a code for initialization of task reduction clause.
void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads) override
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc) override
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) override
Emit outilined function for 'target' directive.
void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc) override
Emits a master region.
void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams,...
const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const override
Translates the native parameter of outlined function if this is required for target.
void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr) override
Emits a masked region.
void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the task directive.
void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter) override
Emit the target offloading code associated with D.
bool emitTargetFunctions(GlobalDecl GD) override
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc) override
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations) override
Emit initialization for doacross loop nesting support.
void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancel' construct.
void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data) override
Emit code for 'taskwait' directive.
void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc) override
Emit a taskgroup region.
void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, CGOpenMPRuntime::TargetDataInfo &Info) override
Emit the target data mapping code associated with D.
void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues) override
This is used for non static scheduled types and when the ordered clause is present on the loop constr...
llvm::Function * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts) override
Emits outlined function for the OpenMP task directive D.
void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the taskloop directive.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
This class organizes the cross-function state that is used while generating LLVM code.
LValue - This represents an lvalue references.
Definition: CGValue.h:171
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
virtual void Exit(CodeGenFunction &CGF)
virtual void Enter(CodeGenFunction &CGF)
Class intended to support codegen of all kind of the reduction clauses.
LValue getSharedLValue(unsigned N) const
Returns LValue for the reduction item.
const Expr * getRefExpr(unsigned N) const
Returns the base declaration of the reduction item.
LValue getOrigLValue(unsigned N) const
Returns LValue for the original reduction item.
bool needCleanups(unsigned N)
Returns true if the private copy requires cleanups.
void emitAggregateType(CodeGenFunction &CGF, unsigned N)
Emits the code for the variable-modified type, if required.
const VarDecl * getBaseDecl(unsigned N) const
Returns the base declaration of the reduction item.
QualType getPrivateType(unsigned N) const
Return the type of the private item.
bool usesReductionInitializer(unsigned N) const
Returns true if the initialization of the reduction item uses initializer from declare reduction cons...
void emitSharedOrigLValue(CodeGenFunction &CGF, unsigned N)
Emits lvalue for the shared and original reduction item.
void emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr, Address SharedAddr, llvm::function_ref< bool(CodeGenFunction &)> DefaultInit)
Performs initialization of the private copy for the reduction item.
std::pair< llvm::Value *, llvm::Value * > getSizes(unsigned N) const
Returns the size of the reduction item (in chars and total number of elements in the item),...
void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Emits cleanup code for the reduction item.
Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Adjusts PrivatedAddr for using instead of the original variable address in normal operations.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
RegionCodeGenTy(Callable &&CodeGen, std::enable_if_t<!std::is_same< std::remove_reference_t< Callable >, RegionCodeGenTy >::value > *=nullptr)
void operator()(CodeGenFunction &CGF) const
void setAction(PrePostActionTy &Action) const
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1237
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
This represents one expression.
Definition: Expr.h:110
Represents a member of a struct/union/class.
Definition: Decl.h:2960
Represents a function declaration or definition.
Definition: Decl.h:1917
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:287
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:171
This represents implicit clause 'depend' for the '#pragma omp task' directive.
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1003
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:416
A (possibly-)qualified type.
Definition: Type.h:736
Represents a struct/union/class.
Definition: Decl.h:4027
Encodes a location in the source.
Stmt - This represents one statement.
Definition: Stmt.h:72
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:701
Represents a variable declaration or definition.
Definition: Decl.h:913
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:24
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:103
@ C
Languages that the frontend can parse and compile.
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
Definition: OpenMPKinds.h:54
@ OMPC_DEPEND_unknown
Definition: OpenMPKinds.h:58
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:30
YAML serialization mapping.
Definition: Dominators.h:30
Definition: Format.h:4761
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type,...
Stores debug location and ThreadID for the function.
llvm::AssertingVH< llvm::Instruction > ServiceInsertPt
Insert point for the service instructions.
struct with the values to be passed to the dispatch runtime function
llvm::Value * Chunk
Chunk size specified using 'schedule' clause (nullptr if chunk was not specified)
DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
Maps the expression for the lastprivate variable to the global copy used to store new value because o...
llvm::MapVector< CanonicalDeclPtr< const Decl >, SmallString< 16 > > DeclToUniqueName
Struct with the values to be passed to the static runtime function.
StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
bool IVSigned
Sign of the iteration variable.
Address UB
Address of the output variable in which the upper iteration number is returned.
Address IL
Address of the output variable in which the flag of the last iteration is returned.
llvm::Value * Chunk
Value of the chunk for the static_chunked scheduled loop.
unsigned IVSize
Size of the iteration variable in bits.
Address ST
Address of the output variable in which the stride value is returned necessary to generated the stati...
bool Ordered
true if loop is ordered, false otherwise.
Address LB
Address of the output variable in which the lower iteration number is returned.
DependData(OpenMPDependClauseKind DepKind, const Expr *IteratorExpr)
SmallVector< const Expr *, 4 > DepExprs
SmallVector< const Expr *, 4 > FirstprivateVars
SmallVector< CanonicalDeclPtr< const VarDecl >, 4 > PrivateLocals
SmallVector< const Expr *, 4 > LastprivateCopies
SmallVector< const Expr *, 4 > PrivateCopies
SmallVector< const Expr *, 4 > ReductionVars
llvm::PointerIntPair< llvm::Value *, 1, bool > Schedule
SmallVector< const Expr *, 4 > FirstprivateInits
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
SmallVector< const Expr *, 4 > ReductionOps
SmallVector< DependData, 4 > Dependences
SmallVector< const Expr *, 4 > ReductionCopies
SmallVector< const Expr *, 4 > PrivateVars
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
SmallVector< const Expr *, 4 > FirstprivateCopies
SmallVector< const Expr *, 4 > LastprivateVars
SmallVector< const Expr *, 4 > ReductionOrigs
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:179