1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This provides a class for OpenMP runtime code generation.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
15 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
18 #include "clang/AST/Type.h"
19 #include "clang/Basic/OpenMPKinds.h"
20 #include "clang/Basic/SourceLocation.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/StringMap.h"
24 #include "llvm/IR/Function.h"
25 #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<std::pair<OpenMPDependClauseKind, const Expr *>, 4> Dependences;
100 llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
101 llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
102 llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
103 unsigned NumberOfParts = 0;
105 bool Nogroup = false;
108 class CGOpenMPRuntime {
112 /// \brief Creates offloading entry for the provided entry ID \a ID,
113 /// address \a Addr, size \a Size, and flags \a Flags.
114 virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
115 uint64_t Size, int32_t Flags = 0);
117 /// \brief Helper to emit outlined function for 'target' directive.
118 /// \param D Directive to emit.
119 /// \param ParentName Name of the function that encloses the target region.
120 /// \param OutlinedFn Outlined function value to be defined by this call.
121 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
122 /// \param IsOffloadEntry True if the outlined function is an offload entry.
123 /// \param CodeGen Lambda codegen specific to an accelerator device.
124 /// An oulined function may not be an entry if, e.g. the if clause always
125 /// evaluates to false.
126 virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D,
127 StringRef ParentName,
128 llvm::Function *&OutlinedFn,
129 llvm::Constant *&OutlinedFnID,
131 const RegionCodeGenTy &CodeGen);
133 /// \brief Emits code for OpenMP 'if' clause using specified \a CodeGen
134 /// function. Here is the logic:
140 void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
141 const RegionCodeGenTy &ThenGen,
142 const RegionCodeGenTy &ElseGen);
144 /// \brief Emits object of ident_t type with info for source location.
145 /// \param Flags Flags for OpenMP location.
147 llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
150 /// \brief Returns pointer to ident_t type.
151 llvm::Type *getIdentTyPointerTy();
153 /// \brief Gets thread id value for the current thread.
155 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
157 /// \brief Get the function name of an outlined region.
158 // The name can be customized depending on the target.
160 virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
163 /// \brief Default const ident_t object used for initialization of all other
165 llvm::Constant *DefaultOpenMPPSource = nullptr;
166 /// \brief Map of flags and corresponding default locations.
167 typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
168 OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
169 Address getOrCreateDefaultLocation(unsigned Flags);
171 llvm::StructType *IdentTy = nullptr;
172 /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
173 typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
174 OpenMPDebugLocMapTy OpenMPDebugLocMap;
175 /// \brief The type for a microtask which gets passed to __kmpc_fork_call().
176 /// Original representation is:
177 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
178 llvm::FunctionType *Kmpc_MicroTy = nullptr;
179 /// \brief Stores debug location and ThreadID for the function.
180 struct DebugLocThreadIdTy {
181 llvm::Value *DebugLoc;
182 llvm::Value *ThreadID;
184 /// \brief Map of local debug location, ThreadId and functions.
185 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
186 OpenMPLocThreadIDMapTy;
187 OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
188 /// Map of UDRs and corresponding combiner/initializer.
189 typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
190 std::pair<llvm::Function *, llvm::Function *>>
193 /// Map of functions and locally defined UDRs.
194 typedef llvm::DenseMap<llvm::Function *,
195 SmallVector<const OMPDeclareReductionDecl *, 4>>
197 FunctionUDRMapTy FunctionUDRMap;
198 IdentifierInfo *In = nullptr;
199 IdentifierInfo *Out = nullptr;
200 IdentifierInfo *Priv = nullptr;
201 IdentifierInfo *Orig = nullptr;
202 /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
203 /// kmp_critical_name[8];
204 llvm::ArrayType *KmpCriticalNameTy;
205 /// \brief An ordered map of auto-generated variables to their unique names.
206 /// It stores variables with the following names: 1) ".gomp_critical_user_" +
207 /// <critical_section_name> + ".var" for "omp critical" directives; 2)
208 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
210 llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
212 /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
213 llvm::Type *KmpRoutineEntryPtrTy = nullptr;
214 QualType KmpRoutineEntryPtrQTy;
215 /// \brief Type typedef struct kmp_task {
216 /// void * shareds; /**< pointer to block of pointers to
218 /// kmp_routine_entry_t routine; /**< pointer to routine to call for
219 /// executing task */
220 /// kmp_int32 part_id; /**< part id for the task */
221 /// kmp_routine_entry_t destructors; /* pointer to function to invoke
222 /// deconstructors of firstprivate C++ objects */
224 QualType KmpTaskTQTy;
225 /// \brief Type typedef struct kmp_depend_info {
226 /// kmp_intptr_t base_addr;
232 /// } kmp_depend_info_t;
233 QualType KmpDependInfoTy;
234 /// struct kmp_dim { // loop bounds info casted to kmp_int64
235 /// kmp_int64 lo; // lower
236 /// kmp_int64 up; // upper
237 /// kmp_int64 st; // stride
240 /// \brief Type struct __tgt_offload_entry{
241 /// void *addr; // Pointer to the offload entry info.
242 /// // (function or global)
243 /// char *name; // Name of the function or global.
244 /// size_t size; // Size of the entry info (0 if it a function).
246 QualType TgtOffloadEntryQTy;
247 /// struct __tgt_device_image{
248 /// void *ImageStart; // Pointer to the target code start.
249 /// void *ImageEnd; // Pointer to the target code end.
250 /// // We also add the host entries to the device image, as it may be useful
251 /// // for the target runtime to have access to that information.
252 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
254 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
255 /// // entries (non inclusive).
257 QualType TgtDeviceImageQTy;
258 /// struct __tgt_bin_desc{
259 /// int32_t NumDevices; // Number of devices supported.
260 /// __tgt_device_image *DeviceImages; // Arrays of device images
261 /// // (one per device).
262 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
264 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
265 /// // entries (non inclusive).
267 QualType TgtBinaryDescriptorQTy;
268 /// \brief Entity that registers the offloading constants that were emitted so
270 class OffloadEntriesInfoManagerTy {
273 /// \brief Number of entries registered so far.
274 unsigned OffloadingEntriesNum;
277 /// Base class of the entries info.
278 class OffloadEntryInfo {
280 /// Kind of a given entry. Currently, only target regions are
282 enum OffloadingEntryInfoKinds : unsigned {
283 // Entry is a target region.
284 OFFLOAD_ENTRY_INFO_TARGET_REGION = 0,
285 // Invalid entry info.
286 OFFLOAD_ENTRY_INFO_INVALID = ~0u
290 : Flags(0), Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
291 explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order,
293 : Flags(Flags), Order(Order), Kind(Kind) {}
295 bool isValid() const { return Order != ~0u; }
296 unsigned getOrder() const { return Order; }
297 OffloadingEntryInfoKinds getKind() const { return Kind; }
298 int32_t getFlags() const { return Flags; }
299 void setFlags(int32_t NewFlags) { Flags = NewFlags; }
300 static bool classof(const OffloadEntryInfo *Info) { return true; }
303 /// Flags associated with the device global.
306 /// Order this entry was emitted.
309 OffloadingEntryInfoKinds Kind;
312 /// \brief Return true if a there are no entries defined.
314 /// \brief Return number of entries defined so far.
315 unsigned size() const { return OffloadingEntriesNum; }
316 OffloadEntriesInfoManagerTy(CodeGenModule &CGM)
317 : CGM(CGM), OffloadingEntriesNum(0) {}
320 /// Target region entries related.
322 /// \brief Target region entries info.
323 class OffloadEntryInfoTargetRegion : public OffloadEntryInfo {
324 // \brief Address of the entity that has to be mapped for offloading.
325 llvm::Constant *Addr;
326 // \brief Address that can be used as the ID of the entry.
330 OffloadEntryInfoTargetRegion()
331 : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, ~0u,
333 Addr(nullptr), ID(nullptr) {}
334 explicit OffloadEntryInfoTargetRegion(unsigned Order,
335 llvm::Constant *Addr,
336 llvm::Constant *ID, int32_t Flags)
337 : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, Order, Flags),
338 Addr(Addr), ID(ID) {}
340 llvm::Constant *getAddress() const { return Addr; }
341 llvm::Constant *getID() const { return ID; }
342 void setAddress(llvm::Constant *V) {
343 assert(!Addr && "Address as been set before!");
346 void setID(llvm::Constant *V) {
347 assert(!ID && "ID as been set before!");
350 static bool classof(const OffloadEntryInfo *Info) {
351 return Info->getKind() == OFFLOAD_ENTRY_INFO_TARGET_REGION;
354 /// \brief Initialize target region entry.
355 void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
356 StringRef ParentName, unsigned LineNum,
358 /// \brief Register target region entry.
359 void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
360 StringRef ParentName, unsigned LineNum,
361 llvm::Constant *Addr, llvm::Constant *ID,
363 /// \brief Return true if a target region entry with the provided
364 /// information exists.
365 bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
366 StringRef ParentName, unsigned LineNum) const;
367 /// brief Applies action \a Action on all registered entries.
368 typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
369 OffloadEntryInfoTargetRegion &)>
370 OffloadTargetRegionEntryInfoActTy;
371 void actOnTargetRegionEntriesInfo(
372 const OffloadTargetRegionEntryInfoActTy &Action);
375 // Storage for target region entries kind. The storage is to be indexed by
376 // file ID, device ID, parent function name and line number.
377 typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
378 OffloadEntriesTargetRegionPerLine;
379 typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
380 OffloadEntriesTargetRegionPerParentName;
381 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
382 OffloadEntriesTargetRegionPerFile;
383 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
384 OffloadEntriesTargetRegionPerDevice;
385 typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
386 OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
388 OffloadEntriesInfoManagerTy OffloadEntriesInfoManager;
390 /// \brief Creates and registers offloading binary descriptor for the current
391 /// compilation unit. The function that does the registration is returned.
392 llvm::Function *createOffloadingBinaryDescriptorRegistration();
394 /// \brief Creates all the offload entries in the current compilation unit
395 /// along with the associated metadata.
396 void createOffloadEntriesAndInfoMetadata();
398 /// \brief Loads all the offload entries information from the host IR
400 void loadOffloadInfoMetadata();
402 /// \brief Returns __tgt_offload_entry type.
403 QualType getTgtOffloadEntryQTy();
405 /// \brief Returns __tgt_device_image type.
406 QualType getTgtDeviceImageQTy();
408 /// \brief Returns __tgt_bin_desc type.
409 QualType getTgtBinaryDescriptorQTy();
411 /// \brief Start scanning from statement \a S and and emit all target regions
412 /// found along the way.
413 /// \param S Starting statement.
414 /// \param ParentName Name of the function declaration that is being scanned.
415 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
417 /// \brief Build type kmp_routine_entry_t (if not built yet).
418 void emitKmpRoutineEntryT(QualType KmpInt32Ty);
420 /// \brief Returns pointer to kmpc_micro type.
421 llvm::Type *getKmpc_MicroPointerTy();
423 /// \brief Returns specified OpenMP runtime function.
424 /// \param Function OpenMP runtime function.
425 /// \return Specified function.
426 llvm::Constant *createRuntimeFunction(unsigned Function);
428 /// \brief Returns __kmpc_for_static_init_* runtime function for the specified
429 /// size \a IVSize and sign \a IVSigned.
430 llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
432 /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified
433 /// size \a IVSize and sign \a IVSigned.
434 llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
436 /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified
437 /// size \a IVSize and sign \a IVSigned.
438 llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
440 /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified
441 /// size \a IVSize and sign \a IVSigned.
442 llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
444 /// \brief If the specified mangled name is not in the module, create and
445 /// return threadprivate cache object. This object is a pointer's worth of
446 /// storage that's reserved for use by the OpenMP runtime.
447 /// \param VD Threadprivate variable.
448 /// \return Cache variable for the specified threadprivate.
449 llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
451 /// \brief Emits address of the word in a memory where current thread id is
453 virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
455 /// \brief Gets (if variable with the given name already exist) or creates
456 /// internal global variable with the specified Name. The created variable has
457 /// linkage CommonLinkage by default and is initialized by null value.
458 /// \param Ty Type of the global variable. If it is exist already the type
459 /// must be the same.
460 /// \param Name Name of the variable.
461 llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
462 const llvm::Twine &Name);
464 /// \brief Set of threadprivate variables with the generated initializer.
465 llvm::SmallPtrSet<const VarDecl *, 4> ThreadPrivateWithDefinition;
467 /// \brief Emits initialization code for the threadprivate variables.
468 /// \param VDAddr Address of the global variable \a VD.
469 /// \param Ctor Pointer to a global init function for \a VD.
470 /// \param CopyCtor Pointer to a global copy function for \a VD.
471 /// \param Dtor Pointer to a global destructor function for \a VD.
472 /// \param Loc Location of threadprivate declaration.
473 void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
474 llvm::Value *Ctor, llvm::Value *CopyCtor,
475 llvm::Value *Dtor, SourceLocation Loc);
477 /// \brief Returns corresponding lock object for the specified critical region
478 /// name. If the lock object does not exist it is created, otherwise the
479 /// reference to the existing copy is returned.
480 /// \param CriticalName Name of the critical region.
482 llvm::Value *getCriticalRegionLock(StringRef CriticalName);
484 struct TaskResultTy {
485 llvm::Value *NewTask = nullptr;
486 llvm::Value *TaskEntry = nullptr;
487 llvm::Value *NewTaskNewTaskTTy = nullptr;
489 RecordDecl *KmpTaskTQTyRD = nullptr;
490 llvm::Value *TaskDupFn = nullptr;
492 /// Emit task region for the task directive. The task region is emitted in
494 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
495 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
496 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
498 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
499 /// TaskFunction(gtid, tt->part_id, tt->shareds);
502 /// 2. Copy a list of shared variables to field shareds of the resulting
503 /// structure kmp_task_t returned by the previous call (if any).
504 /// 3. Copy a pointer to destructions function to field destructions of the
505 /// resulting structure kmp_task_t.
506 /// \param D Current task directive.
507 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
508 /// /*part_id*/, captured_struct */*__context*/);
509 /// \param SharedsTy A type which contains references the shared variables.
510 /// \param Shareds Context with the list of shared variables from the \p
512 /// \param Data Additional data for task generation like tiednsee, final
513 /// state, list of privates etc.
514 TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
515 const OMPExecutableDirective &D,
516 llvm::Value *TaskFunction, QualType SharedsTy,
517 Address Shareds, const OMPTaskDataTy &Data);
520 explicit CGOpenMPRuntime(CodeGenModule &CGM);
521 virtual ~CGOpenMPRuntime() {}
522 virtual void clear();
524 /// Emit code for the specified user defined reduction construct.
525 virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
526 const OMPDeclareReductionDecl *D);
527 /// Get combiner/initializer for the specified user-defined reduction, if any.
528 virtual std::pair<llvm::Function *, llvm::Function *>
529 getUserDefinedReduction(const OMPDeclareReductionDecl *D);
530 /// \brief Emits outlined function for the specified OpenMP parallel directive
531 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
532 /// kmp_int32 BoundID, struct context_vars*).
533 /// \param D OpenMP directive.
534 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
535 /// \param InnermostKind Kind of innermost directive (for simple directives it
536 /// is a directive itself, for combined - its innermost directive).
537 /// \param CodeGen Code generation sequence for the \a D directive.
538 virtual llvm::Value *emitParallelOrTeamsOutlinedFunction(
539 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
540 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
542 /// \brief Emits outlined function for the OpenMP task directive \a D. This
543 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
545 /// \param D OpenMP directive.
546 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
547 /// \param PartIDVar Variable for partition id in the current OpenMP untied
549 /// \param TaskTVar Variable for task_t argument.
550 /// \param InnermostKind Kind of innermost directive (for simple directives it
551 /// is a directive itself, for combined - its innermost directive).
552 /// \param CodeGen Code generation sequence for the \a D directive.
553 /// \param Tied true if task is generated for tied task, false otherwise.
554 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
557 virtual llvm::Value *emitTaskOutlinedFunction(
558 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
559 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
560 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
561 bool Tied, unsigned &NumberOfParts);
563 /// \brief Cleans up references to the objects in finished function.
565 void functionFinished(CodeGenFunction &CGF);
567 /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
568 /// variables captured in a record which address is stored in \a
570 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
571 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
572 /// \param CapturedVars A pointer to the record with the references to
573 /// variables used in \a OutlinedFn function.
574 /// \param IfCond Condition in the associated 'if' clause, if it was
575 /// specified, nullptr otherwise.
577 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
578 llvm::Value *OutlinedFn,
579 ArrayRef<llvm::Value *> CapturedVars,
582 /// \brief Emits a critical region.
583 /// \param CriticalName Name of the critical region.
584 /// \param CriticalOpGen Generator for the statement associated with the given
586 /// \param Hint Value of the 'hint' clause (optional).
587 virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
588 const RegionCodeGenTy &CriticalOpGen,
590 const Expr *Hint = nullptr);
592 /// \brief Emits a master region.
593 /// \param MasterOpGen Generator for the statement associated with the given
595 virtual void emitMasterRegion(CodeGenFunction &CGF,
596 const RegionCodeGenTy &MasterOpGen,
599 /// \brief Emits code for a taskyield directive.
600 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
602 /// \brief Emit a taskgroup region.
603 /// \param TaskgroupOpGen Generator for the statement associated with the
604 /// given taskgroup region.
605 virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
606 const RegionCodeGenTy &TaskgroupOpGen,
609 /// \brief Emits a single region.
610 /// \param SingleOpGen Generator for the statement associated with the given
612 virtual void emitSingleRegion(CodeGenFunction &CGF,
613 const RegionCodeGenTy &SingleOpGen,
615 ArrayRef<const Expr *> CopyprivateVars,
616 ArrayRef<const Expr *> DestExprs,
617 ArrayRef<const Expr *> SrcExprs,
618 ArrayRef<const Expr *> AssignmentOps);
620 /// \brief Emit an ordered region.
621 /// \param OrderedOpGen Generator for the statement associated with the given
623 virtual void emitOrderedRegion(CodeGenFunction &CGF,
624 const RegionCodeGenTy &OrderedOpGen,
625 SourceLocation Loc, bool IsThreads);
627 /// \brief Emit an implicit/explicit barrier for OpenMP threads.
628 /// \param Kind Directive for which this implicit barrier call must be
629 /// generated. Must be OMPD_barrier for explicit barrier generation.
630 /// \param EmitChecks true if need to emit checks for cancellation barriers.
631 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
632 /// runtime class decides which one to emit (simple or with cancellation
635 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
636 OpenMPDirectiveKind Kind,
637 bool EmitChecks = true,
638 bool ForceSimpleCall = false);
640 /// \brief Check if the specified \a ScheduleKind is static non-chunked.
641 /// This kind of worksharing directive is emitted without outer loop.
642 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
643 /// \param Chunked True if chunk is specified in the clause.
645 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
648 /// \brief Check if the specified \a ScheduleKind is static non-chunked.
649 /// This kind of distribute directive is emitted without outer loop.
650 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
651 /// \param Chunked True if chunk is specified in the clause.
653 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
656 /// \brief Check if the specified \a ScheduleKind is dynamic.
657 /// This kind of worksharing directive is emitted without outer loop.
658 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
660 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
662 virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
663 const OpenMPScheduleTy &ScheduleKind,
664 unsigned IVSize, bool IVSigned, bool Ordered,
666 llvm::Value *Chunk = nullptr);
668 /// \brief Call the appropriate runtime routine to initialize it before start
671 /// Depending on the loop schedule, it is nesessary to call some runtime
672 /// routine before start of the OpenMP loop to get the loop upper / lower
673 /// bounds \a LB and \a UB and stride \a ST.
675 /// \param CGF Reference to current CodeGenFunction.
676 /// \param Loc Clang source location.
677 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
678 /// \param IVSize Size of the iteration variable in bits.
679 /// \param IVSigned Sign of the interation variable.
680 /// \param Ordered true if loop is ordered, false otherwise.
681 /// \param IL Address of the output variable in which the flag of the
682 /// last iteration is returned.
683 /// \param LB Address of the output variable in which the lower iteration
684 /// number is returned.
685 /// \param UB Address of the output variable in which the upper iteration
686 /// number is returned.
687 /// \param ST Address of the output variable in which the stride value is
688 /// returned nesessary to generated the static_chunked scheduled loop.
689 /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
690 /// For the default (nullptr) value, the chunk 1 will be used.
692 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
693 const OpenMPScheduleTy &ScheduleKind,
694 unsigned IVSize, bool IVSigned, bool Ordered,
695 Address IL, Address LB, Address UB, Address ST,
696 llvm::Value *Chunk = nullptr);
699 /// \param CGF Reference to current CodeGenFunction.
700 /// \param Loc Clang source location.
701 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
702 /// \param IVSize Size of the iteration variable in bits.
703 /// \param IVSigned Sign of the interation variable.
704 /// \param Ordered true if loop is ordered, false otherwise.
705 /// \param IL Address of the output variable in which the flag of the
706 /// last iteration is returned.
707 /// \param LB Address of the output variable in which the lower iteration
708 /// number is returned.
709 /// \param UB Address of the output variable in which the upper iteration
710 /// number is returned.
711 /// \param ST Address of the output variable in which the stride value is
712 /// returned nesessary to generated the static_chunked scheduled loop.
713 /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
714 /// For the default (nullptr) value, the chunk 1 will be used.
716 virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
717 OpenMPDistScheduleClauseKind SchedKind,
718 unsigned IVSize, bool IVSigned,
719 bool Ordered, Address IL, Address LB,
720 Address UB, Address ST,
721 llvm::Value *Chunk = nullptr);
723 /// \brief Call the appropriate runtime routine to notify that we finished
724 /// iteration of the ordered loop with the dynamic scheduling.
726 /// \param CGF Reference to current CodeGenFunction.
727 /// \param Loc Clang source location.
728 /// \param IVSize Size of the iteration variable in bits.
729 /// \param IVSigned Sign of the interation variable.
731 virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
732 SourceLocation Loc, unsigned IVSize,
735 /// \brief Call the appropriate runtime routine to notify that we finished
736 /// all the work with current loop.
738 /// \param CGF Reference to current CodeGenFunction.
739 /// \param Loc Clang source location.
741 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc);
743 /// Call __kmpc_dispatch_next(
744 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
745 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
746 /// kmp_int[32|64] *p_stride);
747 /// \param IVSize Size of the iteration variable in bits.
748 /// \param IVSigned Sign of the interation variable.
749 /// \param IL Address of the output variable in which the flag of the
750 /// last iteration is returned.
751 /// \param LB Address of the output variable in which the lower iteration
752 /// number is returned.
753 /// \param UB Address of the output variable in which the upper iteration
754 /// number is returned.
755 /// \param ST Address of the output variable in which the stride value is
757 virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
758 unsigned IVSize, bool IVSigned,
759 Address IL, Address LB,
760 Address UB, Address ST);
762 /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
763 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
765 /// \param NumThreads An integer value of threads.
766 virtual void emitNumThreadsClause(CodeGenFunction &CGF,
767 llvm::Value *NumThreads,
770 /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
771 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
772 virtual void emitProcBindClause(CodeGenFunction &CGF,
773 OpenMPProcBindClauseKind ProcBind,
776 /// \brief Returns address of the threadprivate variable for the current
778 /// \param VD Threadprivate variable.
779 /// \param VDAddr Address of the global variable \a VD.
780 /// \param Loc Location of the reference to threadprivate var.
781 /// \return Address of the threadprivate variable for the current thread.
782 virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
787 /// \brief Emit a code for initialization of threadprivate variable. It emits
788 /// a call to runtime library which adds initial value to the newly created
789 /// threadprivate variable (if it is not constant) and registers destructor
790 /// for the variable (if any).
791 /// \param VD Threadprivate variable.
792 /// \param VDAddr Address of the global variable \a VD.
793 /// \param Loc Location of threadprivate declaration.
794 /// \param PerformInit true if initialization expression is not constant.
795 virtual llvm::Function *
796 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
797 SourceLocation Loc, bool PerformInit,
798 CodeGenFunction *CGF = nullptr);
800 /// \brief Emit flush of the variables specified in 'omp flush' directive.
801 /// \param Vars List of variables to flush.
802 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
805 /// \brief Emit task region for the task directive. The task region is
806 /// emitted in several steps:
807 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
808 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
809 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
811 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
812 /// TaskFunction(gtid, tt->part_id, tt->shareds);
815 /// 2. Copy a list of shared variables to field shareds of the resulting
816 /// structure kmp_task_t returned by the previous call (if any).
817 /// 3. Copy a pointer to destructions function to field destructions of the
818 /// resulting structure kmp_task_t.
819 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
820 /// kmp_task_t *new_task), where new_task is a resulting structure from
822 /// \param D Current task directive.
823 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
824 /// /*part_id*/, captured_struct */*__context*/);
825 /// \param SharedsTy A type which contains references the shared variables.
826 /// \param Shareds Context with the list of shared variables from the \p
828 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
830 /// \param Data Additional data for task generation like tiednsee, final
831 /// state, list of privates etc.
832 virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
833 const OMPExecutableDirective &D,
834 llvm::Value *TaskFunction, QualType SharedsTy,
835 Address Shareds, const Expr *IfCond,
836 const OMPTaskDataTy &Data);
838 /// Emit task region for the taskloop directive. The taskloop region is
839 /// emitted in several steps:
840 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
841 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
842 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
844 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
845 /// TaskFunction(gtid, tt->part_id, tt->shareds);
848 /// 2. Copy a list of shared variables to field shareds of the resulting
849 /// structure kmp_task_t returned by the previous call (if any).
850 /// 3. Copy a pointer to destructions function to field destructions of the
851 /// resulting structure kmp_task_t.
852 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
853 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
854 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
855 /// is a resulting structure from
857 /// \param D Current task directive.
858 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
859 /// /*part_id*/, captured_struct */*__context*/);
860 /// \param SharedsTy A type which contains references the shared variables.
861 /// \param Shareds Context with the list of shared variables from the \p
863 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
865 /// \param Data Additional data for task generation like tiednsee, final
866 /// state, list of privates etc.
867 virtual void emitTaskLoopCall(
868 CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D,
869 llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds,
870 const Expr *IfCond, const OMPTaskDataTy &Data);
872 /// \brief Emit code for the directive that does not require outlining.
874 /// \param InnermostKind Kind of innermost directive (for simple directives it
875 /// is a directive itself, for combined - its innermost directive).
876 /// \param CodeGen Code generation sequence for the \a D directive.
877 /// \param HasCancel true if region has inner cancel directive, false
879 virtual void emitInlinedDirective(CodeGenFunction &CGF,
880 OpenMPDirectiveKind InnermostKind,
881 const RegionCodeGenTy &CodeGen,
882 bool HasCancel = false);
883 /// \brief Emit a code for reduction clause. Next code should be emitted for
887 /// static kmp_critical_name lock = { 0 };
889 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
891 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
896 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
897 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
898 /// RedList, reduce_func, &<lock>)) {
901 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
903 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
907 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
914 /// \param Privates List of private copies for original reduction arguments.
915 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
916 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
917 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
918 /// or 'operator binop(LHS, RHS)'.
919 /// \param WithNowait true if parent directive has also nowait clause, false
921 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
922 ArrayRef<const Expr *> Privates,
923 ArrayRef<const Expr *> LHSExprs,
924 ArrayRef<const Expr *> RHSExprs,
925 ArrayRef<const Expr *> ReductionOps,
926 bool WithNowait, bool SimpleReduction);
928 /// \brief Emit code for 'taskwait' directive.
929 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
931 /// \brief Emit code for 'cancellation point' construct.
932 /// \param CancelRegion Region kind for which the cancellation point must be
935 virtual void emitCancellationPointCall(CodeGenFunction &CGF,
937 OpenMPDirectiveKind CancelRegion);
939 /// \brief Emit code for 'cancel' construct.
940 /// \param IfCond Condition in the associated 'if' clause, if it was
941 /// specified, nullptr otherwise.
942 /// \param CancelRegion Region kind for which the cancel must be emitted.
944 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
946 OpenMPDirectiveKind CancelRegion);
948 /// \brief Emit outilined function for 'target' directive.
949 /// \param D Directive to emit.
950 /// \param ParentName Name of the function that encloses the target region.
951 /// \param OutlinedFn Outlined function value to be defined by this call.
952 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
953 /// \param IsOffloadEntry True if the outlined function is an offload entry.
954 /// \param CodeGen Code generation sequence for the \a D directive.
955 /// An oulined function may not be an entry if, e.g. the if clause always
956 /// evaluates to false.
957 virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
958 StringRef ParentName,
959 llvm::Function *&OutlinedFn,
960 llvm::Constant *&OutlinedFnID,
962 const RegionCodeGenTy &CodeGen);
964 /// \brief Emit the target offloading code associated with \a D. The emitted
965 /// code attempts offloading the execution to the device, an the event of
966 /// a failure it executes the host version outlined in \a OutlinedFn.
967 /// \param D Directive to emit.
968 /// \param OutlinedFn Host version of the code to be offloaded.
969 /// \param OutlinedFnID ID of host version of the code to be offloaded.
970 /// \param IfCond Expression evaluated in if clause associated with the target
971 /// directive, or null if no if clause is used.
972 /// \param Device Expression evaluated in device clause associated with the
973 /// target directive, or null if no device clause is used.
974 /// \param CapturedVars Values captured in the current region.
975 virtual void emitTargetCall(CodeGenFunction &CGF,
976 const OMPExecutableDirective &D,
977 llvm::Value *OutlinedFn,
978 llvm::Value *OutlinedFnID, const Expr *IfCond,
980 ArrayRef<llvm::Value *> CapturedVars);
982 /// \brief Emit the target regions enclosed in \a GD function definition or
983 /// the function itself in case it is a valid device function. Returns true if
984 /// \a GD was dealt with successfully.
985 /// \param GD Function to scan.
986 virtual bool emitTargetFunctions(GlobalDecl GD);
988 /// \brief Emit the global variable if it is a valid device global variable.
989 /// Returns true if \a GD was dealt with successfully.
990 /// \param GD Variable declaration to emit.
991 virtual bool emitTargetGlobalVariable(GlobalDecl GD);
993 /// \brief Emit the global \a GD if it is meaningful for the target. Returns
994 /// if it was emitted succesfully.
995 /// \param GD Global to scan.
996 virtual bool emitTargetGlobal(GlobalDecl GD);
998 /// \brief Creates the offloading descriptor in the event any target region
999 /// was emitted in the current module and return the function that registers
1001 virtual llvm::Function *emitRegistrationFunction();
1003 /// \brief Emits code for teams call of the \a OutlinedFn with
1004 /// variables captured in a record which address is stored in \a
1006 /// \param OutlinedFn Outlined function to be run by team masters. Type of
1007 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1008 /// \param CapturedVars A pointer to the record with the references to
1009 /// variables used in \a OutlinedFn function.
1011 virtual void emitTeamsCall(CodeGenFunction &CGF,
1012 const OMPExecutableDirective &D,
1013 SourceLocation Loc, llvm::Value *OutlinedFn,
1014 ArrayRef<llvm::Value *> CapturedVars);
1016 /// \brief Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1017 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1018 /// for num_teams clause.
1019 /// \param NumTeams An integer expression of teams.
1020 /// \param ThreadLimit An integer expression of threads.
1021 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1022 const Expr *ThreadLimit, SourceLocation Loc);
1024 /// Struct that keeps all the relevant information that should be kept
1025 /// throughout a 'target data' region.
1026 class TargetDataInfo {
1027 /// Set to true if device pointer information have to be obtained.
1028 bool RequiresDevicePointerInfo = false;
1031 /// The array of base pointer passed to the runtime library.
1032 llvm::Value *BasePointersArray = nullptr;
1033 /// The array of section pointers passed to the runtime library.
1034 llvm::Value *PointersArray = nullptr;
1035 /// The array of sizes passed to the runtime library.
1036 llvm::Value *SizesArray = nullptr;
1037 /// The array of map types passed to the runtime library.
1038 llvm::Value *MapTypesArray = nullptr;
1039 /// The total number of pointers passed to the runtime library.
1040 unsigned NumberOfPtrs = 0u;
1041 /// Map between the a declaration of a capture and the corresponding base
1042 /// pointer address where the runtime returns the device pointers.
1043 llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1045 explicit TargetDataInfo() {}
1046 explicit TargetDataInfo(bool RequiresDevicePointerInfo)
1047 : RequiresDevicePointerInfo(RequiresDevicePointerInfo) {}
1048 /// Clear information about the data arrays.
1049 void clearArrayInfo() {
1050 BasePointersArray = nullptr;
1051 PointersArray = nullptr;
1052 SizesArray = nullptr;
1053 MapTypesArray = nullptr;
1056 /// Return true if the current target data information has valid arrays.
1058 return BasePointersArray && PointersArray && SizesArray &&
1059 MapTypesArray && NumberOfPtrs;
1061 bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
1064 /// \brief Emit the target data mapping code associated with \a D.
1065 /// \param D Directive to emit.
1066 /// \param IfCond Expression evaluated in if clause associated with the
1067 /// target directive, or null if no device clause is used.
1068 /// \param Device Expression evaluated in device clause associated with the
1069 /// target directive, or null if no device clause is used.
1070 /// \param Info A record used to store information that needs to be preserved
1071 /// until the region is closed.
1072 virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1073 const OMPExecutableDirective &D,
1074 const Expr *IfCond, const Expr *Device,
1075 const RegionCodeGenTy &CodeGen,
1076 TargetDataInfo &Info);
1078 /// \brief Emit the data mapping/movement code associated with the directive
1079 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1080 /// \param D Directive to emit.
1081 /// \param IfCond Expression evaluated in if clause associated with the target
1082 /// directive, or null if no if clause is used.
1083 /// \param Device Expression evaluated in device clause associated with the
1084 /// target directive, or null if no device clause is used.
1085 virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
1086 const OMPExecutableDirective &D,
1088 const Expr *Device);
1090 /// Marks function \a Fn with properly mangled versions of vector functions.
1091 /// \param FD Function marked as 'declare simd'.
1092 /// \param Fn LLVM function that must be marked with 'declare simd'
1094 virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1095 llvm::Function *Fn);
1097 /// Emit initialization for doacross loop nesting support.
1098 /// \param D Loop-based construct used in doacross nesting construct.
1099 virtual void emitDoacrossInit(CodeGenFunction &CGF,
1100 const OMPLoopDirective &D);
1102 /// Emit code for doacross ordered directive with 'depend' clause.
1103 /// \param C 'depend' clause with 'sink|source' dependency kind.
1104 virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1105 const OMPDependClause *C);
1108 } // namespace CodeGen
1109 } // namespace clang