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