clang  5.0.0
CGOpenMPRuntime.h
Go to the documentation of this file.
1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides a class for OpenMP runtime code generation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
15 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
16 
17 #include "CGValue.h"
18 #include "clang/AST/Type.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"
26 
27 namespace llvm {
28 class ArrayType;
29 class Constant;
30 class FunctionType;
31 class GlobalVariable;
32 class StructType;
33 class Type;
34 class Value;
35 } // namespace llvm
36 
37 namespace clang {
38 class Expr;
39 class GlobalDecl;
40 class OMPDependClause;
41 class OMPExecutableDirective;
42 class OMPLoopDirective;
43 class VarDecl;
44 class OMPDeclareReductionDecl;
45 class IdentifierInfo;
46 
47 namespace CodeGen {
48 class Address;
49 class CodeGenFunction;
50 class CodeGenModule;
51 
52 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
53 /// region.
55 public:
56  explicit PrePostActionTy() {}
57  virtual void Enter(CodeGenFunction &CGF) {}
58  virtual void Exit(CodeGenFunction &CGF) {}
59  virtual ~PrePostActionTy() {}
60 };
61 
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 {
65  intptr_t CodeGen;
66  typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
67  CodeGenTy Callback;
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,
74  return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
75  }
76 
77 public:
78  template <typename Callable>
80  Callable &&CodeGen,
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;
89 };
90 
91 struct OMPTaskDataTy final {
103  llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
104  llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
105  llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
107  unsigned NumberOfParts = 0;
108  bool Tied = true;
109  bool Nogroup = false;
110 };
111 
112 /// Class intended to support codegen of all kind of the reduction clauses.
114 private:
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) {}
125  };
126  /// List of reduction-based clauses.
127  SmallVector<ReductionData, 4> ClausesData;
128 
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.
133  /// Base declarations for the reduction items.
135 
136  /// Emits lvalue for shared expresion.
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);
148 
149 public:
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.
169  void
170  emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
171  LValue SharedLVal,
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.
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 {
190  return Sizes[N];
191  }
192  /// Returns the base declaration of the reduction item.
193  const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; }
194  /// Returns true if the initialization of the reduction item uses initializer
195  /// from declare reduction construct.
196  bool usesReductionInitializer(unsigned N) const;
197 };
198 
200 protected:
202 
203  /// \brief Creates offloading entry for the provided entry ID \a ID,
204  /// address \a Addr, size \a Size, and flags \a Flags.
205  virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
206  uint64_t Size, int32_t Flags = 0);
207 
208  /// \brief Helper to emit outlined function for 'target' directive.
209  /// \param D Directive to emit.
210  /// \param ParentName Name of the function that encloses the target region.
211  /// \param OutlinedFn Outlined function value to be defined by this call.
212  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
213  /// \param IsOffloadEntry True if the outlined function is an offload entry.
214  /// \param CodeGen Lambda codegen specific to an accelerator device.
215  /// An outlined function may not be an entry if, e.g. the if clause always
216  /// evaluates to false.
218  StringRef ParentName,
219  llvm::Function *&OutlinedFn,
220  llvm::Constant *&OutlinedFnID,
221  bool IsOffloadEntry,
222  const RegionCodeGenTy &CodeGen);
223 
224  /// \brief Emits code for OpenMP 'if' clause using specified \a CodeGen
225  /// function. Here is the logic:
226  /// if (Cond) {
227  /// ThenGen();
228  /// } else {
229  /// ElseGen();
230  /// }
231  void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
232  const RegionCodeGenTy &ThenGen,
233  const RegionCodeGenTy &ElseGen);
234 
235  /// \brief Emits object of ident_t type with info for source location.
236  /// \param Flags Flags for OpenMP location.
237  ///
239  unsigned Flags = 0);
240 
241  /// \brief Returns pointer to ident_t type.
243 
244  /// \brief Gets thread id value for the current thread.
245  ///
247 
248  /// \brief Get the function name of an outlined region.
249  // The name can be customized depending on the target.
250  //
251  virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
252 
253 private:
254  /// \brief Default const ident_t object used for initialization of all other
255  /// ident_t objects.
256  llvm::Constant *DefaultOpenMPPSource = nullptr;
257  /// \brief Map of flags and corresponding default locations.
258  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
259  OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
260  Address getOrCreateDefaultLocation(unsigned Flags);
261 
262  llvm::StructType *IdentTy = nullptr;
263  /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
264  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
265  OpenMPDebugLocMapTy OpenMPDebugLocMap;
266  /// \brief The type for a microtask which gets passed to __kmpc_fork_call().
267  /// Original representation is:
268  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
269  llvm::FunctionType *Kmpc_MicroTy = nullptr;
270  /// \brief Stores debug location and ThreadID for the function.
271  struct DebugLocThreadIdTy {
272  llvm::Value *DebugLoc;
273  llvm::Value *ThreadID;
274  };
275  /// \brief Map of local debug location, ThreadId and functions.
276  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
277  OpenMPLocThreadIDMapTy;
278  OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
279  /// Map of UDRs and corresponding combiner/initializer.
280  typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
281  std::pair<llvm::Function *, llvm::Function *>>
282  UDRMapTy;
283  UDRMapTy UDRMap;
284  /// Map of functions and locally defined UDRs.
285  typedef llvm::DenseMap<llvm::Function *,
287  FunctionUDRMapTy;
288  FunctionUDRMapTy FunctionUDRMap;
289  IdentifierInfo *In = nullptr;
290  IdentifierInfo *Out = nullptr;
291  IdentifierInfo *Priv = nullptr;
292  IdentifierInfo *Orig = nullptr;
293  /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
294  /// kmp_critical_name[8];
295  llvm::ArrayType *KmpCriticalNameTy;
296  /// \brief An ordered map of auto-generated variables to their unique names.
297  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
298  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
299  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
300  /// variables.
301  llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
302  InternalVars;
303  /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
304  llvm::Type *KmpRoutineEntryPtrTy = nullptr;
305  QualType KmpRoutineEntryPtrQTy;
306  /// \brief Type typedef struct kmp_task {
307  /// void * shareds; /**< pointer to block of pointers to
308  /// shared vars */
309  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
310  /// executing task */
311  /// kmp_int32 part_id; /**< part id for the task */
312  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
313  /// deconstructors of firstprivate C++ objects */
314  /// } kmp_task_t;
316  /// \brief Type typedef struct kmp_depend_info {
317  /// kmp_intptr_t base_addr;
318  /// size_t len;
319  /// struct {
320  /// bool in:1;
321  /// bool out:1;
322  /// } flags;
323  /// } kmp_depend_info_t;
325  /// struct kmp_dim { // loop bounds info casted to kmp_int64
326  /// kmp_int64 lo; // lower
327  /// kmp_int64 up; // upper
328  /// kmp_int64 st; // stride
329  /// };
331  /// \brief Type struct __tgt_offload_entry{
332  /// void *addr; // Pointer to the offload entry info.
333  /// // (function or global)
334  /// char *name; // Name of the function or global.
335  /// size_t size; // Size of the entry info (0 if it a function).
336  /// };
338  /// struct __tgt_device_image{
339  /// void *ImageStart; // Pointer to the target code start.
340  /// void *ImageEnd; // Pointer to the target code end.
341  /// // We also add the host entries to the device image, as it may be useful
342  /// // for the target runtime to have access to that information.
343  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
344  /// // the entries.
345  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
346  /// // entries (non inclusive).
347  /// };
349  /// struct __tgt_bin_desc{
350  /// int32_t NumDevices; // Number of devices supported.
351  /// __tgt_device_image *DeviceImages; // Arrays of device images
352  /// // (one per device).
353  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
354  /// // entries.
355  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
356  /// // entries (non inclusive).
357  /// };
359  /// \brief Entity that registers the offloading constants that were emitted so
360  /// far.
363 
364  /// \brief Number of entries registered so far.
365  unsigned OffloadingEntriesNum;
366 
367  public:
368  /// Base class of the entries info.
370  public:
371  /// Kind of a given entry. Currently, only target regions are
372  /// supported.
373  enum OffloadingEntryInfoKinds : unsigned {
374  // Entry is a target region.
375  OFFLOAD_ENTRY_INFO_TARGET_REGION = 0,
376  // Invalid entry info.
377  OFFLOAD_ENTRY_INFO_INVALID = ~0u
378  };
379 
381  : Flags(0), Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
383  int32_t Flags)
384  : Flags(Flags), Order(Order), Kind(Kind) {}
385 
386  bool isValid() const { return Order != ~0u; }
387  unsigned getOrder() const { return Order; }
389  int32_t getFlags() const { return Flags; }
390  void setFlags(int32_t NewFlags) { Flags = NewFlags; }
391  static bool classof(const OffloadEntryInfo *Info) { return true; }
392 
393  private:
394  /// Flags associated with the device global.
395  int32_t Flags;
396 
397  /// Order this entry was emitted.
398  unsigned Order;
399 
400  OffloadingEntryInfoKinds Kind;
401  };
402 
403  /// \brief Return true if a there are no entries defined.
404  bool empty() const;
405  /// \brief Return number of entries defined so far.
406  unsigned size() const { return OffloadingEntriesNum; }
408  : CGM(CGM), OffloadingEntriesNum(0) {}
409 
410  ///
411  /// Target region entries related.
412  ///
413  /// \brief Target region entries info.
415  // \brief Address of the entity that has to be mapped for offloading.
416  llvm::Constant *Addr;
417  // \brief Address that can be used as the ID of the entry.
418  llvm::Constant *ID;
419 
420  public:
422  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, ~0u,
423  /*Flags=*/0),
424  Addr(nullptr), ID(nullptr) {}
425  explicit OffloadEntryInfoTargetRegion(unsigned Order,
426  llvm::Constant *Addr,
427  llvm::Constant *ID, int32_t Flags)
428  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, Order, Flags),
429  Addr(Addr), ID(ID) {}
430 
431  llvm::Constant *getAddress() const { return Addr; }
432  llvm::Constant *getID() const { return ID; }
433  void setAddress(llvm::Constant *V) {
434  assert(!Addr && "Address as been set before!");
435  Addr = V;
436  }
437  void setID(llvm::Constant *V) {
438  assert(!ID && "ID as been set before!");
439  ID = V;
440  }
441  static bool classof(const OffloadEntryInfo *Info) {
442  return Info->getKind() == OFFLOAD_ENTRY_INFO_TARGET_REGION;
443  }
444  };
445  /// \brief Initialize target region entry.
446  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
447  StringRef ParentName, unsigned LineNum,
448  unsigned Order);
449  /// \brief Register target region entry.
450  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
451  StringRef ParentName, unsigned LineNum,
452  llvm::Constant *Addr, llvm::Constant *ID,
453  int32_t Flags);
454  /// \brief Return true if a target region entry with the provided
455  /// information exists.
456  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
457  StringRef ParentName, unsigned LineNum) const;
458  /// brief Applies action \a Action on all registered entries.
459  typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
460  OffloadEntryInfoTargetRegion &)>
462  void actOnTargetRegionEntriesInfo(
464 
465  private:
466  // Storage for target region entries kind. The storage is to be indexed by
467  // file ID, device ID, parent function name and line number.
468  typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
469  OffloadEntriesTargetRegionPerLine;
470  typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
471  OffloadEntriesTargetRegionPerParentName;
472  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
473  OffloadEntriesTargetRegionPerFile;
474  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
475  OffloadEntriesTargetRegionPerDevice;
476  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
477  OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
478  };
480 
481  /// \brief Creates and registers offloading binary descriptor for the current
482  /// compilation unit. The function that does the registration is returned.
484 
485  /// \brief Creates all the offload entries in the current compilation unit
486  /// along with the associated metadata.
488 
489  /// \brief Loads all the offload entries information from the host IR
490  /// metadata.
492 
493  /// \brief Returns __tgt_offload_entry type.
495 
496  /// \brief Returns __tgt_device_image type.
498 
499  /// \brief Returns __tgt_bin_desc type.
501 
502  /// \brief Start scanning from statement \a S and and emit all target regions
503  /// found along the way.
504  /// \param S Starting statement.
505  /// \param ParentName Name of the function declaration that is being scanned.
506  void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
507 
508  /// \brief Build type kmp_routine_entry_t (if not built yet).
509  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
510 
511  /// \brief Returns pointer to kmpc_micro type.
513 
514  /// \brief Returns specified OpenMP runtime function.
515  /// \param Function OpenMP runtime function.
516  /// \return Specified function.
517  llvm::Constant *createRuntimeFunction(unsigned Function);
518 
519  /// \brief Returns __kmpc_for_static_init_* runtime function for the specified
520  /// size \a IVSize and sign \a IVSigned.
521  llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
522 
523  /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified
524  /// size \a IVSize and sign \a IVSigned.
525  llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
526 
527  /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified
528  /// size \a IVSize and sign \a IVSigned.
529  llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
530 
531  /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified
532  /// size \a IVSize and sign \a IVSigned.
533  llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
534 
535  /// \brief If the specified mangled name is not in the module, create and
536  /// return threadprivate cache object. This object is a pointer's worth of
537  /// storage that's reserved for use by the OpenMP runtime.
538  /// \param VD Threadprivate variable.
539  /// \return Cache variable for the specified threadprivate.
540  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
541 
542  /// \brief Emits address of the word in a memory where current thread id is
543  /// stored.
545 
546  /// \brief Gets (if variable with the given name already exist) or creates
547  /// internal global variable with the specified Name. The created variable has
548  /// linkage CommonLinkage by default and is initialized by null value.
549  /// \param Ty Type of the global variable. If it is exist already the type
550  /// must be the same.
551  /// \param Name Name of the variable.
552  llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
553  const llvm::Twine &Name);
554 
555  /// \brief Set of threadprivate variables with the generated initializer.
556  llvm::SmallPtrSet<const VarDecl *, 4> ThreadPrivateWithDefinition;
557 
558  /// \brief Emits initialization code for the threadprivate variables.
559  /// \param VDAddr Address of the global variable \a VD.
560  /// \param Ctor Pointer to a global init function for \a VD.
561  /// \param CopyCtor Pointer to a global copy function for \a VD.
562  /// \param Dtor Pointer to a global destructor function for \a VD.
563  /// \param Loc Location of threadprivate declaration.
565  llvm::Value *Ctor, llvm::Value *CopyCtor,
566  llvm::Value *Dtor, SourceLocation Loc);
567 
568  /// \brief Returns corresponding lock object for the specified critical region
569  /// name. If the lock object does not exist it is created, otherwise the
570  /// reference to the existing copy is returned.
571  /// \param CriticalName Name of the critical region.
572  ///
573  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
574 
575  struct TaskResultTy {
576  llvm::Value *NewTask = nullptr;
577  llvm::Value *TaskEntry = nullptr;
578  llvm::Value *NewTaskNewTaskTTy = nullptr;
580  RecordDecl *KmpTaskTQTyRD = nullptr;
581  llvm::Value *TaskDupFn = nullptr;
582  };
583  /// Emit task region for the task directive. The task region is emitted in
584  /// several steps:
585  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
586  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
587  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
588  /// function:
589  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
590  /// TaskFunction(gtid, tt->part_id, tt->shareds);
591  /// return 0;
592  /// }
593  /// 2. Copy a list of shared variables to field shareds of the resulting
594  /// structure kmp_task_t returned by the previous call (if any).
595  /// 3. Copy a pointer to destructions function to field destructions of the
596  /// resulting structure kmp_task_t.
597  /// \param D Current task directive.
598  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
599  /// /*part_id*/, captured_struct */*__context*/);
600  /// \param SharedsTy A type which contains references the shared variables.
601  /// \param Shareds Context with the list of shared variables from the \p
602  /// TaskFunction.
603  /// \param Data Additional data for task generation like tiednsee, final
604  /// state, list of privates etc.
606  const OMPExecutableDirective &D,
607  llvm::Value *TaskFunction, QualType SharedsTy,
608  Address Shareds, const OMPTaskDataTy &Data);
609 
610 public:
611  explicit CGOpenMPRuntime(CodeGenModule &CGM);
612  virtual ~CGOpenMPRuntime() {}
613  virtual void clear();
614 
615  /// Emit code for the specified user defined reduction construct.
616  virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
617  const OMPDeclareReductionDecl *D);
618  /// Get combiner/initializer for the specified user-defined reduction, if any.
619  virtual std::pair<llvm::Function *, llvm::Function *>
621 
622  /// \brief Emits outlined function for the specified OpenMP parallel directive
623  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
624  /// kmp_int32 BoundID, struct context_vars*).
625  /// \param D OpenMP directive.
626  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
627  /// \param InnermostKind Kind of innermost directive (for simple directives it
628  /// is a directive itself, for combined - its innermost directive).
629  /// \param CodeGen Code generation sequence for the \a D directive.
631  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
632  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
633 
634  /// \brief Emits outlined function for the specified OpenMP teams directive
635  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
636  /// kmp_int32 BoundID, struct context_vars*).
637  /// \param D OpenMP directive.
638  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
639  /// \param InnermostKind Kind of innermost directive (for simple directives it
640  /// is a directive itself, for combined - its innermost directive).
641  /// \param CodeGen Code generation sequence for the \a D directive.
643  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
644  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
645 
646  /// \brief Emits outlined function for the OpenMP task directive \a D. This
647  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
648  /// TaskT).
649  /// \param D OpenMP directive.
650  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
651  /// \param PartIDVar Variable for partition id in the current OpenMP untied
652  /// task region.
653  /// \param TaskTVar Variable for task_t argument.
654  /// \param InnermostKind Kind of innermost directive (for simple directives it
655  /// is a directive itself, for combined - its innermost directive).
656  /// \param CodeGen Code generation sequence for the \a D directive.
657  /// \param Tied true if task is generated for tied task, false otherwise.
658  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
659  /// tasks.
660  ///
662  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
663  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
664  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
665  bool Tied, unsigned &NumberOfParts);
666 
667  /// \brief Cleans up references to the objects in finished function.
668  ///
669  void functionFinished(CodeGenFunction &CGF);
670 
671  /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
672  /// variables captured in a record which address is stored in \a
673  /// CapturedStruct.
674  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
675  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
676  /// \param CapturedVars A pointer to the record with the references to
677  /// variables used in \a OutlinedFn function.
678  /// \param IfCond Condition in the associated 'if' clause, if it was
679  /// specified, nullptr otherwise.
680  ///
681  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
682  llvm::Value *OutlinedFn,
683  ArrayRef<llvm::Value *> CapturedVars,
684  const Expr *IfCond);
685 
686  /// \brief Emits a critical region.
687  /// \param CriticalName Name of the critical region.
688  /// \param CriticalOpGen Generator for the statement associated with the given
689  /// critical region.
690  /// \param Hint Value of the 'hint' clause (optional).
691  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
692  const RegionCodeGenTy &CriticalOpGen,
693  SourceLocation Loc,
694  const Expr *Hint = nullptr);
695 
696  /// \brief Emits a master region.
697  /// \param MasterOpGen Generator for the statement associated with the given
698  /// master region.
699  virtual void emitMasterRegion(CodeGenFunction &CGF,
700  const RegionCodeGenTy &MasterOpGen,
701  SourceLocation Loc);
702 
703  /// \brief Emits code for a taskyield directive.
704  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
705 
706  /// \brief Emit a taskgroup region.
707  /// \param TaskgroupOpGen Generator for the statement associated with the
708  /// given taskgroup region.
709  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
710  const RegionCodeGenTy &TaskgroupOpGen,
711  SourceLocation Loc);
712 
713  /// \brief Emits a single region.
714  /// \param SingleOpGen Generator for the statement associated with the given
715  /// single region.
716  virtual void emitSingleRegion(CodeGenFunction &CGF,
717  const RegionCodeGenTy &SingleOpGen,
718  SourceLocation Loc,
719  ArrayRef<const Expr *> CopyprivateVars,
720  ArrayRef<const Expr *> DestExprs,
721  ArrayRef<const Expr *> SrcExprs,
722  ArrayRef<const Expr *> AssignmentOps);
723 
724  /// \brief Emit an ordered region.
725  /// \param OrderedOpGen Generator for the statement associated with the given
726  /// ordered region.
727  virtual void emitOrderedRegion(CodeGenFunction &CGF,
728  const RegionCodeGenTy &OrderedOpGen,
729  SourceLocation Loc, bool IsThreads);
730 
731  /// \brief Emit an implicit/explicit barrier for OpenMP threads.
732  /// \param Kind Directive for which this implicit barrier call must be
733  /// generated. Must be OMPD_barrier for explicit barrier generation.
734  /// \param EmitChecks true if need to emit checks for cancellation barriers.
735  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
736  /// runtime class decides which one to emit (simple or with cancellation
737  /// checks).
738  ///
739  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
741  bool EmitChecks = true,
742  bool ForceSimpleCall = false);
743 
744  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
745  /// This kind of worksharing directive is emitted without outer loop.
746  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
747  /// \param Chunked True if chunk is specified in the clause.
748  ///
749  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
750  bool Chunked) const;
751 
752  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
753  /// This kind of distribute directive is emitted without outer loop.
754  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
755  /// \param Chunked True if chunk is specified in the clause.
756  ///
757  virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
758  bool Chunked) const;
759 
760  /// \brief Check if the specified \a ScheduleKind is dynamic.
761  /// This kind of worksharing directive is emitted without outer loop.
762  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
763  ///
764  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
765 
766  /// struct with the values to be passed to the dispatch runtime function
768  /// Loop lower bound
769  llvm::Value *LB = nullptr;
770  /// Loop upper bound
771  llvm::Value *UB = nullptr;
772  /// Chunk size specified using 'schedule' clause (nullptr if chunk
773  /// was not specified)
774  llvm::Value *Chunk = nullptr;
775  DispatchRTInput() = default;
777  : LB(LB), UB(UB), Chunk(Chunk) {}
778  };
779 
780  /// Call the appropriate runtime routine to initialize it before start
781  /// of loop.
782 
783  /// This is used for non static scheduled types and when the ordered
784  /// clause is present on the loop construct.
785  /// Depending on the loop schedule, it is necessary to call some runtime
786  /// routine before start of the OpenMP loop to get the loop upper / lower
787  /// bounds \a LB and \a UB and stride \a ST.
788  ///
789  /// \param CGF Reference to current CodeGenFunction.
790  /// \param Loc Clang source location.
791  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
792  /// \param IVSize Size of the iteration variable in bits.
793  /// \param IVSigned Sign of the iteration variable.
794  /// \param Ordered true if loop is ordered, false otherwise.
795  /// \param DispatchValues struct containing llvm values for lower bound, upper
796  /// bound, and chunk expression.
797  /// For the default (nullptr) value, the chunk 1 will be used.
798  ///
799  virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
800  const OpenMPScheduleTy &ScheduleKind,
801  unsigned IVSize, bool IVSigned, bool Ordered,
802  const DispatchRTInput &DispatchValues);
803 
804  /// \brief Call the appropriate runtime routine to initialize it before start
805  /// of loop.
806  ///
807  /// This is used only in case of static schedule, when the user did not
808  /// specify a ordered clause on the loop construct.
809  /// Depending on the loop schedule, it is necessary to call some runtime
810  /// routine before start of the OpenMP loop to get the loop upper / lower
811  /// bounds \a LB and \a UB and stride \a ST.
812  ///
813  /// \param CGF Reference to current CodeGenFunction.
814  /// \param Loc Clang source location.
815  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
816  /// \param IVSize Size of the iteration variable in bits.
817  /// \param IVSigned Sign of the iteration variable.
818  /// \param Ordered true if loop is ordered, false otherwise.
819  /// \param IL Address of the output variable in which the flag of the
820  /// last iteration is returned.
821  /// \param LB Address of the output variable in which the lower iteration
822  /// number is returned.
823  /// \param UB Address of the output variable in which the upper iteration
824  /// number is returned.
825  /// \param ST Address of the output variable in which the stride value is
826  /// returned necessary to generated the static_chunked scheduled loop.
827  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
828  /// For the default (nullptr) value, the chunk 1 will be used.
829  ///
830  virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
831  const OpenMPScheduleTy &ScheduleKind,
832  unsigned IVSize, bool IVSigned, bool Ordered,
833  Address IL, Address LB, Address UB, Address ST,
834  llvm::Value *Chunk = nullptr);
835 
836  ///
837  /// \param CGF Reference to current CodeGenFunction.
838  /// \param Loc Clang source location.
839  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
840  /// \param IVSize Size of the iteration variable in bits.
841  /// \param IVSigned Sign of the iteration variable.
842  /// \param Ordered true if loop is ordered, false otherwise.
843  /// \param IL Address of the output variable in which the flag of the
844  /// last iteration is returned.
845  /// \param LB Address of the output variable in which the lower iteration
846  /// number is returned.
847  /// \param UB Address of the output variable in which the upper iteration
848  /// number is returned.
849  /// \param ST Address of the output variable in which the stride value is
850  /// returned necessary to generated the static_chunked scheduled loop.
851  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
852  /// For the default (nullptr) value, the chunk 1 will be used.
853  ///
854  virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
856  unsigned IVSize, bool IVSigned,
857  bool Ordered, Address IL, Address LB,
858  Address UB, Address ST,
859  llvm::Value *Chunk = nullptr);
860 
861  /// \brief Call the appropriate runtime routine to notify that we finished
862  /// iteration of the ordered loop with the dynamic scheduling.
863  ///
864  /// \param CGF Reference to current CodeGenFunction.
865  /// \param Loc Clang source location.
866  /// \param IVSize Size of the iteration variable in bits.
867  /// \param IVSigned Sign of the iteration variable.
868  ///
869  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
870  SourceLocation Loc, unsigned IVSize,
871  bool IVSigned);
872 
873  /// \brief Call the appropriate runtime routine to notify that we finished
874  /// all the work with current loop.
875  ///
876  /// \param CGF Reference to current CodeGenFunction.
877  /// \param Loc Clang source location.
878  ///
879  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc);
880 
881  /// Call __kmpc_dispatch_next(
882  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
883  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
884  /// kmp_int[32|64] *p_stride);
885  /// \param IVSize Size of the iteration variable in bits.
886  /// \param IVSigned Sign of the iteration variable.
887  /// \param IL Address of the output variable in which the flag of the
888  /// last iteration is returned.
889  /// \param LB Address of the output variable in which the lower iteration
890  /// number is returned.
891  /// \param UB Address of the output variable in which the upper iteration
892  /// number is returned.
893  /// \param ST Address of the output variable in which the stride value is
894  /// returned.
895  virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
896  unsigned IVSize, bool IVSigned,
897  Address IL, Address LB,
898  Address UB, Address ST);
899 
900  /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
901  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
902  /// clause.
903  /// \param NumThreads An integer value of threads.
904  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
905  llvm::Value *NumThreads,
906  SourceLocation Loc);
907 
908  /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
909  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
910  virtual void emitProcBindClause(CodeGenFunction &CGF,
911  OpenMPProcBindClauseKind ProcBind,
912  SourceLocation Loc);
913 
914  /// \brief Returns address of the threadprivate variable for the current
915  /// thread.
916  /// \param VD Threadprivate variable.
917  /// \param VDAddr Address of the global variable \a VD.
918  /// \param Loc Location of the reference to threadprivate var.
919  /// \return Address of the threadprivate variable for the current thread.
920  virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
921  const VarDecl *VD,
922  Address VDAddr,
923  SourceLocation Loc);
924 
925  /// \brief Emit a code for initialization of threadprivate variable. It emits
926  /// a call to runtime library which adds initial value to the newly created
927  /// threadprivate variable (if it is not constant) and registers destructor
928  /// for the variable (if any).
929  /// \param VD Threadprivate variable.
930  /// \param VDAddr Address of the global variable \a VD.
931  /// \param Loc Location of threadprivate declaration.
932  /// \param PerformInit true if initialization expression is not constant.
933  virtual llvm::Function *
934  emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
935  SourceLocation Loc, bool PerformInit,
936  CodeGenFunction *CGF = nullptr);
937 
938  /// Creates artificial threadprivate variable with name \p Name and type \p
939  /// VarType.
940  /// \param VarType Type of the artificial threadprivate variable.
941  /// \param Name Name of the artificial threadprivate variable.
942  virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
943  QualType VarType,
944  StringRef Name);
945 
946  /// \brief Emit flush of the variables specified in 'omp flush' directive.
947  /// \param Vars List of variables to flush.
948  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
949  SourceLocation Loc);
950 
951  /// \brief Emit task region for the task directive. The task region is
952  /// emitted in several steps:
953  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
954  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
955  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
956  /// function:
957  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
958  /// TaskFunction(gtid, tt->part_id, tt->shareds);
959  /// return 0;
960  /// }
961  /// 2. Copy a list of shared variables to field shareds of the resulting
962  /// structure kmp_task_t returned by the previous call (if any).
963  /// 3. Copy a pointer to destructions function to field destructions of the
964  /// resulting structure kmp_task_t.
965  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
966  /// kmp_task_t *new_task), where new_task is a resulting structure from
967  /// previous items.
968  /// \param D Current task directive.
969  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
970  /// /*part_id*/, captured_struct */*__context*/);
971  /// \param SharedsTy A type which contains references the shared variables.
972  /// \param Shareds Context with the list of shared variables from the \p
973  /// TaskFunction.
974  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
975  /// otherwise.
976  /// \param Data Additional data for task generation like tiednsee, final
977  /// state, list of privates etc.
978  virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
979  const OMPExecutableDirective &D,
980  llvm::Value *TaskFunction, QualType SharedsTy,
981  Address Shareds, const Expr *IfCond,
982  const OMPTaskDataTy &Data);
983 
984  /// Emit task region for the taskloop directive. The taskloop region is
985  /// emitted in several steps:
986  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
987  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
988  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
989  /// function:
990  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
991  /// TaskFunction(gtid, tt->part_id, tt->shareds);
992  /// return 0;
993  /// }
994  /// 2. Copy a list of shared variables to field shareds of the resulting
995  /// structure kmp_task_t returned by the previous call (if any).
996  /// 3. Copy a pointer to destructions function to field destructions of the
997  /// resulting structure kmp_task_t.
998  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
999  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1000  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1001  /// is a resulting structure from
1002  /// previous items.
1003  /// \param D Current task directive.
1004  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1005  /// /*part_id*/, captured_struct */*__context*/);
1006  /// \param SharedsTy A type which contains references the shared variables.
1007  /// \param Shareds Context with the list of shared variables from the \p
1008  /// TaskFunction.
1009  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1010  /// otherwise.
1011  /// \param Data Additional data for task generation like tiednsee, final
1012  /// state, list of privates etc.
1013  virtual void emitTaskLoopCall(
1014  CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D,
1015  llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds,
1016  const Expr *IfCond, const OMPTaskDataTy &Data);
1017 
1018  /// \brief Emit code for the directive that does not require outlining.
1019  ///
1020  /// \param InnermostKind Kind of innermost directive (for simple directives it
1021  /// is a directive itself, for combined - its innermost directive).
1022  /// \param CodeGen Code generation sequence for the \a D directive.
1023  /// \param HasCancel true if region has inner cancel directive, false
1024  /// otherwise.
1025  virtual void emitInlinedDirective(CodeGenFunction &CGF,
1026  OpenMPDirectiveKind InnermostKind,
1027  const RegionCodeGenTy &CodeGen,
1028  bool HasCancel = false);
1029 
1030  /// Emits reduction function.
1031  /// \param ArgsType Array type containing pointers to reduction variables.
1032  /// \param Privates List of private copies for original reduction arguments.
1033  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1034  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1035  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1036  /// or 'operator binop(LHS, RHS)'.
1039  ArrayRef<const Expr *> LHSExprs,
1040  ArrayRef<const Expr *> RHSExprs,
1041  ArrayRef<const Expr *> ReductionOps);
1042 
1043  /// Emits single reduction combiner
1045  const Expr *ReductionOp,
1046  const Expr *PrivateRef,
1047  const DeclRefExpr *LHS,
1048  const DeclRefExpr *RHS);
1049 
1054  };
1055  /// \brief Emit a code for reduction clause. Next code should be emitted for
1056  /// reduction:
1057  /// \code
1058  ///
1059  /// static kmp_critical_name lock = { 0 };
1060  ///
1061  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1062  /// ...
1063  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1064  /// ...
1065  /// }
1066  ///
1067  /// ...
1068  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1069  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1070  /// RedList, reduce_func, &<lock>)) {
1071  /// case 1:
1072  /// ...
1073  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1074  /// ...
1075  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1076  /// break;
1077  /// case 2:
1078  /// ...
1079  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1080  /// ...
1081  /// break;
1082  /// default:;
1083  /// }
1084  /// \endcode
1085  ///
1086  /// \param Privates List of private copies for original reduction arguments.
1087  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1088  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1089  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1090  /// or 'operator binop(LHS, RHS)'.
1091  /// \param Options List of options for reduction codegen:
1092  /// WithNowait true if parent directive has also nowait clause, false
1093  /// otherwise.
1094  /// SimpleReduction Emit reduction operation only. Used for omp simd
1095  /// directive on the host.
1096  /// ReductionKind The kind of reduction to perform.
1097  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1099  ArrayRef<const Expr *> LHSExprs,
1100  ArrayRef<const Expr *> RHSExprs,
1101  ArrayRef<const Expr *> ReductionOps,
1103 
1104  /// Emit a code for initialization of task reduction clause. Next code
1105  /// should be emitted for reduction:
1106  /// \code
1107  ///
1108  /// _task_red_item_t red_data[n];
1109  /// ...
1110  /// red_data[i].shar = &origs[i];
1111  /// red_data[i].size = sizeof(origs[i]);
1112  /// red_data[i].f_init = (void*)RedInit<i>;
1113  /// red_data[i].f_fini = (void*)RedDest<i>;
1114  /// red_data[i].f_comb = (void*)RedOp<i>;
1115  /// red_data[i].flags = <Flag_i>;
1116  /// ...
1117  /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data);
1118  /// \endcode
1119  ///
1120  /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1121  /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1122  /// \param Data Additional data for task generation like tiedness, final
1123  /// state, list of privates, reductions etc.
1125  SourceLocation Loc,
1126  ArrayRef<const Expr *> LHSExprs,
1127  ArrayRef<const Expr *> RHSExprs,
1128  const OMPTaskDataTy &Data);
1129 
1130  /// Required to resolve existing problems in the runtime. Emits threadprivate
1131  /// variables to store the size of the VLAs/array sections for
1132  /// initializer/combiner/finalizer functions + emits threadprivate variable to
1133  /// store the pointer to the original reduction item for the custom
1134  /// initializer defined by declare reduction construct.
1135  /// \param RCG Allows to reuse an existing data for the reductions.
1136  /// \param N Reduction item for which fixups must be emitted.
1138  ReductionCodeGen &RCG, unsigned N);
1139 
1140  /// Get the address of `void *` type of the privatue copy of the reduction
1141  /// item specified by the \p SharedLVal.
1142  /// \param ReductionsPtr Pointer to the reduction data returned by the
1143  /// emitTaskReductionInit function.
1144  /// \param SharedLVal Address of the original reduction item.
1146  llvm::Value *ReductionsPtr,
1147  LValue SharedLVal);
1148 
1149  /// \brief Emit code for 'taskwait' directive.
1150  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
1151 
1152  /// \brief Emit code for 'cancellation point' construct.
1153  /// \param CancelRegion Region kind for which the cancellation point must be
1154  /// emitted.
1155  ///
1156  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
1157  SourceLocation Loc,
1158  OpenMPDirectiveKind CancelRegion);
1159 
1160  /// \brief Emit code for 'cancel' construct.
1161  /// \param IfCond Condition in the associated 'if' clause, if it was
1162  /// specified, nullptr otherwise.
1163  /// \param CancelRegion Region kind for which the cancel must be emitted.
1164  ///
1165  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1166  const Expr *IfCond,
1167  OpenMPDirectiveKind CancelRegion);
1168 
1169  /// \brief Emit outilined function for 'target' directive.
1170  /// \param D Directive to emit.
1171  /// \param ParentName Name of the function that encloses the target region.
1172  /// \param OutlinedFn Outlined function value to be defined by this call.
1173  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1174  /// \param IsOffloadEntry True if the outlined function is an offload entry.
1175  /// \param CodeGen Code generation sequence for the \a D directive.
1176  /// An outlined function may not be an entry if, e.g. the if clause always
1177  /// evaluates to false.
1178  virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
1179  StringRef ParentName,
1180  llvm::Function *&OutlinedFn,
1181  llvm::Constant *&OutlinedFnID,
1182  bool IsOffloadEntry,
1183  const RegionCodeGenTy &CodeGen);
1184 
1185  /// \brief Emit the target offloading code associated with \a D. The emitted
1186  /// code attempts offloading the execution to the device, an the event of
1187  /// a failure it executes the host version outlined in \a OutlinedFn.
1188  /// \param D Directive to emit.
1189  /// \param OutlinedFn Host version of the code to be offloaded.
1190  /// \param OutlinedFnID ID of host version of the code to be offloaded.
1191  /// \param IfCond Expression evaluated in if clause associated with the target
1192  /// directive, or null if no if clause is used.
1193  /// \param Device Expression evaluated in device clause associated with the
1194  /// target directive, or null if no device clause is used.
1195  /// \param CapturedVars Values captured in the current region.
1196  virtual void emitTargetCall(CodeGenFunction &CGF,
1197  const OMPExecutableDirective &D,
1198  llvm::Value *OutlinedFn,
1199  llvm::Value *OutlinedFnID, const Expr *IfCond,
1200  const Expr *Device,
1201  ArrayRef<llvm::Value *> CapturedVars);
1202 
1203  /// \brief Emit the target regions enclosed in \a GD function definition or
1204  /// the function itself in case it is a valid device function. Returns true if
1205  /// \a GD was dealt with successfully.
1206  /// \param GD Function to scan.
1207  virtual bool emitTargetFunctions(GlobalDecl GD);
1208 
1209  /// \brief Emit the global variable if it is a valid device global variable.
1210  /// Returns true if \a GD was dealt with successfully.
1211  /// \param GD Variable declaration to emit.
1212  virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1213 
1214  /// \brief Emit the global \a GD if it is meaningful for the target. Returns
1215  /// if it was emitted successfully.
1216  /// \param GD Global to scan.
1217  virtual bool emitTargetGlobal(GlobalDecl GD);
1218 
1219  /// \brief Creates the offloading descriptor in the event any target region
1220  /// was emitted in the current module and return the function that registers
1221  /// it.
1222  virtual llvm::Function *emitRegistrationFunction();
1223 
1224  /// \brief Emits code for teams call of the \a OutlinedFn with
1225  /// variables captured in a record which address is stored in \a
1226  /// CapturedStruct.
1227  /// \param OutlinedFn Outlined function to be run by team masters. Type of
1228  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1229  /// \param CapturedVars A pointer to the record with the references to
1230  /// variables used in \a OutlinedFn function.
1231  ///
1232  virtual void emitTeamsCall(CodeGenFunction &CGF,
1233  const OMPExecutableDirective &D,
1234  SourceLocation Loc, llvm::Value *OutlinedFn,
1235  ArrayRef<llvm::Value *> CapturedVars);
1236 
1237  /// \brief Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1238  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1239  /// for num_teams clause.
1240  /// \param NumTeams An integer expression of teams.
1241  /// \param ThreadLimit An integer expression of threads.
1242  virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1243  const Expr *ThreadLimit, SourceLocation Loc);
1244 
1245  /// Struct that keeps all the relevant information that should be kept
1246  /// throughout a 'target data' region.
1248  /// Set to true if device pointer information have to be obtained.
1249  bool RequiresDevicePointerInfo = false;
1250 
1251  public:
1252  /// The array of base pointer passed to the runtime library.
1253  llvm::Value *BasePointersArray = nullptr;
1254  /// The array of section pointers passed to the runtime library.
1255  llvm::Value *PointersArray = nullptr;
1256  /// The array of sizes passed to the runtime library.
1257  llvm::Value *SizesArray = nullptr;
1258  /// The array of map types passed to the runtime library.
1259  llvm::Value *MapTypesArray = nullptr;
1260  /// The total number of pointers passed to the runtime library.
1261  unsigned NumberOfPtrs = 0u;
1262  /// Map between the a declaration of a capture and the corresponding base
1263  /// pointer address where the runtime returns the device pointers.
1264  llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1265 
1266  explicit TargetDataInfo() {}
1267  explicit TargetDataInfo(bool RequiresDevicePointerInfo)
1268  : RequiresDevicePointerInfo(RequiresDevicePointerInfo) {}
1269  /// Clear information about the data arrays.
1271  BasePointersArray = nullptr;
1272  PointersArray = nullptr;
1273  SizesArray = nullptr;
1274  MapTypesArray = nullptr;
1275  NumberOfPtrs = 0u;
1276  }
1277  /// Return true if the current target data information has valid arrays.
1278  bool isValid() {
1279  return BasePointersArray && PointersArray && SizesArray &&
1280  MapTypesArray && NumberOfPtrs;
1281  }
1282  bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
1283  };
1284 
1285  /// \brief Emit the target data mapping code associated with \a D.
1286  /// \param D Directive to emit.
1287  /// \param IfCond Expression evaluated in if clause associated with the
1288  /// target directive, or null if no device clause is used.
1289  /// \param Device Expression evaluated in device clause associated with the
1290  /// target directive, or null if no device clause is used.
1291  /// \param Info A record used to store information that needs to be preserved
1292  /// until the region is closed.
1293  virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1294  const OMPExecutableDirective &D,
1295  const Expr *IfCond, const Expr *Device,
1296  const RegionCodeGenTy &CodeGen,
1297  TargetDataInfo &Info);
1298 
1299  /// \brief Emit the data mapping/movement code associated with the directive
1300  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1301  /// \param D Directive to emit.
1302  /// \param IfCond Expression evaluated in if clause associated with the target
1303  /// directive, or null if no if clause is used.
1304  /// \param Device Expression evaluated in device clause associated with the
1305  /// target directive, or null if no device clause is used.
1306  virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
1307  const OMPExecutableDirective &D,
1308  const Expr *IfCond,
1309  const Expr *Device);
1310 
1311  /// Marks function \a Fn with properly mangled versions of vector functions.
1312  /// \param FD Function marked as 'declare simd'.
1313  /// \param Fn LLVM function that must be marked with 'declare simd'
1314  /// attributes.
1315  virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1316  llvm::Function *Fn);
1317 
1318  /// Emit initialization for doacross loop nesting support.
1319  /// \param D Loop-based construct used in doacross nesting construct.
1320  virtual void emitDoacrossInit(CodeGenFunction &CGF,
1321  const OMPLoopDirective &D);
1322 
1323  /// Emit code for doacross ordered directive with 'depend' clause.
1324  /// \param C 'depend' clause with 'sink|source' dependency kind.
1325  virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1326  const OMPDependClause *C);
1327 };
1328 
1329 } // namespace CodeGen
1330 } // namespace clang
1331 
1332 #endif
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1618
QualType TgtDeviceImageQTy
struct __tgt_device_image{ void *ImageStart; // Pointer to the target code start. ...
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:124
A (possibly-)qualified type.
Definition: Type.h:616
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues)
Call the appropriate runtime routine to initialize it before start of loop.
OffloadEntryInfoTargetRegion(unsigned Order, llvm::Constant *Addr, llvm::Constant *ID, int32_t Flags)
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
void emitSingleReductionCombiner(CodeGenFunction &CGF, const Expr *ReductionOp, const Expr *PrivateRef, const DeclRefExpr *LHS, const DeclRefExpr *RHS)
Emits single reduction combiner.
llvm::SmallPtrSet< const VarDecl *, 4 > ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
Stmt - This represents one statement.
Definition: Stmt.h:60
virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)
Emit code for the specified user defined reduction construct.
C Language Family Type Representation.
QualType getTgtBinaryDescriptorQTy()
Returns __tgt_bin_desc type.
SmallVector< std::pair< OpenMPDependClauseKind, const Expr * >, 4 > Dependences
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
SmallVector< const Expr *, 4 > LastprivateCopies
llvm::Constant * getOrCreateInternalVariable(llvm::Type *Ty, const llvm::Twine &Name)
Gets (if variable with the given name already exist) or creates internal global variable with the spe...
virtual void clear()
struct with the values to be passed to the dispatch runtime function
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and and emit all target regions found along the way.
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
SmallVector< const Expr *, 4 > ReductionCopies
DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
bool isValid()
Return true if the current target data information has valid arrays.
llvm::DenseMap< const ValueDecl *, Address > CaptureDeviceAddrMap
Map between the a declaration of a capture and the corresponding base pointer address where the runti...
virtual void Exit(CodeGenFunction &CGF)
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size, int32_t Flags=0)
Creates offloading entry for the provided entry ID ID, address Addr, size Size, and flags Flags...
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata...
LValue getSharedLValue(unsigned N) const
Returns LValue for the reduction item.
Struct that keeps all the relevant information that should be kept throughout a 'target data' region...
QualType getTgtOffloadEntryQTy()
Returns __tgt_offload_entry type.
SmallVector< const Expr *, 4 > PrivateVars
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3354
OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order, int32_t Flags)
One of these records is kept for each identifier that is lexed.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc)
Emit flush of the variables specified in 'omp flush' directive.
SmallVector< const Expr *, 4 > LastprivateVars
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
FrontendAction * Action
Definition: Tooling.cpp:205
Defines some OpenMP-specific enums and functions.
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc...
Definition: StmtOpenMP.h:313
unsigned size() const
Return number of entries defined so far.
static bool classof(const OffloadEntryInfo *Info)
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:100
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
Call the appropriate runtime routine to initialize it before start of loop.
QualType TgtOffloadEntryQTy
Type struct __tgt_offload_entry{ void *addr; // Pointer to the offload entry info.
virtual StringRef getOutlinedHelperName() const
Get the function name of an outlined region.
void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Emits cleanup code for the reduction item.
virtual std::pair< llvm::Function *, llvm::Function * > getUserDefinedReduction(const OMPDeclareReductionDecl *D)
Get combiner/initializer for the specified user-defined reduction, if any.
SmallVector< const Expr *, 4 > PrivateCopies
Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Adjusts PrivatedAddr for using instead of the original variable address in normal operations...
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
SmallVector< const Expr *, 4 > FirstprivateCopies
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags=0)
Emits object of ident_t type with info for source location.
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type...
Definition: opencl-c.h:75
virtual llvm::Value * emitTeamsOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP teams directive D.
SmallVector< const Expr *, 4 > ReductionOps
SmallVector< const Expr *, 4 > ReductionVars
llvm::Value * emitReductionFunction(CodeGenModule &CGM, llvm::Type *ArgsType, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps)
Emits reduction function.
virtual llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST)
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
virtual llvm::Value * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts)
Emits outlined function for the OpenMP task directive D.
virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name)
Creates artificial threadprivate variable with name Name and type VarType.
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param Data Additional data for task generation like final list of privates etc *virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
llvm::Constant * createForStaticInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_for_static_init_* runtime function for the specified size IVSize and sign IVSigned...
TargetDataInfo(bool RequiresDevicePointerInfo)
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
bool needCleanups(unsigned N)
Returns true if the private copy requires cleanups.
Class intended to support codegen of all kind of the reduction clauses.
llvm::Constant * createDispatchFiniFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_fini_* runtime function for the specified size IVSize and sign IVSigned...
QualType getTgtDeviceImageQTy()
Returns __tgt_device_image type.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
RegionCodeGenTy(Callable &&CodeGen, typename std::enable_if< !std::is_same< typename std::remove_reference< Callable >::type, RegionCodeGenTy >::value >::type *=nullptr)
Expr - This represents one expression.
Definition: Expr.h:105
virtual llvm::Value * emitParallelOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP parallel directive D.
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with 'depend' clause.
void loadOffloadInfoMetadata()
Loads all the offload entries information from the host IR metadata.
virtual void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info)
Emit the target data mapping code associated with D.
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual ~CGOpenMPRuntime()
void clearArrayInfo()
Clear information about the data arrays.
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
SmallVector< const Expr *, 4 > FirstprivateVars
virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Helper to emit outlined function for 'target' directive.
CGOpenMPRuntime(CodeGenModule &CGM)
*QualType KmpTaskTQTy
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
Definition: OpenMPKinds.h:51
virtual llvm::Function * emitRegistrationFunction()
Creates the offloading descriptor in the event any target region was emitted in the current module an...
llvm::Constant * createDispatchInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc)
Emit code for 'taskwait' directive.
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
QualType TgtBinaryDescriptorQTy
struct __tgt_bin_desc{ int32_t NumDevices; // Number of devices supported.
The l-value was considered opaque, so the alignment was determined from a type.
const MatchFinder::MatchFinderOptions & Options
Kind
bool usesReductionInitializer(unsigned N) const
Returns true if the initialization of the reduction item uses initializer from declare reduction cons...
void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond, const RegionCodeGenTy &ThenGen, const RegionCodeGenTy &ElseGen)
Emits code for OpenMP 'if' clause using specified CodeGen function.
void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
Encodes a location in the source.
llvm::function_ref< void(unsigned, unsigned, StringRef, unsigned, OffloadEntryInfoTargetRegion &)> OffloadTargetRegionEntryInfoActTy
brief Applies action Action on all registered entries.
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:102
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc)
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams...
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param Data Additional data for task generation like final list of privates etc *virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
const std::string ID
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device)
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
void emitAggregateType(CodeGenFunction &CGF, unsigned N)
Emits the code for the variable-modified type, if required.
virtual void Enter(CodeGenFunction &CGF)
An aligned address.
Definition: Address.h:25
void setAction(PrePostActionTy &Action) const
void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr, llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc)
Emits initialization code for the threadprivate variables.
virtual void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc)
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal)
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final list of privates etc *TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const OMPTaskDataTy &Data)
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
std::pair< llvm::Value *, llvm::Value * > getSizes(unsigned N) const
Returns the size of the reduction item (in chars and total number of elements in the item)...
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
This class organizes the cross-function state that is used while generating LLVM code.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
StringRef Name
Definition: USRFinder.cpp:123
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc)
Call the appropriate runtime routine to notify that we finished all the work with current loop...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:2126
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
llvm::Function * createOffloadingBinaryDescriptorRegistration()
Creates and registers offloading binary descriptor for the current compilation unit.
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Value *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, const Expr *Device, ArrayRef< llvm::Value * > CapturedVars)
Emit the target offloading code associated with D.
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
ReductionCodeGen(ArrayRef< const Expr * > Shareds, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > ReductionOps)
virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N)
Required to resolve existing problems in the runtime.
detail::InMemoryDirectory::const_iterator E
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for 'target' directive.
void emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr, LValue SharedLVal, llvm::function_ref< bool(CodeGenFunction &)> DefaultInit)
Performs initialization of the private copy for the reduction item.
OffloadEntriesInfoManagerTy OffloadEntriesInfoManager
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:59
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options)
Emit a code for reduction clause.
Entity that registers the offloading constants that were emitted so far.
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
virtual llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data)
Emit a code for initialization of task reduction clause.
llvm::Constant * createDispatchNextFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_next_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
virtual void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars)
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
Defines the clang::SourceLocation class and associated facilities.
llvm::PointerIntPair< llvm::Value *, 1, bool > Schedule
Privates[]
Gets the list of initial values for linear variables.
Definition: OpenMPClause.h:136
virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned)
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
const VarDecl * getBaseDecl(unsigned N) const
Returns the base declaration of the reduction item.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:953
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D)
Emit initialization for doacross loop nesting support.
QualType KmpDimTy
struct kmp_dim { // loop bounds info casted to kmp_int64 kmp_int64 lo; // lower kmp_int64 up; // uppe...
LValue - This represents an lvalue references.
Definition: CGValue.h:171
llvm::Constant * createRuntimeFunction(unsigned Function)
Returns specified OpenMP runtime function.
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
void operator()(CodeGenFunction &CGF) const
virtual void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps)
Emits a single region.
virtual void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc)
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
SmallVector< const Expr *, 4 > FirstprivateInits
llvm::Constant * getOrCreateThreadPrivateCache(const VarDecl *VD)
If the specified mangled name is not in the module, create and return threadprivate cache object...
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...