clang  16.0.0git
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/GlobalDecl.h"
19 #include "clang/AST/Type.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/SmallPtrSet.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/StringSet.h"
27 #include "llvm/Frontend/OpenMP/OMPConstants.h"
28 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/ValueHandle.h"
31 #include "llvm/Support/AtomicOrdering.h"
32 
33 namespace llvm {
34 class ArrayType;
35 class Constant;
36 class FunctionType;
37 class GlobalVariable;
38 class Type;
39 class Value;
40 class OpenMPIRBuilder;
41 } // namespace llvm
42 
43 namespace clang {
44 class Expr;
45 class OMPDependClause;
46 class OMPExecutableDirective;
47 class OMPLoopDirective;
48 class VarDecl;
49 class OMPDeclareReductionDecl;
50 
51 namespace CodeGen {
52 class Address;
53 class CodeGenFunction;
54 class CodeGenModule;
55 
56 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
57 /// region.
59 public:
60  explicit PrePostActionTy() {}
61  virtual void Enter(CodeGenFunction &CGF) {}
62  virtual void Exit(CodeGenFunction &CGF) {}
63  virtual ~PrePostActionTy() {}
64 };
65 
66 /// Class provides a way to call simple version of codegen for OpenMP region, or
67 /// an advanced with possible pre|post-actions in codegen.
68 class RegionCodeGenTy final {
69  intptr_t CodeGen;
70  typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
71  CodeGenTy Callback;
72  mutable PrePostActionTy *PrePostAction;
73  RegionCodeGenTy() = delete;
74  template <typename Callable>
75  static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
76  PrePostActionTy &Action) {
77  return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
78  }
79 
80 public:
81  template <typename Callable>
83  Callable &&CodeGen,
84  std::enable_if_t<!std::is_same<std::remove_reference_t<Callable>,
85  RegionCodeGenTy>::value> * = nullptr)
86  : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
87  Callback(CallbackFn<std::remove_reference_t<Callable>>),
88  PrePostAction(nullptr) {}
89  void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
90  void operator()(CodeGenFunction &CGF) const;
91 };
92 
93 struct OMPTaskDataTy final {
106  struct DependData {
108  const Expr *IteratorExpr = nullptr;
110  explicit DependData() = default;
113  };
115  llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
116  llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
117  llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
118  llvm::Value *Reductions = nullptr;
119  unsigned NumberOfParts = 0;
120  bool Tied = true;
121  bool Nogroup = false;
124 };
125 
126 /// Class intended to support codegen of all kind of the reduction clauses.
128 private:
129  /// Data required for codegen of reduction clauses.
130  struct ReductionData {
131  /// Reference to the item shared between tasks to reduce into.
132  const Expr *Shared = nullptr;
133  /// Reference to the original item.
134  const Expr *Ref = nullptr;
135  /// Helper expression for generation of private copy.
136  const Expr *Private = nullptr;
137  /// Helper expression for generation reduction operation.
138  const Expr *ReductionOp = nullptr;
139  ReductionData(const Expr *Shared, const Expr *Ref, const Expr *Private,
140  const Expr *ReductionOp)
141  : Shared(Shared), Ref(Ref), Private(Private), ReductionOp(ReductionOp) {
142  }
143  };
144  /// List of reduction-based clauses.
145  SmallVector<ReductionData, 4> ClausesData;
146 
147  /// List of addresses of shared variables/expressions.
148  SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
149  /// List of addresses of original variables/expressions.
150  SmallVector<std::pair<LValue, LValue>, 4> OrigAddresses;
151  /// Sizes of the reduction items in chars.
153  /// Base declarations for the reduction items.
155 
156  /// Emits lvalue for shared expression.
157  LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
158  /// Emits upper bound for shared expression (if array section).
159  LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
160  /// Performs aggregate initialization.
161  /// \param N Number of reduction item in the common list.
162  /// \param PrivateAddr Address of the corresponding private item.
163  /// \param SharedAddr Address of the original shared variable.
164  /// \param DRD Declare reduction construct used for reduction item.
165  void emitAggregateInitialization(CodeGenFunction &CGF, unsigned N,
166  Address PrivateAddr, Address SharedAddr,
167  const OMPDeclareReductionDecl *DRD);
168 
169 public:
171  ArrayRef<const Expr *> Privates,
172  ArrayRef<const Expr *> ReductionOps);
173  /// Emits lvalue for the shared and original reduction item.
174  /// \param N Number of the reduction item.
175  void emitSharedOrigLValue(CodeGenFunction &CGF, unsigned N);
176  /// Emits the code for the variable-modified type, if required.
177  /// \param N Number of the reduction item.
178  void emitAggregateType(CodeGenFunction &CGF, unsigned N);
179  /// Emits the code for the variable-modified type, if required.
180  /// \param N Number of the reduction item.
181  /// \param Size Size of the type in chars.
182  void emitAggregateType(CodeGenFunction &CGF, unsigned N, llvm::Value *Size);
183  /// Performs initialization of the private copy for the reduction item.
184  /// \param N Number of the reduction item.
185  /// \param PrivateAddr Address of the corresponding private item.
186  /// \param DefaultInit Default initialization sequence that should be
187  /// performed if no reduction specific initialization is found.
188  /// \param SharedAddr Address of the original shared variable.
189  void
190  emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
191  Address SharedAddr,
192  llvm::function_ref<bool(CodeGenFunction &)> DefaultInit);
193  /// Returns true if the private copy requires cleanups.
194  bool needCleanups(unsigned N);
195  /// Emits cleanup code for the reduction item.
196  /// \param N Number of the reduction item.
197  /// \param PrivateAddr Address of the corresponding private item.
198  void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr);
199  /// Adjusts \p PrivatedAddr for using instead of the original variable
200  /// address in normal operations.
201  /// \param N Number of the reduction item.
202  /// \param PrivateAddr Address of the corresponding private item.
204  Address PrivateAddr);
205  /// Returns LValue for the reduction item.
206  LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
207  /// Returns LValue for the original reduction item.
208  LValue getOrigLValue(unsigned N) const { return OrigAddresses[N].first; }
209  /// Returns the size of the reduction item (in chars and total number of
210  /// elements in the item), or nullptr, if the size is a constant.
211  std::pair<llvm::Value *, llvm::Value *> getSizes(unsigned N) const {
212  return Sizes[N];
213  }
214  /// Returns the base declaration of the reduction item.
215  const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; }
216  /// Returns the base declaration of the reduction item.
217  const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
218  /// Returns true if the initialization of the reduction item uses initializer
219  /// from declare reduction construct.
220  bool usesReductionInitializer(unsigned N) const;
221  /// Return the type of the private item.
222  QualType getPrivateType(unsigned N) const {
223  return cast<VarDecl>(cast<DeclRefExpr>(ClausesData[N].Private)->getDecl())
224  ->getType();
225  }
226 };
227 
229 public:
230  /// Allows to disable automatic handling of functions used in target regions
231  /// as those marked as `omp declare target`.
233  CodeGenModule &CGM;
234  bool SavedShouldMarkAsGlobal;
235 
236  public:
239  };
240 
241  /// Manages list of nontemporal decls for the specified directive.
243  CodeGenModule &CGM;
244  const bool NeedToPush;
245 
246  public:
249  };
250 
251  /// Manages list of nontemporal decls for the specified directive.
253  CodeGenModule &CGM;
254  const bool NeedToPush;
255 
256  public:
258  CodeGenFunction &CGF,
259  const llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
260  std::pair<Address, Address>> &LocalVars);
262  };
263 
264  /// Maps the expression for the lastprivate variable to the global copy used
265  /// to store new value because original variables are not mapped in inner
266  /// parallel regions. Only private copies are captured but we need also to
267  /// store private copy in shared address.
268  /// Also, stores the expression for the private loop counter and it
269  /// threaprivate name.
271  llvm::MapVector<CanonicalDeclPtr<const Decl>, SmallString<16>>
274  llvm::Function *Fn = nullptr;
275  bool Disabled = false;
276  };
277  /// Manages list of lastprivate conditional decls for the specified directive.
279  enum class ActionToDo {
280  DoNotPush,
281  PushAsLastprivateConditional,
282  DisableLastprivateConditional,
283  };
284  CodeGenModule &CGM;
285  ActionToDo Action = ActionToDo::DoNotPush;
286 
287  /// Check and try to disable analysis of inner regions for changes in
288  /// lastprivate conditional.
289  void tryToDisableInnerAnalysis(const OMPExecutableDirective &S,
291  &NeedToAddForLPCsAsDisabled) const;
292 
294  const OMPExecutableDirective &S);
295 
296  public:
298  const OMPExecutableDirective &S,
299  LValue IVLVal);
301  const OMPExecutableDirective &S);
303  };
304 
305  llvm::OpenMPIRBuilder &getOMPBuilder() { return OMPBuilder; }
306 
307 protected:
310 
311  /// An OpenMP-IR-Builder instance.
312  llvm::OpenMPIRBuilder OMPBuilder;
313 
314  /// Constructor allowing to redefine the name separator for the variables.
315  explicit CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator,
316  StringRef Separator);
317 
318  /// Creates offloading entry for the provided entry ID \a ID,
319  /// address \a Addr, size \a Size, and flags \a Flags.
320  virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
321  uint64_t Size, int32_t Flags,
322  llvm::GlobalValue::LinkageTypes Linkage);
323 
324  /// Helper to emit outlined function for 'target' directive.
325  /// \param D Directive to emit.
326  /// \param ParentName Name of the function that encloses the target region.
327  /// \param OutlinedFn Outlined function value to be defined by this call.
328  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
329  /// \param IsOffloadEntry True if the outlined function is an offload entry.
330  /// \param CodeGen Lambda codegen specific to an accelerator device.
331  /// An outlined function may not be an entry if, e.g. the if clause always
332  /// evaluates to false.
334  StringRef ParentName,
335  llvm::Function *&OutlinedFn,
336  llvm::Constant *&OutlinedFnID,
337  bool IsOffloadEntry,
338  const RegionCodeGenTy &CodeGen);
339 
340  /// Emits object of ident_t type with info for source location.
341  /// \param Flags Flags for OpenMP location.
342  ///
343  llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
344  unsigned Flags = 0);
345 
346  /// Emit the number of teams for a target directive. Inspect the num_teams
347  /// clause associated with a teams construct combined or closely nested
348  /// with the target directive.
349  ///
350  /// Emit a team of size one for directives such as 'target parallel' that
351  /// have no associated teams construct.
352  ///
353  /// Otherwise, return nullptr.
355  const OMPExecutableDirective &D,
356  int32_t &DefaultVal);
358  const OMPExecutableDirective &D);
359  /// Emit the number of threads for a target directive. Inspect the
360  /// thread_limit clause associated with a teams construct combined or closely
361  /// nested with the target directive.
362  ///
363  /// Emit the num_threads clause for directives such as 'target parallel' that
364  /// have no associated teams construct.
365  ///
366  /// Otherwise, return nullptr.
367  const Expr *
369  const OMPExecutableDirective &D,
370  int32_t &DefaultVal);
371  llvm::Value *
373  const OMPExecutableDirective &D);
374 
375  /// Returns pointer to ident_t type.
376  llvm::Type *getIdentTyPointerTy();
377 
378  /// Gets thread id value for the current thread.
379  ///
380  llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
381 
382  /// Get the function name of an outlined region.
383  // The name can be customized depending on the target.
384  //
385  virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
386 
387  /// Emits \p Callee function call with arguments \p Args with location \p Loc.
388  void emitCall(CodeGenFunction &CGF, SourceLocation Loc,
389  llvm::FunctionCallee Callee,
390  ArrayRef<llvm::Value *> Args = llvm::None) const;
391 
392  /// Emits address of the word in a memory where current thread id is
393  /// stored.
395 
397  bool AtCurrentPoint = false);
399 
400  /// Check if the default location must be constant.
401  /// Default is false to support OMPT/OMPD.
402  virtual bool isDefaultLocationConstant() const { return false; }
403 
404  /// Returns additional flags that can be stored in reserved_2 field of the
405  /// default location.
406  virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
407 
408  /// Returns default flags for the barriers depending on the directive, for
409  /// which this barier is going to be emitted.
411 
412  /// Get the LLVM type for the critical name.
413  llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
414 
415  /// Returns corresponding lock object for the specified critical region
416  /// name. If the lock object does not exist it is created, otherwise the
417  /// reference to the existing copy is returned.
418  /// \param CriticalName Name of the critical region.
419  ///
420  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
421 
422 private:
423 
424  /// Map for SourceLocation and OpenMP runtime library debug locations.
425  typedef llvm::DenseMap<SourceLocation, llvm::Value *> OpenMPDebugLocMapTy;
426  OpenMPDebugLocMapTy OpenMPDebugLocMap;
427  /// The type for a microtask which gets passed to __kmpc_fork_call().
428  /// Original representation is:
429  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
430  llvm::FunctionType *Kmpc_MicroTy = nullptr;
431  /// Stores debug location and ThreadID for the function.
432  struct DebugLocThreadIdTy {
433  llvm::Value *DebugLoc;
434  llvm::Value *ThreadID;
435  /// Insert point for the service instructions.
436  llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
437  };
438  /// Map of local debug location, ThreadId and functions.
439  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
440  OpenMPLocThreadIDMapTy;
441  OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
442  /// Map of UDRs and corresponding combiner/initializer.
443  typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
444  std::pair<llvm::Function *, llvm::Function *>>
445  UDRMapTy;
446  UDRMapTy UDRMap;
447  /// Map of functions and locally defined UDRs.
448  typedef llvm::DenseMap<llvm::Function *,
450  FunctionUDRMapTy;
451  FunctionUDRMapTy FunctionUDRMap;
452  /// Map from the user-defined mapper declaration to its corresponding
453  /// functions.
454  llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
455  /// Map of functions and their local user-defined mappers.
456  using FunctionUDMMapTy =
457  llvm::DenseMap<llvm::Function *,
459  FunctionUDMMapTy FunctionUDMMap;
460  /// Maps local variables marked as lastprivate conditional to their internal
461  /// types.
462  llvm::DenseMap<llvm::Function *,
463  llvm::DenseMap<CanonicalDeclPtr<const Decl>,
464  std::tuple<QualType, const FieldDecl *,
465  const FieldDecl *, LValue>>>
466  LastprivateConditionalToTypes;
467  /// Maps function to the position of the untied task locals stack.
468  llvm::DenseMap<llvm::Function *, unsigned> FunctionToUntiedTaskStackMap;
469  /// Type kmp_critical_name, originally defined as typedef kmp_int32
470  /// kmp_critical_name[8];
471  llvm::ArrayType *KmpCriticalNameTy;
472  /// An ordered map of auto-generated variables to their unique names.
473  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
474  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
475  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
476  /// variables.
477  llvm::StringMap<llvm::AssertingVH<llvm::GlobalVariable>,
478  llvm::BumpPtrAllocator> InternalVars;
479  /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
480  llvm::Type *KmpRoutineEntryPtrTy = nullptr;
481  QualType KmpRoutineEntryPtrQTy;
482  /// Type typedef struct kmp_task {
483  /// void * shareds; /**< pointer to block of pointers to
484  /// shared vars */
485  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
486  /// executing task */
487  /// kmp_int32 part_id; /**< part id for the task */
488  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
489  /// deconstructors of firstprivate C++ objects */
490  /// } kmp_task_t;
491  QualType KmpTaskTQTy;
492  /// Saved kmp_task_t for task directive.
493  QualType SavedKmpTaskTQTy;
494  /// Saved kmp_task_t for taskloop-based directive.
495  QualType SavedKmpTaskloopTQTy;
496  /// Type typedef struct kmp_depend_info {
497  /// kmp_intptr_t base_addr;
498  /// size_t len;
499  /// struct {
500  /// bool in:1;
501  /// bool out:1;
502  /// } flags;
503  /// } kmp_depend_info_t;
504  QualType KmpDependInfoTy;
505  /// Type typedef struct kmp_task_affinity_info {
506  /// kmp_intptr_t base_addr;
507  /// size_t len;
508  /// struct {
509  /// bool flag1 : 1;
510  /// bool flag2 : 1;
511  /// kmp_int32 reserved : 30;
512  /// } flags;
513  /// } kmp_task_affinity_info_t;
514  QualType KmpTaskAffinityInfoTy;
515  /// struct kmp_dim { // loop bounds info casted to kmp_int64
516  /// kmp_int64 lo; // lower
517  /// kmp_int64 up; // upper
518  /// kmp_int64 st; // stride
519  /// };
520  QualType KmpDimTy;
521  /// Entity that registers the offloading constants that were emitted so
522  /// far.
523  class OffloadEntriesInfoManagerTy {
524  CodeGenModule &CGM;
525 
526  /// Number of entries registered so far.
527  unsigned OffloadingEntriesNum = 0;
528 
529  public:
530  /// Base class of the entries info.
532  public:
533  /// Kind of a given entry.
534  enum OffloadingEntryInfoKinds : unsigned {
535  /// Entry is a target region.
537  /// Entry is a declare target variable.
539  /// Invalid entry info.
541  };
542 
543  protected:
544  OffloadEntryInfo() = delete;
545  explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind) : Kind(Kind) {}
546  explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order,
547  uint32_t Flags)
548  : Flags(Flags), Order(Order), Kind(Kind) {}
549  ~OffloadEntryInfo() = default;
550 
551  public:
552  bool isValid() const { return Order != ~0u; }
553  unsigned getOrder() const { return Order; }
554  OffloadingEntryInfoKinds getKind() const { return Kind; }
555  uint32_t getFlags() const { return Flags; }
556  void setFlags(uint32_t NewFlags) { Flags = NewFlags; }
557  llvm::Constant *getAddress() const {
558  return cast_or_null<llvm::Constant>(Addr);
559  }
560  void setAddress(llvm::Constant *V) {
561  assert(!Addr.pointsToAliveValue() && "Address has been set before!");
562  Addr = V;
563  }
564  static bool classof(const OffloadEntryInfo *Info) { return true; }
565 
566  private:
567  /// Address of the entity that has to be mapped for offloading.
568  llvm::WeakTrackingVH Addr;
569 
570  /// Flags associated with the device global.
571  uint32_t Flags = 0u;
572 
573  /// Order this entry was emitted.
574  unsigned Order = ~0u;
575 
577  };
578 
579  /// Return true if a there are no entries defined.
580  bool empty() const;
581  /// Return number of entries defined so far.
582  unsigned size() const { return OffloadingEntriesNum; }
583  OffloadEntriesInfoManagerTy(CodeGenModule &CGM) : CGM(CGM) {}
584 
585  //
586  // Target region entries related.
587  //
588 
589  /// Kind of the target registry entry.
590  enum OMPTargetRegionEntryKind : uint32_t {
591  /// Mark the entry as target region.
592  OMPTargetRegionEntryTargetRegion = 0x0,
593  /// Mark the entry as a global constructor.
594  OMPTargetRegionEntryCtor = 0x02,
595  /// Mark the entry as a global destructor.
596  OMPTargetRegionEntryDtor = 0x04,
597  };
598 
599  /// Target region entries info.
601  /// Address that can be used as the ID of the entry.
602  llvm::Constant *ID = nullptr;
603 
604  public:
607  explicit OffloadEntryInfoTargetRegion(unsigned Order,
608  llvm::Constant *Addr,
609  llvm::Constant *ID,
610  OMPTargetRegionEntryKind Flags)
612  ID(ID) {
613  setAddress(Addr);
614  }
615 
616  llvm::Constant *getID() const { return ID; }
617  void setID(llvm::Constant *V) {
618  assert(!ID && "ID has been set before!");
619  ID = V;
620  }
621  static bool classof(const OffloadEntryInfo *Info) {
622  return Info->getKind() == OffloadingEntryInfoTargetRegion;
623  }
624  };
625 
626  /// Initialize target region entry.
627  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
628  StringRef ParentName, unsigned LineNum,
629  unsigned Order);
630  /// Register target region entry.
631  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
632  StringRef ParentName, unsigned LineNum,
633  llvm::Constant *Addr, llvm::Constant *ID,
634  OMPTargetRegionEntryKind Flags);
635  /// Return true if a target region entry with the provided information
636  /// exists.
637  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
638  StringRef ParentName, unsigned LineNum,
639  bool IgnoreAddressId = false) const;
640  /// brief Applies action \a Action on all registered entries.
641  typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
642  const OffloadEntryInfoTargetRegion &)>
643  OffloadTargetRegionEntryInfoActTy;
644  void actOnTargetRegionEntriesInfo(
645  const OffloadTargetRegionEntryInfoActTy &Action);
646 
647  //
648  // Device global variable entries related.
649  //
650 
651  /// Kind of the global variable entry..
652  enum OMPTargetGlobalVarEntryKind : uint32_t {
653  /// Mark the entry as a to declare target.
654  OMPTargetGlobalVarEntryTo = 0x0,
655  /// Mark the entry as a to declare target link.
656  OMPTargetGlobalVarEntryLink = 0x1,
657  };
658 
659  /// Device global variable entries info.
661  /// Type of the global variable.
662  CharUnits VarSize;
663  llvm::GlobalValue::LinkageTypes Linkage;
664 
665  public:
668  explicit OffloadEntryInfoDeviceGlobalVar(unsigned Order,
669  OMPTargetGlobalVarEntryKind Flags)
672  unsigned Order, llvm::Constant *Addr, CharUnits VarSize,
673  OMPTargetGlobalVarEntryKind Flags,
674  llvm::GlobalValue::LinkageTypes Linkage)
676  VarSize(VarSize), Linkage(Linkage) {
677  setAddress(Addr);
678  }
679 
680  CharUnits getVarSize() const { return VarSize; }
681  void setVarSize(CharUnits Size) { VarSize = Size; }
682  llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
683  void setLinkage(llvm::GlobalValue::LinkageTypes LT) { Linkage = LT; }
684  static bool classof(const OffloadEntryInfo *Info) {
686  }
687  };
688 
689  /// Initialize device global variable entry.
690  void initializeDeviceGlobalVarEntryInfo(StringRef Name,
691  OMPTargetGlobalVarEntryKind Flags,
692  unsigned Order);
693 
694  /// Register device global variable entry.
695  void
696  registerDeviceGlobalVarEntryInfo(StringRef VarName, llvm::Constant *Addr,
697  CharUnits VarSize,
698  OMPTargetGlobalVarEntryKind Flags,
699  llvm::GlobalValue::LinkageTypes Linkage);
700  /// Checks if the variable with the given name has been registered already.
701  bool hasDeviceGlobalVarEntryInfo(StringRef VarName) const {
702  return OffloadEntriesDeviceGlobalVar.count(VarName) > 0;
703  }
704  /// Applies action \a Action on all registered entries.
705  typedef llvm::function_ref<void(StringRef,
706  const OffloadEntryInfoDeviceGlobalVar &)>
707  OffloadDeviceGlobalVarEntryInfoActTy;
708  void actOnDeviceGlobalVarEntriesInfo(
709  const OffloadDeviceGlobalVarEntryInfoActTy &Action);
710 
711  private:
712  // Storage for target region entries kind. The storage is to be indexed by
713  // file ID, device ID, parent function name and line number.
714  typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
715  OffloadEntriesTargetRegionPerLine;
716  typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
717  OffloadEntriesTargetRegionPerParentName;
718  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
719  OffloadEntriesTargetRegionPerFile;
720  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
721  OffloadEntriesTargetRegionPerDevice;
722  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
723  OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
724  /// Storage for device global variable entries kind. The storage is to be
725  /// indexed by mangled name.
726  typedef llvm::StringMap<OffloadEntryInfoDeviceGlobalVar>
727  OffloadEntriesDeviceGlobalVarTy;
728  OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar;
729  };
730  OffloadEntriesInfoManagerTy OffloadEntriesInfoManager;
731 
732  bool ShouldMarkAsGlobal = true;
733  /// List of the emitted declarations.
734  llvm::DenseSet<CanonicalDeclPtr<const Decl>> AlreadyEmittedTargetDecls;
735  /// List of the global variables with their addresses that should not be
736  /// emitted for the target.
737  llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
738 
739  /// List of variables that can become declare target implicitly and, thus,
740  /// must be emitted.
741  llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
742 
743  using NontemporalDeclsSet = llvm::SmallDenseSet<CanonicalDeclPtr<const Decl>>;
744  /// Stack for list of declarations in current context marked as nontemporal.
745  /// The set is the union of all current stack elements.
746  llvm::SmallVector<NontemporalDeclsSet, 4> NontemporalDeclsStack;
747 
748  using UntiedLocalVarsAddressesMap =
749  llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
750  std::pair<Address, Address>>;
752 
753  /// Stack for list of addresses of declarations in current context marked as
754  /// lastprivate conditional. The set is the union of all current stack
755  /// elements.
756  llvm::SmallVector<LastprivateConditionalData, 4> LastprivateConditionalStack;
757 
758  /// Flag for keeping track of weather a requires unified_shared_memory
759  /// directive is present.
760  bool HasRequiresUnifiedSharedMemory = false;
761 
762  /// Atomic ordering from the omp requires directive.
763  llvm::AtomicOrdering RequiresAtomicOrdering = llvm::AtomicOrdering::Monotonic;
764 
765  /// Flag for keeping track of weather a target region has been emitted.
766  bool HasEmittedTargetRegion = false;
767 
768  /// Flag for keeping track of weather a device routine has been emitted.
769  /// Device routines are specific to the
770  bool HasEmittedDeclareTargetRegion = false;
771 
772  /// Loads all the offload entries information from the host IR
773  /// metadata.
774  void loadOffloadInfoMetadata();
775 
776  /// Start scanning from statement \a S and and emit all target regions
777  /// found along the way.
778  /// \param S Starting statement.
779  /// \param ParentName Name of the function declaration that is being scanned.
780  void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
781 
782  /// Build type kmp_routine_entry_t (if not built yet).
783  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
784 
785  /// Returns pointer to kmpc_micro type.
786  llvm::Type *getKmpc_MicroPointerTy();
787 
788  /// Returns __kmpc_for_static_init_* runtime function for the specified
789  /// size \a IVSize and sign \a IVSigned. Will create a distribute call
790  /// __kmpc_distribute_static_init* if \a IsGPUDistribute is set.
791  llvm::FunctionCallee createForStaticInitFunction(unsigned IVSize,
792  bool IVSigned,
793  bool IsGPUDistribute);
794 
795  /// Returns __kmpc_dispatch_init_* runtime function for the specified
796  /// size \a IVSize and sign \a IVSigned.
797  llvm::FunctionCallee createDispatchInitFunction(unsigned IVSize,
798  bool IVSigned);
799 
800  /// Returns __kmpc_dispatch_next_* runtime function for the specified
801  /// size \a IVSize and sign \a IVSigned.
802  llvm::FunctionCallee createDispatchNextFunction(unsigned IVSize,
803  bool IVSigned);
804 
805  /// Returns __kmpc_dispatch_fini_* runtime function for the specified
806  /// size \a IVSize and sign \a IVSigned.
807  llvm::FunctionCallee createDispatchFiniFunction(unsigned IVSize,
808  bool IVSigned);
809 
810  /// If the specified mangled name is not in the module, create and
811  /// return threadprivate cache object. This object is a pointer's worth of
812  /// storage that's reserved for use by the OpenMP runtime.
813  /// \param VD Threadprivate variable.
814  /// \return Cache variable for the specified threadprivate.
815  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
816 
817  /// Gets (if variable with the given name already exist) or creates
818  /// internal global variable with the specified Name. The created variable has
819  /// linkage CommonLinkage by default and is initialized by null value.
820  /// \param Ty Type of the global variable. If it is exist already the type
821  /// must be the same.
822  /// \param Name Name of the variable.
823  llvm::GlobalVariable *getOrCreateInternalVariable(llvm::Type *Ty,
824  const llvm::Twine &Name,
825  unsigned AddressSpace = 0);
826 
827  /// Set of threadprivate variables with the generated initializer.
828  llvm::StringSet<> ThreadPrivateWithDefinition;
829 
830  /// Set of declare target variables with the generated initializer.
831  llvm::StringSet<> DeclareTargetWithDefinition;
832 
833  /// Emits initialization code for the threadprivate variables.
834  /// \param VDAddr Address of the global variable \a VD.
835  /// \param Ctor Pointer to a global init function for \a VD.
836  /// \param CopyCtor Pointer to a global copy function for \a VD.
837  /// \param Dtor Pointer to a global destructor function for \a VD.
838  /// \param Loc Location of threadprivate declaration.
839  void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
840  llvm::Value *Ctor, llvm::Value *CopyCtor,
841  llvm::Value *Dtor, SourceLocation Loc);
842 
843  /// Emit the array initialization or deletion portion for user-defined mapper
844  /// code generation.
845  void emitUDMapperArrayInitOrDel(CodeGenFunction &MapperCGF,
846  llvm::Value *Handle, llvm::Value *BasePtr,
847  llvm::Value *Ptr, llvm::Value *Size,
848  llvm::Value *MapType, llvm::Value *MapName,
849  CharUnits ElementSize,
850  llvm::BasicBlock *ExitBB, bool IsInit);
851 
852  struct TaskResultTy {
853  llvm::Value *NewTask = nullptr;
854  llvm::Function *TaskEntry = nullptr;
855  llvm::Value *NewTaskNewTaskTTy = nullptr;
856  LValue TDBase;
857  const RecordDecl *KmpTaskTQTyRD = nullptr;
858  llvm::Value *TaskDupFn = nullptr;
859  };
860  /// Emit task region for the task directive. The task region is emitted in
861  /// several steps:
862  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
863  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
864  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
865  /// function:
866  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
867  /// TaskFunction(gtid, tt->part_id, tt->shareds);
868  /// return 0;
869  /// }
870  /// 2. Copy a list of shared variables to field shareds of the resulting
871  /// structure kmp_task_t returned by the previous call (if any).
872  /// 3. Copy a pointer to destructions function to field destructions of the
873  /// resulting structure kmp_task_t.
874  /// \param D Current task directive.
875  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
876  /// /*part_id*/, captured_struct */*__context*/);
877  /// \param SharedsTy A type which contains references the shared variables.
878  /// \param Shareds Context with the list of shared variables from the \p
879  /// TaskFunction.
880  /// \param Data Additional data for task generation like tiednsee, final
881  /// state, list of privates etc.
882  TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
883  const OMPExecutableDirective &D,
884  llvm::Function *TaskFunction, QualType SharedsTy,
885  Address Shareds, const OMPTaskDataTy &Data);
886 
887  /// Return the trip count of loops associated with constructs / 'target teams
888  /// distribute' and 'teams distribute parallel for'. \param SizeEmitter Emits
889  /// the int64 value for the number of iterations of the associated loop.
890  llvm::Value *emitTargetNumIterationsCall(
891  CodeGenFunction &CGF, const OMPExecutableDirective &D,
892  llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
893  const OMPLoopDirective &D)>
894  SizeEmitter);
895 
896  /// Emit update for lastprivate conditional data.
897  void emitLastprivateConditionalUpdate(CodeGenFunction &CGF, LValue IVLVal,
898  StringRef UniqueDeclName, LValue LVal,
899  SourceLocation Loc);
900 
901  /// Returns the number of the elements and the address of the depobj
902  /// dependency array.
903  /// \return Number of elements in depobj array and the pointer to the array of
904  /// dependencies.
905  std::pair<llvm::Value *, LValue> getDepobjElements(CodeGenFunction &CGF,
906  LValue DepobjLVal,
907  SourceLocation Loc);
908 
909  SmallVector<llvm::Value *, 4>
910  emitDepobjElementsSizes(CodeGenFunction &CGF, QualType &KmpDependInfoTy,
911  const OMPTaskDataTy::DependData &Data);
912 
913  void emitDepobjElements(CodeGenFunction &CGF, QualType &KmpDependInfoTy,
914  LValue PosLVal, const OMPTaskDataTy::DependData &Data,
915  Address DependenciesArray);
916 
917 public:
919  : CGOpenMPRuntime(CGM, ".", ".") {}
920  virtual ~CGOpenMPRuntime() {}
921  virtual void clear();
922 
923  /// Emits code for OpenMP 'if' clause using specified \a CodeGen
924  /// function. Here is the logic:
925  /// if (Cond) {
926  /// ThenGen();
927  /// } else {
928  /// ElseGen();
929  /// }
930  void emitIfClause(CodeGenFunction &CGF, const Expr *Cond,
931  const RegionCodeGenTy &ThenGen,
932  const RegionCodeGenTy &ElseGen);
933 
934  /// Checks if the \p Body is the \a CompoundStmt and returns its child
935  /// statement iff there is only one that is not evaluatable at the compile
936  /// time.
937  static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
938 
939  /// Get the platform-specific name separator.
941 
942  /// Emit code for the specified user defined reduction construct.
943  virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
944  const OMPDeclareReductionDecl *D);
945  /// Get combiner/initializer for the specified user-defined reduction, if any.
946  virtual std::pair<llvm::Function *, llvm::Function *>
948 
949  /// Emit the function for the user defined mapper construct.
951  CodeGenFunction *CGF = nullptr);
952  /// Get the function for the specified user-defined mapper. If it does not
953  /// exist, create one.
954  llvm::Function *
956 
957  /// Emits outlined function for the specified OpenMP parallel directive
958  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
959  /// kmp_int32 BoundID, struct context_vars*).
960  /// \param D OpenMP directive.
961  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
962  /// \param InnermostKind Kind of innermost directive (for simple directives it
963  /// is a directive itself, for combined - its innermost directive).
964  /// \param CodeGen Code generation sequence for the \a D directive.
965  virtual llvm::Function *emitParallelOutlinedFunction(
966  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
967  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
968 
969  /// Emits outlined function for the specified OpenMP teams directive
970  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
971  /// kmp_int32 BoundID, struct context_vars*).
972  /// \param D OpenMP directive.
973  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
974  /// \param InnermostKind Kind of innermost directive (for simple directives it
975  /// is a directive itself, for combined - its innermost directive).
976  /// \param CodeGen Code generation sequence for the \a D directive.
977  virtual llvm::Function *emitTeamsOutlinedFunction(
978  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
979  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
980 
981  /// Emits outlined function for the OpenMP task directive \a D. This
982  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
983  /// TaskT).
984  /// \param D OpenMP directive.
985  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
986  /// \param PartIDVar Variable for partition id in the current OpenMP untied
987  /// task region.
988  /// \param TaskTVar Variable for task_t argument.
989  /// \param InnermostKind Kind of innermost directive (for simple directives it
990  /// is a directive itself, for combined - its innermost directive).
991  /// \param CodeGen Code generation sequence for the \a D directive.
992  /// \param Tied true if task is generated for tied task, false otherwise.
993  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
994  /// tasks.
995  ///
996  virtual llvm::Function *emitTaskOutlinedFunction(
997  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
998  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
999  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1000  bool Tied, unsigned &NumberOfParts);
1001 
1002  /// Cleans up references to the objects in finished function.
1003  ///
1004  virtual void functionFinished(CodeGenFunction &CGF);
1005 
1006  /// Emits code for parallel or serial call of the \a OutlinedFn with
1007  /// variables captured in a record which address is stored in \a
1008  /// CapturedStruct.
1009  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1010  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1011  /// \param CapturedVars A pointer to the record with the references to
1012  /// variables used in \a OutlinedFn function.
1013  /// \param IfCond Condition in the associated 'if' clause, if it was
1014  /// specified, nullptr otherwise.
1015  /// \param NumThreads The value corresponding to the num_threads clause, if
1016  /// any, or nullptr.
1017  ///
1018  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
1019  llvm::Function *OutlinedFn,
1020  ArrayRef<llvm::Value *> CapturedVars,
1021  const Expr *IfCond, llvm::Value *NumThreads);
1022 
1023  /// Emits a critical region.
1024  /// \param CriticalName Name of the critical region.
1025  /// \param CriticalOpGen Generator for the statement associated with the given
1026  /// critical region.
1027  /// \param Hint Value of the 'hint' clause (optional).
1028  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
1029  const RegionCodeGenTy &CriticalOpGen,
1030  SourceLocation Loc,
1031  const Expr *Hint = nullptr);
1032 
1033  /// Emits a master region.
1034  /// \param MasterOpGen Generator for the statement associated with the given
1035  /// master region.
1036  virtual void emitMasterRegion(CodeGenFunction &CGF,
1037  const RegionCodeGenTy &MasterOpGen,
1038  SourceLocation Loc);
1039 
1040  /// Emits a masked region.
1041  /// \param MaskedOpGen Generator for the statement associated with the given
1042  /// masked region.
1043  virtual void emitMaskedRegion(CodeGenFunction &CGF,
1044  const RegionCodeGenTy &MaskedOpGen,
1045  SourceLocation Loc,
1046  const Expr *Filter = nullptr);
1047 
1048  /// Emits code for a taskyield directive.
1049  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
1050 
1051  /// Emit a taskgroup region.
1052  /// \param TaskgroupOpGen Generator for the statement associated with the
1053  /// given taskgroup region.
1054  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
1055  const RegionCodeGenTy &TaskgroupOpGen,
1056  SourceLocation Loc);
1057 
1058  /// Emits a single region.
1059  /// \param SingleOpGen Generator for the statement associated with the given
1060  /// single region.
1061  virtual void emitSingleRegion(CodeGenFunction &CGF,
1062  const RegionCodeGenTy &SingleOpGen,
1063  SourceLocation Loc,
1064  ArrayRef<const Expr *> CopyprivateVars,
1065  ArrayRef<const Expr *> DestExprs,
1066  ArrayRef<const Expr *> SrcExprs,
1067  ArrayRef<const Expr *> AssignmentOps);
1068 
1069  /// Emit an ordered region.
1070  /// \param OrderedOpGen Generator for the statement associated with the given
1071  /// ordered region.
1072  virtual void emitOrderedRegion(CodeGenFunction &CGF,
1073  const RegionCodeGenTy &OrderedOpGen,
1074  SourceLocation Loc, bool IsThreads);
1075 
1076  /// Emit an implicit/explicit barrier for OpenMP threads.
1077  /// \param Kind Directive for which this implicit barrier call must be
1078  /// generated. Must be OMPD_barrier for explicit barrier generation.
1079  /// \param EmitChecks true if need to emit checks for cancellation barriers.
1080  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1081  /// runtime class decides which one to emit (simple or with cancellation
1082  /// checks).
1083  ///
1084  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
1086  bool EmitChecks = true,
1087  bool ForceSimpleCall = false);
1088 
1089  /// Check if the specified \a ScheduleKind is static non-chunked.
1090  /// This kind of worksharing directive is emitted without outer loop.
1091  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
1092  /// \param Chunked True if chunk is specified in the clause.
1093  ///
1094  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
1095  bool Chunked) const;
1096 
1097  /// Check if the specified \a ScheduleKind is static non-chunked.
1098  /// This kind of distribute directive is emitted without outer loop.
1099  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
1100  /// \param Chunked True if chunk is specified in the clause.
1101  ///
1102  virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
1103  bool Chunked) const;
1104 
1105  /// Check if the specified \a ScheduleKind is static chunked.
1106  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
1107  /// \param Chunked True if chunk is specified in the clause.
1108  ///
1109  virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
1110  bool Chunked) const;
1111 
1112  /// Check if the specified \a ScheduleKind is static non-chunked.
1113  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
1114  /// \param Chunked True if chunk is specified in the clause.
1115  ///
1116  virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
1117  bool Chunked) const;
1118 
1119  /// Check if the specified \a ScheduleKind is dynamic.
1120  /// This kind of worksharing directive is emitted without outer loop.
1121  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
1122  ///
1123  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
1124 
1125  /// struct with the values to be passed to the dispatch runtime function
1127  /// Loop lower bound
1128  llvm::Value *LB = nullptr;
1129  /// Loop upper bound
1130  llvm::Value *UB = nullptr;
1131  /// Chunk size specified using 'schedule' clause (nullptr if chunk
1132  /// was not specified)
1133  llvm::Value *Chunk = nullptr;
1134  DispatchRTInput() = default;
1135  DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
1136  : LB(LB), UB(UB), Chunk(Chunk) {}
1137  };
1138 
1139  /// Call the appropriate runtime routine to initialize it before start
1140  /// of loop.
1141 
1142  /// This is used for non static scheduled types and when the ordered
1143  /// clause is present on the loop construct.
1144  /// Depending on the loop schedule, it is necessary to call some runtime
1145  /// routine before start of the OpenMP loop to get the loop upper / lower
1146  /// bounds \a LB and \a UB and stride \a ST.
1147  ///
1148  /// \param CGF Reference to current CodeGenFunction.
1149  /// \param Loc Clang source location.
1150  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1151  /// \param IVSize Size of the iteration variable in bits.
1152  /// \param IVSigned Sign of the iteration variable.
1153  /// \param Ordered true if loop is ordered, false otherwise.
1154  /// \param DispatchValues struct containing llvm values for lower bound, upper
1155  /// bound, and chunk expression.
1156  /// For the default (nullptr) value, the chunk 1 will be used.
1157  ///
1158  virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
1159  const OpenMPScheduleTy &ScheduleKind,
1160  unsigned IVSize, bool IVSigned, bool Ordered,
1161  const DispatchRTInput &DispatchValues);
1162 
1163  /// Struct with the values to be passed to the static runtime function
1164  struct StaticRTInput {
1165  /// Size of the iteration variable in bits.
1166  unsigned IVSize = 0;
1167  /// Sign of the iteration variable.
1168  bool IVSigned = false;
1169  /// true if loop is ordered, false otherwise.
1170  bool Ordered = false;
1171  /// Address of the output variable in which the flag of the last iteration
1172  /// is returned.
1174  /// Address of the output variable in which the lower iteration number is
1175  /// returned.
1177  /// Address of the output variable in which the upper iteration number is
1178  /// returned.
1180  /// Address of the output variable in which the stride value is returned
1181  /// necessary to generated the static_chunked scheduled loop.
1183  /// Value of the chunk for the static_chunked scheduled loop. For the
1184  /// default (nullptr) value, the chunk 1 will be used.
1185  llvm::Value *Chunk = nullptr;
1188  llvm::Value *Chunk = nullptr)
1190  UB(UB), ST(ST), Chunk(Chunk) {}
1191  };
1192  /// Call the appropriate runtime routine to initialize it before start
1193  /// of loop.
1194  ///
1195  /// This is used only in case of static schedule, when the user did not
1196  /// specify a ordered clause on the loop construct.
1197  /// Depending on the loop schedule, it is necessary to call some runtime
1198  /// routine before start of the OpenMP loop to get the loop upper / lower
1199  /// bounds LB and UB and stride ST.
1200  ///
1201  /// \param CGF Reference to current CodeGenFunction.
1202  /// \param Loc Clang source location.
1203  /// \param DKind Kind of the directive.
1204  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1205  /// \param Values Input arguments for the construct.
1206  ///
1207  virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
1208  OpenMPDirectiveKind DKind,
1209  const OpenMPScheduleTy &ScheduleKind,
1210  const StaticRTInput &Values);
1211 
1212  ///
1213  /// \param CGF Reference to current CodeGenFunction.
1214  /// \param Loc Clang source location.
1215  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1216  /// \param Values Input arguments for the construct.
1217  ///
1218  virtual void emitDistributeStaticInit(CodeGenFunction &CGF,
1219  SourceLocation Loc,
1220  OpenMPDistScheduleClauseKind SchedKind,
1221  const StaticRTInput &Values);
1222 
1223  /// Call the appropriate runtime routine to notify that we finished
1224  /// iteration of the ordered loop with the dynamic scheduling.
1225  ///
1226  /// \param CGF Reference to current CodeGenFunction.
1227  /// \param Loc Clang source location.
1228  /// \param IVSize Size of the iteration variable in bits.
1229  /// \param IVSigned Sign of the iteration variable.
1230  ///
1231  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
1232  SourceLocation Loc, unsigned IVSize,
1233  bool IVSigned);
1234 
1235  /// Call the appropriate runtime routine to notify that we finished
1236  /// all the work with current loop.
1237  ///
1238  /// \param CGF Reference to current CodeGenFunction.
1239  /// \param Loc Clang source location.
1240  /// \param DKind Kind of the directive for which the static finish is emitted.
1241  ///
1242  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1243  OpenMPDirectiveKind DKind);
1244 
1245  /// Call __kmpc_dispatch_next(
1246  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1247  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1248  /// kmp_int[32|64] *p_stride);
1249  /// \param IVSize Size of the iteration variable in bits.
1250  /// \param IVSigned Sign of the iteration variable.
1251  /// \param IL Address of the output variable in which the flag of the
1252  /// last iteration is returned.
1253  /// \param LB Address of the output variable in which the lower iteration
1254  /// number is returned.
1255  /// \param UB Address of the output variable in which the upper iteration
1256  /// number is returned.
1257  /// \param ST Address of the output variable in which the stride value is
1258  /// returned.
1259  virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1260  unsigned IVSize, bool IVSigned,
1261  Address IL, Address LB,
1262  Address UB, Address ST);
1263 
1264  /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1265  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1266  /// clause.
1267  /// \param NumThreads An integer value of threads.
1268  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
1269  llvm::Value *NumThreads,
1270  SourceLocation Loc);
1271 
1272  /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1273  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1274  virtual void emitProcBindClause(CodeGenFunction &CGF,
1275  llvm::omp::ProcBindKind ProcBind,
1276  SourceLocation Loc);
1277 
1278  /// Returns address of the threadprivate variable for the current
1279  /// thread.
1280  /// \param VD Threadprivate variable.
1281  /// \param VDAddr Address of the global variable \a VD.
1282  /// \param Loc Location of the reference to threadprivate var.
1283  /// \return Address of the threadprivate variable for the current thread.
1285  const VarDecl *VD,
1286  Address VDAddr,
1287  SourceLocation Loc);
1288 
1289  /// Returns the address of the variable marked as declare target with link
1290  /// clause OR as declare target with to clause and unified memory.
1291  virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD);
1292 
1293  /// Emit a code for initialization of threadprivate variable. It emits
1294  /// a call to runtime library which adds initial value to the newly created
1295  /// threadprivate variable (if it is not constant) and registers destructor
1296  /// for the variable (if any).
1297  /// \param VD Threadprivate variable.
1298  /// \param VDAddr Address of the global variable \a VD.
1299  /// \param Loc Location of threadprivate declaration.
1300  /// \param PerformInit true if initialization expression is not constant.
1301  virtual llvm::Function *
1303  SourceLocation Loc, bool PerformInit,
1304  CodeGenFunction *CGF = nullptr);
1305 
1306  /// Emit a code for initialization of declare target variable.
1307  /// \param VD Declare target variable.
1308  /// \param Addr Address of the global variable \a VD.
1309  /// \param PerformInit true if initialization expression is not constant.
1310  virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD,
1311  llvm::GlobalVariable *Addr,
1312  bool PerformInit);
1313 
1314  /// Creates artificial threadprivate variable with name \p Name and type \p
1315  /// VarType.
1316  /// \param VarType Type of the artificial threadprivate variable.
1317  /// \param Name Name of the artificial threadprivate variable.
1319  QualType VarType,
1320  StringRef Name);
1321 
1322  /// Emit flush of the variables specified in 'omp flush' directive.
1323  /// \param Vars List of variables to flush.
1324  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1325  SourceLocation Loc, llvm::AtomicOrdering AO);
1326 
1327  /// Emit task region for the task directive. The task region is
1328  /// emitted in several steps:
1329  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1330  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1331  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1332  /// function:
1333  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1334  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1335  /// return 0;
1336  /// }
1337  /// 2. Copy a list of shared variables to field shareds of the resulting
1338  /// structure kmp_task_t returned by the previous call (if any).
1339  /// 3. Copy a pointer to destructions function to field destructions of the
1340  /// resulting structure kmp_task_t.
1341  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1342  /// kmp_task_t *new_task), where new_task is a resulting structure from
1343  /// previous items.
1344  /// \param D Current task directive.
1345  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1346  /// /*part_id*/, captured_struct */*__context*/);
1347  /// \param SharedsTy A type which contains references the shared variables.
1348  /// \param Shareds Context with the list of shared variables from the \p
1349  /// TaskFunction.
1350  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1351  /// otherwise.
1352  /// \param Data Additional data for task generation like tiednsee, final
1353  /// state, list of privates etc.
1354  virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1355  const OMPExecutableDirective &D,
1356  llvm::Function *TaskFunction, QualType SharedsTy,
1357  Address Shareds, const Expr *IfCond,
1358  const OMPTaskDataTy &Data);
1359 
1360  /// Emit task region for the taskloop directive. The taskloop region is
1361  /// emitted in several steps:
1362  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1363  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1364  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1365  /// function:
1366  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1367  /// TaskFunction(gtid, tt->part_id, tt->shareds);
1368  /// return 0;
1369  /// }
1370  /// 2. Copy a list of shared variables to field shareds of the resulting
1371  /// structure kmp_task_t returned by the previous call (if any).
1372  /// 3. Copy a pointer to destructions function to field destructions of the
1373  /// resulting structure kmp_task_t.
1374  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1375  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1376  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1377  /// is a resulting structure from
1378  /// previous items.
1379  /// \param D Current task directive.
1380  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1381  /// /*part_id*/, captured_struct */*__context*/);
1382  /// \param SharedsTy A type which contains references the shared variables.
1383  /// \param Shareds Context with the list of shared variables from the \p
1384  /// TaskFunction.
1385  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1386  /// otherwise.
1387  /// \param Data Additional data for task generation like tiednsee, final
1388  /// state, list of privates etc.
1389  virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1390  const OMPLoopDirective &D,
1391  llvm::Function *TaskFunction,
1392  QualType SharedsTy, Address Shareds,
1393  const Expr *IfCond, const OMPTaskDataTy &Data);
1394 
1395  /// Emit code for the directive that does not require outlining.
1396  ///
1397  /// \param InnermostKind Kind of innermost directive (for simple directives it
1398  /// is a directive itself, for combined - its innermost directive).
1399  /// \param CodeGen Code generation sequence for the \a D directive.
1400  /// \param HasCancel true if region has inner cancel directive, false
1401  /// otherwise.
1402  virtual void emitInlinedDirective(CodeGenFunction &CGF,
1403  OpenMPDirectiveKind InnermostKind,
1404  const RegionCodeGenTy &CodeGen,
1405  bool HasCancel = false);
1406 
1407  /// Emits reduction function.
1408  /// \param ArgsElemType Array type containing pointers to reduction variables.
1409  /// \param Privates List of private copies for original reduction arguments.
1410  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1411  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1412  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1413  /// or 'operator binop(LHS, RHS)'.
1414  llvm::Function *emitReductionFunction(SourceLocation Loc,
1415  llvm::Type *ArgsElemType,
1416  ArrayRef<const Expr *> Privates,
1417  ArrayRef<const Expr *> LHSExprs,
1418  ArrayRef<const Expr *> RHSExprs,
1419  ArrayRef<const Expr *> ReductionOps);
1420 
1421  /// Emits single reduction combiner
1423  const Expr *ReductionOp,
1424  const Expr *PrivateRef,
1425  const DeclRefExpr *LHS,
1426  const DeclRefExpr *RHS);
1427 
1432  };
1433  /// Emit a code for reduction clause. Next code should be emitted for
1434  /// reduction:
1435  /// \code
1436  ///
1437  /// static kmp_critical_name lock = { 0 };
1438  ///
1439  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1440  /// ...
1441  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1442  /// ...
1443  /// }
1444  ///
1445  /// ...
1446  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1447  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1448  /// RedList, reduce_func, &<lock>)) {
1449  /// case 1:
1450  /// ...
1451  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1452  /// ...
1453  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1454  /// break;
1455  /// case 2:
1456  /// ...
1457  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1458  /// ...
1459  /// break;
1460  /// default:;
1461  /// }
1462  /// \endcode
1463  ///
1464  /// \param Privates List of private copies for original reduction arguments.
1465  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1466  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1467  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1468  /// or 'operator binop(LHS, RHS)'.
1469  /// \param Options List of options for reduction codegen:
1470  /// WithNowait true if parent directive has also nowait clause, false
1471  /// otherwise.
1472  /// SimpleReduction Emit reduction operation only. Used for omp simd
1473  /// directive on the host.
1474  /// ReductionKind The kind of reduction to perform.
1475  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1476  ArrayRef<const Expr *> Privates,
1477  ArrayRef<const Expr *> LHSExprs,
1478  ArrayRef<const Expr *> RHSExprs,
1479  ArrayRef<const Expr *> ReductionOps,
1480  ReductionOptionsTy Options);
1481 
1482  /// Emit a code for initialization of task reduction clause. Next code
1483  /// should be emitted for reduction:
1484  /// \code
1485  ///
1486  /// _taskred_item_t red_data[n];
1487  /// ...
1488  /// red_data[i].shar = &shareds[i];
1489  /// red_data[i].orig = &origs[i];
1490  /// red_data[i].size = sizeof(origs[i]);
1491  /// red_data[i].f_init = (void*)RedInit<i>;
1492  /// red_data[i].f_fini = (void*)RedDest<i>;
1493  /// red_data[i].f_comb = (void*)RedOp<i>;
1494  /// red_data[i].flags = <Flag_i>;
1495  /// ...
1496  /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
1497  /// \endcode
1498  /// For reduction clause with task modifier it emits the next call:
1499  /// \code
1500  ///
1501  /// _taskred_item_t red_data[n];
1502  /// ...
1503  /// red_data[i].shar = &shareds[i];
1504  /// red_data[i].orig = &origs[i];
1505  /// red_data[i].size = sizeof(origs[i]);
1506  /// red_data[i].f_init = (void*)RedInit<i>;
1507  /// red_data[i].f_fini = (void*)RedDest<i>;
1508  /// red_data[i].f_comb = (void*)RedOp<i>;
1509  /// red_data[i].flags = <Flag_i>;
1510  /// ...
1511  /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
1512  /// red_data);
1513  /// \endcode
1514  /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1515  /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1516  /// \param Data Additional data for task generation like tiedness, final
1517  /// state, list of privates, reductions etc.
1518  virtual llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF,
1519  SourceLocation Loc,
1520  ArrayRef<const Expr *> LHSExprs,
1521  ArrayRef<const Expr *> RHSExprs,
1522  const OMPTaskDataTy &Data);
1523 
1524  /// Emits the following code for reduction clause with task modifier:
1525  /// \code
1526  /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
1527  /// \endcode
1528  virtual void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc,
1529  bool IsWorksharingReduction);
1530 
1531  /// Required to resolve existing problems in the runtime. Emits threadprivate
1532  /// variables to store the size of the VLAs/array sections for
1533  /// initializer/combiner/finalizer functions.
1534  /// \param RCG Allows to reuse an existing data for the reductions.
1535  /// \param N Reduction item for which fixups must be emitted.
1537  ReductionCodeGen &RCG, unsigned N);
1538 
1539  /// Get the address of `void *` type of the privatue copy of the reduction
1540  /// item specified by the \p SharedLVal.
1541  /// \param ReductionsPtr Pointer to the reduction data returned by the
1542  /// emitTaskReductionInit function.
1543  /// \param SharedLVal Address of the original reduction item.
1545  llvm::Value *ReductionsPtr,
1546  LValue SharedLVal);
1547 
1548  /// Emit code for 'taskwait' directive.
1549  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc,
1550  const OMPTaskDataTy &Data);
1551 
1552  /// Emit code for 'cancellation point' construct.
1553  /// \param CancelRegion Region kind for which the cancellation point must be
1554  /// emitted.
1555  ///
1556  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
1557  SourceLocation Loc,
1558  OpenMPDirectiveKind CancelRegion);
1559 
1560  /// Emit code for 'cancel' construct.
1561  /// \param IfCond Condition in the associated 'if' clause, if it was
1562  /// specified, nullptr otherwise.
1563  /// \param CancelRegion Region kind for which the cancel must be emitted.
1564  ///
1565  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1566  const Expr *IfCond,
1567  OpenMPDirectiveKind CancelRegion);
1568 
1569  /// Emit outilined function for 'target' directive.
1570  /// \param D Directive to emit.
1571  /// \param ParentName Name of the function that encloses the target region.
1572  /// \param OutlinedFn Outlined function value to be defined by this call.
1573  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1574  /// \param IsOffloadEntry True if the outlined function is an offload entry.
1575  /// \param CodeGen Code generation sequence for the \a D directive.
1576  /// An outlined function may not be an entry if, e.g. the if clause always
1577  /// evaluates to false.
1578  virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
1579  StringRef ParentName,
1580  llvm::Function *&OutlinedFn,
1581  llvm::Constant *&OutlinedFnID,
1582  bool IsOffloadEntry,
1583  const RegionCodeGenTy &CodeGen);
1584 
1585  /// Emit the target offloading code associated with \a D. The emitted
1586  /// code attempts offloading the execution to the device, an the event of
1587  /// a failure it executes the host version outlined in \a OutlinedFn.
1588  /// \param D Directive to emit.
1589  /// \param OutlinedFn Host version of the code to be offloaded.
1590  /// \param OutlinedFnID ID of host version of the code to be offloaded.
1591  /// \param IfCond Expression evaluated in if clause associated with the target
1592  /// directive, or null if no if clause is used.
1593  /// \param Device Expression evaluated in device clause associated with the
1594  /// target directive, or null if no device clause is used and device modifier.
1595  /// \param SizeEmitter Callback to emit number of iterations for loop-based
1596  /// directives.
1597  virtual void emitTargetCall(
1598  CodeGenFunction &CGF, const OMPExecutableDirective &D,
1599  llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
1600  llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
1601  llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
1602  const OMPLoopDirective &D)>
1603  SizeEmitter);
1604 
1605  /// Emit the target regions enclosed in \a GD function definition or
1606  /// the function itself in case it is a valid device function. Returns true if
1607  /// \a GD was dealt with successfully.
1608  /// \param GD Function to scan.
1609  virtual bool emitTargetFunctions(GlobalDecl GD);
1610 
1611  /// Emit the global variable if it is a valid device global variable.
1612  /// Returns true if \a GD was dealt with successfully.
1613  /// \param GD Variable declaration to emit.
1614  virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1615 
1616  /// Checks if the provided global decl \a GD is a declare target variable and
1617  /// registers it when emitting code for the host.
1618  virtual void registerTargetGlobalVariable(const VarDecl *VD,
1619  llvm::Constant *Addr);
1620 
1621  /// Emit the global \a GD if it is meaningful for the target. Returns
1622  /// if it was emitted successfully.
1623  /// \param GD Global to scan.
1624  virtual bool emitTargetGlobal(GlobalDecl GD);
1625 
1626  /// Creates and returns a registration function for when at least one
1627  /// requires directives was used in the current module.
1628  llvm::Function *emitRequiresDirectiveRegFun();
1629 
1630  /// Creates all the offload entries in the current compilation unit
1631  /// along with the associated metadata.
1633 
1634  /// Emits code for teams call of the \a OutlinedFn with
1635  /// variables captured in a record which address is stored in \a
1636  /// CapturedStruct.
1637  /// \param OutlinedFn Outlined function to be run by team masters. Type of
1638  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1639  /// \param CapturedVars A pointer to the record with the references to
1640  /// variables used in \a OutlinedFn function.
1641  ///
1642  virtual void emitTeamsCall(CodeGenFunction &CGF,
1643  const OMPExecutableDirective &D,
1644  SourceLocation Loc, llvm::Function *OutlinedFn,
1645  ArrayRef<llvm::Value *> CapturedVars);
1646 
1647  /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1648  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1649  /// for num_teams clause.
1650  /// \param NumTeams An integer expression of teams.
1651  /// \param ThreadLimit An integer expression of threads.
1652  virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1653  const Expr *ThreadLimit, SourceLocation Loc);
1654 
1655  /// Struct that keeps all the relevant information that should be kept
1656  /// throughout a 'target data' region.
1658  /// Set to true if device pointer information have to be obtained.
1659  bool RequiresDevicePointerInfo = false;
1660  /// Set to true if Clang emits separate runtime calls for the beginning and
1661  /// end of the region. These calls might have separate map type arrays.
1662  bool SeparateBeginEndCalls = false;
1663 
1664  public:
1665  /// The array of base pointer passed to the runtime library.
1666  llvm::Value *BasePointersArray = nullptr;
1667  /// The array of section pointers passed to the runtime library.
1668  llvm::Value *PointersArray = nullptr;
1669  /// The array of sizes passed to the runtime library.
1670  llvm::Value *SizesArray = nullptr;
1671  /// The array of map types passed to the runtime library for the beginning
1672  /// of the region or for the entire region if there are no separate map
1673  /// types for the region end.
1674  llvm::Value *MapTypesArray = nullptr;
1675  /// The array of map types passed to the runtime library for the end of the
1676  /// region, or nullptr if there are no separate map types for the region
1677  /// end.
1678  llvm::Value *MapTypesArrayEnd = nullptr;
1679  /// The array of user-defined mappers passed to the runtime library.
1680  llvm::Value *MappersArray = nullptr;
1681  /// The array of original declaration names of mapped pointers sent to the
1682  /// runtime library for debugging
1683  llvm::Value *MapNamesArray = nullptr;
1684  /// Indicate whether any user-defined mapper exists.
1685  bool HasMapper = false;
1686  /// The total number of pointers passed to the runtime library.
1687  unsigned NumberOfPtrs = 0u;
1688  /// Map between the a declaration of a capture and the corresponding base
1689  /// pointer address where the runtime returns the device pointers.
1690  llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1691 
1692  explicit TargetDataInfo() {}
1693  explicit TargetDataInfo(bool RequiresDevicePointerInfo,
1694  bool SeparateBeginEndCalls)
1695  : RequiresDevicePointerInfo(RequiresDevicePointerInfo),
1696  SeparateBeginEndCalls(SeparateBeginEndCalls) {}
1697  /// Clear information about the data arrays.
1699  BasePointersArray = nullptr;
1700  PointersArray = nullptr;
1701  SizesArray = nullptr;
1702  MapTypesArray = nullptr;
1703  MapTypesArrayEnd = nullptr;
1704  MapNamesArray = nullptr;
1705  MappersArray = nullptr;
1706  HasMapper = false;
1707  NumberOfPtrs = 0u;
1708  }
1709  /// Return true if the current target data information has valid arrays.
1710  bool isValid() {
1713  }
1714  bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
1715  bool separateBeginEndCalls() { return SeparateBeginEndCalls; }
1716  };
1717 
1718  /// Emit the target data mapping code associated with \a D.
1719  /// \param D Directive to emit.
1720  /// \param IfCond Expression evaluated in if clause associated with the
1721  /// target directive, or null if no device clause is used.
1722  /// \param Device Expression evaluated in device clause associated with the
1723  /// target directive, or null if no device clause is used.
1724  /// \param Info A record used to store information that needs to be preserved
1725  /// until the region is closed.
1726  virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1727  const OMPExecutableDirective &D,
1728  const Expr *IfCond, const Expr *Device,
1729  const RegionCodeGenTy &CodeGen,
1730  TargetDataInfo &Info);
1731 
1732  /// Emit the data mapping/movement code associated with the directive
1733  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1734  /// \param D Directive to emit.
1735  /// \param IfCond Expression evaluated in if clause associated with the target
1736  /// directive, or null if no if clause is used.
1737  /// \param Device Expression evaluated in device clause associated with the
1738  /// target directive, or null if no device clause is used.
1740  const OMPExecutableDirective &D,
1741  const Expr *IfCond,
1742  const Expr *Device);
1743 
1744  /// Marks function \a Fn with properly mangled versions of vector functions.
1745  /// \param FD Function marked as 'declare simd'.
1746  /// \param Fn LLVM function that must be marked with 'declare simd'
1747  /// attributes.
1748  virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1749  llvm::Function *Fn);
1750 
1751  /// Emit initialization for doacross loop nesting support.
1752  /// \param D Loop-based construct used in doacross nesting construct.
1753  virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
1754  ArrayRef<Expr *> NumIterations);
1755 
1756  /// Emit code for doacross ordered directive with 'depend' clause.
1757  /// \param C 'depend' clause with 'sink|source' dependency kind.
1758  virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1759  const OMPDependClause *C);
1760 
1761  /// Translates the native parameter of outlined function if this is required
1762  /// for target.
1763  /// \param FD Field decl from captured record for the parameter.
1764  /// \param NativeParam Parameter itself.
1765  virtual const VarDecl *translateParameter(const FieldDecl *FD,
1766  const VarDecl *NativeParam) const {
1767  return NativeParam;
1768  }
1769 
1770  /// Gets the address of the native argument basing on the address of the
1771  /// target-specific parameter.
1772  /// \param NativeParam Parameter itself.
1773  /// \param TargetParam Corresponding target-specific parameter.
1775  const VarDecl *NativeParam,
1776  const VarDecl *TargetParam) const;
1777 
1778  /// Choose default schedule type and chunk value for the
1779  /// dist_schedule clause.
1781  const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1782  llvm::Value *&Chunk) const {}
1783 
1784  /// Choose default schedule type and chunk value for the
1785  /// schedule clause.
1786  virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF,
1787  const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1788  const Expr *&ChunkExpr) const;
1789 
1790  /// Emits call of the outlined function with the provided arguments,
1791  /// translating these arguments to correct target-specific arguments.
1792  virtual void
1794  llvm::FunctionCallee OutlinedFn,
1795  ArrayRef<llvm::Value *> Args = llvm::None) const;
1796 
1797  /// Emits OpenMP-specific function prolog.
1798  /// Required for device constructs.
1799  virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D);
1800 
1801  /// Gets the OpenMP-specific address of the local variable.
1803  const VarDecl *VD);
1804 
1805  /// Marks the declaration as already emitted for the device code and returns
1806  /// true, if it was marked already, and false, otherwise.
1807  bool markAsGlobalTarget(GlobalDecl GD);
1808 
1809  /// Emit deferred declare target variables marked for deferred emission.
1810  void emitDeferredTargetDecls() const;
1811 
1812  /// Adjust some parameters for the target-based directives, like addresses of
1813  /// the variables captured by reference in lambdas.
1814  virtual void
1816  const OMPExecutableDirective &D) const;
1817 
1818  /// Perform check on requires decl to ensure that target architecture
1819  /// supports unified addressing
1820  virtual void processRequiresDirective(const OMPRequiresDecl *D);
1821 
1822  /// Gets default memory ordering as specified in requires directive.
1823  llvm::AtomicOrdering getDefaultMemoryOrdering() const;
1824 
1825  /// Checks if the variable has associated OMPAllocateDeclAttr attribute with
1826  /// the predefined allocator and translates it into the corresponding address
1827  /// space.
1828  virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS);
1829 
1830  /// Return whether the unified_shared_memory has been specified.
1831  bool hasRequiresUnifiedSharedMemory() const;
1832 
1833  /// Checks if the \p VD variable is marked as nontemporal declaration in
1834  /// current context.
1835  bool isNontemporalDecl(const ValueDecl *VD) const;
1836 
1837  /// Create specialized alloca to handle lastprivate conditionals.
1839  const VarDecl *VD);
1840 
1841  /// Checks if the provided \p LVal is lastprivate conditional and emits the
1842  /// code to update the value of the original variable.
1843  /// \code
1844  /// lastprivate(conditional: a)
1845  /// ...
1846  /// <type> a;
1847  /// lp_a = ...;
1848  /// #pragma omp critical(a)
1849  /// if (last_iv_a <= iv) {
1850  /// last_iv_a = iv;
1851  /// global_a = lp_a;
1852  /// }
1853  /// \endcode
1855  const Expr *LHS);
1856 
1857  /// Checks if the lastprivate conditional was updated in inner region and
1858  /// writes the value.
1859  /// \code
1860  /// lastprivate(conditional: a)
1861  /// ...
1862  /// <type> a;bool Fired = false;
1863  /// #pragma omp ... shared(a)
1864  /// {
1865  /// lp_a = ...;
1866  /// Fired = true;
1867  /// }
1868  /// if (Fired) {
1869  /// #pragma omp critical(a)
1870  /// if (last_iv_a <= iv) {
1871  /// last_iv_a = iv;
1872  /// global_a = lp_a;
1873  /// }
1874  /// Fired = false;
1875  /// }
1876  /// \endcode
1878  CodeGenFunction &CGF, const OMPExecutableDirective &D,
1879  const llvm::DenseSet<CanonicalDeclPtr<const VarDecl>> &IgnoredDecls);
1880 
1881  /// Gets the address of the global copy used for lastprivate conditional
1882  /// update, if any.
1883  /// \param PrivLVal LValue for the private copy.
1884  /// \param VD Original lastprivate declaration.
1886  LValue PrivLVal,
1887  const VarDecl *VD,
1888  SourceLocation Loc);
1889 
1890  /// Emits list of dependecies based on the provided data (array of
1891  /// dependence/expression pairs).
1892  /// \returns Pointer to the first element of the array casted to VoidPtr type.
1893  std::pair<llvm::Value *, Address>
1896  SourceLocation Loc);
1897 
1898  /// Emits list of dependecies based on the provided data (array of
1899  /// dependence/expression pairs) for depobj construct. In this case, the
1900  /// variable is allocated in dynamically. \returns Pointer to the first
1901  /// element of the array casted to VoidPtr type.
1903  const OMPTaskDataTy::DependData &Dependencies,
1904  SourceLocation Loc);
1905 
1906  /// Emits the code to destroy the dependency object provided in depobj
1907  /// directive.
1908  void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal,
1909  SourceLocation Loc);
1910 
1911  /// Updates the dependency kind in the specified depobj object.
1912  /// \param DepobjLVal LValue for the main depobj object.
1913  /// \param NewDepKind New dependency kind.
1914  void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal,
1915  OpenMPDependClauseKind NewDepKind, SourceLocation Loc);
1916 
1917  /// Initializes user defined allocators specified in the uses_allocators
1918  /// clauses.
1919  void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator,
1920  const Expr *AllocatorTraits);
1921 
1922  /// Destroys user defined allocators specified in the uses_allocators clause.
1923  void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator);
1924 
1925  /// Returns true if the variable is a local variable in untied task.
1926  bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const;
1927 };
1928 
1929 /// Class supports emissionof SIMD-only code.
1930 class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime {
1931 public:
1933  ~CGOpenMPSIMDRuntime() override {}
1934 
1935  /// Emits outlined function for the specified OpenMP parallel directive
1936  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1937  /// kmp_int32 BoundID, struct context_vars*).
1938  /// \param D OpenMP directive.
1939  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1940  /// \param InnermostKind Kind of innermost directive (for simple directives it
1941  /// is a directive itself, for combined - its innermost directive).
1942  /// \param CodeGen Code generation sequence for the \a D directive.
1943  llvm::Function *
1945  const VarDecl *ThreadIDVar,
1946  OpenMPDirectiveKind InnermostKind,
1947  const RegionCodeGenTy &CodeGen) override;
1948 
1949  /// Emits outlined function for the specified OpenMP teams directive
1950  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1951  /// kmp_int32 BoundID, struct context_vars*).
1952  /// \param D OpenMP directive.
1953  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1954  /// \param InnermostKind Kind of innermost directive (for simple directives it
1955  /// is a directive itself, for combined - its innermost directive).
1956  /// \param CodeGen Code generation sequence for the \a D directive.
1957  llvm::Function *
1959  const VarDecl *ThreadIDVar,
1960  OpenMPDirectiveKind InnermostKind,
1961  const RegionCodeGenTy &CodeGen) override;
1962 
1963  /// Emits outlined function for the OpenMP task directive \a D. This
1964  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1965  /// TaskT).
1966  /// \param D OpenMP directive.
1967  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1968  /// \param PartIDVar Variable for partition id in the current OpenMP untied
1969  /// task region.
1970  /// \param TaskTVar Variable for task_t argument.
1971  /// \param InnermostKind Kind of innermost directive (for simple directives it
1972  /// is a directive itself, for combined - its innermost directive).
1973  /// \param CodeGen Code generation sequence for the \a D directive.
1974  /// \param Tied true if task is generated for tied task, false otherwise.
1975  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1976  /// tasks.
1977  ///
1978  llvm::Function *emitTaskOutlinedFunction(
1979  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
1980  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
1981  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1982  bool Tied, unsigned &NumberOfParts) override;
1983 
1984  /// Emits code for parallel or serial call of the \a OutlinedFn with
1985  /// variables captured in a record which address is stored in \a
1986  /// CapturedStruct.
1987  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1988  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1989  /// \param CapturedVars A pointer to the record with the references to
1990  /// variables used in \a OutlinedFn function.
1991  /// \param IfCond Condition in the associated 'if' clause, if it was
1992  /// specified, nullptr otherwise.
1993  /// \param NumThreads The value corresponding to the num_threads clause, if
1994  /// any, or nullptr.
1995  ///
1997  llvm::Function *OutlinedFn,
1998  ArrayRef<llvm::Value *> CapturedVars,
1999  const Expr *IfCond, llvm::Value *NumThreads) override;
2000 
2001  /// Emits a critical region.
2002  /// \param CriticalName Name of the critical region.
2003  /// \param CriticalOpGen Generator for the statement associated with the given
2004  /// critical region.
2005  /// \param Hint Value of the 'hint' clause (optional).
2006  void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
2007  const RegionCodeGenTy &CriticalOpGen,
2008  SourceLocation Loc,
2009  const Expr *Hint = nullptr) override;
2010 
2011  /// Emits a master region.
2012  /// \param MasterOpGen Generator for the statement associated with the given
2013  /// master region.
2015  const RegionCodeGenTy &MasterOpGen,
2016  SourceLocation Loc) override;
2017 
2018  /// Emits a masked region.
2019  /// \param MaskedOpGen Generator for the statement associated with the given
2020  /// masked region.
2022  const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc,
2023  const Expr *Filter = nullptr) override;
2024 
2025  /// Emits a masked region.
2026  /// \param MaskedOpGen Generator for the statement associated with the given
2027  /// masked region.
2028 
2029  /// Emits code for a taskyield directive.
2030  void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
2031 
2032  /// Emit a taskgroup region.
2033  /// \param TaskgroupOpGen Generator for the statement associated with the
2034  /// given taskgroup region.
2036  const RegionCodeGenTy &TaskgroupOpGen,
2037  SourceLocation Loc) override;
2038 
2039  /// Emits a single region.
2040  /// \param SingleOpGen Generator for the statement associated with the given
2041  /// single region.
2043  const RegionCodeGenTy &SingleOpGen, SourceLocation Loc,
2044  ArrayRef<const Expr *> CopyprivateVars,
2045  ArrayRef<const Expr *> DestExprs,
2046  ArrayRef<const Expr *> SrcExprs,
2047  ArrayRef<const Expr *> AssignmentOps) override;
2048 
2049  /// Emit an ordered region.
2050  /// \param OrderedOpGen Generator for the statement associated with the given
2051  /// ordered region.
2053  const RegionCodeGenTy &OrderedOpGen,
2054  SourceLocation Loc, bool IsThreads) override;
2055 
2056  /// Emit an implicit/explicit barrier for OpenMP threads.
2057  /// \param Kind Directive for which this implicit barrier call must be
2058  /// generated. Must be OMPD_barrier for explicit barrier generation.
2059  /// \param EmitChecks true if need to emit checks for cancellation barriers.
2060  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
2061  /// runtime class decides which one to emit (simple or with cancellation
2062  /// checks).
2063  ///
2065  OpenMPDirectiveKind Kind, bool EmitChecks = true,
2066  bool ForceSimpleCall = false) override;
2067 
2068  /// This is used for non static scheduled types and when the ordered
2069  /// clause is present on the loop construct.
2070  /// Depending on the loop schedule, it is necessary to call some runtime
2071  /// routine before start of the OpenMP loop to get the loop upper / lower
2072  /// bounds \a LB and \a UB and stride \a ST.
2073  ///
2074  /// \param CGF Reference to current CodeGenFunction.
2075  /// \param Loc Clang source location.
2076  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
2077  /// \param IVSize Size of the iteration variable in bits.
2078  /// \param IVSigned Sign of the iteration variable.
2079  /// \param Ordered true if loop is ordered, false otherwise.
2080  /// \param DispatchValues struct containing llvm values for lower bound, upper
2081  /// bound, and chunk expression.
2082  /// For the default (nullptr) value, the chunk 1 will be used.
2083  ///
2085  const OpenMPScheduleTy &ScheduleKind,
2086  unsigned IVSize, bool IVSigned, bool Ordered,
2087  const DispatchRTInput &DispatchValues) override;
2088 
2089  /// Call the appropriate runtime routine to initialize it before start
2090  /// of loop.
2091  ///
2092  /// This is used only in case of static schedule, when the user did not
2093  /// specify a ordered clause on the loop construct.
2094  /// Depending on the loop schedule, it is necessary to call some runtime
2095  /// routine before start of the OpenMP loop to get the loop upper / lower
2096  /// bounds LB and UB and stride ST.
2097  ///
2098  /// \param CGF Reference to current CodeGenFunction.
2099  /// \param Loc Clang source location.
2100  /// \param DKind Kind of the directive.
2101  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
2102  /// \param Values Input arguments for the construct.
2103  ///
2105  OpenMPDirectiveKind DKind,
2106  const OpenMPScheduleTy &ScheduleKind,
2107  const StaticRTInput &Values) override;
2108 
2109  ///
2110  /// \param CGF Reference to current CodeGenFunction.
2111  /// \param Loc Clang source location.
2112  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
2113  /// \param Values Input arguments for the construct.
2114  ///
2116  OpenMPDistScheduleClauseKind SchedKind,
2117  const StaticRTInput &Values) override;
2118 
2119  /// Call the appropriate runtime routine to notify that we finished
2120  /// iteration of the ordered loop with the dynamic scheduling.
2121  ///
2122  /// \param CGF Reference to current CodeGenFunction.
2123  /// \param Loc Clang source location.
2124  /// \param IVSize Size of the iteration variable in bits.
2125  /// \param IVSigned Sign of the iteration variable.
2126  ///
2128  unsigned IVSize, bool IVSigned) override;
2129 
2130  /// Call the appropriate runtime routine to notify that we finished
2131  /// all the work with current loop.
2132  ///
2133  /// \param CGF Reference to current CodeGenFunction.
2134  /// \param Loc Clang source location.
2135  /// \param DKind Kind of the directive for which the static finish is emitted.
2136  ///
2138  OpenMPDirectiveKind DKind) override;
2139 
2140  /// Call __kmpc_dispatch_next(
2141  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
2142  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
2143  /// kmp_int[32|64] *p_stride);
2144  /// \param IVSize Size of the iteration variable in bits.
2145  /// \param IVSigned Sign of the iteration variable.
2146  /// \param IL Address of the output variable in which the flag of the
2147  /// last iteration is returned.
2148  /// \param LB Address of the output variable in which the lower iteration
2149  /// number is returned.
2150  /// \param UB Address of the output variable in which the upper iteration
2151  /// number is returned.
2152  /// \param ST Address of the output variable in which the stride value is
2153  /// returned.
2154  llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
2155  unsigned IVSize, bool IVSigned, Address IL,
2156  Address LB, Address UB, Address ST) override;
2157 
2158  /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
2159  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
2160  /// clause.
2161  /// \param NumThreads An integer value of threads.
2162  void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads,
2163  SourceLocation Loc) override;
2164 
2165  /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
2166  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
2168  llvm::omp::ProcBindKind ProcBind,
2169  SourceLocation Loc) override;
2170 
2171  /// Returns address of the threadprivate variable for the current
2172  /// thread.
2173  /// \param VD Threadprivate variable.
2174  /// \param VDAddr Address of the global variable \a VD.
2175  /// \param Loc Location of the reference to threadprivate var.
2176  /// \return Address of the threadprivate variable for the current thread.
2178  Address VDAddr, SourceLocation Loc) override;
2179 
2180  /// Emit a code for initialization of threadprivate variable. It emits
2181  /// a call to runtime library which adds initial value to the newly created
2182  /// threadprivate variable (if it is not constant) and registers destructor
2183  /// for the variable (if any).
2184  /// \param VD Threadprivate variable.
2185  /// \param VDAddr Address of the global variable \a VD.
2186  /// \param Loc Location of threadprivate declaration.
2187  /// \param PerformInit true if initialization expression is not constant.
2188  llvm::Function *
2190  SourceLocation Loc, bool PerformInit,
2191  CodeGenFunction *CGF = nullptr) override;
2192 
2193  /// Creates artificial threadprivate variable with name \p Name and type \p
2194  /// VarType.
2195  /// \param VarType Type of the artificial threadprivate variable.
2196  /// \param Name Name of the artificial threadprivate variable.
2198  QualType VarType,
2199  StringRef Name) override;
2200 
2201  /// Emit flush of the variables specified in 'omp flush' directive.
2202  /// \param Vars List of variables to flush.
2204  SourceLocation Loc, llvm::AtomicOrdering AO) override;
2205 
2206  /// Emit task region for the task directive. The task region is
2207  /// emitted in several steps:
2208  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
2209  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
2210  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
2211  /// function:
2212  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
2213  /// TaskFunction(gtid, tt->part_id, tt->shareds);
2214  /// return 0;
2215  /// }
2216  /// 2. Copy a list of shared variables to field shareds of the resulting
2217  /// structure kmp_task_t returned by the previous call (if any).
2218  /// 3. Copy a pointer to destructions function to field destructions of the
2219  /// resulting structure kmp_task_t.
2220  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
2221  /// kmp_task_t *new_task), where new_task is a resulting structure from
2222  /// previous items.
2223  /// \param D Current task directive.
2224  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
2225  /// /*part_id*/, captured_struct */*__context*/);
2226  /// \param SharedsTy A type which contains references the shared variables.
2227  /// \param Shareds Context with the list of shared variables from the \p
2228  /// TaskFunction.
2229  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
2230  /// otherwise.
2231  /// \param Data Additional data for task generation like tiednsee, final
2232  /// state, list of privates etc.
2234  const OMPExecutableDirective &D,
2235  llvm::Function *TaskFunction, QualType SharedsTy,
2236  Address Shareds, const Expr *IfCond,
2237  const OMPTaskDataTy &Data) override;
2238 
2239  /// Emit task region for the taskloop directive. The taskloop region is
2240  /// emitted in several steps:
2241  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
2242  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
2243  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
2244  /// function:
2245  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
2246  /// TaskFunction(gtid, tt->part_id, tt->shareds);
2247  /// return 0;
2248  /// }
2249  /// 2. Copy a list of shared variables to field shareds of the resulting
2250  /// structure kmp_task_t returned by the previous call (if any).
2251  /// 3. Copy a pointer to destructions function to field destructions of the
2252  /// resulting structure kmp_task_t.
2253  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
2254  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
2255  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
2256  /// is a resulting structure from
2257  /// previous items.
2258  /// \param D Current task directive.
2259  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
2260  /// /*part_id*/, captured_struct */*__context*/);
2261  /// \param SharedsTy A type which contains references the shared variables.
2262  /// \param Shareds Context with the list of shared variables from the \p
2263  /// TaskFunction.
2264  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
2265  /// otherwise.
2266  /// \param Data Additional data for task generation like tiednsee, final
2267  /// state, list of privates etc.
2269  const OMPLoopDirective &D, llvm::Function *TaskFunction,
2270  QualType SharedsTy, Address Shareds, const Expr *IfCond,
2271  const OMPTaskDataTy &Data) override;
2272 
2273  /// Emit a code for reduction clause. Next code should be emitted for
2274  /// reduction:
2275  /// \code
2276  ///
2277  /// static kmp_critical_name lock = { 0 };
2278  ///
2279  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
2280  /// ...
2281  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
2282  /// ...
2283  /// }
2284  ///
2285  /// ...
2286  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
2287  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
2288  /// RedList, reduce_func, &<lock>)) {
2289  /// case 1:
2290  /// ...
2291  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
2292  /// ...
2293  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
2294  /// break;
2295  /// case 2:
2296  /// ...
2297  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
2298  /// ...
2299  /// break;
2300  /// default:;
2301  /// }
2302  /// \endcode
2303  ///
2304  /// \param Privates List of private copies for original reduction arguments.
2305  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
2306  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
2307  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
2308  /// or 'operator binop(LHS, RHS)'.
2309  /// \param Options List of options for reduction codegen:
2310  /// WithNowait true if parent directive has also nowait clause, false
2311  /// otherwise.
2312  /// SimpleReduction Emit reduction operation only. Used for omp simd
2313  /// directive on the host.
2314  /// ReductionKind The kind of reduction to perform.
2316  ArrayRef<const Expr *> Privates,
2317  ArrayRef<const Expr *> LHSExprs,
2318  ArrayRef<const Expr *> RHSExprs,
2319  ArrayRef<const Expr *> ReductionOps,
2320  ReductionOptionsTy Options) override;
2321 
2322  /// Emit a code for initialization of task reduction clause. Next code
2323  /// should be emitted for reduction:
2324  /// \code
2325  ///
2326  /// _taskred_item_t red_data[n];
2327  /// ...
2328  /// red_data[i].shar = &shareds[i];
2329  /// red_data[i].orig = &origs[i];
2330  /// red_data[i].size = sizeof(origs[i]);
2331  /// red_data[i].f_init = (void*)RedInit<i>;
2332  /// red_data[i].f_fini = (void*)RedDest<i>;
2333  /// red_data[i].f_comb = (void*)RedOp<i>;
2334  /// red_data[i].flags = <Flag_i>;
2335  /// ...
2336  /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
2337  /// \endcode
2338  /// For reduction clause with task modifier it emits the next call:
2339  /// \code
2340  ///
2341  /// _taskred_item_t red_data[n];
2342  /// ...
2343  /// red_data[i].shar = &shareds[i];
2344  /// red_data[i].orig = &origs[i];
2345  /// red_data[i].size = sizeof(origs[i]);
2346  /// red_data[i].f_init = (void*)RedInit<i>;
2347  /// red_data[i].f_fini = (void*)RedDest<i>;
2348  /// red_data[i].f_comb = (void*)RedOp<i>;
2349  /// red_data[i].flags = <Flag_i>;
2350  /// ...
2351  /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
2352  /// red_data);
2353  /// \endcode
2354  /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
2355  /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
2356  /// \param Data Additional data for task generation like tiedness, final
2357  /// state, list of privates, reductions etc.
2358  llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc,
2359  ArrayRef<const Expr *> LHSExprs,
2360  ArrayRef<const Expr *> RHSExprs,
2361  const OMPTaskDataTy &Data) override;
2362 
2363  /// Emits the following code for reduction clause with task modifier:
2364  /// \code
2365  /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
2366  /// \endcode
2368  bool IsWorksharingReduction) override;
2369 
2370  /// Required to resolve existing problems in the runtime. Emits threadprivate
2371  /// variables to store the size of the VLAs/array sections for
2372  /// initializer/combiner/finalizer functions + emits threadprivate variable to
2373  /// store the pointer to the original reduction item for the custom
2374  /// initializer defined by declare reduction construct.
2375  /// \param RCG Allows to reuse an existing data for the reductions.
2376  /// \param N Reduction item for which fixups must be emitted.
2378  ReductionCodeGen &RCG, unsigned N) override;
2379 
2380  /// Get the address of `void *` type of the privatue copy of the reduction
2381  /// item specified by the \p SharedLVal.
2382  /// \param ReductionsPtr Pointer to the reduction data returned by the
2383  /// emitTaskReductionInit function.
2384  /// \param SharedLVal Address of the original reduction item.
2386  llvm::Value *ReductionsPtr,
2387  LValue SharedLVal) override;
2388 
2389  /// Emit code for 'taskwait' directive.
2391  const OMPTaskDataTy &Data) override;
2392 
2393  /// Emit code for 'cancellation point' construct.
2394  /// \param CancelRegion Region kind for which the cancellation point must be
2395  /// emitted.
2396  ///
2398  OpenMPDirectiveKind CancelRegion) override;
2399 
2400  /// Emit code for 'cancel' construct.
2401  /// \param IfCond Condition in the associated 'if' clause, if it was
2402  /// specified, nullptr otherwise.
2403  /// \param CancelRegion Region kind for which the cancel must be emitted.
2404  ///
2406  const Expr *IfCond,
2407  OpenMPDirectiveKind CancelRegion) override;
2408 
2409  /// Emit outilined function for 'target' directive.
2410  /// \param D Directive to emit.
2411  /// \param ParentName Name of the function that encloses the target region.
2412  /// \param OutlinedFn Outlined function value to be defined by this call.
2413  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2414  /// \param IsOffloadEntry True if the outlined function is an offload entry.
2415  /// \param CodeGen Code generation sequence for the \a D directive.
2416  /// An outlined function may not be an entry if, e.g. the if clause always
2417  /// evaluates to false.
2419  StringRef ParentName,
2420  llvm::Function *&OutlinedFn,
2421  llvm::Constant *&OutlinedFnID,
2422  bool IsOffloadEntry,
2423  const RegionCodeGenTy &CodeGen) override;
2424 
2425  /// Emit the target offloading code associated with \a D. The emitted
2426  /// code attempts offloading the execution to the device, an the event of
2427  /// a failure it executes the host version outlined in \a OutlinedFn.
2428  /// \param D Directive to emit.
2429  /// \param OutlinedFn Host version of the code to be offloaded.
2430  /// \param OutlinedFnID ID of host version of the code to be offloaded.
2431  /// \param IfCond Expression evaluated in if clause associated with the target
2432  /// directive, or null if no if clause is used.
2433  /// \param Device Expression evaluated in device clause associated with the
2434  /// target directive, or null if no device clause is used and device modifier.
2435  void emitTargetCall(
2436  CodeGenFunction &CGF, const OMPExecutableDirective &D,
2437  llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
2438  llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
2439  llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
2440  const OMPLoopDirective &D)>
2441  SizeEmitter) override;
2442 
2443  /// Emit the target regions enclosed in \a GD function definition or
2444  /// the function itself in case it is a valid device function. Returns true if
2445  /// \a GD was dealt with successfully.
2446  /// \param GD Function to scan.
2447  bool emitTargetFunctions(GlobalDecl GD) override;
2448 
2449  /// Emit the global variable if it is a valid device global variable.
2450  /// Returns true if \a GD was dealt with successfully.
2451  /// \param GD Variable declaration to emit.
2452  bool emitTargetGlobalVariable(GlobalDecl GD) override;
2453 
2454  /// Emit the global \a GD if it is meaningful for the target. Returns
2455  /// if it was emitted successfully.
2456  /// \param GD Global to scan.
2457  bool emitTargetGlobal(GlobalDecl GD) override;
2458 
2459  /// Emits code for teams call of the \a OutlinedFn with
2460  /// variables captured in a record which address is stored in \a
2461  /// CapturedStruct.
2462  /// \param OutlinedFn Outlined function to be run by team masters. Type of
2463  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2464  /// \param CapturedVars A pointer to the record with the references to
2465  /// variables used in \a OutlinedFn function.
2466  ///
2468  SourceLocation Loc, llvm::Function *OutlinedFn,
2469  ArrayRef<llvm::Value *> CapturedVars) override;
2470 
2471  /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2472  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2473  /// for num_teams clause.
2474  /// \param NumTeams An integer expression of teams.
2475  /// \param ThreadLimit An integer expression of threads.
2476  void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2477  const Expr *ThreadLimit, SourceLocation Loc) override;
2478 
2479  /// Emit the target data mapping code associated with \a D.
2480  /// \param D Directive to emit.
2481  /// \param IfCond Expression evaluated in if clause associated with the
2482  /// target directive, or null if no device clause is used.
2483  /// \param Device Expression evaluated in device clause associated with the
2484  /// target directive, or null if no device clause is used.
2485  /// \param Info A record used to store information that needs to be preserved
2486  /// until the region is closed.
2488  const OMPExecutableDirective &D, const Expr *IfCond,
2489  const Expr *Device, const RegionCodeGenTy &CodeGen,
2490  TargetDataInfo &Info) override;
2491 
2492  /// Emit the data mapping/movement code associated with the directive
2493  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2494  /// \param D Directive to emit.
2495  /// \param IfCond Expression evaluated in if clause associated with the target
2496  /// directive, or null if no if clause is used.
2497  /// \param Device Expression evaluated in device clause associated with the
2498  /// target directive, or null if no device clause is used.
2500  const OMPExecutableDirective &D,
2501  const Expr *IfCond,
2502  const Expr *Device) override;
2503 
2504  /// Emit initialization for doacross loop nesting support.
2505  /// \param D Loop-based construct used in doacross nesting construct.
2507  ArrayRef<Expr *> NumIterations) override;
2508 
2509  /// Emit code for doacross ordered directive with 'depend' clause.
2510  /// \param C 'depend' clause with 'sink|source' dependency kind.
2512  const OMPDependClause *C) override;
2513 
2514  /// Translates the native parameter of outlined function if this is required
2515  /// for target.
2516  /// \param FD Field decl from captured record for the parameter.
2517  /// \param NativeParam Parameter itself.
2518  const VarDecl *translateParameter(const FieldDecl *FD,
2519  const VarDecl *NativeParam) const override;
2520 
2521  /// Gets the address of the native argument basing on the address of the
2522  /// target-specific parameter.
2523  /// \param NativeParam Parameter itself.
2524  /// \param TargetParam Corresponding target-specific parameter.
2525  Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2526  const VarDecl *TargetParam) const override;
2527 
2528  /// Gets the OpenMP-specific address of the local variable.
2530  const VarDecl *VD) override {
2531  return Address::invalid();
2532  }
2533 };
2534 
2535 } // namespace CodeGen
2536 } // namespace clang
2537 
2538 #endif
clang::CodeGen::OMPTaskDataTy::ReductionOps
SmallVector< const Expr *, 4 > ReductionOps
Definition: CGOpenMPRuntime.h:104
clang::CodeGen::OMPTaskDataTy::Reductions
llvm::Value * Reductions
Definition: CGOpenMPRuntime.h:118
clang::CodeGen::CGOpenMPRuntime::emitTaskLoopCall
virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the taskloop directive.
Definition: CGOpenMPRuntime.cpp:5131
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::OffloadEntryInfoDeviceGlobalVar
OffloadEntryInfoDeviceGlobalVar()
Definition: CGOpenMPRuntime.h:666
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::getLinkage
llvm::GlobalValue::LinkageTypes getLinkage() const
Definition: CGOpenMPRuntime.h:682
clang::CodeGen::CGOpenMPSIMDRuntime::emitCancelCall
void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancel' construct.
Definition: CGOpenMPRuntime.cpp:13026
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::BasePointersArray
llvm::Value * BasePointersArray
The array of base pointer passed to the runtime library.
Definition: CGOpenMPRuntime.h:1666
clang::CodeGen::CGOpenMPRuntime::emitTaskReductionFini
virtual void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction)
Emits the following code for reduction clause with task modifier:
Definition: CGOpenMPRuntime.cpp:6075
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::ST
Address ST
Address of the output variable in which the stride value is returned necessary to generated the stati...
Definition: CGOpenMPRuntime.h:1182
llvm
YAML serialization mapping.
Definition: Dominators.h:30
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskwaitCall
void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data) override
Emit code for 'taskwait' directive.
Definition: CGOpenMPRuntime.cpp:13014
clang::CodeGen::CGOpenMPRuntime::getThreadID
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
Definition: CGOpenMPRuntime.cpp:1394
clang::CodeGen::CGOpenMPRuntime::getAddressOfLocalVariable
virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)
Gets the OpenMP-specific address of the local variable.
Definition: CGOpenMPRuntime.cpp:12179
LT
ASTImporterLookupTable & LT
Definition: ASTImporterLookupTable.cpp:24
clang::CodeGen::OMPTaskDataTy::IsReductionWithTaskMod
bool IsReductionWithTaskMod
Definition: CGOpenMPRuntime.h:122
clang::CodeGen::CGOpenMPRuntime::emitLastprivateConditionalFinalUpdate
virtual void emitLastprivateConditionalFinalUpdate(CodeGenFunction &CGF, LValue PrivLVal, const VarDecl *VD, SourceLocation Loc)
Gets the address of the global copy used for lastprivate conditional update, if any.
Definition: CGOpenMPRuntime.cpp:12783
clang::CodeGen::CGOpenMPSIMDRuntime::translateParameter
const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const override
Translates the native parameter of outlined function if this is required for target.
Definition: CGOpenMPRuntime.cpp:13100
clang::CodeGen::CGOpenMPRuntime
Definition: CGOpenMPRuntime.h:228
clang::CodeGen::CGOpenMPSIMDRuntime::CGOpenMPSIMDRuntime
CGOpenMPSIMDRuntime(CodeGenModule &CGM)
Definition: CGOpenMPRuntime.h:1932
clang::CodeGen::CGOpenMPRuntime::checkAndEmitSharedLastprivateConditional
virtual void checkAndEmitSharedLastprivateConditional(CodeGenFunction &CGF, const OMPExecutableDirective &D, const llvm::DenseSet< CanonicalDeclPtr< const VarDecl >> &IgnoredDecls)
Checks if the lastprivate conditional was updated in inner region and writes the value.
Definition: CGOpenMPRuntime.cpp:12733
clang::CodeGen::OMPTaskDataTy::DependData::IteratorExpr
const Expr * IteratorExpr
Definition: CGOpenMPRuntime.h:108
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskCall
void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the task directive.
Definition: CGOpenMPRuntime.cpp:12963
clang::CodeGen::OMPTaskDataTy::LastprivateVars
SmallVector< const Expr *, 4 > LastprivateVars
Definition: CGOpenMPRuntime.h:99
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::PointersArray
llvm::Value * PointersArray
The array of section pointers passed to the runtime library.
Definition: CGOpenMPRuntime.h:1668
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalData
Maps the expression for the lastprivate variable to the global copy used to store new value because o...
Definition: CGOpenMPRuntime.h:270
clang::CodeGen::CGOpenMPRuntime::registerTargetGlobalVariable
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...
Definition: CGOpenMPRuntime.cpp:10763
clang::CodeGen::CGOpenMPRuntime::emitSingleReductionCombiner
void emitSingleReductionCombiner(CodeGenFunction &CGF, const Expr *ReductionOp, const Expr *PrivateRef, const DeclRefExpr *LHS, const DeclRefExpr *RHS)
Emits single reduction combiner.
Definition: CGOpenMPRuntime.cpp:5411
clang::CodeGen::ReductionCodeGen::adjustPrivateAddress
Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Adjusts PrivatedAddr for using instead of the original variable address in normal operations.
Definition: CGOpenMPRuntime.cpp:988
clang::CodeGen::CGOpenMPRuntime::emitForStaticFinish
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.
Definition: CGOpenMPRuntime.cpp:2823
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskLoopCall
void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the taskloop directive.
Definition: CGOpenMPRuntime.cpp:12972
clang::CodeGen::CGOpenMPRuntime::Separator
StringRef Separator
Definition: CGOpenMPRuntime.h:309
clang::CodeGen::OMPTaskDataTy::DependData
Definition: CGOpenMPRuntime.h:106
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::MappersArray
llvm::Value * MappersArray
The array of user-defined mappers passed to the runtime library.
Definition: CGOpenMPRuntime.h:1680
clang::CodeGen::CGOpenMPRuntime::getName
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Definition: CGOpenMPRuntime.cpp:1086
clang::CodeGen::CGOpenMPSIMDRuntime::emitForNext
llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST) override
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
Definition: CGOpenMPRuntime.cpp:12918
clang::CodeGen::CGOpenMPRuntime::emitParallelOutlinedFunction
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.
Definition: CGOpenMPRuntime.cpp:1269
clang::CodeGen::CGOpenMPRuntime::emitProcBindClause
virtual void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc)
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
Definition: CGOpenMPRuntime.cpp:2899
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetDataStandAloneCall
void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device) override
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
Definition: CGOpenMPRuntime.cpp:13082
clang::CodeGen::CGOpenMPSIMDRuntime::emitDoacrossInit
void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations) override
Emit initialization for doacross loop nesting support.
Definition: CGOpenMPRuntime.cpp:13088
clang::CodeGen::CGOpenMPRuntime::StaticRTInput
Struct with the values to be passed to the static runtime function.
Definition: CGOpenMPRuntime.h:1164
clang::CodeGen::CGOpenMPRuntime::clearLocThreadIdInsertPt
void clearLocThreadIdInsertPt(CodeGenFunction &CGF)
Definition: CGOpenMPRuntime.cpp:1348
clang::CodeGen::ReductionCodeGen
Class intended to support codegen of all kind of the reduction clauses.
Definition: CGOpenMPRuntime.h:127
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::isValid
bool isValid() const
Definition: CGOpenMPRuntime.h:552
llvm::SmallVector
Definition: LLVM.h:38
clang::CodeGen::CGOpenMPRuntime::getNumThreadsExprForTargetDirective
const Expr * getNumThreadsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &DefaultVal)
Emit the number of threads for a target directive.
Definition: CGOpenMPRuntime.cpp:6818
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskReductionFixups
void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N) override
Required to resolve existing problems in the runtime.
Definition: CGOpenMPRuntime.cpp:13000
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::~OffloadEntryInfo
~OffloadEntryInfo()=default
clang::CodeGen::CGOpenMPRuntime::CGOpenMPRuntime
CGOpenMPRuntime(CodeGenModule &CGM)
Definition: CGOpenMPRuntime.h:918
clang::CodeGen::CGOpenMPRuntime::emitParallelCall
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
Definition: CGOpenMPRuntime.cpp:2039
clang::OMPC_DEPEND_unknown
@ OMPC_DEPEND_unknown
Definition: OpenMPKinds.h:58
clang::CodeGen::CGOpenMPRuntime::setLocThreadIdInsertPt
void setLocThreadIdInsertPt(CodeGenFunction &CGF, bool AtCurrentPoint=false)
Definition: CGOpenMPRuntime.cpp:1332
clang::CodeGen::CGOpenMPRuntime::emitCancellationPointCall
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
Definition: CGOpenMPRuntime.cpp:6219
clang::CodeGen::CGOpenMPRuntime::getNumTeamsExprForTargetDirective
const Expr * getNumTeamsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &DefaultVal)
Emit the number of teams for a target directive.
Definition: CGOpenMPRuntime.cpp:6557
clang::CodeGen::CGOpenMPRuntime::getCriticalRegionLock
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
Definition: CGOpenMPRuntime.cpp:2154
clang::CodeGen::CGOpenMPSIMDRuntime::emitForDispatchInit
void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues) override
This is used for non static scheduled types and when the ordered clause is present on the loop constr...
Definition: CGOpenMPRuntime.cpp:12886
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:737
clang::CodeGen::CGOpenMPRuntime::ReductionOptionsTy::ReductionKind
OpenMPDirectiveKind ReductionKind
Definition: CGOpenMPRuntime.h:1431
clang::CodeGen::CGOpenMPRuntime::emitTaskyieldCall
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
Definition: CGOpenMPRuntime.cpp:2281
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::separateBeginEndCalls
bool separateBeginEndCalls()
Definition: CGOpenMPRuntime.h:1715
clang::CodeGen::CGOpenMPSIMDRuntime::emitProcBindClause
void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc) override
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
Definition: CGOpenMPRuntime.cpp:12932
clang::tooling::Filter
llvm::cl::opt< std::string > Filter
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2903
clang::CodeGen::CGOpenMPRuntime::OMPBuilder
llvm::OpenMPIRBuilder OMPBuilder
An OpenMP-IR-Builder instance.
Definition: CGOpenMPRuntime.h:312
clang::CodeGen::PrePostActionTy::Exit
virtual void Exit(CodeGenFunction &CGF)
Definition: CGOpenMPRuntime.h:62
clang::CodeGen::CGOpenMPRuntime::hasAllocateAttributeForGlobalVar
virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS)
Checks if the variable has associated OMPAllocateDeclAttr attribute with the predefined allocator and...
Definition: CGOpenMPRuntime.cpp:10905
clang::CodeGen::CGOpenMPRuntime::emitCriticalRegion
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
Definition: CGOpenMPRuntime.cpp:2199
clang::CodeGen::CGOpenMPRuntime::emitTargetOutlinedFunction
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for 'target' directive.
Definition: CGOpenMPRuntime.cpp:6333
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::UB
Address UB
Address of the output variable in which the upper iteration number is returned.
Definition: CGOpenMPRuntime.h:1179
clang::CodeGen::CGOpenMPRuntime::emitDepobjDependClause
Address emitDepobjDependClause(CodeGenFunction &CGF, const OMPTaskDataTy::DependData &Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs) for depob...
Definition: CGOpenMPRuntime.cpp:4854
clang::CodeGen::CGOpenMPRuntime::NontemporalDeclsRAII::NontemporalDeclsRAII
NontemporalDeclsRAII(CodeGenModule &CGM, const OMPLoopDirective &S)
Definition: CGOpenMPRuntime.cpp:12287
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetOutlinedFunction
void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) override
Emit outilined function for 'target' directive.
Definition: CGOpenMPRuntime.cpp:13032
DeclOpenMP.h
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalData::DeclToUniqueName
llvm::MapVector< CanonicalDeclPtr< const Decl >, SmallString< 16 > > DeclToUniqueName
Definition: CGOpenMPRuntime.h:272
clang::CodeGen::CGOpenMPRuntime::UntiedTaskLocalDeclsRAII::~UntiedTaskLocalDeclsRAII
~UntiedTaskLocalDeclsRAII()
Definition: CGOpenMPRuntime.cpp:12331
clang::CodeGen::CGOpenMPRuntime::emitRequiresDirectiveRegFun
llvm::Function * emitRequiresDirectiveRegFun()
Creates and returns a registration function for when at least one requires directives was used in the...
Definition: CGOpenMPRuntime.cpp:10968
clang::CodeGen::CGOpenMPRuntime::emitTaskReductionFixups
virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N)
Required to resolve existing problems in the runtime.
Definition: CGOpenMPRuntime.cpp:6093
clang::CodeGen::CGOpenMPRuntime::emitThreadIDAddress
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
Definition: CGOpenMPRuntime.cpp:2117
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion::setID
void setID(llvm::Constant *V)
Definition: CGOpenMPRuntime.h:617
clang::CodeGen::OMPTaskDataTy::Schedule
llvm::PointerIntPair< llvm::Value *, 1, bool > Schedule
Definition: CGOpenMPRuntime.h:116
clang::CodeGen::RegionCodeGenTy::operator()
void operator()(CodeGenFunction &CGF) const
Definition: CGOpenMPRuntime.cpp:596
clang::CodeGen::CGOpenMPRuntime::emitTargetFunctions
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
Definition: CGOpenMPRuntime.cpp:10699
clang::CodeGen::CGOpenMPSIMDRuntime::emitThreadPrivateVarDefinition
llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr) override
Emit a code for initialization of threadprivate variable.
Definition: CGOpenMPRuntime.cpp:12945
clang::CodeGen::CGOpenMPSIMDRuntime::emitCancellationPointCall
void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancellation point' construct.
Definition: CGOpenMPRuntime.cpp:13020
clang::CodeGen::CGOpenMPRuntime::emitBarrierCall
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
Definition: CGOpenMPRuntime.cpp:2536
clang::CodeGen::CGOpenMPRuntime::isDynamic
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
Definition: CGOpenMPRuntime.cpp:2641
clang::CodeGen::CGOpenMPSIMDRuntime::~CGOpenMPSIMDRuntime
~CGOpenMPSIMDRuntime() override
Definition: CGOpenMPRuntime.h:1933
clang::CodeGen::OMPTaskDataTy::Final
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
Definition: CGOpenMPRuntime.h:115
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalRAII::disable
static LastprivateConditionalRAII disable(CodeGenFunction &CGF, const OMPExecutableDirective &S)
Definition: CGOpenMPRuntime.cpp:12476
clang::CodeGen::CGOpenMPRuntime::getDefaultMemoryOrdering
llvm::AtomicOrdering getDefaultMemoryOrdering() const
Gets default memory ordering as specified in requires directive.
Definition: CGOpenMPRuntime.cpp:10901
clang::CodeGen::CGOpenMPRuntime::emitFlush
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO)
Emit flush of the variables specified in 'omp flush' directive.
Definition: CGOpenMPRuntime.cpp:2914
clang::CodeGen::CGOpenMPRuntime::~CGOpenMPRuntime
virtual ~CGOpenMPRuntime()
Definition: CGOpenMPRuntime.h:920
clang::CodeGen::CGOpenMPRuntime::emitForNext
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...
Definition: CGOpenMPRuntime.cpp:2861
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetGlobalVariable
bool emitTargetGlobalVariable(GlobalDecl GD) override
Emit the global variable if it is a valid device global variable.
Definition: CGOpenMPRuntime.cpp:13053
clang::CodeGen::CGOpenMPSIMDRuntime::getAddrOfThreadPrivate
Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc) override
Returns address of the threadprivate variable for the current thread.
Definition: CGOpenMPRuntime.cpp:12938
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::MapTypesArrayEnd
llvm::Value * MapTypesArrayEnd
The array of map types passed to the runtime library for the end of the region, or nullptr if there a...
Definition: CGOpenMPRuntime.h:1678
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadingEntryInfoKinds
OffloadingEntryInfoKinds
Kind of a given entry.
Definition: CGOpenMPRuntime.h:534
clang::CodeGen::CGOpenMPRuntime::emitCall
void emitCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args=llvm::None) const
Emits Callee function call with arguments Args with location Loc.
Definition: CGOpenMPRuntime.cpp:12116
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::setAddress
void setAddress(llvm::Constant *V)
Definition: CGOpenMPRuntime.h:560
clang::CodeGen::ReductionCodeGen::getSizes
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),...
Definition: CGOpenMPRuntime.h:211
clang::GlobalDecl
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::OffloadEntryInfoDeviceGlobalVar
OffloadEntryInfoDeviceGlobalVar(unsigned Order, OMPTargetGlobalVarEntryKind Flags)
Definition: CGOpenMPRuntime.h:668
uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:24
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo
Struct that keeps all the relevant information that should be kept throughout a 'target data' region.
Definition: CGOpenMPRuntime.h:1657
clang::CodeGen::CGOpenMPRuntime::emitFunctionProlog
virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D)
Emits OpenMP-specific function prolog.
Definition: CGOpenMPRuntime.cpp:12137
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::NumberOfPtrs
unsigned NumberOfPtrs
The total number of pointers passed to the runtime library.
Definition: CGOpenMPRuntime.h:1687
clang::CodeGen::OMPTaskDataTy::DependData::DependData
DependData()=default
clang::CodeGen::OMPTaskDataTy::Priority
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
Definition: CGOpenMPRuntime.h:117
clang::CodeGen::CGOpenMPRuntime::emitForDispatchInit
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.
Definition: CGOpenMPRuntime.cpp:2699
V
#define V(N, I)
Definition: ASTContext.h:3233
clang::CodeGen::CGOpenMPRuntime::emitForOrderedIterationEnd
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...
Definition: CGOpenMPRuntime.cpp:2850
clang::CodeGen::CGOpenMPRuntime::isStaticNonchunked
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
Definition: CGOpenMPRuntime.cpp:2615
clang::CodeGen::CGOpenMPRuntime::getOMPBuilder
llvm::OpenMPIRBuilder & getOMPBuilder()
Definition: CGOpenMPRuntime.h:305
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalData::Fn
llvm::Function * Fn
Definition: CGOpenMPRuntime.h:274
clang::CodeGen::CGOpenMPRuntime::emitTaskReductionInit
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.
Definition: CGOpenMPRuntime.cpp:5946
clang::CodeGen::OMPTaskDataTy::DependData::DependData
DependData(OpenMPDependClauseKind DepKind, const Expr *IteratorExpr)
Definition: CGOpenMPRuntime.h:111
clang::CodeGen::CGOpenMPRuntime::emitDestroyClause
void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal, SourceLocation Loc)
Emits the code to destroy the dependency object provided in depobj directive.
Definition: CGOpenMPRuntime.cpp:4939
clang::CodeGen::CGOpenMPSIMDRuntime::emitNumThreadsClause
void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc) override
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
Definition: CGOpenMPRuntime.cpp:12926
clang::CodeGen::CGOpenMPRuntime::emitTeamsCall
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...
Definition: CGOpenMPRuntime.cpp:11010
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetDataCalls
void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) override
Emit the target data mapping code associated with D.
Definition: CGOpenMPRuntime.cpp:13076
clang::OMPDeclareReductionDecl
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:171
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput
struct with the values to be passed to the dispatch runtime function
Definition: CGOpenMPRuntime.h:1126
clang::CodeGen::ReductionCodeGen::getBaseDecl
const VarDecl * getBaseDecl(unsigned N) const
Returns the base declaration of the reduction item.
Definition: CGOpenMPRuntime.h:215
clang::Linkage
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:23
clang::CodeGen::OMPTaskDataTy::Tied
bool Tied
Definition: CGOpenMPRuntime.h:120
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::TargetDataInfo
TargetDataInfo()
Definition: CGOpenMPRuntime.h:1692
clang::CodeGen::OMPTaskDataTy::Dependences
SmallVector< DependData, 4 > Dependences
Definition: CGOpenMPRuntime.h:114
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::getKind
OffloadingEntryInfoKinds getKind() const
Definition: CGOpenMPRuntime.h:554
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo
Base class of the entries info.
Definition: CGOpenMPRuntime.h:531
clang::CodeGen::CGOpenMPRuntime::emitDependClause
std::pair< llvm::Value *, Address > emitDependClause(CodeGenFunction &CGF, ArrayRef< OMPTaskDataTy::DependData > Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs).
Definition: CGOpenMPRuntime.cpp:4729
CGValue.h
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadingEntryInfoDeviceGlobalVar
@ OffloadingEntryInfoDeviceGlobalVar
Entry is a declare target variable.
Definition: CGOpenMPRuntime.h:538
clang::CodeGen::CGOpenMPRuntime::emitMaskedRegion
virtual void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr)
Emits a masked region.
Definition: CGOpenMPRuntime.cpp:2252
clang::OMPLoopDirective
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1002
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadEntryInfo
OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order, uint32_t Flags)
Definition: CGOpenMPRuntime.h:546
clang::CodeGen::CGOpenMPSIMDRuntime::emitSingleRegion
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) override
Emits a single region.
Definition: CGOpenMPRuntime.cpp:12863
clang::CodeGen::CGOpenMPSIMDRuntime::emitNumTeamsClause
void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams,...
Definition: CGOpenMPRuntime.cpp:13069
clang::CodeGen::OMPTaskDataTy::Nogroup
bool Nogroup
Definition: CGOpenMPRuntime.h:121
clang::CodeGen::CGOpenMPRuntime::hasRequiresUnifiedSharedMemory
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
Definition: CGOpenMPRuntime.cpp:10930
clang::CodeGen::OMPTaskDataTy::PrivateLocals
SmallVector< CanonicalDeclPtr< const VarDecl >, 4 > PrivateLocals
Definition: CGOpenMPRuntime.h:105
clang::CodeGen::ReductionCodeGen::emitInitialization
void emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr, Address SharedAddr, llvm::function_ref< bool(CodeGenFunction &)> DefaultInit)
Performs initialization of the private copy for the reduction item.
Definition: CGOpenMPRuntime.cpp:877
clang::CodeGen::CGOpenMPRuntime::emitTargetOutlinedFunctionHelper
virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Helper to emit outlined function for 'target' directive.
Definition: CGOpenMPRuntime.cpp:6405
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::getOrder
unsigned getOrder() const
Definition: CGOpenMPRuntime.h:553
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar
Device global variable entries info.
Definition: CGOpenMPRuntime.h:660
clang::CodeGen::CGOpenMPRuntime::getDefaultLocationReserved2Flags
virtual unsigned getDefaultLocationReserved2Flags() const
Returns additional flags that can be stored in reserved_2 field of the default location.
Definition: CGOpenMPRuntime.h:406
clang::CodeGen::CGOpenMPRuntime::emitForStaticInit
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.
Definition: CGOpenMPRuntime.cpp:2781
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalData::Disabled
bool Disabled
Definition: CGOpenMPRuntime.h:275
clang::CodeGen::CGOpenMPSIMDRuntime::getAddrOfArtificialThreadPrivate
Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name) override
Creates artificial threadprivate variable with name Name and type VarType.
Definition: CGOpenMPRuntime.cpp:12951
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::TargetDataInfo
TargetDataInfo(bool RequiresDevicePointerInfo, bool SeparateBeginEndCalls)
Definition: CGOpenMPRuntime.h:1693
clang::CodeGen::CGOpenMPRuntime::FirstSeparator
StringRef FirstSeparator
Definition: CGOpenMPRuntime.h:309
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetFunctions
bool emitTargetFunctions(GlobalDecl GD) override
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
Definition: CGOpenMPRuntime.cpp:13049
intptr_t
__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-base.h:133
clang::CodeGen::CGOpenMPRuntime::emitDoacrossInit
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations)
Emit initialization for doacross loop nesting support.
Definition: CGOpenMPRuntime.cpp:12012
OpenMPKinds.h
clang::CodeGen::ReductionCodeGen::ReductionCodeGen
ReductionCodeGen(ArrayRef< const Expr * > Shareds, ArrayRef< const Expr * > Origs, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > ReductionOps)
Definition: CGOpenMPRuntime.cpp:792
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::HasMapper
bool HasMapper
Indicate whether any user-defined mapper exists.
Definition: CGOpenMPRuntime.h:1685
clang::CodeGen::OMPTaskDataTy::DependData::DepExprs
SmallVector< const Expr *, 4 > DepExprs
Definition: CGOpenMPRuntime.h:109
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput::DispatchRTInput
DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
Definition: CGOpenMPRuntime.h:1135
clang::CodeGen::CGOpenMPSIMDRuntime::emitFlush
void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO) override
Emit flush of the variables specified in 'omp flush' directive.
Definition: CGOpenMPRuntime.cpp:12956
clang::CodeGen::ReductionCodeGen::emitAggregateType
void emitAggregateType(CodeGenFunction &CGF, unsigned N)
Emits the code for the variable-modified type, if required.
Definition: CGOpenMPRuntime.cpp:826
Type.h
clang::CodeGen::CGOpenMPSIMDRuntime::emitOrderedRegion
void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads) override
Emit an ordered region.
Definition: CGOpenMPRuntime.cpp:12871
clang::CodeGen::OMPTaskDataTy::FirstprivateInits
SmallVector< const Expr *, 4 > FirstprivateInits
Definition: CGOpenMPRuntime.h:98
clang::CodeGen::CGOpenMPRuntime::emitInlinedDirective
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
Definition: CGOpenMPRuntime.cpp:6181
clang::CodeGen::CGOpenMPRuntime::getDefaultFlagsForBarriers
static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind)
Returns default flags for the barriers depending on the directive, for which this barier is going to ...
Definition: CGOpenMPRuntime.cpp:2503
clang::CodeGen::CGOpenMPRuntime::isStaticChunked
virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static chunked.
Definition: CGOpenMPRuntime.cpp:2628
llvm::SmallString< 16 >
clang::CodeGen::OMPTaskDataTy::IsWorksharingReduction
bool IsWorksharingReduction
Definition: CGOpenMPRuntime.h:123
clang::CodeGen::CGOpenMPSIMDRuntime::emitCriticalRegion
void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr) override
Emits a critical region.
Definition: CGOpenMPRuntime.cpp:12832
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:879
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::OffloadEntryInfoDeviceGlobalVar
OffloadEntryInfoDeviceGlobalVar(unsigned Order, llvm::Constant *Addr, CharUnits VarSize, OMPTargetGlobalVarEntryKind Flags, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGOpenMPRuntime.h:671
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::CaptureDeviceAddrMap
llvm::DenseMap< const ValueDecl *, Address > CaptureDeviceAddrMap
Map between the a declaration of a capture and the corresponding base pointer address where the runti...
Definition: CGOpenMPRuntime.h:1690
clang::CodeGen::CGOpenMPSIMDRuntime::emitMasterRegion
void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc) override
Emits a master region.
Definition: CGOpenMPRuntime.cpp:12839
clang::OMPDeclareMapperDecl
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:286
clang::CodeGen::CGOpenMPSIMDRuntime::emitMaskedRegion
void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr) override
Emits a masked region.
Definition: CGOpenMPRuntime.cpp:12845
llvm::DenseSet
Definition: Sema.h:77
clang::CodeGen::ReductionCodeGen::getOrigLValue
LValue getOrigLValue(unsigned N) const
Returns LValue for the original reduction item.
Definition: CGOpenMPRuntime.h:208
clang::CodeGen::CGOpenMPRuntime::emitLastprivateConditionalInit
Address emitLastprivateConditionalInit(CodeGenFunction &CGF, const VarDecl *VD)
Create specialized alloca to handle lastprivate conditionals.
Definition: CGOpenMPRuntime.cpp:12497
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalRAII
Manages list of lastprivate conditional decls for the specified directive.
Definition: CGOpenMPRuntime.h:278
clang::CodeGen::CGOpenMPRuntime::emitMasterRegion
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
Definition: CGOpenMPRuntime.cpp:2229
clang::CodeGen::CGOpenMPRuntime::getDefaultDistScheduleAndChunk
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.
Definition: CGOpenMPRuntime.h:1780
clang::CodeGen::CGOpenMPRuntime::getIdentTyPointerTy
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
Definition: CGOpenMPRuntime.cpp:1484
clang::CodeGen::CGOpenMPRuntime::emitNumThreadsForTargetDirective
llvm::Value * emitNumThreadsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
Definition: CGOpenMPRuntime.cpp:6940
clang::CodeGen::CGOpenMPRuntime::ReductionOptionsTy
Definition: CGOpenMPRuntime.h:1428
clang::CodeGen::CGOpenMPRuntime::isNontemporalDecl
bool isNontemporalDecl(const ValueDecl *VD) const
Checks if the VD variable is marked as nontemporal declaration in current context.
Definition: CGOpenMPRuntime.cpp:12337
clang::CodeGen::CGOpenMPRuntime::getSingleCompoundChild
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 ...
Definition: CGOpenMPRuntime.cpp:6515
clang::CodeGen::CGOpenMPSIMDRuntime::emitForStaticFinish
void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind) override
Call the appropriate runtime routine to notify that we finished all the work with current loop.
Definition: CGOpenMPRuntime.cpp:12912
clang::CodeGen::Address
An aligned address.
Definition: Address.h:74
clang::CodeGen::CGOpenMPRuntime::DisableAutoDeclareTargetRAII::DisableAutoDeclareTargetRAII
DisableAutoDeclareTargetRAII(CodeGenModule &CGM)
Definition: CGOpenMPRuntime.cpp:10934
clang::CodeGen::OMPTaskDataTy::ReductionCopies
SmallVector< const Expr *, 4 > ReductionCopies
Definition: CGOpenMPRuntime.h:103
clang::CodeGen::CGOpenMPSIMDRuntime::getTaskReductionItem
Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal) override
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
Definition: CGOpenMPRuntime.cpp:13007
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskReductionInit
llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data) override
Emit a code for initialization of task reduction clause.
Definition: CGOpenMPRuntime.cpp:12988
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::StaticRTInput
StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
Definition: CGOpenMPRuntime.h:1186
clang::CodeGen::ReductionCodeGen::getSharedLValue
LValue getSharedLValue(unsigned N) const
Returns LValue for the reduction item.
Definition: CGOpenMPRuntime.h:206
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput::DispatchRTInput
DispatchRTInput()=default
clang::OpenMPDependClauseKind
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
Definition: OpenMPKinds.h:54
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskgroupRegion
void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc) override
Emit a taskgroup region.
Definition: CGOpenMPRuntime.cpp:12857
clang::CodeGen::CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata.
Definition: CGOpenMPRuntime.cpp:3097
clang::CodeGen::CGOpenMPRuntime::emitDistributeStaticInit
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values)
Definition: CGOpenMPRuntime.cpp:2802
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadEntryInfo
OffloadEntryInfo()=delete
clang::CodeGen::OMPTaskDataTy::NumberOfParts
unsigned NumberOfParts
Definition: CGOpenMPRuntime.h:119
clang::CodeGen::CGOpenMPRuntime::emitUpdateLocation
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags=0)
Emits object of ident_t type with info for source location.
Definition: CGOpenMPRuntime.cpp:1370
clang::CodeGen::CGOpenMPRuntime::emitUpdateClause
void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal, OpenMPDependClauseKind NewDepKind, SourceLocation Loc)
Updates the dependency kind in the specified depobj object.
Definition: CGOpenMPRuntime.cpp:4966
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput::UB
llvm::Value * UB
Loop upper bound.
Definition: CGOpenMPRuntime.h:1130
clang::CodeGen::CGOpenMPRuntime::emitDeclareTargetVarDefinition
virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Addr, bool PerformInit)
Emit a code for initialization of declare target variable.
Definition: CGOpenMPRuntime.cpp:1837
clang::CodeGen::CGOpenMPRuntime::getAddrOfDeclareTargetVar
virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
Definition: CGOpenMPRuntime.cpp:1625
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput::LB
llvm::Value * LB
Loop lower bound.
Definition: CGOpenMPRuntime.h:1128
clang::CodeGen::CGOpenMPRuntime::getOutlinedHelperName
virtual StringRef getOutlinedHelperName() const
Get the function name of an outlined region.
Definition: CGOpenMPRuntime.h:385
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::clearArrayInfo
void clearArrayInfo()
Clear information about the data arrays.
Definition: CGOpenMPRuntime.h:1698
clang::LangAS
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
clang::CodeGen::CGOpenMPSIMDRuntime
Class supports emissionof SIMD-only code.
Definition: CGOpenMPRuntime.h:1930
clang::CodeGen::CGOpenMPRuntime::getAddrOfThreadPrivate
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
Definition: CGOpenMPRuntime.cpp:1674
clang::CodeGen::RegionCodeGenTy
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
Definition: CGOpenMPRuntime.h:68
clang::CodeGen::CGOpenMPRuntime::isDefaultLocationConstant
virtual bool isDefaultLocationConstant() const
Check if the default location must be constant.
Definition: CGOpenMPRuntime.h:402
clang::CodeGen::CGOpenMPRuntime::getTaskReductionItem
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...
Definition: CGOpenMPRuntime.cpp:6110
clang::CodeGen::PrePostActionTy::~PrePostActionTy
virtual ~PrePostActionTy()
Definition: CGOpenMPRuntime.h:63
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::Ordered
bool Ordered
true if loop is ordered, false otherwise.
Definition: CGOpenMPRuntime.h:1170
clang::CodeGen::LValue
LValue - This represents an lvalue references.
Definition: CGValue.h:171
SourceLocation.h
clang::OMPDependClause
This represents implicit clause 'depend' for the '#pragma omp task' directive.
Definition: OpenMPClause.h:4742
clang::CodeGen::ReductionCodeGen::emitSharedOrigLValue
void emitSharedOrigLValue(CodeGenFunction &CGF, unsigned N)
Emits lvalue for the shared and original reduction item.
Definition: CGOpenMPRuntime.cpp:811
clang::CodeGen::PrePostActionTy::PrePostActionTy
PrePostActionTy()
Definition: CGOpenMPRuntime.h:60
clang::CodeGen::CGOpenMPRuntime::emitNumTeamsClause
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,...
Definition: CGOpenMPRuntime.cpp:11035
clang::CodeGen::CGOpenMPRuntime::NontemporalDeclsRAII::~NontemporalDeclsRAII
~NontemporalDeclsRAII()
Definition: CGOpenMPRuntime.cpp:12313
clang::CodeGen::CGOpenMPRuntime::translateParameter
virtual const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const
Translates the native parameter of outlined function if this is required for target.
Definition: CGOpenMPRuntime.h:1765
clang::CodeGen::CGOpenMPRuntime::emitDeferredTargetDecls
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
Definition: CGOpenMPRuntime.cpp:10853
clang::CodeGen::CGOpenMPRuntime::checkAndEmitLastprivateConditional
virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF, const Expr *LHS)
Checks if the provided LVal is lastprivate conditional and emits the code to update the value of the ...
Definition: CGOpenMPRuntime.cpp:12689
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion::getID
llvm::Constant * getID() const
Definition: CGOpenMPRuntime.h:616
clang::CodeGen::CGOpenMPRuntime::DispatchRTInput::Chunk
llvm::Value * Chunk
Chunk size specified using 'schedule' clause (nullptr if chunk was not specified)
Definition: CGOpenMPRuntime.h:1133
clang::CodeGen::PrePostActionTy::Enter
virtual void Enter(CodeGenFunction &CGF)
Definition: CGOpenMPRuntime.h:61
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:231
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::MapTypesArray
llvm::Value * MapTypesArray
The array of map types passed to the runtime library for the beginning of the region or for the entir...
Definition: CGOpenMPRuntime.h:1674
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadEntryInfo
OffloadEntryInfo(OffloadingEntryInfoKinds Kind)
Definition: CGOpenMPRuntime.h:545
clang::CodeGen::CGOpenMPSIMDRuntime::emitTeamsCall
void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars) override
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
Definition: CGOpenMPRuntime.cpp:13061
clang::CodeGen::OMPTaskDataTy::LastprivateCopies
SmallVector< const Expr *, 4 > LastprivateCopies
Definition: CGOpenMPRuntime.h:100
clang::CodeGen::CGOpenMPRuntime::processRequiresDirective
virtual void processRequiresDirective(const OMPRequiresDecl *D)
Perform check on requires decl to ensure that target architecture supports unified addressing.
Definition: CGOpenMPRuntime.cpp:10878
clang::CodeGen::OMPTaskDataTy::DependData::DepKind
OpenMPDependClauseKind DepKind
Definition: CGOpenMPRuntime.h:107
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetCall
void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter) override
Emit the target offloading code associated with D.
Definition: CGOpenMPRuntime.cpp:13039
clang::CodeGen::CGOpenMPRuntime::CGOpenMPRuntime
CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator, StringRef Separator)
Constructor allowing to redefine the name separator for the variables.
Definition: CGOpenMPRuntime.cpp:1060
clang::CodeGen::CGOpenMPRuntime::DisableAutoDeclareTargetRAII::~DisableAutoDeclareTargetRAII
~DisableAutoDeclareTargetRAII()
Definition: CGOpenMPRuntime.cpp:10943
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:279
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion::OffloadEntryInfoTargetRegion
OffloadEntryInfoTargetRegion(unsigned Order, llvm::Constant *Addr, llvm::Constant *ID, OMPTargetRegionEntryKind Flags)
Definition: CGOpenMPRuntime.h:607
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::IL
Address IL
Address of the output variable in which the flag of the last iteration is returned.
Definition: CGOpenMPRuntime.h:1173
clang::CodeGen::CGOpenMPSIMDRuntime::emitTeamsOutlinedFunction
llvm::Function * emitTeamsOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP teams directive D.
Definition: CGOpenMPRuntime.cpp:12809
llvm::ArrayRef
Definition: LLVM.h:34
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::setLinkage
void setLinkage(llvm::GlobalValue::LinkageTypes LT)
Definition: CGOpenMPRuntime.h:683
Value
Value
Definition: UninitializedValues.cpp:102
clang::CodeGen::OMPTaskDataTy::ReductionOrigs
SmallVector< const Expr *, 4 > ReductionOrigs
Definition: CGOpenMPRuntime.h:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::CodeGen::CGOpenMPRuntime::emitNumThreadsClause
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)...
Definition: CGOpenMPRuntime.cpp:2885
clang::CodeGen::CGOpenMPRuntime::getKmpCriticalNameTy
llvm::ArrayType * getKmpCriticalNameTy() const
Get the LLVM type for the critical name.
Definition: CGOpenMPRuntime.h:413
clang::CodeGen::Address::invalid
static Address invalid()
Definition: Address.h:90
clang::CodeGen::OMPTaskDataTy
Definition: CGOpenMPRuntime.h:93
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion
Target region entries info.
Definition: CGOpenMPRuntime.h:600
clang::CodeGen::CGOpenMPRuntime::ReductionOptionsTy::WithNowait
bool WithNowait
Definition: CGOpenMPRuntime.h:1429
clang::CodeGen::CGOpenMPRuntime::adjustTargetSpecificDataForLambdas
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...
Definition: CGOpenMPRuntime.cpp:10872
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskyieldCall
void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override
Emits a masked region.
Definition: CGOpenMPRuntime.cpp:12852
clang::CodeGen::CGOpenMPRuntime::emitTargetDataCalls
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.
Definition: CGOpenMPRuntime.cpp:11064
clang::CodeGen::OMPTaskDataTy::PrivateCopies
SmallVector< const Expr *, 4 > PrivateCopies
Definition: CGOpenMPRuntime.h:95
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::Chunk
llvm::Value * Chunk
Value of the chunk for the static_chunked scheduled loop.
Definition: CGOpenMPRuntime.h:1185
clang::CodeGen::ReductionCodeGen::getPrivateType
QualType getPrivateType(unsigned N) const
Return the type of the private item.
Definition: CGOpenMPRuntime.h:222
clang::CodeGen::CGOpenMPSIMDRuntime::emitBarrierCall
void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false) override
Emit an implicit/explicit barrier for OpenMP threads.
Definition: CGOpenMPRuntime.cpp:12878
clang::CodeGen::CGOpenMPRuntime::markAsGlobalTarget
bool markAsGlobalTarget(GlobalDecl GD)
Marks the declaration as already emitted for the device code and returns true, if it was marked alrea...
Definition: CGOpenMPRuntime.cpp:10948
clang::CodeGen::OMPTaskDataTy::FirstprivateCopies
SmallVector< const Expr *, 4 > FirstprivateCopies
Definition: CGOpenMPRuntime.h:97
clang::CodeGen::CGOpenMPRuntime::emitOutlinedFunctionCall
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...
Definition: CGOpenMPRuntime.cpp:12131
clang::CodeGen::CGOpenMPSIMDRuntime::emitDistributeStaticInit
void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values) override
Definition: CGOpenMPRuntime.cpp:12899
clang::CodeGen::CGOpenMPRuntime::emitReductionFunction
llvm::Function * emitReductionFunction(SourceLocation Loc, llvm::Type *ArgsElemType, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps)
Emits reduction function.
Definition: CGOpenMPRuntime.cpp:5321
clang::CodeGen::CGOpenMPRuntime::emitSingleRegion
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.
Definition: CGOpenMPRuntime.cpp:2392
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
clang::CodeGen::CGOpenMPRuntime::getDefaultScheduleAndChunk
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.
Definition: CGOpenMPRuntime.cpp:2518
clang::CodeGen::CGOpenMPSIMDRuntime::emitForOrderedIterationEnd
void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned) override
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
Definition: CGOpenMPRuntime.cpp:12905
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion::classof
static bool classof(const OffloadEntryInfo *Info)
Definition: CGOpenMPRuntime.h:621
clang::CodeGen::CGOpenMPRuntime::ReductionOptionsTy::SimpleReduction
bool SimpleReduction
Definition: CGOpenMPRuntime.h:1430
clang::CodeGen::CGOpenMPRuntime::emitTaskOutlinedFunction
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.
Definition: CGOpenMPRuntime.cpp:1285
clang::CodeGen::CGOpenMPRuntime::UntiedTaskLocalDeclsRAII
Manages list of nontemporal decls for the specified directive.
Definition: CGOpenMPRuntime.h:252
clang::CodeGen::CGOpenMPRuntime::emitOrderedRegion
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
Definition: CGOpenMPRuntime.cpp:2479
std
Definition: Format.h:4321
clang::CodeGen::CGOpenMPSIMDRuntime::emitDoacrossOrdered
void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C) override
Emit code for doacross ordered directive with 'depend' clause.
Definition: CGOpenMPRuntime.cpp:13094
clang::CodeGen::CGOpenMPSIMDRuntime::emitParallelCall
void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads) override
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
Definition: CGOpenMPRuntime.cpp:12823
clang::CodeGen::CGOpenMPRuntime::getOrCreateUserDefinedMapperFunc
llvm::Function * getOrCreateUserDefinedMapperFunc(const OMPDeclareMapperDecl *D)
Get the function for the specified user-defined mapper.
Definition: CGOpenMPRuntime.cpp:10219
clang::CodeGen::CGOpenMPSIMDRuntime::getParameterAddress
Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const override
Gets the address of the native argument basing on the address of the target-specific parameter.
Definition: CGOpenMPRuntime.cpp:13106
clang::CodeGen::CGOpenMPRuntime::emitUserDefinedReduction
virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)
Emit code for the specified user defined reduction construct.
Definition: CGOpenMPRuntime.cpp:1152
clang::Builtin::ID
ID
Definition: Builtins.h:52
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::isValid
bool isValid()
Return true if the current target data information has valid arrays.
Definition: CGOpenMPRuntime.h:1710
clang::CodeGen::CGOpenMPRuntime::emitCancelCall
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
Definition: CGOpenMPRuntime.cpp:6259
clang
Definition: CalledOnceCheck.h:17
clang::CodeGen::ReductionCodeGen::emitCleanups
void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Emits cleanup code for the reduction item.
Definition: CGOpenMPRuntime.cpp:908
clang::CodeGen::CGOpenMPRuntime::emitIfClause
void emitIfClause(CodeGenFunction &CGF, const Expr *Cond, const RegionCodeGenTy &ThenGen, const RegionCodeGenTy &ElseGen)
Emits code for OpenMP 'if' clause using specified CodeGen function.
Definition: CGOpenMPRuntime.cpp:2000
clang::OpenMPDistScheduleClauseKind
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:103
clang::CodeGen::CGOpenMPRuntime::emitTargetGlobal
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
Definition: CGOpenMPRuntime.cpp:10845
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskReductionFini
void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction) override
Emits the following code for reduction clause with task modifier:
Definition: CGOpenMPRuntime.cpp:12994
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:70
clang::CodeGen::ReductionCodeGen::needCleanups
bool needCleanups(unsigned N)
Returns true if the private copy requires cleanups.
Definition: CGOpenMPRuntime.cpp:902
clang::CodeGen::CGOpenMPRuntime::emitUserDefinedMapper
void emitUserDefinedMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit the function for the user defined mapper construct.
Definition: CGOpenMPRuntime.cpp:9903
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::setVarSize
void setVarSize(CharUnits Size)
Definition: CGOpenMPRuntime.h:681
clang::CodeGen::CGOpenMPRuntime::clear
virtual void clear()
Definition: CGOpenMPRuntime.cpp:1071
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::getVarSize
CharUnits getVarSize() const
Definition: CGOpenMPRuntime.h:680
clang::CodeGen::CGOpenMPSIMDRuntime::emitParallelOutlinedFunction
llvm::Function * emitParallelOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP parallel directive D.
Definition: CGOpenMPRuntime.cpp:12803
clang::CodeGen::CGOpenMPRuntime::emitDoacrossOrdered
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with 'depend' clause.
Definition: CGOpenMPRuntime.cpp:12083
clang::CodeGen::CGOpenMPRuntime::emitNumTeamsForTargetDirective
llvm::Value * emitNumTeamsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
Definition: CGOpenMPRuntime.cpp:6686
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalRAII::~LastprivateConditionalRAII
~LastprivateConditionalRAII()
Definition: CGOpenMPRuntime.cpp:12481
clang::CodeGen::CGOpenMPRuntime::emitTeamsOutlinedFunction
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.
Definition: CGOpenMPRuntime.cpp:1277
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::getAddress
llvm::Constant * getAddress() const
Definition: CGOpenMPRuntime.h:557
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang::CodeGen::RegionCodeGenTy::setAction
void setAction(PrePostActionTy &Action) const
Definition: CGOpenMPRuntime.h:89
clang::OMPRequiresDecl
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:416
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion::OffloadEntryInfoTargetRegion
OffloadEntryInfoTargetRegion()
Definition: CGOpenMPRuntime.h:605
clang::CodeGen::OMPTaskDataTy::PrivateVars
SmallVector< const Expr *, 4 > PrivateVars
Definition: CGOpenMPRuntime.h:94
clang::CodeGen::CGOpenMPRuntime::emitTargetDataStandAloneCall
virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device)
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
Definition: CGOpenMPRuntime.cpp:11218
clang::CodeGen::CGOpenMPRuntime::getAddrOfArtificialThreadPrivate
virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name)
Creates artificial threadprivate variable with name Name and type VarType.
Definition: CGOpenMPRuntime.cpp:1968
clang::CodeGen::RegionCodeGenTy::RegionCodeGenTy
RegionCodeGenTy(Callable &&CodeGen, std::enable_if_t<!std::is_same< std::remove_reference_t< Callable >, RegionCodeGenTy >::value > *=nullptr)
Definition: CGOpenMPRuntime.h:82
clang::CodeGen::CGOpenMPSIMDRuntime::emitForStaticInit
void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values) override
Call the appropriate runtime routine to initialize it before start of loop.
Definition: CGOpenMPRuntime.cpp:12893
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::MapNamesArray
llvm::Value * MapNamesArray
The array of original declaration names of mapped pointers sent to the runtime library for debugging.
Definition: CGOpenMPRuntime.h:1683
GlobalDecl.h
clang::CodeGen::CGOpenMPRuntime::NontemporalDeclsRAII
Manages list of nontemporal decls for the specified directive.
Definition: CGOpenMPRuntime.h:242
clang::CodeGen::CGOpenMPRuntime::emitTargetGlobalVariable
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
Definition: CGOpenMPRuntime.cpp:10725
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadingEntryInfoInvalid
@ OffloadingEntryInfoInvalid
Invalid entry info.
Definition: CGOpenMPRuntime.h:540
clang::CodeGen::CGOpenMPRuntime::UntiedTaskLocalDeclsRAII::UntiedTaskLocalDeclsRAII
UntiedTaskLocalDeclsRAII(CodeGenFunction &CGF, const llvm::MapVector< CanonicalDeclPtr< const VarDecl >, std::pair< Address, Address >> &LocalVars)
Definition: CGOpenMPRuntime.cpp:12319
clang::OpenMPDirectiveKind
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:24
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::getFlags
uint32_t getFlags() const
Definition: CGOpenMPRuntime.h:555
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::OffloadingEntryInfoTargetRegion
@ OffloadingEntryInfoTargetRegion
Entry is a target region.
Definition: CGOpenMPRuntime.h:536
clang::CanonicalDeclPtr
A wrapper class around a pointer that always points to its canonical declaration.
Definition: Redeclarable.h:349
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::SizesArray
llvm::Value * SizesArray
The array of sizes passed to the runtime library.
Definition: CGOpenMPRuntime.h:1670
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::CodeGen::CGOpenMPRuntime::isLocalVarInUntiedTask
bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const
Returns true if the variable is a local variable in untied task.
Definition: CGOpenMPRuntime.cpp:12279
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::LB
Address LB
Address of the output variable in which the lower iteration number is returned.
Definition: CGOpenMPRuntime.h:1176
clang::CodeGen::OMPTaskDataTy::FirstprivateVars
SmallVector< const Expr *, 4 > FirstprivateVars
Definition: CGOpenMPRuntime.h:96
clang::CodeGen::CGOpenMPRuntime::emitThreadPrivateVarDefinition
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
Definition: CGOpenMPRuntime.cpp:1716
clang::CodeGen::CGOpenMPSIMDRuntime::getAddressOfLocalVariable
Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD) override
Gets the OpenMP-specific address of the local variable.
Definition: CGOpenMPRuntime.h:2529
clang::CodeGen::CGOpenMPRuntime::DisableAutoDeclareTargetRAII
Allows to disable automatic handling of functions used in target regions as those marked as omp decla...
Definition: CGOpenMPRuntime.h:232
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::IVSigned
bool IVSigned
Sign of the iteration variable.
Definition: CGOpenMPRuntime.h:1168
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::CodeGen::CGOpenMPRuntime::emitTaskgroupRegion
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
Definition: CGOpenMPRuntime.cpp:2301
clang::OpenMPScheduleClauseKind
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:30
clang::CodeGen::CGOpenMPRuntime::CGM
CodeGenModule & CGM
Definition: CGOpenMPRuntime.h:308
clang::CodeGen::OMPTaskDataTy::ReductionVars
SmallVector< const Expr *, 4 > ReductionVars
Definition: CGOpenMPRuntime.h:101
clang::CodeGen::CGOpenMPRuntime::emitUsesAllocatorsFini
void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator)
Destroys user defined allocators specified in the uses_allocators clause.
Definition: CGOpenMPRuntime.cpp:6389
clang::CodeGen::CGOpenMPRuntime::emitTaskCall
virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the task directive.
Definition: CGOpenMPRuntime.cpp:5013
clang::CodeGen::CGOpenMPRuntime::emitDeclareSimdFunction
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
Definition: CGOpenMPRuntime.cpp:11834
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::classof
static bool classof(const OffloadEntryInfo *Info)
Definition: CGOpenMPRuntime.h:564
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1231
clang::CodeGen::CGOpenMPRuntime::emitUsesAllocatorsInit
void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator, const Expr *AllocatorTraits)
Initializes user defined allocators specified in the uses_allocators clauses.
Definition: CGOpenMPRuntime.cpp:6354
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1877
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3954
clang::CodeGen::CGOpenMPRuntime::emitReduction
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.
Definition: CGOpenMPRuntime.cpp:5431
clang::CodeGen::CGOpenMPSIMDRuntime::emitTargetGlobal
bool emitTargetGlobal(GlobalDecl GD) override
Emit the global GD if it is meaningful for the target.
Definition: CGOpenMPRuntime.cpp:13057
clang::CodeGen::ReductionCodeGen::getRefExpr
const Expr * getRefExpr(unsigned N) const
Returns the base declaration of the reduction item.
Definition: CGOpenMPRuntime.h:217
clang::CodeGen::CGOpenMPRuntime::createOffloadEntry
virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size, int32_t Flags, llvm::GlobalValue::LinkageTypes Linkage)
Creates offloading entry for the provided entry ID ID, address Addr, size Size, and flags Flags.
Definition: CGOpenMPRuntime.cpp:3091
clang::CodeGen::CGOpenMPRuntime::LastprivateConditionalData::IVLVal
LValue IVLVal
Definition: CGOpenMPRuntime.h:273
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar::classof
static bool classof(const OffloadEntryInfo *Info)
Definition: CGOpenMPRuntime.h:684
clang::CodeGen::CGOpenMPRuntime::OffloadEntriesInfoManagerTy::OffloadEntryInfo::setFlags
void setFlags(uint32_t NewFlags)
Definition: CGOpenMPRuntime.h:556
clang::CodeGen::CGOpenMPRuntime::emitTargetCall
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter)
Emit the target offloading code associated with D.
Definition: CGOpenMPRuntime.cpp:10247
clang::ShaderStage::Callable
@ Callable
clang::CodeGen::PrePostActionTy
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
Definition: CGOpenMPRuntime.h:58
clang::OpenMPScheduleTy
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:157
clang::CodeGen::CGOpenMPRuntime::StaticRTInput::IVSize
unsigned IVSize
Size of the iteration variable in bits.
Definition: CGOpenMPRuntime.h:1166
clang::CodeGen::CGOpenMPRuntime::TargetDataInfo::requiresDevicePointerInfo
bool requiresDevicePointerInfo()
Definition: CGOpenMPRuntime.h:1714
clang::CodeGen::CGOpenMPSIMDRuntime::emitTaskOutlinedFunction
llvm::Function * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts) override
Emits outlined function for the OpenMP task directive D.
Definition: CGOpenMPRuntime.cpp:12815
clang::CodeGen::CGOpenMPRuntime::functionFinished
virtual void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
Definition: CGOpenMPRuntime.cpp:1463
clang::CodeGen::CGOpenMPRuntime::getUserDefinedReduction
virtual std::pair< llvm::Function *, llvm::Function * > getUserDefinedReduction(const OMPDeclareReductionDecl *D)
Get combiner/initializer for the specified user-defined reduction, if any.
Definition: CGOpenMPRuntime.cpp:1179
clang::CodeGen::CGOpenMPSIMDRuntime::emitReduction
void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options) override
Emit a code for reduction clause.
Definition: CGOpenMPRuntime.cpp:12979
Type
MatchType Type
Definition: ASTMatchFinder.cpp:71
clang::CodeGen::CGOpenMPRuntime::getParameterAddress
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.
Definition: CGOpenMPRuntime.cpp:12143
clang::CodeGen::CGOpenMPRuntime::emitTaskwaitCall
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data)
Emit code for 'taskwait' directive.
Definition: CGOpenMPRuntime.cpp:6130
clang::CodeGen::ReductionCodeGen::usesReductionInitializer
bool usesReductionInitializer(unsigned N) const
Returns true if the initialization of the reduction item uses initializer from declare reduction cons...
Definition: CGOpenMPRuntime.cpp:1015