clang  8.0.0svn
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/StringMap.h"
23 #include "llvm/ADT/StringSet.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,
73  PrePostActionTy &Action) {
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;
106  llvm::Value *Reductions = nullptr;
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 expression.
137  LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
138  /// Emits upper bound for shared expression (if array section).
139  LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
140  /// Performs aggregate initialization.
141  /// \param N Number of reduction item in the common list.
142  /// \param PrivateAddr Address of the corresponding private item.
143  /// \param SharedLVal Address of the original shared variable.
144  /// \param DRD Declare reduction construct used for reduction item.
145  void emitAggregateInitialization(CodeGenFunction &CGF, unsigned N,
146  Address PrivateAddr, LValue SharedLVal,
147  const OMPDeclareReductionDecl *DRD);
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.
183  Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N,
184  Address PrivateAddr);
185  /// Returns LValue for the reduction item.
186  LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
187  /// Returns the size of the reduction item (in chars and total number of
188  /// elements in the item), or nullptr, if the size is a constant.
189  std::pair<llvm::Value *, llvm::Value *> getSizes(unsigned N) const {
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 the base declaration of the reduction item.
195  const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
196  /// Returns true if the initialization of the reduction item uses initializer
197  /// from declare reduction construct.
198  bool usesReductionInitializer(unsigned N) const;
199 };
200 
202 public:
203  /// Allows to disable automatic handling of functions used in target regions
204  /// as those marked as `omp declare target`.
206  CodeGenModule &CGM;
207  bool SavedShouldMarkAsGlobal;
208 
209  public:
212  };
213 
214 protected:
216  StringRef FirstSeparator, Separator;
217 
218  /// Constructor allowing to redefine the name separator for the variables.
219  explicit CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator,
220  StringRef Separator);
221 
222  /// Creates offloading entry for the provided entry ID \a ID,
223  /// address \a Addr, size \a Size, and flags \a Flags.
224  virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
225  uint64_t Size, int32_t Flags,
226  llvm::GlobalValue::LinkageTypes Linkage);
227 
228  /// Helper to emit outlined function for 'target' directive.
229  /// \param D Directive to emit.
230  /// \param ParentName Name of the function that encloses the target region.
231  /// \param OutlinedFn Outlined function value to be defined by this call.
232  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
233  /// \param IsOffloadEntry True if the outlined function is an offload entry.
234  /// \param CodeGen Lambda codegen specific to an accelerator device.
235  /// An outlined function may not be an entry if, e.g. the if clause always
236  /// evaluates to false.
237  virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D,
238  StringRef ParentName,
239  llvm::Function *&OutlinedFn,
240  llvm::Constant *&OutlinedFnID,
241  bool IsOffloadEntry,
242  const RegionCodeGenTy &CodeGen);
243 
244  /// Emits code for OpenMP 'if' clause using specified \a CodeGen
245  /// function. Here is the logic:
246  /// if (Cond) {
247  /// ThenGen();
248  /// } else {
249  /// ElseGen();
250  /// }
251  void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond,
252  const RegionCodeGenTy &ThenGen,
253  const RegionCodeGenTy &ElseGen);
254 
255  /// Emits object of ident_t type with info for source location.
256  /// \param Flags Flags for OpenMP location.
257  ///
258  llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
259  unsigned Flags = 0);
260 
261  /// Returns pointer to ident_t type.
262  llvm::Type *getIdentTyPointerTy();
263 
264  /// Gets thread id value for the current thread.
265  ///
266  llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
267 
268  /// Get the function name of an outlined region.
269  // The name can be customized depending on the target.
270  //
271  virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
272 
273  /// Emits \p Callee function call with arguments \p Args with location \p Loc.
274  void emitCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *Callee,
275  ArrayRef<llvm::Value *> Args = llvm::None) const;
276 
277  /// Emits address of the word in a memory where current thread id is
278  /// stored.
279  virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
280 
281  void setLocThreadIdInsertPt(CodeGenFunction &CGF,
282  bool AtCurrentPoint = false);
283  void clearLocThreadIdInsertPt(CodeGenFunction &CGF);
284 
285  /// Check if the default location must be constant.
286  /// Default is false to support OMPT/OMPD.
287  virtual bool isDefaultLocationConstant() const { return false; }
288 
289  /// Returns additional flags that can be stored in reserved_2 field of the
290  /// default location.
291  virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
292 
293  /// Returns default flags for the barriers depending on the directive, for
294  /// which this barier is going to be emitted.
295  static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind);
296 
297  /// Get the LLVM type for the critical name.
298  llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
299 
300  /// Returns corresponding lock object for the specified critical region
301  /// name. If the lock object does not exist it is created, otherwise the
302  /// reference to the existing copy is returned.
303  /// \param CriticalName Name of the critical region.
304  ///
305  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
306 
307 private:
308  /// Default const ident_t object used for initialization of all other
309  /// ident_t objects.
310  llvm::Constant *DefaultOpenMPPSource = nullptr;
311  using FlagsTy = std::pair<unsigned, unsigned>;
312  /// Map of flags and corresponding default locations.
313  using OpenMPDefaultLocMapTy = llvm::DenseMap<FlagsTy, llvm::Value *>;
314  OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
315  Address getOrCreateDefaultLocation(unsigned Flags);
316 
317  QualType IdentQTy;
318  llvm::StructType *IdentTy = nullptr;
319  /// Map for SourceLocation and OpenMP runtime library debug locations.
320  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
321  OpenMPDebugLocMapTy OpenMPDebugLocMap;
322  /// The type for a microtask which gets passed to __kmpc_fork_call().
323  /// Original representation is:
324  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
325  llvm::FunctionType *Kmpc_MicroTy = nullptr;
326  /// Stores debug location and ThreadID for the function.
327  struct DebugLocThreadIdTy {
328  llvm::Value *DebugLoc;
329  llvm::Value *ThreadID;
330  /// Insert point for the service instructions.
331  llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
332  };
333  /// Map of local debug location, ThreadId and functions.
334  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
335  OpenMPLocThreadIDMapTy;
336  OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
337  /// Map of UDRs and corresponding combiner/initializer.
338  typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
339  std::pair<llvm::Function *, llvm::Function *>>
340  UDRMapTy;
341  UDRMapTy UDRMap;
342  /// Map of functions and locally defined UDRs.
343  typedef llvm::DenseMap<llvm::Function *,
345  FunctionUDRMapTy;
346  FunctionUDRMapTy FunctionUDRMap;
347  /// Type kmp_critical_name, originally defined as typedef kmp_int32
348  /// kmp_critical_name[8];
349  llvm::ArrayType *KmpCriticalNameTy;
350  /// An ordered map of auto-generated variables to their unique names.
351  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
352  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
353  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
354  /// variables.
355  llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
356  InternalVars;
357  /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
358  llvm::Type *KmpRoutineEntryPtrTy = nullptr;
359  QualType KmpRoutineEntryPtrQTy;
360  /// Type typedef struct kmp_task {
361  /// void * shareds; /**< pointer to block of pointers to
362  /// shared vars */
363  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
364  /// executing task */
365  /// kmp_int32 part_id; /**< part id for the task */
366  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
367  /// deconstructors of firstprivate C++ objects */
368  /// } kmp_task_t;
370  /// Saved kmp_task_t for task directive.
372  /// Saved kmp_task_t for taskloop-based directive.
374  /// Type typedef struct kmp_depend_info {
375  /// kmp_intptr_t base_addr;
376  /// size_t len;
377  /// struct {
378  /// bool in:1;
379  /// bool out:1;
380  /// } flags;
381  /// } kmp_depend_info_t;
383  /// struct kmp_dim { // loop bounds info casted to kmp_int64
384  /// kmp_int64 lo; // lower
385  /// kmp_int64 up; // upper
386  /// kmp_int64 st; // stride
387  /// };
389  /// Type struct __tgt_offload_entry{
390  /// void *addr; // Pointer to the offload entry info.
391  /// // (function or global)
392  /// char *name; // Name of the function or global.
393  /// size_t size; // Size of the entry info (0 if it a function).
394  /// };
396  /// struct __tgt_device_image{
397  /// void *ImageStart; // Pointer to the target code start.
398  /// void *ImageEnd; // Pointer to the target code end.
399  /// // We also add the host entries to the device image, as it may be useful
400  /// // for the target runtime to have access to that information.
401  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
402  /// // the entries.
403  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
404  /// // entries (non inclusive).
405  /// };
407  /// struct __tgt_bin_desc{
408  /// int32_t NumDevices; // Number of devices supported.
409  /// __tgt_device_image *DeviceImages; // Arrays of device images
410  /// // (one per device).
411  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
412  /// // entries.
413  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
414  /// // entries (non inclusive).
415  /// };
417  /// Entity that registers the offloading constants that were emitted so
418  /// far.
420  CodeGenModule &CGM;
421 
422  /// Number of entries registered so far.
423  unsigned OffloadingEntriesNum = 0;
424 
425  public:
426  /// Base class of the entries info.
428  public:
429  /// Kind of a given entry.
430  enum OffloadingEntryInfoKinds : unsigned {
431  /// Entry is a target region.
432  OffloadingEntryInfoTargetRegion = 0,
433  /// Entry is a declare target variable.
434  OffloadingEntryInfoDeviceGlobalVar = 1,
435  /// Invalid entry info.
436  OffloadingEntryInfoInvalid = ~0u
437  };
438 
439  protected:
440  OffloadEntryInfo() = delete;
441  explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind) : Kind(Kind) {}
442  explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order,
443  uint32_t Flags)
444  : Flags(Flags), Order(Order), Kind(Kind) {}
445  ~OffloadEntryInfo() = default;
446 
447  public:
448  bool isValid() const { return Order != ~0u; }
449  unsigned getOrder() const { return Order; }
451  uint32_t getFlags() const { return Flags; }
452  void setFlags(uint32_t NewFlags) { Flags = NewFlags; }
453  llvm::Constant *getAddress() const {
454  return cast_or_null<llvm::Constant>(Addr);
455  }
456  void setAddress(llvm::Constant *V) {
457  assert(!Addr.pointsToAliveValue() && "Address has been set before!");
458  Addr = V;
459  }
460  static bool classof(const OffloadEntryInfo *Info) { return true; }
461 
462  private:
463  /// Address of the entity that has to be mapped for offloading.
464  llvm::WeakTrackingVH Addr;
465 
466  /// Flags associated with the device global.
467  uint32_t Flags = 0u;
468 
469  /// Order this entry was emitted.
470  unsigned Order = ~0u;
471 
472  OffloadingEntryInfoKinds Kind = OffloadingEntryInfoInvalid;
473  };
474 
475  /// Return true if a there are no entries defined.
476  bool empty() const;
477  /// Return number of entries defined so far.
478  unsigned size() const { return OffloadingEntriesNum; }
480 
481  //
482  // Target region entries related.
483  //
484 
485  /// Kind of the target registry entry.
486  enum OMPTargetRegionEntryKind : uint32_t {
487  /// Mark the entry as target region.
488  OMPTargetRegionEntryTargetRegion = 0x0,
489  /// Mark the entry as a global constructor.
490  OMPTargetRegionEntryCtor = 0x02,
491  /// Mark the entry as a global destructor.
492  OMPTargetRegionEntryDtor = 0x04,
493  };
494 
495  /// Target region entries info.
497  /// Address that can be used as the ID of the entry.
498  llvm::Constant *ID = nullptr;
499 
500  public:
502  : OffloadEntryInfo(OffloadingEntryInfoTargetRegion) {}
503  explicit OffloadEntryInfoTargetRegion(unsigned Order,
504  llvm::Constant *Addr,
505  llvm::Constant *ID,
507  : OffloadEntryInfo(OffloadingEntryInfoTargetRegion, Order, Flags),
508  ID(ID) {
509  setAddress(Addr);
510  }
511 
512  llvm::Constant *getID() const { return ID; }
513  void setID(llvm::Constant *V) {
514  assert(!ID && "ID has been set before!");
515  ID = V;
516  }
517  static bool classof(const OffloadEntryInfo *Info) {
518  return Info->getKind() == OffloadingEntryInfoTargetRegion;
519  }
520  };
521 
522  /// Initialize target region entry.
523  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
524  StringRef ParentName, unsigned LineNum,
525  unsigned Order);
526  /// Register target region entry.
527  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
528  StringRef ParentName, unsigned LineNum,
529  llvm::Constant *Addr, llvm::Constant *ID,
531  /// Return true if a target region entry with the provided information
532  /// exists.
533  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
534  StringRef ParentName, unsigned LineNum) const;
535  /// brief Applies action \a Action on all registered entries.
536  typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
539  void actOnTargetRegionEntriesInfo(
540  const OffloadTargetRegionEntryInfoActTy &Action);
541 
542  //
543  // Device global variable entries related.
544  //
545 
546  /// Kind of the global variable entry..
547  enum OMPTargetGlobalVarEntryKind : uint32_t {
548  /// Mark the entry as a to declare target.
549  OMPTargetGlobalVarEntryTo = 0x0,
550  /// Mark the entry as a to declare target link.
551  OMPTargetGlobalVarEntryLink = 0x1,
552  };
553 
554  /// Device global variable entries info.
556  /// Type of the global variable.
557  CharUnits VarSize;
558  llvm::GlobalValue::LinkageTypes Linkage;
559 
560  public:
562  : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar) {}
563  explicit OffloadEntryInfoDeviceGlobalVar(unsigned Order,
565  : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags) {}
567  unsigned Order, llvm::Constant *Addr, CharUnits VarSize,
569  llvm::GlobalValue::LinkageTypes Linkage)
570  : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags),
571  VarSize(VarSize), Linkage(Linkage) {
572  setAddress(Addr);
573  }
574 
575  CharUnits getVarSize() const { return VarSize; }
576  void setVarSize(CharUnits Size) { VarSize = Size; }
577  llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
578  void setLinkage(llvm::GlobalValue::LinkageTypes LT) { Linkage = LT; }
579  static bool classof(const OffloadEntryInfo *Info) {
580  return Info->getKind() == OffloadingEntryInfoDeviceGlobalVar;
581  }
582  };
583 
584  /// Initialize device global variable entry.
585  void initializeDeviceGlobalVarEntryInfo(StringRef Name,
587  unsigned Order);
588 
589  /// Register device global variable entry.
590  void
591  registerDeviceGlobalVarEntryInfo(StringRef VarName, llvm::Constant *Addr,
592  CharUnits VarSize,
594  llvm::GlobalValue::LinkageTypes Linkage);
595  /// Checks if the variable with the given name has been registered already.
596  bool hasDeviceGlobalVarEntryInfo(StringRef VarName) const {
597  return OffloadEntriesDeviceGlobalVar.count(VarName) > 0;
598  }
599  /// Applies action \a Action on all registered entries.
600  typedef llvm::function_ref<void(StringRef,
603  void actOnDeviceGlobalVarEntriesInfo(
605 
606  private:
607  // Storage for target region entries kind. The storage is to be indexed by
608  // file ID, device ID, parent function name and line number.
609  typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
610  OffloadEntriesTargetRegionPerLine;
611  typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
612  OffloadEntriesTargetRegionPerParentName;
613  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
614  OffloadEntriesTargetRegionPerFile;
615  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
616  OffloadEntriesTargetRegionPerDevice;
617  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
618  OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
619  /// Storage for device global variable entries kind. The storage is to be
620  /// indexed by mangled name.
621  typedef llvm::StringMap<OffloadEntryInfoDeviceGlobalVar>
622  OffloadEntriesDeviceGlobalVarTy;
623  OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar;
624  };
626 
627  bool ShouldMarkAsGlobal = true;
628  /// List of the emitted functions.
629  llvm::StringSet<> AlreadyEmittedTargetFunctions;
630  /// List of the global variables with their addresses that should not be
631  /// emitted for the target.
632  llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
633 
634  /// List of variables that can become declare target implicitly and, thus,
635  /// must be emitted.
636  llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
637 
638  /// Creates and registers offloading binary descriptor for the current
639  /// compilation unit. The function that does the registration is returned.
641 
642  /// Creates all the offload entries in the current compilation unit
643  /// along with the associated metadata.
645 
646  /// Loads all the offload entries information from the host IR
647  /// metadata.
649 
650  /// Returns __tgt_offload_entry type.
652 
653  /// Returns __tgt_device_image type.
655 
656  /// Returns __tgt_bin_desc type.
658 
659  /// Start scanning from statement \a S and and emit all target regions
660  /// found along the way.
661  /// \param S Starting statement.
662  /// \param ParentName Name of the function declaration that is being scanned.
663  void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
664 
665  /// Build type kmp_routine_entry_t (if not built yet).
666  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
667 
668  /// Returns pointer to kmpc_micro type.
669  llvm::Type *getKmpc_MicroPointerTy();
670 
671  /// Returns specified OpenMP runtime function.
672  /// \param Function OpenMP runtime function.
673  /// \return Specified function.
674  llvm::Constant *createRuntimeFunction(unsigned Function);
675 
676  /// Returns __kmpc_for_static_init_* runtime function for the specified
677  /// size \a IVSize and sign \a IVSigned.
678  llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
679 
680  /// Returns __kmpc_dispatch_init_* runtime function for the specified
681  /// size \a IVSize and sign \a IVSigned.
682  llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
683 
684  /// Returns __kmpc_dispatch_next_* runtime function for the specified
685  /// size \a IVSize and sign \a IVSigned.
686  llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
687 
688  /// Returns __kmpc_dispatch_fini_* runtime function for the specified
689  /// size \a IVSize and sign \a IVSigned.
690  llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
691 
692  /// If the specified mangled name is not in the module, create and
693  /// return threadprivate cache object. This object is a pointer's worth of
694  /// storage that's reserved for use by the OpenMP runtime.
695  /// \param VD Threadprivate variable.
696  /// \return Cache variable for the specified threadprivate.
697  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
698 
699  /// Gets (if variable with the given name already exist) or creates
700  /// internal global variable with the specified Name. The created variable has
701  /// linkage CommonLinkage by default and is initialized by null value.
702  /// \param Ty Type of the global variable. If it is exist already the type
703  /// must be the same.
704  /// \param Name Name of the variable.
705  llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
706  const llvm::Twine &Name);
707 
708  /// Set of threadprivate variables with the generated initializer.
709  llvm::StringSet<> ThreadPrivateWithDefinition;
710 
711  /// Set of declare target variables with the generated initializer.
712  llvm::StringSet<> DeclareTargetWithDefinition;
713 
714  /// Emits initialization code for the threadprivate variables.
715  /// \param VDAddr Address of the global variable \a VD.
716  /// \param Ctor Pointer to a global init function for \a VD.
717  /// \param CopyCtor Pointer to a global copy function for \a VD.
718  /// \param Dtor Pointer to a global destructor function for \a VD.
719  /// \param Loc Location of threadprivate declaration.
721  llvm::Value *Ctor, llvm::Value *CopyCtor,
722  llvm::Value *Dtor, SourceLocation Loc);
723 
724  struct TaskResultTy {
725  llvm::Value *NewTask = nullptr;
726  llvm::Value *TaskEntry = nullptr;
727  llvm::Value *NewTaskNewTaskTTy = nullptr;
729  const RecordDecl *KmpTaskTQTyRD = nullptr;
730  llvm::Value *TaskDupFn = nullptr;
731  };
732  /// Emit task region for the task directive. The task region is emitted in
733  /// several steps:
734  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
735  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
736  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
737  /// function:
738  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
739  /// TaskFunction(gtid, tt->part_id, tt->shareds);
740  /// return 0;
741  /// }
742  /// 2. Copy a list of shared variables to field shareds of the resulting
743  /// structure kmp_task_t returned by the previous call (if any).
744  /// 3. Copy a pointer to destructions function to field destructions of the
745  /// resulting structure kmp_task_t.
746  /// \param D Current task directive.
747  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
748  /// /*part_id*/, captured_struct */*__context*/);
749  /// \param SharedsTy A type which contains references the shared variables.
750  /// \param Shareds Context with the list of shared variables from the \p
751  /// TaskFunction.
752  /// \param Data Additional data for task generation like tiednsee, final
753  /// state, list of privates etc.
755  const OMPExecutableDirective &D,
756  llvm::Value *TaskFunction, QualType SharedsTy,
757  Address Shareds, const OMPTaskDataTy &Data);
758 
759 public:
761  : CGOpenMPRuntime(CGM, ".", ".") {}
762  virtual ~CGOpenMPRuntime() {}
763  virtual void clear();
764 
765  /// Get the platform-specific name separator.
766  std::string getName(ArrayRef<StringRef> Parts) const;
767 
768  /// Emit code for the specified user defined reduction construct.
769  virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
770  const OMPDeclareReductionDecl *D);
771  /// Get combiner/initializer for the specified user-defined reduction, if any.
772  virtual std::pair<llvm::Function *, llvm::Function *>
773  getUserDefinedReduction(const OMPDeclareReductionDecl *D);
774 
775  /// Emits outlined function for the specified OpenMP parallel directive
776  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
777  /// kmp_int32 BoundID, struct context_vars*).
778  /// \param D OpenMP directive.
779  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
780  /// \param InnermostKind Kind of innermost directive (for simple directives it
781  /// is a directive itself, for combined - its innermost directive).
782  /// \param CodeGen Code generation sequence for the \a D directive.
784  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
785  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
786 
787  /// Emits outlined function for the specified OpenMP teams directive
788  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
789  /// kmp_int32 BoundID, struct context_vars*).
790  /// \param D OpenMP directive.
791  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
792  /// \param InnermostKind Kind of innermost directive (for simple directives it
793  /// is a directive itself, for combined - its innermost directive).
794  /// \param CodeGen Code generation sequence for the \a D directive.
796  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
797  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
798 
799  /// Emits outlined function for the OpenMP task directive \a D. This
800  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
801  /// TaskT).
802  /// \param D OpenMP directive.
803  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
804  /// \param PartIDVar Variable for partition id in the current OpenMP untied
805  /// task region.
806  /// \param TaskTVar Variable for task_t argument.
807  /// \param InnermostKind Kind of innermost directive (for simple directives it
808  /// is a directive itself, for combined - its innermost directive).
809  /// \param CodeGen Code generation sequence for the \a D directive.
810  /// \param Tied true if task is generated for tied task, false otherwise.
811  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
812  /// tasks.
813  ///
815  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
816  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
817  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
818  bool Tied, unsigned &NumberOfParts);
819 
820  /// Cleans up references to the objects in finished function.
821  ///
822  virtual void functionFinished(CodeGenFunction &CGF);
823 
824  /// Emits code for parallel or serial call of the \a OutlinedFn with
825  /// variables captured in a record which address is stored in \a
826  /// CapturedStruct.
827  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
828  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
829  /// \param CapturedVars A pointer to the record with the references to
830  /// variables used in \a OutlinedFn function.
831  /// \param IfCond Condition in the associated 'if' clause, if it was
832  /// specified, nullptr otherwise.
833  ///
834  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
835  llvm::Value *OutlinedFn,
836  ArrayRef<llvm::Value *> CapturedVars,
837  const Expr *IfCond);
838 
839  /// Emits a critical region.
840  /// \param CriticalName Name of the critical region.
841  /// \param CriticalOpGen Generator for the statement associated with the given
842  /// critical region.
843  /// \param Hint Value of the 'hint' clause (optional).
844  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
845  const RegionCodeGenTy &CriticalOpGen,
846  SourceLocation Loc,
847  const Expr *Hint = nullptr);
848 
849  /// Emits a master region.
850  /// \param MasterOpGen Generator for the statement associated with the given
851  /// master region.
852  virtual void emitMasterRegion(CodeGenFunction &CGF,
853  const RegionCodeGenTy &MasterOpGen,
854  SourceLocation Loc);
855 
856  /// Emits code for a taskyield directive.
857  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
858 
859  /// Emit a taskgroup region.
860  /// \param TaskgroupOpGen Generator for the statement associated with the
861  /// given taskgroup region.
862  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
863  const RegionCodeGenTy &TaskgroupOpGen,
864  SourceLocation Loc);
865 
866  /// Emits a single region.
867  /// \param SingleOpGen Generator for the statement associated with the given
868  /// single region.
869  virtual void emitSingleRegion(CodeGenFunction &CGF,
870  const RegionCodeGenTy &SingleOpGen,
871  SourceLocation Loc,
872  ArrayRef<const Expr *> CopyprivateVars,
873  ArrayRef<const Expr *> DestExprs,
874  ArrayRef<const Expr *> SrcExprs,
875  ArrayRef<const Expr *> AssignmentOps);
876 
877  /// Emit an ordered region.
878  /// \param OrderedOpGen Generator for the statement associated with the given
879  /// ordered region.
880  virtual void emitOrderedRegion(CodeGenFunction &CGF,
881  const RegionCodeGenTy &OrderedOpGen,
882  SourceLocation Loc, bool IsThreads);
883 
884  /// Emit an implicit/explicit barrier for OpenMP threads.
885  /// \param Kind Directive for which this implicit barrier call must be
886  /// generated. Must be OMPD_barrier for explicit barrier generation.
887  /// \param EmitChecks true if need to emit checks for cancellation barriers.
888  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
889  /// runtime class decides which one to emit (simple or with cancellation
890  /// checks).
891  ///
892  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
893  OpenMPDirectiveKind Kind,
894  bool EmitChecks = true,
895  bool ForceSimpleCall = false);
896 
897  /// Check if the specified \a ScheduleKind is static non-chunked.
898  /// This kind of worksharing directive is emitted without outer loop.
899  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
900  /// \param Chunked True if chunk is specified in the clause.
901  ///
902  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
903  bool Chunked) const;
904 
905  /// Check if the specified \a ScheduleKind is static non-chunked.
906  /// This kind of distribute directive is emitted without outer loop.
907  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
908  /// \param Chunked True if chunk is specified in the clause.
909  ///
910  virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
911  bool Chunked) const;
912 
913  /// Check if the specified \a ScheduleKind is static chunked.
914  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
915  /// \param Chunked True if chunk is specified in the clause.
916  ///
917  virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
918  bool Chunked) const;
919 
920  /// Check if the specified \a ScheduleKind is static non-chunked.
921  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
922  /// \param Chunked True if chunk is specified in the clause.
923  ///
924  virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
925  bool Chunked) const;
926 
927  /// Check if the specified \a ScheduleKind is dynamic.
928  /// This kind of worksharing directive is emitted without outer loop.
929  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
930  ///
931  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
932 
933  /// struct with the values to be passed to the dispatch runtime function
935  /// Loop lower bound
936  llvm::Value *LB = nullptr;
937  /// Loop upper bound
938  llvm::Value *UB = nullptr;
939  /// Chunk size specified using 'schedule' clause (nullptr if chunk
940  /// was not specified)
941  llvm::Value *Chunk = nullptr;
942  DispatchRTInput() = default;
944  : LB(LB), UB(UB), Chunk(Chunk) {}
945  };
946 
947  /// Call the appropriate runtime routine to initialize it before start
948  /// of loop.
949 
950  /// This is used for non static scheduled types and when the ordered
951  /// clause is present on the loop construct.
952  /// Depending on the loop schedule, it is necessary to call some runtime
953  /// routine before start of the OpenMP loop to get the loop upper / lower
954  /// bounds \a LB and \a UB and stride \a ST.
955  ///
956  /// \param CGF Reference to current CodeGenFunction.
957  /// \param Loc Clang source location.
958  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
959  /// \param IVSize Size of the iteration variable in bits.
960  /// \param IVSigned Sign of the iteration variable.
961  /// \param Ordered true if loop is ordered, false otherwise.
962  /// \param DispatchValues struct containing llvm values for lower bound, upper
963  /// bound, and chunk expression.
964  /// For the default (nullptr) value, the chunk 1 will be used.
965  ///
966  virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
967  const OpenMPScheduleTy &ScheduleKind,
968  unsigned IVSize, bool IVSigned, bool Ordered,
969  const DispatchRTInput &DispatchValues);
970 
971  /// Struct with the values to be passed to the static runtime function
972  struct StaticRTInput {
973  /// Size of the iteration variable in bits.
974  unsigned IVSize = 0;
975  /// Sign of the iteration variable.
976  bool IVSigned = false;
977  /// true if loop is ordered, false otherwise.
978  bool Ordered = false;
979  /// Address of the output variable in which the flag of the last iteration
980  /// is returned.
981  Address IL = Address::invalid();
982  /// Address of the output variable in which the lower iteration number is
983  /// returned.
984  Address LB = Address::invalid();
985  /// Address of the output variable in which the upper iteration number is
986  /// returned.
987  Address UB = Address::invalid();
988  /// Address of the output variable in which the stride value is returned
989  /// necessary to generated the static_chunked scheduled loop.
990  Address ST = Address::invalid();
991  /// Value of the chunk for the static_chunked scheduled loop. For the
992  /// default (nullptr) value, the chunk 1 will be used.
993  llvm::Value *Chunk = nullptr;
994  StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL,
995  Address LB, Address UB, Address ST,
996  llvm::Value *Chunk = nullptr)
997  : IVSize(IVSize), IVSigned(IVSigned), Ordered(Ordered), IL(IL), LB(LB),
998  UB(UB), ST(ST), Chunk(Chunk) {}
999  };
1000  /// Call the appropriate runtime routine to initialize it before start
1001  /// of loop.
1002  ///
1003  /// This is used only in case of static schedule, when the user did not
1004  /// specify a ordered clause on the loop construct.
1005  /// Depending on the loop schedule, it is necessary to call some runtime
1006  /// routine before start of the OpenMP loop to get the loop upper / lower
1007  /// bounds LB and UB and stride ST.
1008  ///
1009  /// \param CGF Reference to current CodeGenFunction.
1010  /// \param Loc Clang source location.
1011  /// \param DKind Kind of the directive.
1012  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1013  /// \param Values Input arguments for the construct.
1014  ///
1015  virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1016  OpenMPDirectiveKind DKind,
1017  const OpenMPScheduleTy &ScheduleKind,
1018  const StaticRTInput &Values);
1019 
1020  ///
1021  /// \param CGF Reference to current CodeGenFunction.
1022  /// \param Loc Clang source location.
1023  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1024  /// \param Values Input arguments for the construct.
1025  ///
1026  virtual void emitDistributeStaticInit(CodeGenFunction &CGF,
1027  SourceLocation Loc,
1028  OpenMPDistScheduleClauseKind SchedKind,
1029  const StaticRTInput &Values);
1030 
1031  /// Call the appropriate runtime routine to notify that we finished
1032  /// iteration of the ordered loop with the dynamic scheduling.
1033  ///
1034  /// \param CGF Reference to current CodeGenFunction.
1035  /// \param Loc Clang source location.
1036  /// \param IVSize Size of the iteration variable in bits.
1037  /// \param IVSigned Sign of the iteration variable.
1038  ///
1039  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
1040  SourceLocation Loc, unsigned IVSize,
1041  bool IVSigned);
1042 
1043  /// Call the appropriate runtime routine to notify that we finished
1044  /// all the work with current loop.
1045  ///
1046  /// \param CGF Reference to current CodeGenFunction.
1047  /// \param Loc Clang source location.
1048  /// \param DKind Kind of the directive for which the static finish is emitted.
1049  ///
1050  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1051  OpenMPDirectiveKind DKind);
1052 
1053  /// Call __kmpc_dispatch_next(
1054  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1055  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1056  /// kmp_int[32|64] *p_stride);
1057  /// \param IVSize Size of the iteration variable in bits.
1058  /// \param IVSigned Sign of the iteration variable.
1059  /// \param IL Address of the output variable in which the flag of the
1060  /// last iteration is returned.
1061  /// \param LB Address of the output variable in which the lower iteration
1062  /// number is returned.
1063  /// \param UB Address of the output variable in which the upper iteration
1064  /// number is returned.
1065  /// \param ST Address of the output variable in which the stride value is
1066  /// returned.
1068  unsigned IVSize, bool IVSigned,
1069  Address IL, Address LB,
1070  Address UB, Address ST);
1071 
1072  /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1073  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1074  /// clause.
1075  /// \param NumThreads An integer value of threads.
1076  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
1077  llvm::Value *NumThreads,
1078  SourceLocation Loc);
1079 
1080  /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1081  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1082  virtual void emitProcBindClause(CodeGenFunction &CGF,
1083  OpenMPProcBindClauseKind ProcBind,
1084  SourceLocation Loc);
1085 
1086  /// Returns address of the threadprivate variable for the current
1087  /// thread.
1088  /// \param VD Threadprivate variable.
1089  /// \param VDAddr Address of the global variable \a VD.
1090  /// \param Loc Location of the reference to threadprivate var.
1091  /// \return Address of the threadprivate variable for the current thread.
1093  const VarDecl *VD,
1094  Address VDAddr,
1095  SourceLocation Loc);
1096 
1097  /// Returns the address of the variable marked as declare target with link
1098  /// clause.
1099  virtual Address getAddrOfDeclareTargetLink(const VarDecl *VD);
1100 
1101  /// Emit a code for initialization of threadprivate variable. It emits
1102  /// a call to runtime library which adds initial value to the newly created
1103  /// threadprivate variable (if it is not constant) and registers destructor
1104  /// for the variable (if any).
1105  /// \param VD Threadprivate variable.
1106  /// \param VDAddr Address of the global variable \a VD.
1107  /// \param Loc Location of threadprivate declaration.
1108  /// \param PerformInit true if initialization expression is not constant.
1109  virtual llvm::Function *
1111  SourceLocation Loc, bool PerformInit,
1112  CodeGenFunction *CGF = nullptr);
1113 
1114  /// Emit a code for initialization of declare target variable.
1115  /// \param VD Declare target variable.
1116  /// \param Addr Address of the global variable \a VD.
1117  /// \param PerformInit true if initialization expression is not constant.
1118  virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD,
1119  llvm::GlobalVariable *Addr,
1120  bool PerformInit);
1121 
1122  /// Creates artificial threadprivate variable with name \p Name and type \p
1123  /// VarType.
1124  /// \param VarType Type of the artificial threadprivate variable.
1125  /// \param Name Name of the artificial threadprivate variable.
1127  QualType VarType,
1128  StringRef Name);
1129 
1130  /// Emit flush of the variables specified in 'omp flush' directive.
1131  /// \param Vars List of variables to flush.
1132  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1133  SourceLocation Loc);
1134 
1135  /// Emit task region for the task directive. The task region is
1136  /// emitted in several steps:
1137  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1138  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1139  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1140  /// function:
1141  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1142  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1143  /// return 0;
1144  /// }
1145  /// 2. Copy a list of shared variables to field shareds of the resulting
1146  /// structure kmp_task_t returned by the previous call (if any).
1147  /// 3. Copy a pointer to destructions function to field destructions of the
1148  /// resulting structure kmp_task_t.
1149  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1150  /// kmp_task_t *new_task), where new_task is a resulting structure from
1151  /// previous items.
1152  /// \param D Current task directive.
1153  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1154  /// /*part_id*/, captured_struct */*__context*/);
1155  /// \param SharedsTy A type which contains references the shared variables.
1156  /// \param Shareds Context with the list of shared variables from the \p
1157  /// TaskFunction.
1158  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1159  /// otherwise.
1160  /// \param Data Additional data for task generation like tiednsee, final
1161  /// state, list of privates etc.
1162  virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1163  const OMPExecutableDirective &D,
1164  llvm::Value *TaskFunction, QualType SharedsTy,
1165  Address Shareds, const Expr *IfCond,
1166  const OMPTaskDataTy &Data);
1167 
1168  /// Emit task region for the taskloop directive. The taskloop region is
1169  /// emitted in several steps:
1170  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1171  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1172  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1173  /// function:
1174  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1175  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1176  /// return 0;
1177  /// }
1178  /// 2. Copy a list of shared variables to field shareds of the resulting
1179  /// structure kmp_task_t returned by the previous call (if any).
1180  /// 3. Copy a pointer to destructions function to field destructions of the
1181  /// resulting structure kmp_task_t.
1182  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1183  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1184  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1185  /// is a resulting structure from
1186  /// previous items.
1187  /// \param D Current task directive.
1188  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1189  /// /*part_id*/, captured_struct */*__context*/);
1190  /// \param SharedsTy A type which contains references the shared variables.
1191  /// \param Shareds Context with the list of shared variables from the \p
1192  /// TaskFunction.
1193  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1194  /// otherwise.
1195  /// \param Data Additional data for task generation like tiednsee, final
1196  /// state, list of privates etc.
1197  virtual void emitTaskLoopCall(
1198  CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D,
1199  llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds,
1200  const Expr *IfCond, const OMPTaskDataTy &Data);
1201 
1202  /// Emit code for the directive that does not require outlining.
1203  ///
1204  /// \param InnermostKind Kind of innermost directive (for simple directives it
1205  /// is a directive itself, for combined - its innermost directive).
1206  /// \param CodeGen Code generation sequence for the \a D directive.
1207  /// \param HasCancel true if region has inner cancel directive, false
1208  /// otherwise.
1209  virtual void emitInlinedDirective(CodeGenFunction &CGF,
1210  OpenMPDirectiveKind InnermostKind,
1211  const RegionCodeGenTy &CodeGen,
1212  bool HasCancel = false);
1213 
1214  /// Emits reduction function.
1215  /// \param ArgsType Array type containing pointers to reduction variables.
1216  /// \param Privates List of private copies for original reduction arguments.
1217  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1218  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1219  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1220  /// or 'operator binop(LHS, RHS)'.
1222  llvm::Type *ArgsType,
1224  ArrayRef<const Expr *> LHSExprs,
1225  ArrayRef<const Expr *> RHSExprs,
1226  ArrayRef<const Expr *> ReductionOps);
1227 
1228  /// Emits single reduction combiner
1230  const Expr *ReductionOp,
1231  const Expr *PrivateRef,
1232  const DeclRefExpr *LHS,
1233  const DeclRefExpr *RHS);
1234 
1239  };
1240  /// Emit a code for reduction clause. Next code should be emitted for
1241  /// reduction:
1242  /// \code
1243  ///
1244  /// static kmp_critical_name lock = { 0 };
1245  ///
1246  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1247  /// ...
1248  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1249  /// ...
1250  /// }
1251  ///
1252  /// ...
1253  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1254  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1255  /// RedList, reduce_func, &<lock>)) {
1256  /// case 1:
1257  /// ...
1258  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1259  /// ...
1260  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1261  /// break;
1262  /// case 2:
1263  /// ...
1264  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1265  /// ...
1266  /// break;
1267  /// default:;
1268  /// }
1269  /// \endcode
1270  ///
1271  /// \param Privates List of private copies for original reduction arguments.
1272  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1273  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1274  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1275  /// or 'operator binop(LHS, RHS)'.
1276  /// \param Options List of options for reduction codegen:
1277  /// WithNowait true if parent directive has also nowait clause, false
1278  /// otherwise.
1279  /// SimpleReduction Emit reduction operation only. Used for omp simd
1280  /// directive on the host.
1281  /// ReductionKind The kind of reduction to perform.
1282  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1284  ArrayRef<const Expr *> LHSExprs,
1285  ArrayRef<const Expr *> RHSExprs,
1286  ArrayRef<const Expr *> ReductionOps,
1287  ReductionOptionsTy Options);
1288 
1289  /// Emit a code for initialization of task reduction clause. Next code
1290  /// should be emitted for reduction:
1291  /// \code
1292  ///
1293  /// _task_red_item_t red_data[n];
1294  /// ...
1295  /// red_data[i].shar = &origs[i];
1296  /// red_data[i].size = sizeof(origs[i]);
1297  /// red_data[i].f_init = (void*)RedInit<i>;
1298  /// red_data[i].f_fini = (void*)RedDest<i>;
1299  /// red_data[i].f_comb = (void*)RedOp<i>;
1300  /// red_data[i].flags = <Flag_i>;
1301  /// ...
1302  /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data);
1303  /// \endcode
1304  ///
1305  /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1306  /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1307  /// \param Data Additional data for task generation like tiedness, final
1308  /// state, list of privates, reductions etc.
1310  SourceLocation Loc,
1311  ArrayRef<const Expr *> LHSExprs,
1312  ArrayRef<const Expr *> RHSExprs,
1313  const OMPTaskDataTy &Data);
1314 
1315  /// Required to resolve existing problems in the runtime. Emits threadprivate
1316  /// variables to store the size of the VLAs/array sections for
1317  /// initializer/combiner/finalizer functions + emits threadprivate variable to
1318  /// store the pointer to the original reduction item for the custom
1319  /// initializer defined by declare reduction construct.
1320  /// \param RCG Allows to reuse an existing data for the reductions.
1321  /// \param N Reduction item for which fixups must be emitted.
1323  ReductionCodeGen &RCG, unsigned N);
1324 
1325  /// Get the address of `void *` type of the privatue copy of the reduction
1326  /// item specified by the \p SharedLVal.
1327  /// \param ReductionsPtr Pointer to the reduction data returned by the
1328  /// emitTaskReductionInit function.
1329  /// \param SharedLVal Address of the original reduction item.
1331  llvm::Value *ReductionsPtr,
1332  LValue SharedLVal);
1333 
1334  /// Emit code for 'taskwait' directive.
1335  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
1336 
1337  /// Emit code for 'cancellation point' construct.
1338  /// \param CancelRegion Region kind for which the cancellation point must be
1339  /// emitted.
1340  ///
1341  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
1342  SourceLocation Loc,
1343  OpenMPDirectiveKind CancelRegion);
1344 
1345  /// Emit code for 'cancel' construct.
1346  /// \param IfCond Condition in the associated 'if' clause, if it was
1347  /// specified, nullptr otherwise.
1348  /// \param CancelRegion Region kind for which the cancel must be emitted.
1349  ///
1350  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1351  const Expr *IfCond,
1352  OpenMPDirectiveKind CancelRegion);
1353 
1354  /// Emit outilined function for 'target' directive.
1355  /// \param D Directive to emit.
1356  /// \param ParentName Name of the function that encloses the target region.
1357  /// \param OutlinedFn Outlined function value to be defined by this call.
1358  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1359  /// \param IsOffloadEntry True if the outlined function is an offload entry.
1360  /// \param CodeGen Code generation sequence for the \a D directive.
1361  /// An outlined function may not be an entry if, e.g. the if clause always
1362  /// evaluates to false.
1363  virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
1364  StringRef ParentName,
1365  llvm::Function *&OutlinedFn,
1366  llvm::Constant *&OutlinedFnID,
1367  bool IsOffloadEntry,
1368  const RegionCodeGenTy &CodeGen);
1369 
1370  /// Emit the target offloading code associated with \a D. The emitted
1371  /// code attempts offloading the execution to the device, an the event of
1372  /// a failure it executes the host version outlined in \a OutlinedFn.
1373  /// \param D Directive to emit.
1374  /// \param OutlinedFn Host version of the code to be offloaded.
1375  /// \param OutlinedFnID ID of host version of the code to be offloaded.
1376  /// \param IfCond Expression evaluated in if clause associated with the target
1377  /// directive, or null if no if clause is used.
1378  /// \param Device Expression evaluated in device clause associated with the
1379  /// target directive, or null if no device clause is used.
1380  virtual void emitTargetCall(CodeGenFunction &CGF,
1381  const OMPExecutableDirective &D,
1382  llvm::Value *OutlinedFn,
1383  llvm::Value *OutlinedFnID, const Expr *IfCond,
1384  const Expr *Device);
1385 
1386  /// Emit the target regions enclosed in \a GD function definition or
1387  /// the function itself in case it is a valid device function. Returns true if
1388  /// \a GD was dealt with successfully.
1389  /// \param GD Function to scan.
1390  virtual bool emitTargetFunctions(GlobalDecl GD);
1391 
1392  /// Emit the global variable if it is a valid device global variable.
1393  /// Returns true if \a GD was dealt with successfully.
1394  /// \param GD Variable declaration to emit.
1395  virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1396 
1397  /// Checks if the provided global decl \a GD is a declare target variable and
1398  /// registers it when emitting code for the host.
1399  virtual void registerTargetGlobalVariable(const VarDecl *VD,
1400  llvm::Constant *Addr);
1401 
1402  /// Emit the global \a GD if it is meaningful for the target. Returns
1403  /// if it was emitted successfully.
1404  /// \param GD Global to scan.
1405  virtual bool emitTargetGlobal(GlobalDecl GD);
1406 
1407  /// Creates the offloading descriptor in the event any target region
1408  /// was emitted in the current module and return the function that registers
1409  /// it.
1410  virtual llvm::Function *emitRegistrationFunction();
1411 
1412  /// Emits code for teams call of the \a OutlinedFn with
1413  /// variables captured in a record which address is stored in \a
1414  /// CapturedStruct.
1415  /// \param OutlinedFn Outlined function to be run by team masters. Type of
1416  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1417  /// \param CapturedVars A pointer to the record with the references to
1418  /// variables used in \a OutlinedFn function.
1419  ///
1420  virtual void emitTeamsCall(CodeGenFunction &CGF,
1421  const OMPExecutableDirective &D,
1422  SourceLocation Loc, llvm::Value *OutlinedFn,
1423  ArrayRef<llvm::Value *> CapturedVars);
1424 
1425  /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1426  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1427  /// for num_teams clause.
1428  /// \param NumTeams An integer expression of teams.
1429  /// \param ThreadLimit An integer expression of threads.
1430  virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1431  const Expr *ThreadLimit, SourceLocation Loc);
1432 
1433  /// Struct that keeps all the relevant information that should be kept
1434  /// throughout a 'target data' region.
1436  /// Set to true if device pointer information have to be obtained.
1437  bool RequiresDevicePointerInfo = false;
1438 
1439  public:
1440  /// The array of base pointer passed to the runtime library.
1441  llvm::Value *BasePointersArray = nullptr;
1442  /// The array of section pointers passed to the runtime library.
1443  llvm::Value *PointersArray = nullptr;
1444  /// The array of sizes passed to the runtime library.
1445  llvm::Value *SizesArray = nullptr;
1446  /// The array of map types passed to the runtime library.
1447  llvm::Value *MapTypesArray = nullptr;
1448  /// The total number of pointers passed to the runtime library.
1449  unsigned NumberOfPtrs = 0u;
1450  /// Map between the a declaration of a capture and the corresponding base
1451  /// pointer address where the runtime returns the device pointers.
1452  llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1453 
1454  explicit TargetDataInfo() {}
1455  explicit TargetDataInfo(bool RequiresDevicePointerInfo)
1456  : RequiresDevicePointerInfo(RequiresDevicePointerInfo) {}
1457  /// Clear information about the data arrays.
1459  BasePointersArray = nullptr;
1460  PointersArray = nullptr;
1461  SizesArray = nullptr;
1462  MapTypesArray = nullptr;
1463  NumberOfPtrs = 0u;
1464  }
1465  /// Return true if the current target data information has valid arrays.
1466  bool isValid() {
1467  return BasePointersArray && PointersArray && SizesArray &&
1468  MapTypesArray && NumberOfPtrs;
1469  }
1470  bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
1471  };
1472 
1473  /// Emit the target data mapping code associated with \a D.
1474  /// \param D Directive to emit.
1475  /// \param IfCond Expression evaluated in if clause associated with the
1476  /// target directive, or null if no device clause is used.
1477  /// \param Device Expression evaluated in device clause associated with the
1478  /// target directive, or null if no device clause is used.
1479  /// \param Info A record used to store information that needs to be preserved
1480  /// until the region is closed.
1481  virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1482  const OMPExecutableDirective &D,
1483  const Expr *IfCond, const Expr *Device,
1484  const RegionCodeGenTy &CodeGen,
1485  TargetDataInfo &Info);
1486 
1487  /// Emit the data mapping/movement code associated with the directive
1488  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1489  /// \param D Directive to emit.
1490  /// \param IfCond Expression evaluated in if clause associated with the target
1491  /// directive, or null if no if clause is used.
1492  /// \param Device Expression evaluated in device clause associated with the
1493  /// target directive, or null if no device clause is used.
1495  const OMPExecutableDirective &D,
1496  const Expr *IfCond,
1497  const Expr *Device);
1498 
1499  /// Marks function \a Fn with properly mangled versions of vector functions.
1500  /// \param FD Function marked as 'declare simd'.
1501  /// \param Fn LLVM function that must be marked with 'declare simd'
1502  /// attributes.
1503  virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1504  llvm::Function *Fn);
1505 
1506  /// Emit initialization for doacross loop nesting support.
1507  /// \param D Loop-based construct used in doacross nesting construct.
1508  virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
1509  ArrayRef<Expr *> NumIterations);
1510 
1511  /// Emit code for doacross ordered directive with 'depend' clause.
1512  /// \param C 'depend' clause with 'sink|source' dependency kind.
1513  virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1514  const OMPDependClause *C);
1515 
1516  /// Translates the native parameter of outlined function if this is required
1517  /// for target.
1518  /// \param FD Field decl from captured record for the parameter.
1519  /// \param NativeParam Parameter itself.
1520  virtual const VarDecl *translateParameter(const FieldDecl *FD,
1521  const VarDecl *NativeParam) const {
1522  return NativeParam;
1523  }
1524 
1525  /// Gets the address of the native argument basing on the address of the
1526  /// target-specific parameter.
1527  /// \param NativeParam Parameter itself.
1528  /// \param TargetParam Corresponding target-specific parameter.
1530  const VarDecl *NativeParam,
1531  const VarDecl *TargetParam) const;
1532 
1533  /// Choose default schedule type and chunk value for the
1534  /// dist_schedule clause.
1536  const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1537  llvm::Value *&Chunk) const {}
1538 
1539  /// Choose default schedule type and chunk value for the
1540  /// schedule clause.
1542  const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1543  const Expr *&ChunkExpr) const {}
1544 
1545  /// Emits call of the outlined function with the provided arguments,
1546  /// translating these arguments to correct target-specific arguments.
1547  virtual void
1549  llvm::Value *OutlinedFn,
1550  ArrayRef<llvm::Value *> Args = llvm::None) const;
1551 
1552  /// Emits OpenMP-specific function prolog.
1553  /// Required for device constructs.
1554  virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D) {}
1555 
1556  /// Gets the OpenMP-specific address of the local variable.
1558  const VarDecl *VD);
1559 
1560  /// Marks the declaration as already emitted for the device code and returns
1561  /// true, if it was marked already, and false, otherwise.
1562  bool markAsGlobalTarget(GlobalDecl GD);
1563 
1564  /// Emit deferred declare target variables marked for deferred emission.
1565  void emitDeferredTargetDecls() const;
1566 
1567  /// Adjust some parameters for the target-based directives, like addresses of
1568  /// the variables captured by reference in lambdas.
1569  virtual void
1571  const OMPExecutableDirective &D) const;
1572 
1573  /// Perform check on requires decl to ensure that target architecture
1574  /// supports unified addressing
1576  const OMPRequiresDecl *D) const {}
1577 };
1578 
1579 /// Class supports emissionof SIMD-only code.
1580 class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime {
1581 public:
1582  explicit CGOpenMPSIMDRuntime(CodeGenModule &CGM) : CGOpenMPRuntime(CGM) {}
1583  ~CGOpenMPSIMDRuntime() override {}
1584 
1585  /// Emits outlined function for the specified OpenMP parallel directive
1586  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1587  /// kmp_int32 BoundID, struct context_vars*).
1588  /// \param D OpenMP directive.
1589  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1590  /// \param InnermostKind Kind of innermost directive (for simple directives it
1591  /// is a directive itself, for combined - its innermost directive).
1592  /// \param CodeGen Code generation sequence for the \a D directive.
1593  llvm::Value *
1595  const VarDecl *ThreadIDVar,
1596  OpenMPDirectiveKind InnermostKind,
1597  const RegionCodeGenTy &CodeGen) override;
1598 
1599  /// Emits outlined function for the specified OpenMP teams directive
1600  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1601  /// kmp_int32 BoundID, struct context_vars*).
1602  /// \param D OpenMP directive.
1603  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1604  /// \param InnermostKind Kind of innermost directive (for simple directives it
1605  /// is a directive itself, for combined - its innermost directive).
1606  /// \param CodeGen Code generation sequence for the \a D directive.
1607  llvm::Value *
1609  const VarDecl *ThreadIDVar,
1610  OpenMPDirectiveKind InnermostKind,
1611  const RegionCodeGenTy &CodeGen) override;
1612 
1613  /// Emits outlined function for the OpenMP task directive \a D. This
1614  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1615  /// TaskT).
1616  /// \param D OpenMP directive.
1617  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1618  /// \param PartIDVar Variable for partition id in the current OpenMP untied
1619  /// task region.
1620  /// \param TaskTVar Variable for task_t argument.
1621  /// \param InnermostKind Kind of innermost directive (for simple directives it
1622  /// is a directive itself, for combined - its innermost directive).
1623  /// \param CodeGen Code generation sequence for the \a D directive.
1624  /// \param Tied true if task is generated for tied task, false otherwise.
1625  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1626  /// tasks.
1627  ///
1629  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
1630  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
1631  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1632  bool Tied, unsigned &NumberOfParts) override;
1633 
1634  /// Emits code for parallel or serial call of the \a OutlinedFn with
1635  /// variables captured in a record which address is stored in \a
1636  /// CapturedStruct.
1637  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1638  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1639  /// \param CapturedVars A pointer to the record with the references to
1640  /// variables used in \a OutlinedFn function.
1641  /// \param IfCond Condition in the associated 'if' clause, if it was
1642  /// specified, nullptr otherwise.
1643  ///
1644  void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
1645  llvm::Value *OutlinedFn,
1646  ArrayRef<llvm::Value *> CapturedVars,
1647  const Expr *IfCond) override;
1648 
1649  /// Emits a critical region.
1650  /// \param CriticalName Name of the critical region.
1651  /// \param CriticalOpGen Generator for the statement associated with the given
1652  /// critical region.
1653  /// \param Hint Value of the 'hint' clause (optional).
1654  void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
1655  const RegionCodeGenTy &CriticalOpGen,
1656  SourceLocation Loc,
1657  const Expr *Hint = nullptr) override;
1658 
1659  /// Emits a master region.
1660  /// \param MasterOpGen Generator for the statement associated with the given
1661  /// master region.
1662  void emitMasterRegion(CodeGenFunction &CGF,
1663  const RegionCodeGenTy &MasterOpGen,
1664  SourceLocation Loc) override;
1665 
1666  /// Emits code for a taskyield directive.
1667  void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
1668 
1669  /// Emit a taskgroup region.
1670  /// \param TaskgroupOpGen Generator for the statement associated with the
1671  /// given taskgroup region.
1672  void emitTaskgroupRegion(CodeGenFunction &CGF,
1673  const RegionCodeGenTy &TaskgroupOpGen,
1674  SourceLocation Loc) override;
1675 
1676  /// Emits a single region.
1677  /// \param SingleOpGen Generator for the statement associated with the given
1678  /// single region.
1679  void emitSingleRegion(CodeGenFunction &CGF,
1680  const RegionCodeGenTy &SingleOpGen, SourceLocation Loc,
1681  ArrayRef<const Expr *> CopyprivateVars,
1682  ArrayRef<const Expr *> DestExprs,
1683  ArrayRef<const Expr *> SrcExprs,
1684  ArrayRef<const Expr *> AssignmentOps) override;
1685 
1686  /// Emit an ordered region.
1687  /// \param OrderedOpGen Generator for the statement associated with the given
1688  /// ordered region.
1689  void emitOrderedRegion(CodeGenFunction &CGF,
1690  const RegionCodeGenTy &OrderedOpGen,
1691  SourceLocation Loc, bool IsThreads) override;
1692 
1693  /// Emit an implicit/explicit barrier for OpenMP threads.
1694  /// \param Kind Directive for which this implicit barrier call must be
1695  /// generated. Must be OMPD_barrier for explicit barrier generation.
1696  /// \param EmitChecks true if need to emit checks for cancellation barriers.
1697  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1698  /// runtime class decides which one to emit (simple or with cancellation
1699  /// checks).
1700  ///
1701  void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
1702  OpenMPDirectiveKind Kind, bool EmitChecks = true,
1703  bool ForceSimpleCall = false) override;
1704 
1705  /// This is used for non static scheduled types and when the ordered
1706  /// clause is present on the loop construct.
1707  /// Depending on the loop schedule, it is necessary to call some runtime
1708  /// routine before start of the OpenMP loop to get the loop upper / lower
1709  /// bounds \a LB and \a UB and stride \a ST.
1710  ///
1711  /// \param CGF Reference to current CodeGenFunction.
1712  /// \param Loc Clang source location.
1713  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1714  /// \param IVSize Size of the iteration variable in bits.
1715  /// \param IVSigned Sign of the iteration variable.
1716  /// \param Ordered true if loop is ordered, false otherwise.
1717  /// \param DispatchValues struct containing llvm values for lower bound, upper
1718  /// bound, and chunk expression.
1719  /// For the default (nullptr) value, the chunk 1 will be used.
1720  ///
1721  void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
1722  const OpenMPScheduleTy &ScheduleKind,
1723  unsigned IVSize, bool IVSigned, bool Ordered,
1724  const DispatchRTInput &DispatchValues) override;
1725 
1726  /// Call the appropriate runtime routine to initialize it before start
1727  /// of loop.
1728  ///
1729  /// This is used only in case of static schedule, when the user did not
1730  /// specify a ordered clause on the loop construct.
1731  /// Depending on the loop schedule, it is necessary to call some runtime
1732  /// routine before start of the OpenMP loop to get the loop upper / lower
1733  /// bounds LB and UB and stride ST.
1734  ///
1735  /// \param CGF Reference to current CodeGenFunction.
1736  /// \param Loc Clang source location.
1737  /// \param DKind Kind of the directive.
1738  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1739  /// \param Values Input arguments for the construct.
1740  ///
1741  void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1742  OpenMPDirectiveKind DKind,
1743  const OpenMPScheduleTy &ScheduleKind,
1744  const StaticRTInput &Values) override;
1745 
1746  ///
1747  /// \param CGF Reference to current CodeGenFunction.
1748  /// \param Loc Clang source location.
1749  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1750  /// \param Values Input arguments for the construct.
1751  ///
1752  void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1753  OpenMPDistScheduleClauseKind SchedKind,
1754  const StaticRTInput &Values) override;
1755 
1756  /// Call the appropriate runtime routine to notify that we finished
1757  /// iteration of the ordered loop with the dynamic scheduling.
1758  ///
1759  /// \param CGF Reference to current CodeGenFunction.
1760  /// \param Loc Clang source location.
1761  /// \param IVSize Size of the iteration variable in bits.
1762  /// \param IVSigned Sign of the iteration variable.
1763  ///
1764  void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc,
1765  unsigned IVSize, bool IVSigned) override;
1766 
1767  /// Call the appropriate runtime routine to notify that we finished
1768  /// all the work with current loop.
1769  ///
1770  /// \param CGF Reference to current CodeGenFunction.
1771  /// \param Loc Clang source location.
1772  /// \param DKind Kind of the directive for which the static finish is emitted.
1773  ///
1774  void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1775  OpenMPDirectiveKind DKind) override;
1776 
1777  /// Call __kmpc_dispatch_next(
1778  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1779  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1780  /// kmp_int[32|64] *p_stride);
1781  /// \param IVSize Size of the iteration variable in bits.
1782  /// \param IVSigned Sign of the iteration variable.
1783  /// \param IL Address of the output variable in which the flag of the
1784  /// last iteration is returned.
1785  /// \param LB Address of the output variable in which the lower iteration
1786  /// number is returned.
1787  /// \param UB Address of the output variable in which the upper iteration
1788  /// number is returned.
1789  /// \param ST Address of the output variable in which the stride value is
1790  /// returned.
1791  llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1792  unsigned IVSize, bool IVSigned, Address IL,
1793  Address LB, Address UB, Address ST) override;
1794 
1795  /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1796  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1797  /// clause.
1798  /// \param NumThreads An integer value of threads.
1799  void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads,
1800  SourceLocation Loc) override;
1801 
1802  /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1803  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1804  void emitProcBindClause(CodeGenFunction &CGF,
1805  OpenMPProcBindClauseKind ProcBind,
1806  SourceLocation Loc) override;
1807 
1808  /// Returns address of the threadprivate variable for the current
1809  /// thread.
1810  /// \param VD Threadprivate variable.
1811  /// \param VDAddr Address of the global variable \a VD.
1812  /// \param Loc Location of the reference to threadprivate var.
1813  /// \return Address of the threadprivate variable for the current thread.
1814  Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD,
1815  Address VDAddr, SourceLocation Loc) override;
1816 
1817  /// Emit a code for initialization of threadprivate variable. It emits
1818  /// a call to runtime library which adds initial value to the newly created
1819  /// threadprivate variable (if it is not constant) and registers destructor
1820  /// for the variable (if any).
1821  /// \param VD Threadprivate variable.
1822  /// \param VDAddr Address of the global variable \a VD.
1823  /// \param Loc Location of threadprivate declaration.
1824  /// \param PerformInit true if initialization expression is not constant.
1825  llvm::Function *
1826  emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1827  SourceLocation Loc, bool PerformInit,
1828  CodeGenFunction *CGF = nullptr) override;
1829 
1830  /// Creates artificial threadprivate variable with name \p Name and type \p
1831  /// VarType.
1832  /// \param VarType Type of the artificial threadprivate variable.
1833  /// \param Name Name of the artificial threadprivate variable.
1834  Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1835  QualType VarType,
1836  StringRef Name) override;
1837 
1838  /// Emit flush of the variables specified in 'omp flush' directive.
1839  /// \param Vars List of variables to flush.
1840  void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1841  SourceLocation Loc) override;
1842 
1843  /// Emit task region for the task directive. The task region is
1844  /// emitted in several steps:
1845  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1846  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1847  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1848  /// function:
1849  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1850  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1851  /// return 0;
1852  /// }
1853  /// 2. Copy a list of shared variables to field shareds of the resulting
1854  /// structure kmp_task_t returned by the previous call (if any).
1855  /// 3. Copy a pointer to destructions function to field destructions of the
1856  /// resulting structure kmp_task_t.
1857  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1858  /// kmp_task_t *new_task), where new_task is a resulting structure from
1859  /// previous items.
1860  /// \param D Current task directive.
1861  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1862  /// /*part_id*/, captured_struct */*__context*/);
1863  /// \param SharedsTy A type which contains references the shared variables.
1864  /// \param Shareds Context with the list of shared variables from the \p
1865  /// TaskFunction.
1866  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1867  /// otherwise.
1868  /// \param Data Additional data for task generation like tiednsee, final
1869  /// state, list of privates etc.
1870  void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1871  const OMPExecutableDirective &D, llvm::Value *TaskFunction,
1872  QualType SharedsTy, Address Shareds, const Expr *IfCond,
1873  const OMPTaskDataTy &Data) override;
1874 
1875  /// Emit task region for the taskloop directive. The taskloop region is
1876  /// emitted in several steps:
1877  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1878  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1879  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1880  /// function:
1881  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1882  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1883  /// return 0;
1884  /// }
1885  /// 2. Copy a list of shared variables to field shareds of the resulting
1886  /// structure kmp_task_t returned by the previous call (if any).
1887  /// 3. Copy a pointer to destructions function to field destructions of the
1888  /// resulting structure kmp_task_t.
1889  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1890  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1891  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1892  /// is a resulting structure from
1893  /// previous items.
1894  /// \param D Current task directive.
1895  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1896  /// /*part_id*/, captured_struct */*__context*/);
1897  /// \param SharedsTy A type which contains references the shared variables.
1898  /// \param Shareds Context with the list of shared variables from the \p
1899  /// TaskFunction.
1900  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1901  /// otherwise.
1902  /// \param Data Additional data for task generation like tiednsee, final
1903  /// state, list of privates etc.
1904  void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1905  const OMPLoopDirective &D, llvm::Value *TaskFunction,
1906  QualType SharedsTy, Address Shareds, const Expr *IfCond,
1907  const OMPTaskDataTy &Data) override;
1908 
1909  /// Emit a code for reduction clause. Next code should be emitted for
1910  /// reduction:
1911  /// \code
1912  ///
1913  /// static kmp_critical_name lock = { 0 };
1914  ///
1915  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1916  /// ...
1917  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1918  /// ...
1919  /// }
1920  ///
1921  /// ...
1922  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1923  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1924  /// RedList, reduce_func, &<lock>)) {
1925  /// case 1:
1926  /// ...
1927  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1928  /// ...
1929  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1930  /// break;
1931  /// case 2:
1932  /// ...
1933  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1934  /// ...
1935  /// break;
1936  /// default:;
1937  /// }
1938  /// \endcode
1939  ///
1940  /// \param Privates List of private copies for original reduction arguments.
1941  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1942  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1943  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1944  /// or 'operator binop(LHS, RHS)'.
1945  /// \param Options List of options for reduction codegen:
1946  /// WithNowait true if parent directive has also nowait clause, false
1947  /// otherwise.
1948  /// SimpleReduction Emit reduction operation only. Used for omp simd
1949  /// directive on the host.
1950  /// ReductionKind The kind of reduction to perform.
1951  void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1953  ArrayRef<const Expr *> LHSExprs,
1954  ArrayRef<const Expr *> RHSExprs,
1955  ArrayRef<const Expr *> ReductionOps,
1956  ReductionOptionsTy Options) override;
1957 
1958  /// Emit a code for initialization of task reduction clause. Next code
1959  /// should be emitted for reduction:
1960  /// \code
1961  ///
1962  /// _task_red_item_t red_data[n];
1963  /// ...
1964  /// red_data[i].shar = &origs[i];
1965  /// red_data[i].size = sizeof(origs[i]);
1966  /// red_data[i].f_init = (void*)RedInit<i>;
1967  /// red_data[i].f_fini = (void*)RedDest<i>;
1968  /// red_data[i].f_comb = (void*)RedOp<i>;
1969  /// red_data[i].flags = <Flag_i>;
1970  /// ...
1971  /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data);
1972  /// \endcode
1973  ///
1974  /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1975  /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1976  /// \param Data Additional data for task generation like tiedness, final
1977  /// state, list of privates, reductions etc.
1978  llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc,
1979  ArrayRef<const Expr *> LHSExprs,
1980  ArrayRef<const Expr *> RHSExprs,
1981  const OMPTaskDataTy &Data) override;
1982 
1983  /// Required to resolve existing problems in the runtime. Emits threadprivate
1984  /// variables to store the size of the VLAs/array sections for
1985  /// initializer/combiner/finalizer functions + emits threadprivate variable to
1986  /// store the pointer to the original reduction item for the custom
1987  /// initializer defined by declare reduction construct.
1988  /// \param RCG Allows to reuse an existing data for the reductions.
1989  /// \param N Reduction item for which fixups must be emitted.
1990  void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc,
1991  ReductionCodeGen &RCG, unsigned N) override;
1992 
1993  /// Get the address of `void *` type of the privatue copy of the reduction
1994  /// item specified by the \p SharedLVal.
1995  /// \param ReductionsPtr Pointer to the reduction data returned by the
1996  /// emitTaskReductionInit function.
1997  /// \param SharedLVal Address of the original reduction item.
1998  Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
1999  llvm::Value *ReductionsPtr,
2000  LValue SharedLVal) override;
2001 
2002  /// Emit code for 'taskwait' directive.
2003  void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc) override;
2004 
2005  /// Emit code for 'cancellation point' construct.
2006  /// \param CancelRegion Region kind for which the cancellation point must be
2007  /// emitted.
2008  ///
2009  void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc,
2010  OpenMPDirectiveKind CancelRegion) override;
2011 
2012  /// Emit code for 'cancel' construct.
2013  /// \param IfCond Condition in the associated 'if' clause, if it was
2014  /// specified, nullptr otherwise.
2015  /// \param CancelRegion Region kind for which the cancel must be emitted.
2016  ///
2017  void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
2018  const Expr *IfCond,
2019  OpenMPDirectiveKind CancelRegion) override;
2020 
2021  /// Emit outilined function for 'target' directive.
2022  /// \param D Directive to emit.
2023  /// \param ParentName Name of the function that encloses the target region.
2024  /// \param OutlinedFn Outlined function value to be defined by this call.
2025  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2026  /// \param IsOffloadEntry True if the outlined function is an offload entry.
2027  /// \param CodeGen Code generation sequence for the \a D directive.
2028  /// An outlined function may not be an entry if, e.g. the if clause always
2029  /// evaluates to false.
2031  StringRef ParentName,
2032  llvm::Function *&OutlinedFn,
2033  llvm::Constant *&OutlinedFnID,
2034  bool IsOffloadEntry,
2035  const RegionCodeGenTy &CodeGen) override;
2036 
2037  /// Emit the target offloading code associated with \a D. The emitted
2038  /// code attempts offloading the execution to the device, an the event of
2039  /// a failure it executes the host version outlined in \a OutlinedFn.
2040  /// \param D Directive to emit.
2041  /// \param OutlinedFn Host version of the code to be offloaded.
2042  /// \param OutlinedFnID ID of host version of the code to be offloaded.
2043  /// \param IfCond Expression evaluated in if clause associated with the target
2044  /// directive, or null if no if clause is used.
2045  /// \param Device Expression evaluated in device clause associated with the
2046  /// target directive, or null if no device clause is used.
2047  void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
2048  llvm::Value *OutlinedFn, llvm::Value *OutlinedFnID,
2049  const Expr *IfCond, const Expr *Device) override;
2050 
2051  /// Emit the target regions enclosed in \a GD function definition or
2052  /// the function itself in case it is a valid device function. Returns true if
2053  /// \a GD was dealt with successfully.
2054  /// \param GD Function to scan.
2055  bool emitTargetFunctions(GlobalDecl GD) override;
2056 
2057  /// Emit the global variable if it is a valid device global variable.
2058  /// Returns true if \a GD was dealt with successfully.
2059  /// \param GD Variable declaration to emit.
2060  bool emitTargetGlobalVariable(GlobalDecl GD) override;
2061 
2062  /// Emit the global \a GD if it is meaningful for the target. Returns
2063  /// if it was emitted successfully.
2064  /// \param GD Global to scan.
2065  bool emitTargetGlobal(GlobalDecl GD) override;
2066 
2067  /// Creates the offloading descriptor in the event any target region
2068  /// was emitted in the current module and return the function that registers
2069  /// it.
2070  llvm::Function *emitRegistrationFunction() override;
2071 
2072  /// Emits code for teams call of the \a OutlinedFn with
2073  /// variables captured in a record which address is stored in \a
2074  /// CapturedStruct.
2075  /// \param OutlinedFn Outlined function to be run by team masters. Type of
2076  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2077  /// \param CapturedVars A pointer to the record with the references to
2078  /// variables used in \a OutlinedFn function.
2079  ///
2080  void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
2081  SourceLocation Loc, llvm::Value *OutlinedFn,
2082  ArrayRef<llvm::Value *> CapturedVars) override;
2083 
2084  /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2085  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2086  /// for num_teams clause.
2087  /// \param NumTeams An integer expression of teams.
2088  /// \param ThreadLimit An integer expression of threads.
2089  void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2090  const Expr *ThreadLimit, SourceLocation Loc) override;
2091 
2092  /// Emit the target data mapping code associated with \a D.
2093  /// \param D Directive to emit.
2094  /// \param IfCond Expression evaluated in if clause associated with the
2095  /// target directive, or null if no device clause is used.
2096  /// \param Device Expression evaluated in device clause associated with the
2097  /// target directive, or null if no device clause is used.
2098  /// \param Info A record used to store information that needs to be preserved
2099  /// until the region is closed.
2100  void emitTargetDataCalls(CodeGenFunction &CGF,
2101  const OMPExecutableDirective &D, const Expr *IfCond,
2102  const Expr *Device, const RegionCodeGenTy &CodeGen,
2103  TargetDataInfo &Info) override;
2104 
2105  /// Emit the data mapping/movement code associated with the directive
2106  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2107  /// \param D Directive to emit.
2108  /// \param IfCond Expression evaluated in if clause associated with the target
2109  /// directive, or null if no if clause is used.
2110  /// \param Device Expression evaluated in device clause associated with the
2111  /// target directive, or null if no device clause is used.
2112  void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
2113  const OMPExecutableDirective &D,
2114  const Expr *IfCond,
2115  const Expr *Device) override;
2116 
2117  /// Emit initialization for doacross loop nesting support.
2118  /// \param D Loop-based construct used in doacross nesting construct.
2119  void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
2120  ArrayRef<Expr *> NumIterations) override;
2121 
2122  /// Emit code for doacross ordered directive with 'depend' clause.
2123  /// \param C 'depend' clause with 'sink|source' dependency kind.
2124  void emitDoacrossOrdered(CodeGenFunction &CGF,
2125  const OMPDependClause *C) override;
2126 
2127  /// Translates the native parameter of outlined function if this is required
2128  /// for target.
2129  /// \param FD Field decl from captured record for the parameter.
2130  /// \param NativeParam Parameter itself.
2131  const VarDecl *translateParameter(const FieldDecl *FD,
2132  const VarDecl *NativeParam) const override;
2133 
2134  /// Gets the address of the native argument basing on the address of the
2135  /// target-specific parameter.
2136  /// \param NativeParam Parameter itself.
2137  /// \param TargetParam Corresponding target-specific parameter.
2138  Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2139  const VarDecl *TargetParam) const override;
2140 };
2141 
2142 } // namespace CodeGen
2143 } // namespace clang
2144 
2145 #endif
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
llvm::function_ref< void(unsigned, unsigned, StringRef, unsigned, const OffloadEntryInfoTargetRegion &)> OffloadTargetRegionEntryInfoActTy
brief Applies action Action on all registered entries.
Represents a function declaration or definition.
Definition: Decl.h:1739
OMPTargetRegionEntryKind
Kind of the target registry entry.
virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)
Gets the OpenMP-specific address of the local variable.
QualType TgtDeviceImageQTy
struct __tgt_device_image{ void *ImageStart; // Pointer to the target code start. ...
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:132
A (possibly-)qualified type.
Definition: Type.h:642
Allows to disable automatic handling of functions used in target regions as those marked as omp decla...
void emitSingleReductionCombiner(CodeGenFunction &CGF, const Expr *ReductionOp, const Expr *PrivateRef, const DeclRefExpr *LHS, const DeclRefExpr *RHS)
Emits single reduction combiner.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
Stmt - This represents one statement.
Definition: Stmt.h:66
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
SmallVector< const Expr *, 4 > LastprivateCopies
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
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 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::SmallDenseSet< const VarDecl * > DeferredGlobalVariables
List of variables that can become declare target implicitly and, thus, must be emitted.
virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name)
Creates artificial threadprivate variable with name Name and type VarType.
virtual void clear()
bool markAsGlobalTarget(GlobalDecl GD)
Marks the declaration as already emitted for the device code and returns true, if it was marked alrea...
struct with the values to be passed to the dispatch runtime function
OffloadEntryInfoDeviceGlobalVar(unsigned Order, OMPTargetGlobalVarEntryKind Flags)
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and and emit all target regions found along the way.
virtual void checkArchForUnifiedAddressing(CodeGenModule &CGM, const OMPRequiresDecl *D) const
Perform check on requires decl to ensure that target architecture supports unified addressing...
SmallVector< const Expr *, 4 > ReductionCopies
DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
Represents a variable declaration or definition.
Definition: Decl.h:812
virtual void emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value *> Args=llvm::None) const
Emits call of the outlined function with the provided arguments, translating these arguments to corre...
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...
Class supports emissionof SIMD-only code.
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 void Exit(CodeGenFunction &CGF)
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata...
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Struct that keeps all the relevant information that should be kept throughout a &#39;target data&#39; region...
QualType getTgtOffloadEntryQTy()
Returns __tgt_offload_entry type.
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 &#39;targe...
SmallVector< const Expr *, 4 > PrivateVars
Represents a struct/union/class.
Definition: Decl.h:3602
llvm::StringMap< llvm::WeakTrackingVH > EmittedNonTargetVariables
List of the global variables with their addresses that should not be emitted for the target...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned)
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
SmallVector< const Expr *, 4 > LastprivateVars
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with &#39;depend&#39; clause.
Represents a member of a struct/union/class.
Definition: Decl.h:2588
Definition: Format.h:2072
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)...
OMPTargetGlobalVarEntryKind
Kind of the global variable entry..
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
Defines some OpenMP-specific enums and functions.
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
This is a common base class for loop directives (&#39;omp simd&#39;, &#39;omp for&#39;, &#39;omp for simd&#39; etc...
Definition: StmtOpenMP.h:338
static bool classof(const OffloadEntryInfo *Info)
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
OpenMPDistScheduleClauseKind
OpenMP attributes for &#39;dist_schedule&#39; clause.
Definition: OpenMPKinds.h:100
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr *> NumIterations)
Emit initialization for doacross loop nesting support.
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Value *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, const Expr *Device)
Emit the target offloading code associated with D.
QualType TgtOffloadEntryQTy
Type struct __tgt_offload_entry{ void *addr; // Pointer to the offload entry info.
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
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.
llvm::ArrayType * getKmpCriticalNameTy() const
Get the LLVM type for the critical name.
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)
llvm::StringSet ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
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
llvm::StringSet AlreadyEmittedTargetFunctions
List of the emitted functions.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
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...
SmallVector< const Expr *, 4 > FirstprivateCopies
llvm::Value * emitReductionFunction(CodeGenModule &CGM, SourceLocation Loc, llvm::Type *ArgsType, ArrayRef< const Expr *> Privates, ArrayRef< const Expr *> LHSExprs, ArrayRef< const Expr *> RHSExprs, ArrayRef< const Expr *> ReductionOps)
Emits reduction function.
virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D)
Emits OpenMP-specific function prolog.
const VarDecl * getBaseDecl(unsigned N) const
Returns the base declaration of the reduction item.
__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:83
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
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind)
Call the appropriate runtime routine to notify that we finished all the work with current loop...
virtual Address getAddrOfDeclareTargetLink(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause.
virtual Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const
Gets the address of the native argument basing on the address of the target-specific parameter...
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)
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...
This represents &#39;#pragma omp requires...&#39; directive.
Definition: DeclOpenMP.h:250
QualType getTgtDeviceImageQTy()
Returns __tgt_device_image type.
This represents implicit clause &#39;depend&#39; for the &#39;#pragma omp task&#39; directive.
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N)
Required to resolve existing problems in the runtime.
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr *> Vars, SourceLocation Loc)
Emit flush of the variables specified in &#39;omp flush&#39; directive.
OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order, uint32_t Flags)
RegionCodeGenTy(Callable &&CodeGen, typename std::enable_if< !std::is_same< typename std::remove_reference< Callable >::type, RegionCodeGenTy >::value >::type *=nullptr)
This represents one expression.
Definition: Expr.h:106
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.
void loadOffloadInfoMetadata()
Loads all the offload entries information from the host IR metadata.
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const
Translates the native parameter of outlined function if this is required for target.
QualType SavedKmpTaskloopTQTy
Saved kmp_task_t for taskloop-based directive.
virtual ~CGOpenMPRuntime()
virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
CGOpenMPRuntime(CodeGenModule &CGM)
void clearArrayInfo()
Clear information about the data arrays.
SmallVector< const Expr *, 4 > FirstprivateVars
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
*QualType KmpTaskTQTy
OpenMPProcBindClauseKind
OpenMP attributes for &#39;proc_bind&#39; clause.
Definition: OpenMPKinds.h:51
llvm::Constant * createDispatchInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:35
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
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.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
Kind
Encodes a location in the source.
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:103
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
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 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
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for &#39;cancellation point&#39; construct.
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
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 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.
unsigned size() const
Return number of entries defined so far.
virtual void Enter(CodeGenFunction &CGF)
An aligned address.
Definition: Address.h:25
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...
bool hasDeviceGlobalVarEntryInfo(StringRef VarName) const
Checks if the variable with the given name has been registered already.
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 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
OffloadEntryInfoDeviceGlobalVar(unsigned Order, llvm::Constant *Addr, CharUnits VarSize, OMPTargetGlobalVarEntryKind Flags, llvm::GlobalValue::LinkageTypes Linkage)
virtual void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
const Expr * getRefExpr(unsigned N) const
Returns the base declaration of the reduction item.
Struct with the values to be passed to the static runtime function.
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)
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
void setAction(PrePostActionTy &Action) const
This class organizes the cross-function state that is used while generating LLVM code.
Optional< types::ID > Type
Dataflow Directional Tag Classes.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
OffloadEntryInfoTargetRegion(unsigned Order, llvm::Constant *Addr, llvm::Constant *ID, OMPTargetRegionEntryKind Flags)
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for &#39;cancel&#39; construct.
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
LValue getSharedLValue(unsigned N) const
Returns LValue for the reduction item.
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)
llvm::Function * createOffloadingBinaryDescriptorRegistration()
Creates and registers offloading binary descriptor for the current compilation unit.
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for &#39;target&#39; directive.
virtual bool isDefaultLocationConstant() const
Check if the default location must be constant.
OffloadEntriesInfoManagerTy OffloadEntriesInfoManager
CGOpenMPSIMDRuntime(CodeGenModule &CGM)
virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Addr, bool PerformInit)
Emit a code for initialization of declare target variable.
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values)
virtual StringRef getOutlinedHelperName() const
Get the function name of an outlined region.
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
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 &#39;schedule&#39; clause.
Definition: OpenMPKinds.h:59
Entity that registers the offloading constants that were emitted so far.
llvm::function_ref< void(StringRef, const OffloadEntryInfoDeviceGlobalVar &)> OffloadDeviceGlobalVarEntryInfoActTy
Applies action Action on all registered entries.
llvm::Constant * createDispatchNextFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_next_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
virtual llvm::Function * emitRegistrationFunction()
Creates the offloading descriptor in the event any target region was emitted in the current module an...
virtual void adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF, const OMPExecutableDirective &D) const
Adjust some parameters for the target-based directives, like addresses of the variables captured by r...
virtual void 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.
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:151
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
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.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1042
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values)
Call the appropriate runtime routine to initialize it before start of loop.
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:167
virtual unsigned getDefaultLocationReserved2Flags() const
Returns additional flags that can be stored in reserved_2 field of the default location.
virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind, llvm::Value *&Chunk) const
Choose default schedule type and chunk value for the dist_schedule clause.
QualType SavedKmpTaskTQTy
Saved kmp_task_t for task directive.
virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal)
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind, const Expr *&ChunkExpr) const
Choose default schedule type and chunk value for the schedule clause.
llvm::Constant * createRuntimeFunction(unsigned Function)
Returns specified OpenMP runtime function.
llvm::StringSet DeclareTargetWithDefinition
Set of declare target variables with the generated initializer.
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 emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc)
Emit code for &#39;taskwait&#39; directive.