1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This provides a class for OpenMP runtime code generation.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
14 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/AST/GlobalDecl.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/OpenMPKinds.h"
21 #include "clang/Basic/SourceLocation.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/StringMap.h"
24 #include "llvm/ADT/StringSet.h"
25 #include "llvm/IR/Function.h"
26 #include "llvm/IR/ValueHandle.h"
40 class OMPDependClause;
41 class OMPExecutableDirective;
42 class OMPLoopDirective;
44 class OMPDeclareReductionDecl;
49 class CodeGenFunction;
52 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
54 class PrePostActionTy {
56 explicit PrePostActionTy() {}
57 virtual void Enter(CodeGenFunction &CGF) {}
58 virtual void Exit(CodeGenFunction &CGF) {}
59 virtual ~PrePostActionTy() {}
62 /// Class provides a way to call simple version of codegen for OpenMP region, or
63 /// an advanced with possible pre|post-actions in codegen.
64 class RegionCodeGenTy final {
66 typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
68 mutable PrePostActionTy *PrePostAction;
69 RegionCodeGenTy() = delete;
70 RegionCodeGenTy &operator=(const RegionCodeGenTy &) = delete;
71 template <typename Callable>
72 static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
73 PrePostActionTy &Action) {
74 return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
78 template <typename Callable>
81 typename std::enable_if<
82 !std::is_same<typename std::remove_reference<Callable>::type,
83 RegionCodeGenTy>::value>::type * = nullptr)
84 : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
85 Callback(CallbackFn<typename std::remove_reference<Callable>::type>),
86 PrePostAction(nullptr) {}
87 void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
88 void operator()(CodeGenFunction &CGF) const;
91 struct OMPTaskDataTy final {
92 SmallVector<const Expr *, 4> PrivateVars;
93 SmallVector<const Expr *, 4> PrivateCopies;
94 SmallVector<const Expr *, 4> FirstprivateVars;
95 SmallVector<const Expr *, 4> FirstprivateCopies;
96 SmallVector<const Expr *, 4> FirstprivateInits;
97 SmallVector<const Expr *, 4> LastprivateVars;
98 SmallVector<const Expr *, 4> LastprivateCopies;
99 SmallVector<const Expr *, 4> ReductionVars;
100 SmallVector<const Expr *, 4> ReductionCopies;
101 SmallVector<const Expr *, 4> ReductionOps;
102 SmallVector<std::pair<OpenMPDependClauseKind, const Expr *>, 4> Dependences;
103 llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
104 llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
105 llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
106 llvm::Value *Reductions = nullptr;
107 unsigned NumberOfParts = 0;
109 bool Nogroup = false;
112 /// Class intended to support codegen of all kind of the reduction clauses.
113 class ReductionCodeGen {
115 /// Data required for codegen of reduction clauses.
116 struct ReductionData {
117 /// Reference to the original shared item.
118 const Expr *Ref = nullptr;
119 /// Helper expression for generation of private copy.
120 const Expr *Private = nullptr;
121 /// Helper expression for generation reduction operation.
122 const Expr *ReductionOp = nullptr;
123 ReductionData(const Expr *Ref, const Expr *Private, const Expr *ReductionOp)
124 : Ref(Ref), Private(Private), ReductionOp(ReductionOp) {}
126 /// List of reduction-based clauses.
127 SmallVector<ReductionData, 4> ClausesData;
129 /// List of addresses of original shared variables/expressions.
130 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
131 /// Sizes of the reduction items in chars.
132 SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes;
133 /// Base declarations for the reduction items.
134 SmallVector<const VarDecl *, 4> BaseDecls;
136 /// Emits lvalue for shared expression.
137 LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
138 /// Emits upper bound for shared expression (if array section).
139 LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
140 /// Performs aggregate initialization.
141 /// \param N Number of reduction item in the common list.
142 /// \param PrivateAddr Address of the corresponding private item.
143 /// \param SharedLVal Address of the original shared variable.
144 /// \param DRD Declare reduction construct used for reduction item.
145 void emitAggregateInitialization(CodeGenFunction &CGF, unsigned N,
146 Address PrivateAddr, LValue SharedLVal,
147 const OMPDeclareReductionDecl *DRD);
150 ReductionCodeGen(ArrayRef<const Expr *> Shareds,
151 ArrayRef<const Expr *> Privates,
152 ArrayRef<const Expr *> ReductionOps);
153 /// Emits lvalue for a reduction item.
154 /// \param N Number of the reduction item.
155 void emitSharedLValue(CodeGenFunction &CGF, unsigned N);
156 /// Emits the code for the variable-modified type, if required.
157 /// \param N Number of the reduction item.
158 void emitAggregateType(CodeGenFunction &CGF, unsigned N);
159 /// Emits the code for the variable-modified type, if required.
160 /// \param N Number of the reduction item.
161 /// \param Size Size of the type in chars.
162 void emitAggregateType(CodeGenFunction &CGF, unsigned N, llvm::Value *Size);
163 /// Performs initialization of the private copy for the reduction item.
164 /// \param N Number of the reduction item.
165 /// \param PrivateAddr Address of the corresponding private item.
166 /// \param DefaultInit Default initialization sequence that should be
167 /// performed if no reduction specific initialization is found.
168 /// \param SharedLVal Address of the original shared variable.
170 emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
172 llvm::function_ref<bool(CodeGenFunction &)> DefaultInit);
173 /// Returns true if the private copy requires cleanups.
174 bool needCleanups(unsigned N);
175 /// Emits cleanup code for the reduction item.
176 /// \param N Number of the reduction item.
177 /// \param PrivateAddr Address of the corresponding private item.
178 void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr);
179 /// Adjusts \p PrivatedAddr for using instead of the original variable
180 /// address in normal operations.
181 /// \param N Number of the reduction item.
182 /// \param PrivateAddr Address of the corresponding private item.
183 Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N,
184 Address PrivateAddr);
185 /// Returns LValue for the reduction item.
186 LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
187 /// Returns the size of the reduction item (in chars and total number of
188 /// elements in the item), or nullptr, if the size is a constant.
189 std::pair<llvm::Value *, llvm::Value *> getSizes(unsigned N) const {
192 /// Returns the base declaration of the reduction item.
193 const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; }
194 /// Returns the base declaration of the reduction item.
195 const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
196 /// Returns true if the initialization of the reduction item uses initializer
197 /// from declare reduction construct.
198 bool usesReductionInitializer(unsigned N) const;
201 class CGOpenMPRuntime {
203 /// Allows to disable automatic handling of functions used in target regions
204 /// as those marked as `omp declare target`.
205 class DisableAutoDeclareTargetRAII {
207 bool SavedShouldMarkAsGlobal;
210 DisableAutoDeclareTargetRAII(CodeGenModule &CGM);
211 ~DisableAutoDeclareTargetRAII();
216 StringRef FirstSeparator, Separator;
218 /// Constructor allowing to redefine the name separator for the variables.
219 explicit CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator,
220 StringRef Separator);
222 /// Creates offloading entry for the provided entry ID \a ID,
223 /// address \a Addr, size \a Size, and flags \a Flags.
224 virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
225 uint64_t Size, int32_t Flags,
226 llvm::GlobalValue::LinkageTypes Linkage);
228 /// Helper to emit outlined function for 'target' directive.
229 /// \param D Directive to emit.
230 /// \param ParentName Name of the function that encloses the target region.
231 /// \param OutlinedFn Outlined function value to be defined by this call.
232 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
233 /// \param IsOffloadEntry True if the outlined function is an offload entry.
234 /// \param CodeGen Lambda codegen specific to an accelerator device.
235 /// An outlined function may not be an entry if, e.g. the if clause always
236 /// evaluates to false.
237 virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D,
238 StringRef ParentName,
239 llvm::Function *&OutlinedFn,
240 llvm::Constant *&OutlinedFnID,
242 const RegionCodeGenTy &CodeGen);
244 /// Emits code for OpenMP 'if' clause using specified \a CodeGen
245 /// function. Here is the logic:
251 void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
252 const RegionCodeGenTy &ThenGen,
253 const RegionCodeGenTy &ElseGen);
255 /// Emits object of ident_t type with info for source location.
256 /// \param Flags Flags for OpenMP location.
258 llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
261 /// Returns pointer to ident_t type.
262 llvm::Type *getIdentTyPointerTy();
264 /// Gets thread id value for the current thread.
266 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
268 /// Get the function name of an outlined region.
269 // The name can be customized depending on the target.
271 virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
273 /// Emits \p Callee function call with arguments \p Args with location \p Loc.
274 void emitCall(CodeGenFunction &CGF, SourceLocation Loc,
275 llvm::FunctionCallee Callee,
276 ArrayRef<llvm::Value *> Args = llvm::None) const;
278 /// Emits address of the word in a memory where current thread id is
280 virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
282 void setLocThreadIdInsertPt(CodeGenFunction &CGF,
283 bool AtCurrentPoint = false);
284 void clearLocThreadIdInsertPt(CodeGenFunction &CGF);
286 /// Check if the default location must be constant.
287 /// Default is false to support OMPT/OMPD.
288 virtual bool isDefaultLocationConstant() const { return false; }
290 /// Returns additional flags that can be stored in reserved_2 field of the
291 /// default location.
292 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
294 /// Tries to emit declare variant function for \p OldGD from \p NewGD.
295 /// \param OrigAddr LLVM IR value for \p OldGD.
296 /// \param IsForDefinition true, if requested emission for the definition of
298 /// \returns true, was able to emit a definition function for \p OldGD, which
299 /// points to \p NewGD.
300 virtual bool tryEmitDeclareVariant(const GlobalDecl &NewGD,
301 const GlobalDecl &OldGD,
302 llvm::GlobalValue *OrigAddr,
303 bool IsForDefinition);
305 /// Returns default flags for the barriers depending on the directive, for
306 /// which this barier is going to be emitted.
307 static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind);
309 /// Get the LLVM type for the critical name.
310 llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
312 /// Returns corresponding lock object for the specified critical region
313 /// name. If the lock object does not exist it is created, otherwise the
314 /// reference to the existing copy is returned.
315 /// \param CriticalName Name of the critical region.
317 llvm::Value *getCriticalRegionLock(StringRef CriticalName);
320 /// Default const ident_t object used for initialization of all other
322 llvm::Constant *DefaultOpenMPPSource = nullptr;
323 using FlagsTy = std::pair<unsigned, unsigned>;
324 /// Map of flags and corresponding default locations.
325 using OpenMPDefaultLocMapTy = llvm::DenseMap<FlagsTy, llvm::Value *>;
326 OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
327 Address getOrCreateDefaultLocation(unsigned Flags);
330 llvm::StructType *IdentTy = nullptr;
331 /// Map for SourceLocation and OpenMP runtime library debug locations.
332 typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
333 OpenMPDebugLocMapTy OpenMPDebugLocMap;
334 /// The type for a microtask which gets passed to __kmpc_fork_call().
335 /// Original representation is:
336 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
337 llvm::FunctionType *Kmpc_MicroTy = nullptr;
338 /// Stores debug location and ThreadID for the function.
339 struct DebugLocThreadIdTy {
340 llvm::Value *DebugLoc;
341 llvm::Value *ThreadID;
342 /// Insert point for the service instructions.
343 llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
345 /// Map of local debug location, ThreadId and functions.
346 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
347 OpenMPLocThreadIDMapTy;
348 OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
349 /// Map of UDRs and corresponding combiner/initializer.
350 typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
351 std::pair<llvm::Function *, llvm::Function *>>
354 /// Map of functions and locally defined UDRs.
355 typedef llvm::DenseMap<llvm::Function *,
356 SmallVector<const OMPDeclareReductionDecl *, 4>>
358 FunctionUDRMapTy FunctionUDRMap;
359 /// Map from the user-defined mapper declaration to its corresponding
361 llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
362 /// Map of functions and their local user-defined mappers.
363 using FunctionUDMMapTy =
364 llvm::DenseMap<llvm::Function *,
365 SmallVector<const OMPDeclareMapperDecl *, 4>>;
366 FunctionUDMMapTy FunctionUDMMap;
367 /// Type kmp_critical_name, originally defined as typedef kmp_int32
368 /// kmp_critical_name[8];
369 llvm::ArrayType *KmpCriticalNameTy;
370 /// An ordered map of auto-generated variables to their unique names.
371 /// It stores variables with the following names: 1) ".gomp_critical_user_" +
372 /// <critical_section_name> + ".var" for "omp critical" directives; 2)
373 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
375 llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
377 /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
378 llvm::Type *KmpRoutineEntryPtrTy = nullptr;
379 QualType KmpRoutineEntryPtrQTy;
380 /// Type typedef struct kmp_task {
381 /// void * shareds; /**< pointer to block of pointers to
383 /// kmp_routine_entry_t routine; /**< pointer to routine to call for
384 /// executing task */
385 /// kmp_int32 part_id; /**< part id for the task */
386 /// kmp_routine_entry_t destructors; /* pointer to function to invoke
387 /// deconstructors of firstprivate C++ objects */
389 QualType KmpTaskTQTy;
390 /// Saved kmp_task_t for task directive.
391 QualType SavedKmpTaskTQTy;
392 /// Saved kmp_task_t for taskloop-based directive.
393 QualType SavedKmpTaskloopTQTy;
394 /// Type typedef struct kmp_depend_info {
395 /// kmp_intptr_t base_addr;
401 /// } kmp_depend_info_t;
402 QualType KmpDependInfoTy;
403 /// struct kmp_dim { // loop bounds info casted to kmp_int64
404 /// kmp_int64 lo; // lower
405 /// kmp_int64 up; // upper
406 /// kmp_int64 st; // stride
409 /// Type struct __tgt_offload_entry{
410 /// void *addr; // Pointer to the offload entry info.
411 /// // (function or global)
412 /// char *name; // Name of the function or global.
413 /// size_t size; // Size of the entry info (0 if it a function).
415 QualType TgtOffloadEntryQTy;
416 /// struct __tgt_device_image{
417 /// void *ImageStart; // Pointer to the target code start.
418 /// void *ImageEnd; // Pointer to the target code end.
419 /// // We also add the host entries to the device image, as it may be useful
420 /// // for the target runtime to have access to that information.
421 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
423 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
424 /// // entries (non inclusive).
426 QualType TgtDeviceImageQTy;
427 /// struct __tgt_bin_desc{
428 /// int32_t NumDevices; // Number of devices supported.
429 /// __tgt_device_image *DeviceImages; // Arrays of device images
430 /// // (one per device).
431 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
433 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
434 /// // entries (non inclusive).
436 QualType TgtBinaryDescriptorQTy;
437 /// Entity that registers the offloading constants that were emitted so
439 class OffloadEntriesInfoManagerTy {
442 /// Number of entries registered so far.
443 unsigned OffloadingEntriesNum = 0;
446 /// Base class of the entries info.
447 class OffloadEntryInfo {
449 /// Kind of a given entry.
450 enum OffloadingEntryInfoKinds : unsigned {
451 /// Entry is a target region.
452 OffloadingEntryInfoTargetRegion = 0,
453 /// Entry is a declare target variable.
454 OffloadingEntryInfoDeviceGlobalVar = 1,
455 /// Invalid entry info.
456 OffloadingEntryInfoInvalid = ~0u
460 OffloadEntryInfo() = delete;
461 explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind) : Kind(Kind) {}
462 explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order,
464 : Flags(Flags), Order(Order), Kind(Kind) {}
465 ~OffloadEntryInfo() = default;
468 bool isValid() const { return Order != ~0u; }
469 unsigned getOrder() const { return Order; }
470 OffloadingEntryInfoKinds getKind() const { return Kind; }
471 uint32_t getFlags() const { return Flags; }
472 void setFlags(uint32_t NewFlags) { Flags = NewFlags; }
473 llvm::Constant *getAddress() const {
474 return cast_or_null<llvm::Constant>(Addr);
476 void setAddress(llvm::Constant *V) {
477 assert(!Addr.pointsToAliveValue() && "Address has been set before!");
480 static bool classof(const OffloadEntryInfo *Info) { return true; }
483 /// Address of the entity that has to be mapped for offloading.
484 llvm::WeakTrackingVH Addr;
486 /// Flags associated with the device global.
489 /// Order this entry was emitted.
490 unsigned Order = ~0u;
492 OffloadingEntryInfoKinds Kind = OffloadingEntryInfoInvalid;
495 /// Return true if a there are no entries defined.
497 /// Return number of entries defined so far.
498 unsigned size() const { return OffloadingEntriesNum; }
499 OffloadEntriesInfoManagerTy(CodeGenModule &CGM) : CGM(CGM) {}
502 // Target region entries related.
505 /// Kind of the target registry entry.
506 enum OMPTargetRegionEntryKind : uint32_t {
507 /// Mark the entry as target region.
508 OMPTargetRegionEntryTargetRegion = 0x0,
509 /// Mark the entry as a global constructor.
510 OMPTargetRegionEntryCtor = 0x02,
511 /// Mark the entry as a global destructor.
512 OMPTargetRegionEntryDtor = 0x04,
515 /// Target region entries info.
516 class OffloadEntryInfoTargetRegion final : public OffloadEntryInfo {
517 /// Address that can be used as the ID of the entry.
518 llvm::Constant *ID = nullptr;
521 OffloadEntryInfoTargetRegion()
522 : OffloadEntryInfo(OffloadingEntryInfoTargetRegion) {}
523 explicit OffloadEntryInfoTargetRegion(unsigned Order,
524 llvm::Constant *Addr,
526 OMPTargetRegionEntryKind Flags)
527 : OffloadEntryInfo(OffloadingEntryInfoTargetRegion, Order, Flags),
532 llvm::Constant *getID() const { return ID; }
533 void setID(llvm::Constant *V) {
534 assert(!ID && "ID has been set before!");
537 static bool classof(const OffloadEntryInfo *Info) {
538 return Info->getKind() == OffloadingEntryInfoTargetRegion;
542 /// Initialize target region entry.
543 void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
544 StringRef ParentName, unsigned LineNum,
546 /// Register target region entry.
547 void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
548 StringRef ParentName, unsigned LineNum,
549 llvm::Constant *Addr, llvm::Constant *ID,
550 OMPTargetRegionEntryKind Flags);
551 /// Return true if a target region entry with the provided information
553 bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
554 StringRef ParentName, unsigned LineNum) const;
555 /// brief Applies action \a Action on all registered entries.
556 typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
557 const OffloadEntryInfoTargetRegion &)>
558 OffloadTargetRegionEntryInfoActTy;
559 void actOnTargetRegionEntriesInfo(
560 const OffloadTargetRegionEntryInfoActTy &Action);
563 // Device global variable entries related.
566 /// Kind of the global variable entry..
567 enum OMPTargetGlobalVarEntryKind : uint32_t {
568 /// Mark the entry as a to declare target.
569 OMPTargetGlobalVarEntryTo = 0x0,
570 /// Mark the entry as a to declare target link.
571 OMPTargetGlobalVarEntryLink = 0x1,
574 /// Device global variable entries info.
575 class OffloadEntryInfoDeviceGlobalVar final : public OffloadEntryInfo {
576 /// Type of the global variable.
578 llvm::GlobalValue::LinkageTypes Linkage;
581 OffloadEntryInfoDeviceGlobalVar()
582 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar) {}
583 explicit OffloadEntryInfoDeviceGlobalVar(unsigned Order,
584 OMPTargetGlobalVarEntryKind Flags)
585 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags) {}
586 explicit OffloadEntryInfoDeviceGlobalVar(
587 unsigned Order, llvm::Constant *Addr, CharUnits VarSize,
588 OMPTargetGlobalVarEntryKind Flags,
589 llvm::GlobalValue::LinkageTypes Linkage)
590 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags),
591 VarSize(VarSize), Linkage(Linkage) {
595 CharUnits getVarSize() const { return VarSize; }
596 void setVarSize(CharUnits Size) { VarSize = Size; }
597 llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
598 void setLinkage(llvm::GlobalValue::LinkageTypes LT) { Linkage = LT; }
599 static bool classof(const OffloadEntryInfo *Info) {
600 return Info->getKind() == OffloadingEntryInfoDeviceGlobalVar;
604 /// Initialize device global variable entry.
605 void initializeDeviceGlobalVarEntryInfo(StringRef Name,
606 OMPTargetGlobalVarEntryKind Flags,
609 /// Register device global variable entry.
611 registerDeviceGlobalVarEntryInfo(StringRef VarName, llvm::Constant *Addr,
613 OMPTargetGlobalVarEntryKind Flags,
614 llvm::GlobalValue::LinkageTypes Linkage);
615 /// Checks if the variable with the given name has been registered already.
616 bool hasDeviceGlobalVarEntryInfo(StringRef VarName) const {
617 return OffloadEntriesDeviceGlobalVar.count(VarName) > 0;
619 /// Applies action \a Action on all registered entries.
620 typedef llvm::function_ref<void(StringRef,
621 const OffloadEntryInfoDeviceGlobalVar &)>
622 OffloadDeviceGlobalVarEntryInfoActTy;
623 void actOnDeviceGlobalVarEntriesInfo(
624 const OffloadDeviceGlobalVarEntryInfoActTy &Action);
627 // Storage for target region entries kind. The storage is to be indexed by
628 // file ID, device ID, parent function name and line number.
629 typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
630 OffloadEntriesTargetRegionPerLine;
631 typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
632 OffloadEntriesTargetRegionPerParentName;
633 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
634 OffloadEntriesTargetRegionPerFile;
635 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
636 OffloadEntriesTargetRegionPerDevice;
637 typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
638 OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
639 /// Storage for device global variable entries kind. The storage is to be
640 /// indexed by mangled name.
641 typedef llvm::StringMap<OffloadEntryInfoDeviceGlobalVar>
642 OffloadEntriesDeviceGlobalVarTy;
643 OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar;
645 OffloadEntriesInfoManagerTy OffloadEntriesInfoManager;
647 bool ShouldMarkAsGlobal = true;
648 /// List of the emitted functions.
649 llvm::StringSet<> AlreadyEmittedTargetFunctions;
650 /// List of the global variables with their addresses that should not be
651 /// emitted for the target.
652 llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
654 /// List of variables that can become declare target implicitly and, thus,
656 llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
658 /// Mapping of the original functions to their variants and original global
660 llvm::MapVector<CanonicalDeclPtr<const FunctionDecl>,
661 std::pair<GlobalDecl, GlobalDecl>>
662 DeferredVariantFunction;
664 /// Flag for keeping track of weather a requires unified_shared_memory
665 /// directive is present.
666 bool HasRequiresUnifiedSharedMemory = false;
668 /// Flag for keeping track of weather a target region has been emitted.
669 bool HasEmittedTargetRegion = false;
671 /// Flag for keeping track of weather a device routine has been emitted.
672 /// Device routines are specific to the
673 bool HasEmittedDeclareTargetRegion = false;
675 /// Loads all the offload entries information from the host IR
677 void loadOffloadInfoMetadata();
679 /// Returns __tgt_offload_entry type.
680 QualType getTgtOffloadEntryQTy();
682 /// Returns __tgt_device_image type.
683 QualType getTgtDeviceImageQTy();
685 /// Returns __tgt_bin_desc type.
686 QualType getTgtBinaryDescriptorQTy();
688 /// Start scanning from statement \a S and and emit all target regions
689 /// found along the way.
690 /// \param S Starting statement.
691 /// \param ParentName Name of the function declaration that is being scanned.
692 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
694 /// Build type kmp_routine_entry_t (if not built yet).
695 void emitKmpRoutineEntryT(QualType KmpInt32Ty);
697 /// Returns pointer to kmpc_micro type.
698 llvm::Type *getKmpc_MicroPointerTy();
700 /// Returns specified OpenMP runtime function.
701 /// \param Function OpenMP runtime function.
702 /// \return Specified function.
703 llvm::FunctionCallee createRuntimeFunction(unsigned Function);
705 /// Returns __kmpc_for_static_init_* runtime function for the specified
706 /// size \a IVSize and sign \a IVSigned.
707 llvm::FunctionCallee createForStaticInitFunction(unsigned IVSize,
710 /// Returns __kmpc_dispatch_init_* runtime function for the specified
711 /// size \a IVSize and sign \a IVSigned.
712 llvm::FunctionCallee createDispatchInitFunction(unsigned IVSize,
715 /// Returns __kmpc_dispatch_next_* runtime function for the specified
716 /// size \a IVSize and sign \a IVSigned.
717 llvm::FunctionCallee createDispatchNextFunction(unsigned IVSize,
720 /// Returns __kmpc_dispatch_fini_* runtime function for the specified
721 /// size \a IVSize and sign \a IVSigned.
722 llvm::FunctionCallee createDispatchFiniFunction(unsigned IVSize,
725 /// If the specified mangled name is not in the module, create and
726 /// return threadprivate cache object. This object is a pointer's worth of
727 /// storage that's reserved for use by the OpenMP runtime.
728 /// \param VD Threadprivate variable.
729 /// \return Cache variable for the specified threadprivate.
730 llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
732 /// Gets (if variable with the given name already exist) or creates
733 /// internal global variable with the specified Name. The created variable has
734 /// linkage CommonLinkage by default and is initialized by null value.
735 /// \param Ty Type of the global variable. If it is exist already the type
736 /// must be the same.
737 /// \param Name Name of the variable.
738 llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
739 const llvm::Twine &Name,
740 unsigned AddressSpace = 0);
742 /// Set of threadprivate variables with the generated initializer.
743 llvm::StringSet<> ThreadPrivateWithDefinition;
745 /// Set of declare target variables with the generated initializer.
746 llvm::StringSet<> DeclareTargetWithDefinition;
748 /// Emits initialization code for the threadprivate variables.
749 /// \param VDAddr Address of the global variable \a VD.
750 /// \param Ctor Pointer to a global init function for \a VD.
751 /// \param CopyCtor Pointer to a global copy function for \a VD.
752 /// \param Dtor Pointer to a global destructor function for \a VD.
753 /// \param Loc Location of threadprivate declaration.
754 void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
755 llvm::Value *Ctor, llvm::Value *CopyCtor,
756 llvm::Value *Dtor, SourceLocation Loc);
758 /// Emit the array initialization or deletion portion for user-defined mapper
760 void emitUDMapperArrayInitOrDel(CodeGenFunction &MapperCGF,
761 llvm::Value *Handle, llvm::Value *BasePtr,
762 llvm::Value *Ptr, llvm::Value *Size,
763 llvm::Value *MapType, CharUnits ElementSize,
764 llvm::BasicBlock *ExitBB, bool IsInit);
766 struct TaskResultTy {
767 llvm::Value *NewTask = nullptr;
768 llvm::Function *TaskEntry = nullptr;
769 llvm::Value *NewTaskNewTaskTTy = nullptr;
771 const RecordDecl *KmpTaskTQTyRD = nullptr;
772 llvm::Value *TaskDupFn = nullptr;
774 /// Emit task region for the task directive. The task region is emitted in
776 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
777 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
778 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
780 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
781 /// TaskFunction(gtid, tt->part_id, tt->shareds);
784 /// 2. Copy a list of shared variables to field shareds of the resulting
785 /// structure kmp_task_t returned by the previous call (if any).
786 /// 3. Copy a pointer to destructions function to field destructions of the
787 /// resulting structure kmp_task_t.
788 /// \param D Current task directive.
789 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
790 /// /*part_id*/, captured_struct */*__context*/);
791 /// \param SharedsTy A type which contains references the shared variables.
792 /// \param Shareds Context with the list of shared variables from the \p
794 /// \param Data Additional data for task generation like tiednsee, final
795 /// state, list of privates etc.
796 TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
797 const OMPExecutableDirective &D,
798 llvm::Function *TaskFunction, QualType SharedsTy,
799 Address Shareds, const OMPTaskDataTy &Data);
801 /// Returns default address space for the constant firstprivates, 0 by
803 virtual unsigned getDefaultFirstprivateAddressSpace() const { return 0; }
805 /// Emit code that pushes the trip count of loops associated with constructs
806 /// 'target teams distribute' and 'teams distribute parallel for'.
807 /// \param SizeEmitter Emits the int64 value for the number of iterations of
808 /// the associated loop.
809 void emitTargetNumIterationsCall(
810 CodeGenFunction &CGF, const OMPExecutableDirective &D,
811 llvm::Value *DeviceID,
812 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
813 const OMPLoopDirective &D)>
817 explicit CGOpenMPRuntime(CodeGenModule &CGM)
818 : CGOpenMPRuntime(CGM, ".", ".") {}
819 virtual ~CGOpenMPRuntime() {}
820 virtual void clear();
822 /// Checks if the \p Body is the \a CompoundStmt and returns its child
823 /// statement iff there is only one that is not evaluatable at the compile
825 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
827 /// Get the platform-specific name separator.
828 std::string getName(ArrayRef<StringRef> Parts) const;
830 /// Emit code for the specified user defined reduction construct.
831 virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
832 const OMPDeclareReductionDecl *D);
833 /// Get combiner/initializer for the specified user-defined reduction, if any.
834 virtual std::pair<llvm::Function *, llvm::Function *>
835 getUserDefinedReduction(const OMPDeclareReductionDecl *D);
837 /// Emit the function for the user defined mapper construct.
838 void emitUserDefinedMapper(const OMPDeclareMapperDecl *D,
839 CodeGenFunction *CGF = nullptr);
841 /// Emits outlined function for the specified OpenMP parallel directive
842 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
843 /// kmp_int32 BoundID, struct context_vars*).
844 /// \param D OpenMP directive.
845 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
846 /// \param InnermostKind Kind of innermost directive (for simple directives it
847 /// is a directive itself, for combined - its innermost directive).
848 /// \param CodeGen Code generation sequence for the \a D directive.
849 virtual llvm::Function *emitParallelOutlinedFunction(
850 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
851 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
853 /// Emits outlined function for the specified OpenMP teams directive
854 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
855 /// kmp_int32 BoundID, struct context_vars*).
856 /// \param D OpenMP directive.
857 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
858 /// \param InnermostKind Kind of innermost directive (for simple directives it
859 /// is a directive itself, for combined - its innermost directive).
860 /// \param CodeGen Code generation sequence for the \a D directive.
861 virtual llvm::Function *emitTeamsOutlinedFunction(
862 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
863 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
865 /// Emits outlined function for the OpenMP task directive \a D. This
866 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
868 /// \param D OpenMP directive.
869 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
870 /// \param PartIDVar Variable for partition id in the current OpenMP untied
872 /// \param TaskTVar Variable for task_t argument.
873 /// \param InnermostKind Kind of innermost directive (for simple directives it
874 /// is a directive itself, for combined - its innermost directive).
875 /// \param CodeGen Code generation sequence for the \a D directive.
876 /// \param Tied true if task is generated for tied task, false otherwise.
877 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
880 virtual llvm::Function *emitTaskOutlinedFunction(
881 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
882 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
883 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
884 bool Tied, unsigned &NumberOfParts);
886 /// Cleans up references to the objects in finished function.
888 virtual void functionFinished(CodeGenFunction &CGF);
890 /// Emits code for parallel or serial call of the \a OutlinedFn with
891 /// variables captured in a record which address is stored in \a
893 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
894 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
895 /// \param CapturedVars A pointer to the record with the references to
896 /// variables used in \a OutlinedFn function.
897 /// \param IfCond Condition in the associated 'if' clause, if it was
898 /// specified, nullptr otherwise.
900 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
901 llvm::Function *OutlinedFn,
902 ArrayRef<llvm::Value *> CapturedVars,
905 /// Emits a critical region.
906 /// \param CriticalName Name of the critical region.
907 /// \param CriticalOpGen Generator for the statement associated with the given
909 /// \param Hint Value of the 'hint' clause (optional).
910 virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
911 const RegionCodeGenTy &CriticalOpGen,
913 const Expr *Hint = nullptr);
915 /// Emits a master region.
916 /// \param MasterOpGen Generator for the statement associated with the given
918 virtual void emitMasterRegion(CodeGenFunction &CGF,
919 const RegionCodeGenTy &MasterOpGen,
922 /// Emits code for a taskyield directive.
923 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
925 /// Emit a taskgroup region.
926 /// \param TaskgroupOpGen Generator for the statement associated with the
927 /// given taskgroup region.
928 virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
929 const RegionCodeGenTy &TaskgroupOpGen,
932 /// Emits a single region.
933 /// \param SingleOpGen Generator for the statement associated with the given
935 virtual void emitSingleRegion(CodeGenFunction &CGF,
936 const RegionCodeGenTy &SingleOpGen,
938 ArrayRef<const Expr *> CopyprivateVars,
939 ArrayRef<const Expr *> DestExprs,
940 ArrayRef<const Expr *> SrcExprs,
941 ArrayRef<const Expr *> AssignmentOps);
943 /// Emit an ordered region.
944 /// \param OrderedOpGen Generator for the statement associated with the given
946 virtual void emitOrderedRegion(CodeGenFunction &CGF,
947 const RegionCodeGenTy &OrderedOpGen,
948 SourceLocation Loc, bool IsThreads);
950 /// Emit an implicit/explicit barrier for OpenMP threads.
951 /// \param Kind Directive for which this implicit barrier call must be
952 /// generated. Must be OMPD_barrier for explicit barrier generation.
953 /// \param EmitChecks true if need to emit checks for cancellation barriers.
954 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
955 /// runtime class decides which one to emit (simple or with cancellation
958 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
959 OpenMPDirectiveKind Kind,
960 bool EmitChecks = true,
961 bool ForceSimpleCall = false);
963 /// Check if the specified \a ScheduleKind is static non-chunked.
964 /// This kind of worksharing directive is emitted without outer loop.
965 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
966 /// \param Chunked True if chunk is specified in the clause.
968 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
971 /// Check if the specified \a ScheduleKind is static non-chunked.
972 /// This kind of distribute directive is emitted without outer loop.
973 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
974 /// \param Chunked True if chunk is specified in the clause.
976 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
979 /// Check if the specified \a ScheduleKind is static chunked.
980 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
981 /// \param Chunked True if chunk is specified in the clause.
983 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
986 /// Check if the specified \a ScheduleKind is static non-chunked.
987 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
988 /// \param Chunked True if chunk is specified in the clause.
990 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
993 /// Check if the specified \a ScheduleKind is dynamic.
994 /// This kind of worksharing directive is emitted without outer loop.
995 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
997 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
999 /// struct with the values to be passed to the dispatch runtime function
1000 struct DispatchRTInput {
1001 /// Loop lower bound
1002 llvm::Value *LB = nullptr;
1003 /// Loop upper bound
1004 llvm::Value *UB = nullptr;
1005 /// Chunk size specified using 'schedule' clause (nullptr if chunk
1006 /// was not specified)
1007 llvm::Value *Chunk = nullptr;
1008 DispatchRTInput() = default;
1009 DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
1010 : LB(LB), UB(UB), Chunk(Chunk) {}
1013 /// Call the appropriate runtime routine to initialize it before start
1016 /// This is used for non static scheduled types and when the ordered
1017 /// clause is present on the loop construct.
1018 /// Depending on the loop schedule, it is necessary to call some runtime
1019 /// routine before start of the OpenMP loop to get the loop upper / lower
1020 /// bounds \a LB and \a UB and stride \a ST.
1022 /// \param CGF Reference to current CodeGenFunction.
1023 /// \param Loc Clang source location.
1024 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1025 /// \param IVSize Size of the iteration variable in bits.
1026 /// \param IVSigned Sign of the iteration variable.
1027 /// \param Ordered true if loop is ordered, false otherwise.
1028 /// \param DispatchValues struct containing llvm values for lower bound, upper
1029 /// bound, and chunk expression.
1030 /// For the default (nullptr) value, the chunk 1 will be used.
1032 virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
1033 const OpenMPScheduleTy &ScheduleKind,
1034 unsigned IVSize, bool IVSigned, bool Ordered,
1035 const DispatchRTInput &DispatchValues);
1037 /// Struct with the values to be passed to the static runtime function
1038 struct StaticRTInput {
1039 /// Size of the iteration variable in bits.
1040 unsigned IVSize = 0;
1041 /// Sign of the iteration variable.
1042 bool IVSigned = false;
1043 /// true if loop is ordered, false otherwise.
1044 bool Ordered = false;
1045 /// Address of the output variable in which the flag of the last iteration
1047 Address IL = Address::invalid();
1048 /// Address of the output variable in which the lower iteration number is
1050 Address LB = Address::invalid();
1051 /// Address of the output variable in which the upper iteration number is
1053 Address UB = Address::invalid();
1054 /// Address of the output variable in which the stride value is returned
1055 /// necessary to generated the static_chunked scheduled loop.
1056 Address ST = Address::invalid();
1057 /// Value of the chunk for the static_chunked scheduled loop. For the
1058 /// default (nullptr) value, the chunk 1 will be used.
1059 llvm::Value *Chunk = nullptr;
1060 StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL,
1061 Address LB, Address UB, Address ST,
1062 llvm::Value *Chunk = nullptr)
1063 : IVSize(IVSize), IVSigned(IVSigned), Ordered(Ordered), IL(IL), LB(LB),
1064 UB(UB), ST(ST), Chunk(Chunk) {}
1066 /// Call the appropriate runtime routine to initialize it before start
1069 /// This is used only in case of static schedule, when the user did not
1070 /// specify a ordered clause on the loop construct.
1071 /// Depending on the loop schedule, it is necessary to call some runtime
1072 /// routine before start of the OpenMP loop to get the loop upper / lower
1073 /// bounds LB and UB and stride ST.
1075 /// \param CGF Reference to current CodeGenFunction.
1076 /// \param Loc Clang source location.
1077 /// \param DKind Kind of the directive.
1078 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1079 /// \param Values Input arguments for the construct.
1081 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1082 OpenMPDirectiveKind DKind,
1083 const OpenMPScheduleTy &ScheduleKind,
1084 const StaticRTInput &Values);
1087 /// \param CGF Reference to current CodeGenFunction.
1088 /// \param Loc Clang source location.
1089 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1090 /// \param Values Input arguments for the construct.
1092 virtual void emitDistributeStaticInit(CodeGenFunction &CGF,
1094 OpenMPDistScheduleClauseKind SchedKind,
1095 const StaticRTInput &Values);
1097 /// Call the appropriate runtime routine to notify that we finished
1098 /// iteration of the ordered loop with the dynamic scheduling.
1100 /// \param CGF Reference to current CodeGenFunction.
1101 /// \param Loc Clang source location.
1102 /// \param IVSize Size of the iteration variable in bits.
1103 /// \param IVSigned Sign of the iteration variable.
1105 virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
1106 SourceLocation Loc, unsigned IVSize,
1109 /// Call the appropriate runtime routine to notify that we finished
1110 /// all the work with current loop.
1112 /// \param CGF Reference to current CodeGenFunction.
1113 /// \param Loc Clang source location.
1114 /// \param DKind Kind of the directive for which the static finish is emitted.
1116 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1117 OpenMPDirectiveKind DKind);
1119 /// Call __kmpc_dispatch_next(
1120 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1121 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1122 /// kmp_int[32|64] *p_stride);
1123 /// \param IVSize Size of the iteration variable in bits.
1124 /// \param IVSigned Sign of the iteration variable.
1125 /// \param IL Address of the output variable in which the flag of the
1126 /// last iteration is returned.
1127 /// \param LB Address of the output variable in which the lower iteration
1128 /// number is returned.
1129 /// \param UB Address of the output variable in which the upper iteration
1130 /// number is returned.
1131 /// \param ST Address of the output variable in which the stride value is
1133 virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1134 unsigned IVSize, bool IVSigned,
1135 Address IL, Address LB,
1136 Address UB, Address ST);
1138 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1139 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1141 /// \param NumThreads An integer value of threads.
1142 virtual void emitNumThreadsClause(CodeGenFunction &CGF,
1143 llvm::Value *NumThreads,
1144 SourceLocation Loc);
1146 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1147 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1148 virtual void emitProcBindClause(CodeGenFunction &CGF,
1149 OpenMPProcBindClauseKind ProcBind,
1150 SourceLocation Loc);
1152 /// Returns address of the threadprivate variable for the current
1154 /// \param VD Threadprivate variable.
1155 /// \param VDAddr Address of the global variable \a VD.
1156 /// \param Loc Location of the reference to threadprivate var.
1157 /// \return Address of the threadprivate variable for the current thread.
1158 virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
1161 SourceLocation Loc);
1163 /// Returns the address of the variable marked as declare target with link
1164 /// clause OR as declare target with to clause and unified memory.
1165 virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD);
1167 /// Emit a code for initialization of threadprivate variable. It emits
1168 /// a call to runtime library which adds initial value to the newly created
1169 /// threadprivate variable (if it is not constant) and registers destructor
1170 /// for the variable (if any).
1171 /// \param VD Threadprivate variable.
1172 /// \param VDAddr Address of the global variable \a VD.
1173 /// \param Loc Location of threadprivate declaration.
1174 /// \param PerformInit true if initialization expression is not constant.
1175 virtual llvm::Function *
1176 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1177 SourceLocation Loc, bool PerformInit,
1178 CodeGenFunction *CGF = nullptr);
1180 /// Emit a code for initialization of declare target variable.
1181 /// \param VD Declare target variable.
1182 /// \param Addr Address of the global variable \a VD.
1183 /// \param PerformInit true if initialization expression is not constant.
1184 virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD,
1185 llvm::GlobalVariable *Addr,
1188 /// Creates artificial threadprivate variable with name \p Name and type \p
1190 /// \param VarType Type of the artificial threadprivate variable.
1191 /// \param Name Name of the artificial threadprivate variable.
1192 virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1196 /// Emit flush of the variables specified in 'omp flush' directive.
1197 /// \param Vars List of variables to flush.
1198 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1199 SourceLocation Loc);
1201 /// Emit task region for the task directive. The task region is
1202 /// emitted in several steps:
1203 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1204 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1205 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1207 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1208 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1211 /// 2. Copy a list of shared variables to field shareds of the resulting
1212 /// structure kmp_task_t returned by the previous call (if any).
1213 /// 3. Copy a pointer to destructions function to field destructions of the
1214 /// resulting structure kmp_task_t.
1215 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1216 /// kmp_task_t *new_task), where new_task is a resulting structure from
1218 /// \param D Current task directive.
1219 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1220 /// /*part_id*/, captured_struct */*__context*/);
1221 /// \param SharedsTy A type which contains references the shared variables.
1222 /// \param Shareds Context with the list of shared variables from the \p
1224 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1226 /// \param Data Additional data for task generation like tiednsee, final
1227 /// state, list of privates etc.
1228 virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1229 const OMPExecutableDirective &D,
1230 llvm::Function *TaskFunction, QualType SharedsTy,
1231 Address Shareds, const Expr *IfCond,
1232 const OMPTaskDataTy &Data);
1234 /// Emit task region for the taskloop directive. The taskloop region is
1235 /// emitted in several steps:
1236 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1237 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1238 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1240 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1241 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1244 /// 2. Copy a list of shared variables to field shareds of the resulting
1245 /// structure kmp_task_t returned by the previous call (if any).
1246 /// 3. Copy a pointer to destructions function to field destructions of the
1247 /// resulting structure kmp_task_t.
1248 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1249 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1250 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1251 /// is a resulting structure from
1253 /// \param D Current task directive.
1254 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1255 /// /*part_id*/, captured_struct */*__context*/);
1256 /// \param SharedsTy A type which contains references the shared variables.
1257 /// \param Shareds Context with the list of shared variables from the \p
1259 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1261 /// \param Data Additional data for task generation like tiednsee, final
1262 /// state, list of privates etc.
1263 virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1264 const OMPLoopDirective &D,
1265 llvm::Function *TaskFunction,
1266 QualType SharedsTy, Address Shareds,
1267 const Expr *IfCond, const OMPTaskDataTy &Data);
1269 /// Emit code for the directive that does not require outlining.
1271 /// \param InnermostKind Kind of innermost directive (for simple directives it
1272 /// is a directive itself, for combined - its innermost directive).
1273 /// \param CodeGen Code generation sequence for the \a D directive.
1274 /// \param HasCancel true if region has inner cancel directive, false
1276 virtual void emitInlinedDirective(CodeGenFunction &CGF,
1277 OpenMPDirectiveKind InnermostKind,
1278 const RegionCodeGenTy &CodeGen,
1279 bool HasCancel = false);
1281 /// Emits reduction function.
1282 /// \param ArgsType Array type containing pointers to reduction variables.
1283 /// \param Privates List of private copies for original reduction arguments.
1284 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1285 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1286 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1287 /// or 'operator binop(LHS, RHS)'.
1288 llvm::Function *emitReductionFunction(SourceLocation Loc,
1289 llvm::Type *ArgsType,
1290 ArrayRef<const Expr *> Privates,
1291 ArrayRef<const Expr *> LHSExprs,
1292 ArrayRef<const Expr *> RHSExprs,
1293 ArrayRef<const Expr *> ReductionOps);
1295 /// Emits single reduction combiner
1296 void emitSingleReductionCombiner(CodeGenFunction &CGF,
1297 const Expr *ReductionOp,
1298 const Expr *PrivateRef,
1299 const DeclRefExpr *LHS,
1300 const DeclRefExpr *RHS);
1302 struct ReductionOptionsTy {
1304 bool SimpleReduction;
1305 OpenMPDirectiveKind ReductionKind;
1307 /// Emit a code for reduction clause. Next code should be emitted for
1311 /// static kmp_critical_name lock = { 0 };
1313 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1315 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1320 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1321 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1322 /// RedList, reduce_func, &<lock>)) {
1325 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1327 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1331 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1338 /// \param Privates List of private copies for original reduction arguments.
1339 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1340 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1341 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1342 /// or 'operator binop(LHS, RHS)'.
1343 /// \param Options List of options for reduction codegen:
1344 /// WithNowait true if parent directive has also nowait clause, false
1346 /// SimpleReduction Emit reduction operation only. Used for omp simd
1347 /// directive on the host.
1348 /// ReductionKind The kind of reduction to perform.
1349 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1350 ArrayRef<const Expr *> Privates,
1351 ArrayRef<const Expr *> LHSExprs,
1352 ArrayRef<const Expr *> RHSExprs,
1353 ArrayRef<const Expr *> ReductionOps,
1354 ReductionOptionsTy Options);
1356 /// Emit a code for initialization of task reduction clause. Next code
1357 /// should be emitted for reduction:
1360 /// _task_red_item_t red_data[n];
1362 /// red_data[i].shar = &origs[i];
1363 /// red_data[i].size = sizeof(origs[i]);
1364 /// red_data[i].f_init = (void*)RedInit<i>;
1365 /// red_data[i].f_fini = (void*)RedDest<i>;
1366 /// red_data[i].f_comb = (void*)RedOp<i>;
1367 /// red_data[i].flags = <Flag_i>;
1369 /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data);
1372 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1373 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1374 /// \param Data Additional data for task generation like tiedness, final
1375 /// state, list of privates, reductions etc.
1376 virtual llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF,
1378 ArrayRef<const Expr *> LHSExprs,
1379 ArrayRef<const Expr *> RHSExprs,
1380 const OMPTaskDataTy &Data);
1382 /// Required to resolve existing problems in the runtime. Emits threadprivate
1383 /// variables to store the size of the VLAs/array sections for
1384 /// initializer/combiner/finalizer functions + emits threadprivate variable to
1385 /// store the pointer to the original reduction item for the custom
1386 /// initializer defined by declare reduction construct.
1387 /// \param RCG Allows to reuse an existing data for the reductions.
1388 /// \param N Reduction item for which fixups must be emitted.
1389 virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc,
1390 ReductionCodeGen &RCG, unsigned N);
1392 /// Get the address of `void *` type of the privatue copy of the reduction
1393 /// item specified by the \p SharedLVal.
1394 /// \param ReductionsPtr Pointer to the reduction data returned by the
1395 /// emitTaskReductionInit function.
1396 /// \param SharedLVal Address of the original reduction item.
1397 virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
1398 llvm::Value *ReductionsPtr,
1401 /// Emit code for 'taskwait' directive.
1402 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
1404 /// Emit code for 'cancellation point' construct.
1405 /// \param CancelRegion Region kind for which the cancellation point must be
1408 virtual void emitCancellationPointCall(CodeGenFunction &CGF,
1410 OpenMPDirectiveKind CancelRegion);
1412 /// Emit code for 'cancel' construct.
1413 /// \param IfCond Condition in the associated 'if' clause, if it was
1414 /// specified, nullptr otherwise.
1415 /// \param CancelRegion Region kind for which the cancel must be emitted.
1417 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1419 OpenMPDirectiveKind CancelRegion);
1421 /// Emit outilined function for 'target' directive.
1422 /// \param D Directive to emit.
1423 /// \param ParentName Name of the function that encloses the target region.
1424 /// \param OutlinedFn Outlined function value to be defined by this call.
1425 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1426 /// \param IsOffloadEntry True if the outlined function is an offload entry.
1427 /// \param CodeGen Code generation sequence for the \a D directive.
1428 /// An outlined function may not be an entry if, e.g. the if clause always
1429 /// evaluates to false.
1430 virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
1431 StringRef ParentName,
1432 llvm::Function *&OutlinedFn,
1433 llvm::Constant *&OutlinedFnID,
1434 bool IsOffloadEntry,
1435 const RegionCodeGenTy &CodeGen);
1437 /// Emit the target offloading code associated with \a D. The emitted
1438 /// code attempts offloading the execution to the device, an the event of
1439 /// a failure it executes the host version outlined in \a OutlinedFn.
1440 /// \param D Directive to emit.
1441 /// \param OutlinedFn Host version of the code to be offloaded.
1442 /// \param OutlinedFnID ID of host version of the code to be offloaded.
1443 /// \param IfCond Expression evaluated in if clause associated with the target
1444 /// directive, or null if no if clause is used.
1445 /// \param Device Expression evaluated in device clause associated with the
1446 /// target directive, or null if no device clause is used.
1447 /// \param SizeEmitter Callback to emit number of iterations for loop-based
1450 emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
1451 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID,
1452 const Expr *IfCond, const Expr *Device,
1453 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
1454 const OMPLoopDirective &D)>
1457 /// Emit the target regions enclosed in \a GD function definition or
1458 /// the function itself in case it is a valid device function. Returns true if
1459 /// \a GD was dealt with successfully.
1460 /// \param GD Function to scan.
1461 virtual bool emitTargetFunctions(GlobalDecl GD);
1463 /// Emit the global variable if it is a valid device global variable.
1464 /// Returns true if \a GD was dealt with successfully.
1465 /// \param GD Variable declaration to emit.
1466 virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1468 /// Checks if the provided global decl \a GD is a declare target variable and
1469 /// registers it when emitting code for the host.
1470 virtual void registerTargetGlobalVariable(const VarDecl *VD,
1471 llvm::Constant *Addr);
1473 /// Registers provided target firstprivate variable as global on the
1475 llvm::Constant *registerTargetFirstprivateCopy(CodeGenFunction &CGF,
1478 /// Emit the global \a GD if it is meaningful for the target. Returns
1479 /// if it was emitted successfully.
1480 /// \param GD Global to scan.
1481 virtual bool emitTargetGlobal(GlobalDecl GD);
1483 /// Creates and returns a registration function for when at least one
1484 /// requires directives was used in the current module.
1485 llvm::Function *emitRequiresDirectiveRegFun();
1487 /// Creates all the offload entries in the current compilation unit
1488 /// along with the associated metadata.
1489 void createOffloadEntriesAndInfoMetadata();
1491 /// Emits code for teams call of the \a OutlinedFn with
1492 /// variables captured in a record which address is stored in \a
1494 /// \param OutlinedFn Outlined function to be run by team masters. Type of
1495 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1496 /// \param CapturedVars A pointer to the record with the references to
1497 /// variables used in \a OutlinedFn function.
1499 virtual void emitTeamsCall(CodeGenFunction &CGF,
1500 const OMPExecutableDirective &D,
1501 SourceLocation Loc, llvm::Function *OutlinedFn,
1502 ArrayRef<llvm::Value *> CapturedVars);
1504 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1505 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1506 /// for num_teams clause.
1507 /// \param NumTeams An integer expression of teams.
1508 /// \param ThreadLimit An integer expression of threads.
1509 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1510 const Expr *ThreadLimit, SourceLocation Loc);
1512 /// Struct that keeps all the relevant information that should be kept
1513 /// throughout a 'target data' region.
1514 class TargetDataInfo {
1515 /// Set to true if device pointer information have to be obtained.
1516 bool RequiresDevicePointerInfo = false;
1519 /// The array of base pointer passed to the runtime library.
1520 llvm::Value *BasePointersArray = nullptr;
1521 /// The array of section pointers passed to the runtime library.
1522 llvm::Value *PointersArray = nullptr;
1523 /// The array of sizes passed to the runtime library.
1524 llvm::Value *SizesArray = nullptr;
1525 /// The array of map types passed to the runtime library.
1526 llvm::Value *MapTypesArray = nullptr;
1527 /// The total number of pointers passed to the runtime library.
1528 unsigned NumberOfPtrs = 0u;
1529 /// Map between the a declaration of a capture and the corresponding base
1530 /// pointer address where the runtime returns the device pointers.
1531 llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1533 explicit TargetDataInfo() {}
1534 explicit TargetDataInfo(bool RequiresDevicePointerInfo)
1535 : RequiresDevicePointerInfo(RequiresDevicePointerInfo) {}
1536 /// Clear information about the data arrays.
1537 void clearArrayInfo() {
1538 BasePointersArray = nullptr;
1539 PointersArray = nullptr;
1540 SizesArray = nullptr;
1541 MapTypesArray = nullptr;
1544 /// Return true if the current target data information has valid arrays.
1546 return BasePointersArray && PointersArray && SizesArray &&
1547 MapTypesArray && NumberOfPtrs;
1549 bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
1552 /// Emit the target data mapping code associated with \a D.
1553 /// \param D Directive to emit.
1554 /// \param IfCond Expression evaluated in if clause associated with the
1555 /// target directive, or null if no device clause is used.
1556 /// \param Device Expression evaluated in device clause associated with the
1557 /// target directive, or null if no device clause is used.
1558 /// \param Info A record used to store information that needs to be preserved
1559 /// until the region is closed.
1560 virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1561 const OMPExecutableDirective &D,
1562 const Expr *IfCond, const Expr *Device,
1563 const RegionCodeGenTy &CodeGen,
1564 TargetDataInfo &Info);
1566 /// Emit the data mapping/movement code associated with the directive
1567 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1568 /// \param D Directive to emit.
1569 /// \param IfCond Expression evaluated in if clause associated with the target
1570 /// directive, or null if no if clause is used.
1571 /// \param Device Expression evaluated in device clause associated with the
1572 /// target directive, or null if no device clause is used.
1573 virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
1574 const OMPExecutableDirective &D,
1576 const Expr *Device);
1578 /// Marks function \a Fn with properly mangled versions of vector functions.
1579 /// \param FD Function marked as 'declare simd'.
1580 /// \param Fn LLVM function that must be marked with 'declare simd'
1582 virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1583 llvm::Function *Fn);
1585 /// Emit initialization for doacross loop nesting support.
1586 /// \param D Loop-based construct used in doacross nesting construct.
1587 virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
1588 ArrayRef<Expr *> NumIterations);
1590 /// Emit code for doacross ordered directive with 'depend' clause.
1591 /// \param C 'depend' clause with 'sink|source' dependency kind.
1592 virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1593 const OMPDependClause *C);
1595 /// Translates the native parameter of outlined function if this is required
1597 /// \param FD Field decl from captured record for the parameter.
1598 /// \param NativeParam Parameter itself.
1599 virtual const VarDecl *translateParameter(const FieldDecl *FD,
1600 const VarDecl *NativeParam) const {
1604 /// Gets the address of the native argument basing on the address of the
1605 /// target-specific parameter.
1606 /// \param NativeParam Parameter itself.
1607 /// \param TargetParam Corresponding target-specific parameter.
1608 virtual Address getParameterAddress(CodeGenFunction &CGF,
1609 const VarDecl *NativeParam,
1610 const VarDecl *TargetParam) const;
1612 /// Choose default schedule type and chunk value for the
1613 /// dist_schedule clause.
1614 virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF,
1615 const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1616 llvm::Value *&Chunk) const {}
1618 /// Choose default schedule type and chunk value for the
1619 /// schedule clause.
1620 virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF,
1621 const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1622 const Expr *&ChunkExpr) const;
1624 /// Emits call of the outlined function with the provided arguments,
1625 /// translating these arguments to correct target-specific arguments.
1627 emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc,
1628 llvm::FunctionCallee OutlinedFn,
1629 ArrayRef<llvm::Value *> Args = llvm::None) const;
1631 /// Emits OpenMP-specific function prolog.
1632 /// Required for device constructs.
1633 virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D);
1635 /// Gets the OpenMP-specific address of the local variable.
1636 virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF,
1639 /// Marks the declaration as already emitted for the device code and returns
1640 /// true, if it was marked already, and false, otherwise.
1641 bool markAsGlobalTarget(GlobalDecl GD);
1643 /// Emit deferred declare target variables marked for deferred emission.
1644 void emitDeferredTargetDecls() const;
1646 /// Adjust some parameters for the target-based directives, like addresses of
1647 /// the variables captured by reference in lambdas.
1649 adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF,
1650 const OMPExecutableDirective &D) const;
1652 /// Perform check on requires decl to ensure that target architecture
1653 /// supports unified addressing
1654 virtual void checkArchForUnifiedAddressing(const OMPRequiresDecl *D);
1656 /// Checks if the variable has associated OMPAllocateDeclAttr attribute with
1657 /// the predefined allocator and translates it into the corresponding address
1659 virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS);
1661 /// Return whether the unified_shared_memory has been specified.
1662 bool hasRequiresUnifiedSharedMemory() const;
1664 /// Emits the definition of the declare variant function.
1665 virtual bool emitDeclareVariant(GlobalDecl GD, bool IsForDefinition);
1668 /// Class supports emissionof SIMD-only code.
1669 class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime {
1671 explicit CGOpenMPSIMDRuntime(CodeGenModule &CGM) : CGOpenMPRuntime(CGM) {}
1672 ~CGOpenMPSIMDRuntime() override {}
1674 /// Emits outlined function for the specified OpenMP parallel directive
1675 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1676 /// kmp_int32 BoundID, struct context_vars*).
1677 /// \param D OpenMP directive.
1678 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1679 /// \param InnermostKind Kind of innermost directive (for simple directives it
1680 /// is a directive itself, for combined - its innermost directive).
1681 /// \param CodeGen Code generation sequence for the \a D directive.
1683 emitParallelOutlinedFunction(const OMPExecutableDirective &D,
1684 const VarDecl *ThreadIDVar,
1685 OpenMPDirectiveKind InnermostKind,
1686 const RegionCodeGenTy &CodeGen) override;
1688 /// Emits outlined function for the specified OpenMP teams directive
1689 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1690 /// kmp_int32 BoundID, struct context_vars*).
1691 /// \param D OpenMP directive.
1692 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1693 /// \param InnermostKind Kind of innermost directive (for simple directives it
1694 /// is a directive itself, for combined - its innermost directive).
1695 /// \param CodeGen Code generation sequence for the \a D directive.
1697 emitTeamsOutlinedFunction(const OMPExecutableDirective &D,
1698 const VarDecl *ThreadIDVar,
1699 OpenMPDirectiveKind InnermostKind,
1700 const RegionCodeGenTy &CodeGen) override;
1702 /// Emits outlined function for the OpenMP task directive \a D. This
1703 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1705 /// \param D OpenMP directive.
1706 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1707 /// \param PartIDVar Variable for partition id in the current OpenMP untied
1709 /// \param TaskTVar Variable for task_t argument.
1710 /// \param InnermostKind Kind of innermost directive (for simple directives it
1711 /// is a directive itself, for combined - its innermost directive).
1712 /// \param CodeGen Code generation sequence for the \a D directive.
1713 /// \param Tied true if task is generated for tied task, false otherwise.
1714 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1717 llvm::Function *emitTaskOutlinedFunction(
1718 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
1719 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
1720 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1721 bool Tied, unsigned &NumberOfParts) override;
1723 /// Emits code for parallel or serial call of the \a OutlinedFn with
1724 /// variables captured in a record which address is stored in \a
1726 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1727 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1728 /// \param CapturedVars A pointer to the record with the references to
1729 /// variables used in \a OutlinedFn function.
1730 /// \param IfCond Condition in the associated 'if' clause, if it was
1731 /// specified, nullptr otherwise.
1733 void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
1734 llvm::Function *OutlinedFn,
1735 ArrayRef<llvm::Value *> CapturedVars,
1736 const Expr *IfCond) override;
1738 /// Emits a critical region.
1739 /// \param CriticalName Name of the critical region.
1740 /// \param CriticalOpGen Generator for the statement associated with the given
1741 /// critical region.
1742 /// \param Hint Value of the 'hint' clause (optional).
1743 void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
1744 const RegionCodeGenTy &CriticalOpGen,
1746 const Expr *Hint = nullptr) override;
1748 /// Emits a master region.
1749 /// \param MasterOpGen Generator for the statement associated with the given
1751 void emitMasterRegion(CodeGenFunction &CGF,
1752 const RegionCodeGenTy &MasterOpGen,
1753 SourceLocation Loc) override;
1755 /// Emits code for a taskyield directive.
1756 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
1758 /// Emit a taskgroup region.
1759 /// \param TaskgroupOpGen Generator for the statement associated with the
1760 /// given taskgroup region.
1761 void emitTaskgroupRegion(CodeGenFunction &CGF,
1762 const RegionCodeGenTy &TaskgroupOpGen,
1763 SourceLocation Loc) override;
1765 /// Emits a single region.
1766 /// \param SingleOpGen Generator for the statement associated with the given
1768 void emitSingleRegion(CodeGenFunction &CGF,
1769 const RegionCodeGenTy &SingleOpGen, SourceLocation Loc,
1770 ArrayRef<const Expr *> CopyprivateVars,
1771 ArrayRef<const Expr *> DestExprs,
1772 ArrayRef<const Expr *> SrcExprs,
1773 ArrayRef<const Expr *> AssignmentOps) override;
1775 /// Emit an ordered region.
1776 /// \param OrderedOpGen Generator for the statement associated with the given
1778 void emitOrderedRegion(CodeGenFunction &CGF,
1779 const RegionCodeGenTy &OrderedOpGen,
1780 SourceLocation Loc, bool IsThreads) override;
1782 /// Emit an implicit/explicit barrier for OpenMP threads.
1783 /// \param Kind Directive for which this implicit barrier call must be
1784 /// generated. Must be OMPD_barrier for explicit barrier generation.
1785 /// \param EmitChecks true if need to emit checks for cancellation barriers.
1786 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1787 /// runtime class decides which one to emit (simple or with cancellation
1790 void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
1791 OpenMPDirectiveKind Kind, bool EmitChecks = true,
1792 bool ForceSimpleCall = false) override;
1794 /// This is used for non static scheduled types and when the ordered
1795 /// clause is present on the loop construct.
1796 /// Depending on the loop schedule, it is necessary to call some runtime
1797 /// routine before start of the OpenMP loop to get the loop upper / lower
1798 /// bounds \a LB and \a UB and stride \a ST.
1800 /// \param CGF Reference to current CodeGenFunction.
1801 /// \param Loc Clang source location.
1802 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1803 /// \param IVSize Size of the iteration variable in bits.
1804 /// \param IVSigned Sign of the iteration variable.
1805 /// \param Ordered true if loop is ordered, false otherwise.
1806 /// \param DispatchValues struct containing llvm values for lower bound, upper
1807 /// bound, and chunk expression.
1808 /// For the default (nullptr) value, the chunk 1 will be used.
1810 void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
1811 const OpenMPScheduleTy &ScheduleKind,
1812 unsigned IVSize, bool IVSigned, bool Ordered,
1813 const DispatchRTInput &DispatchValues) override;
1815 /// Call the appropriate runtime routine to initialize it before start
1818 /// This is used only in case of static schedule, when the user did not
1819 /// specify a ordered clause on the loop construct.
1820 /// Depending on the loop schedule, it is necessary to call some runtime
1821 /// routine before start of the OpenMP loop to get the loop upper / lower
1822 /// bounds LB and UB and stride ST.
1824 /// \param CGF Reference to current CodeGenFunction.
1825 /// \param Loc Clang source location.
1826 /// \param DKind Kind of the directive.
1827 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1828 /// \param Values Input arguments for the construct.
1830 void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1831 OpenMPDirectiveKind DKind,
1832 const OpenMPScheduleTy &ScheduleKind,
1833 const StaticRTInput &Values) override;
1836 /// \param CGF Reference to current CodeGenFunction.
1837 /// \param Loc Clang source location.
1838 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1839 /// \param Values Input arguments for the construct.
1841 void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1842 OpenMPDistScheduleClauseKind SchedKind,
1843 const StaticRTInput &Values) override;
1845 /// Call the appropriate runtime routine to notify that we finished
1846 /// iteration of the ordered loop with the dynamic scheduling.
1848 /// \param CGF Reference to current CodeGenFunction.
1849 /// \param Loc Clang source location.
1850 /// \param IVSize Size of the iteration variable in bits.
1851 /// \param IVSigned Sign of the iteration variable.
1853 void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc,
1854 unsigned IVSize, bool IVSigned) override;
1856 /// Call the appropriate runtime routine to notify that we finished
1857 /// all the work with current loop.
1859 /// \param CGF Reference to current CodeGenFunction.
1860 /// \param Loc Clang source location.
1861 /// \param DKind Kind of the directive for which the static finish is emitted.
1863 void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1864 OpenMPDirectiveKind DKind) override;
1866 /// Call __kmpc_dispatch_next(
1867 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1868 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1869 /// kmp_int[32|64] *p_stride);
1870 /// \param IVSize Size of the iteration variable in bits.
1871 /// \param IVSigned Sign of the iteration variable.
1872 /// \param IL Address of the output variable in which the flag of the
1873 /// last iteration is returned.
1874 /// \param LB Address of the output variable in which the lower iteration
1875 /// number is returned.
1876 /// \param UB Address of the output variable in which the upper iteration
1877 /// number is returned.
1878 /// \param ST Address of the output variable in which the stride value is
1880 llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1881 unsigned IVSize, bool IVSigned, Address IL,
1882 Address LB, Address UB, Address ST) override;
1884 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1885 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1887 /// \param NumThreads An integer value of threads.
1888 void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads,
1889 SourceLocation Loc) override;
1891 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1892 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1893 void emitProcBindClause(CodeGenFunction &CGF,
1894 OpenMPProcBindClauseKind ProcBind,
1895 SourceLocation Loc) override;
1897 /// Returns address of the threadprivate variable for the current
1899 /// \param VD Threadprivate variable.
1900 /// \param VDAddr Address of the global variable \a VD.
1901 /// \param Loc Location of the reference to threadprivate var.
1902 /// \return Address of the threadprivate variable for the current thread.
1903 Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD,
1904 Address VDAddr, SourceLocation Loc) override;
1906 /// Emit a code for initialization of threadprivate variable. It emits
1907 /// a call to runtime library which adds initial value to the newly created
1908 /// threadprivate variable (if it is not constant) and registers destructor
1909 /// for the variable (if any).
1910 /// \param VD Threadprivate variable.
1911 /// \param VDAddr Address of the global variable \a VD.
1912 /// \param Loc Location of threadprivate declaration.
1913 /// \param PerformInit true if initialization expression is not constant.
1915 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1916 SourceLocation Loc, bool PerformInit,
1917 CodeGenFunction *CGF = nullptr) override;
1919 /// Creates artificial threadprivate variable with name \p Name and type \p
1921 /// \param VarType Type of the artificial threadprivate variable.
1922 /// \param Name Name of the artificial threadprivate variable.
1923 Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1925 StringRef Name) override;
1927 /// Emit flush of the variables specified in 'omp flush' directive.
1928 /// \param Vars List of variables to flush.
1929 void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1930 SourceLocation Loc) override;
1932 /// Emit task region for the task directive. The task region is
1933 /// emitted in several steps:
1934 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1935 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1936 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1938 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1939 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1942 /// 2. Copy a list of shared variables to field shareds of the resulting
1943 /// structure kmp_task_t returned by the previous call (if any).
1944 /// 3. Copy a pointer to destructions function to field destructions of the
1945 /// resulting structure kmp_task_t.
1946 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1947 /// kmp_task_t *new_task), where new_task is a resulting structure from
1949 /// \param D Current task directive.
1950 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1951 /// /*part_id*/, captured_struct */*__context*/);
1952 /// \param SharedsTy A type which contains references the shared variables.
1953 /// \param Shareds Context with the list of shared variables from the \p
1955 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1957 /// \param Data Additional data for task generation like tiednsee, final
1958 /// state, list of privates etc.
1959 void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1960 const OMPExecutableDirective &D,
1961 llvm::Function *TaskFunction, QualType SharedsTy,
1962 Address Shareds, const Expr *IfCond,
1963 const OMPTaskDataTy &Data) override;
1965 /// Emit task region for the taskloop directive. The taskloop region is
1966 /// emitted in several steps:
1967 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1968 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1969 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1971 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1972 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1975 /// 2. Copy a list of shared variables to field shareds of the resulting
1976 /// structure kmp_task_t returned by the previous call (if any).
1977 /// 3. Copy a pointer to destructions function to field destructions of the
1978 /// resulting structure kmp_task_t.
1979 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1980 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1981 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1982 /// is a resulting structure from
1984 /// \param D Current task directive.
1985 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1986 /// /*part_id*/, captured_struct */*__context*/);
1987 /// \param SharedsTy A type which contains references the shared variables.
1988 /// \param Shareds Context with the list of shared variables from the \p
1990 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1992 /// \param Data Additional data for task generation like tiednsee, final
1993 /// state, list of privates etc.
1994 void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1995 const OMPLoopDirective &D, llvm::Function *TaskFunction,
1996 QualType SharedsTy, Address Shareds, const Expr *IfCond,
1997 const OMPTaskDataTy &Data) override;
1999 /// Emit a code for reduction clause. Next code should be emitted for
2003 /// static kmp_critical_name lock = { 0 };
2005 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
2007 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
2012 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
2013 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
2014 /// RedList, reduce_func, &<lock>)) {
2017 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
2019 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
2023 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
2030 /// \param Privates List of private copies for original reduction arguments.
2031 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
2032 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
2033 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
2034 /// or 'operator binop(LHS, RHS)'.
2035 /// \param Options List of options for reduction codegen:
2036 /// WithNowait true if parent directive has also nowait clause, false
2038 /// SimpleReduction Emit reduction operation only. Used for omp simd
2039 /// directive on the host.
2040 /// ReductionKind The kind of reduction to perform.
2041 void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
2042 ArrayRef<const Expr *> Privates,
2043 ArrayRef<const Expr *> LHSExprs,
2044 ArrayRef<const Expr *> RHSExprs,
2045 ArrayRef<const Expr *> ReductionOps,
2046 ReductionOptionsTy Options) override;
2048 /// Emit a code for initialization of task reduction clause. Next code
2049 /// should be emitted for reduction:
2052 /// _task_red_item_t red_data[n];
2054 /// red_data[i].shar = &origs[i];
2055 /// red_data[i].size = sizeof(origs[i]);
2056 /// red_data[i].f_init = (void*)RedInit<i>;
2057 /// red_data[i].f_fini = (void*)RedDest<i>;
2058 /// red_data[i].f_comb = (void*)RedOp<i>;
2059 /// red_data[i].flags = <Flag_i>;
2061 /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data);
2064 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
2065 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
2066 /// \param Data Additional data for task generation like tiedness, final
2067 /// state, list of privates, reductions etc.
2068 llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc,
2069 ArrayRef<const Expr *> LHSExprs,
2070 ArrayRef<const Expr *> RHSExprs,
2071 const OMPTaskDataTy &Data) override;
2073 /// Required to resolve existing problems in the runtime. Emits threadprivate
2074 /// variables to store the size of the VLAs/array sections for
2075 /// initializer/combiner/finalizer functions + emits threadprivate variable to
2076 /// store the pointer to the original reduction item for the custom
2077 /// initializer defined by declare reduction construct.
2078 /// \param RCG Allows to reuse an existing data for the reductions.
2079 /// \param N Reduction item for which fixups must be emitted.
2080 void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc,
2081 ReductionCodeGen &RCG, unsigned N) override;
2083 /// Get the address of `void *` type of the privatue copy of the reduction
2084 /// item specified by the \p SharedLVal.
2085 /// \param ReductionsPtr Pointer to the reduction data returned by the
2086 /// emitTaskReductionInit function.
2087 /// \param SharedLVal Address of the original reduction item.
2088 Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
2089 llvm::Value *ReductionsPtr,
2090 LValue SharedLVal) override;
2092 /// Emit code for 'taskwait' directive.
2093 void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc) override;
2095 /// Emit code for 'cancellation point' construct.
2096 /// \param CancelRegion Region kind for which the cancellation point must be
2099 void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc,
2100 OpenMPDirectiveKind CancelRegion) override;
2102 /// Emit code for 'cancel' construct.
2103 /// \param IfCond Condition in the associated 'if' clause, if it was
2104 /// specified, nullptr otherwise.
2105 /// \param CancelRegion Region kind for which the cancel must be emitted.
2107 void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
2109 OpenMPDirectiveKind CancelRegion) override;
2111 /// Emit outilined function for 'target' directive.
2112 /// \param D Directive to emit.
2113 /// \param ParentName Name of the function that encloses the target region.
2114 /// \param OutlinedFn Outlined function value to be defined by this call.
2115 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2116 /// \param IsOffloadEntry True if the outlined function is an offload entry.
2117 /// \param CodeGen Code generation sequence for the \a D directive.
2118 /// An outlined function may not be an entry if, e.g. the if clause always
2119 /// evaluates to false.
2120 void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
2121 StringRef ParentName,
2122 llvm::Function *&OutlinedFn,
2123 llvm::Constant *&OutlinedFnID,
2124 bool IsOffloadEntry,
2125 const RegionCodeGenTy &CodeGen) override;
2127 /// Emit the target offloading code associated with \a D. The emitted
2128 /// code attempts offloading the execution to the device, an the event of
2129 /// a failure it executes the host version outlined in \a OutlinedFn.
2130 /// \param D Directive to emit.
2131 /// \param OutlinedFn Host version of the code to be offloaded.
2132 /// \param OutlinedFnID ID of host version of the code to be offloaded.
2133 /// \param IfCond Expression evaluated in if clause associated with the target
2134 /// directive, or null if no if clause is used.
2135 /// \param Device Expression evaluated in device clause associated with the
2136 /// target directive, or null if no device clause is used.
2138 emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
2139 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID,
2140 const Expr *IfCond, const Expr *Device,
2141 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
2142 const OMPLoopDirective &D)>
2143 SizeEmitter) override;
2145 /// Emit the target regions enclosed in \a GD function definition or
2146 /// the function itself in case it is a valid device function. Returns true if
2147 /// \a GD was dealt with successfully.
2148 /// \param GD Function to scan.
2149 bool emitTargetFunctions(GlobalDecl GD) override;
2151 /// Emit the global variable if it is a valid device global variable.
2152 /// Returns true if \a GD was dealt with successfully.
2153 /// \param GD Variable declaration to emit.
2154 bool emitTargetGlobalVariable(GlobalDecl GD) override;
2156 /// Emit the global \a GD if it is meaningful for the target. Returns
2157 /// if it was emitted successfully.
2158 /// \param GD Global to scan.
2159 bool emitTargetGlobal(GlobalDecl GD) override;
2161 /// Emits code for teams call of the \a OutlinedFn with
2162 /// variables captured in a record which address is stored in \a
2164 /// \param OutlinedFn Outlined function to be run by team masters. Type of
2165 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2166 /// \param CapturedVars A pointer to the record with the references to
2167 /// variables used in \a OutlinedFn function.
2169 void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
2170 SourceLocation Loc, llvm::Function *OutlinedFn,
2171 ArrayRef<llvm::Value *> CapturedVars) override;
2173 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2174 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2175 /// for num_teams clause.
2176 /// \param NumTeams An integer expression of teams.
2177 /// \param ThreadLimit An integer expression of threads.
2178 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2179 const Expr *ThreadLimit, SourceLocation Loc) override;
2181 /// Emit the target data mapping code associated with \a D.
2182 /// \param D Directive to emit.
2183 /// \param IfCond Expression evaluated in if clause associated with the
2184 /// target directive, or null if no device clause is used.
2185 /// \param Device Expression evaluated in device clause associated with the
2186 /// target directive, or null if no device clause is used.
2187 /// \param Info A record used to store information that needs to be preserved
2188 /// until the region is closed.
2189 void emitTargetDataCalls(CodeGenFunction &CGF,
2190 const OMPExecutableDirective &D, const Expr *IfCond,
2191 const Expr *Device, const RegionCodeGenTy &CodeGen,
2192 TargetDataInfo &Info) override;
2194 /// Emit the data mapping/movement code associated with the directive
2195 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2196 /// \param D Directive to emit.
2197 /// \param IfCond Expression evaluated in if clause associated with the target
2198 /// directive, or null if no if clause is used.
2199 /// \param Device Expression evaluated in device clause associated with the
2200 /// target directive, or null if no device clause is used.
2201 void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
2202 const OMPExecutableDirective &D,
2204 const Expr *Device) override;
2206 /// Emit initialization for doacross loop nesting support.
2207 /// \param D Loop-based construct used in doacross nesting construct.
2208 void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
2209 ArrayRef<Expr *> NumIterations) override;
2211 /// Emit code for doacross ordered directive with 'depend' clause.
2212 /// \param C 'depend' clause with 'sink|source' dependency kind.
2213 void emitDoacrossOrdered(CodeGenFunction &CGF,
2214 const OMPDependClause *C) override;
2216 /// Translates the native parameter of outlined function if this is required
2218 /// \param FD Field decl from captured record for the parameter.
2219 /// \param NativeParam Parameter itself.
2220 const VarDecl *translateParameter(const FieldDecl *FD,
2221 const VarDecl *NativeParam) const override;
2223 /// Gets the address of the native argument basing on the address of the
2224 /// target-specific parameter.
2225 /// \param NativeParam Parameter itself.
2226 /// \param TargetParam Corresponding target-specific parameter.
2227 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2228 const VarDecl *TargetParam) const override;
2230 /// Gets the OpenMP-specific address of the local variable.
2231 Address getAddressOfLocalVariable(CodeGenFunction &CGF,
2232 const VarDecl *VD) override {
2233 return Address::invalid();
2237 } // namespace CodeGen
2238 } // namespace clang