clang  3.9.0
CGOpenMPRuntime.h
Go to the documentation of this file.
1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides a class for OpenMP runtime code generation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
15 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
16 
17 #include "CGValue.h"
18 #include "clang/AST/Type.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/StringMap.h"
24 #include "llvm/IR/Function.h"
25 #include "llvm/IR/ValueHandle.h"
26 
27 namespace llvm {
28 class ArrayType;
29 class Constant;
30 class FunctionType;
31 class GlobalVariable;
32 class StructType;
33 class Type;
34 class Value;
35 } // namespace llvm
36 
37 namespace clang {
38 class Expr;
39 class GlobalDecl;
40 class OMPDependClause;
41 class OMPExecutableDirective;
42 class OMPLoopDirective;
43 class VarDecl;
44 class OMPDeclareReductionDecl;
45 class IdentifierInfo;
46 
47 namespace CodeGen {
48 class Address;
49 class CodeGenFunction;
50 class CodeGenModule;
51 
52 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
53 /// region.
55 public:
56  explicit PrePostActionTy() {}
57  virtual void Enter(CodeGenFunction &CGF) {}
58  virtual void Exit(CodeGenFunction &CGF) {}
59  virtual ~PrePostActionTy() {}
60 };
61 
62 /// Class provides a way to call simple version of codegen for OpenMP region, or
63 /// an advanced with possible pre|post-actions in codegen.
64 class RegionCodeGenTy final {
65  intptr_t CodeGen;
66  typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
67  CodeGenTy Callback;
68  mutable PrePostActionTy *PrePostAction;
69  RegionCodeGenTy() = delete;
70  RegionCodeGenTy &operator=(const RegionCodeGenTy &) = delete;
71  template <typename Callable>
72  static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
74  return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
75  }
76 
77 public:
78  template <typename Callable>
80  Callable &&CodeGen,
81  typename std::enable_if<
82  !std::is_same<typename std::remove_reference<Callable>::type,
83  RegionCodeGenTy>::value>::type * = nullptr)
84  : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
85  Callback(CallbackFn<typename std::remove_reference<Callable>::type>),
86  PrePostAction(nullptr) {}
87  void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
88  void operator()(CodeGenFunction &CGF) const;
89 };
90 
91 struct OMPTaskDataTy final {
100  llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
101  llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule;
102  llvm::PointerIntPair<llvm::Value *, 1, bool> Priority;
103  unsigned NumberOfParts = 0;
104  bool Tied = true;
105  bool Nogroup = false;
106 };
107 
109 protected:
111 
112  /// \brief Creates offloading entry for the provided entry ID \a ID,
113  /// address \a Addr and size \a Size.
114  virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
115  uint64_t Size);
116 
117  /// \brief Helper to emit outlined function for 'target' directive.
118  /// \param D Directive to emit.
119  /// \param ParentName Name of the function that encloses the target region.
120  /// \param OutlinedFn Outlined function value to be defined by this call.
121  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
122  /// \param IsOffloadEntry True if the outlined function is an offload entry.
123  /// \param CodeGen Lambda codegen specific to an accelerator device.
124  /// An oulined function may not be an entry if, e.g. the if clause always
125  /// evaluates to false.
127  StringRef ParentName,
128  llvm::Function *&OutlinedFn,
129  llvm::Constant *&OutlinedFnID,
130  bool IsOffloadEntry,
131  const RegionCodeGenTy &CodeGen);
132 
133 private:
134  /// \brief Default const ident_t object used for initialization of all other
135  /// ident_t objects.
136  llvm::Constant *DefaultOpenMPPSource = nullptr;
137  /// \brief Map of flags and corresponding default locations.
138  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
139  OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
140  Address getOrCreateDefaultLocation(unsigned Flags);
141 
142  llvm::StructType *IdentTy = nullptr;
143  /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
144  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
145  OpenMPDebugLocMapTy OpenMPDebugLocMap;
146  /// \brief The type for a microtask which gets passed to __kmpc_fork_call().
147  /// Original representation is:
148  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
149  llvm::FunctionType *Kmpc_MicroTy = nullptr;
150  /// \brief Stores debug location and ThreadID for the function.
151  struct DebugLocThreadIdTy {
152  llvm::Value *DebugLoc;
153  llvm::Value *ThreadID;
154  };
155  /// \brief Map of local debug location, ThreadId and functions.
156  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
157  OpenMPLocThreadIDMapTy;
158  OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
159  /// Map of UDRs and corresponding combiner/initializer.
160  typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
161  std::pair<llvm::Function *, llvm::Function *>>
162  UDRMapTy;
163  UDRMapTy UDRMap;
164  /// Map of functions and locally defined UDRs.
165  typedef llvm::DenseMap<llvm::Function *,
167  FunctionUDRMapTy;
168  FunctionUDRMapTy FunctionUDRMap;
169  IdentifierInfo *In = nullptr;
170  IdentifierInfo *Out = nullptr;
171  IdentifierInfo *Priv = nullptr;
172  IdentifierInfo *Orig = nullptr;
173  /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
174  /// kmp_critical_name[8];
175  llvm::ArrayType *KmpCriticalNameTy;
176  /// \brief An ordered map of auto-generated variables to their unique names.
177  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
178  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
179  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
180  /// variables.
181  llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
182  InternalVars;
183  /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
184  llvm::Type *KmpRoutineEntryPtrTy = nullptr;
185  QualType KmpRoutineEntryPtrQTy;
186  /// \brief Type typedef struct kmp_task {
187  /// void * shareds; /**< pointer to block of pointers to
188  /// shared vars */
189  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
190  /// executing task */
191  /// kmp_int32 part_id; /**< part id for the task */
192  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
193  /// deconstructors of firstprivate C++ objects */
194  /// } kmp_task_t;
196  /// \brief Type typedef struct kmp_depend_info {
197  /// kmp_intptr_t base_addr;
198  /// size_t len;
199  /// struct {
200  /// bool in:1;
201  /// bool out:1;
202  /// } flags;
203  /// } kmp_depend_info_t;
205  /// struct kmp_dim { // loop bounds info casted to kmp_int64
206  /// kmp_int64 lo; // lower
207  /// kmp_int64 up; // upper
208  /// kmp_int64 st; // stride
209  /// };
211  /// \brief Type struct __tgt_offload_entry{
212  /// void *addr; // Pointer to the offload entry info.
213  /// // (function or global)
214  /// char *name; // Name of the function or global.
215  /// size_t size; // Size of the entry info (0 if it a function).
216  /// };
218  /// struct __tgt_device_image{
219  /// void *ImageStart; // Pointer to the target code start.
220  /// void *ImageEnd; // Pointer to the target code end.
221  /// // We also add the host entries to the device image, as it may be useful
222  /// // for the target runtime to have access to that information.
223  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
224  /// // the entries.
225  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
226  /// // entries (non inclusive).
227  /// };
229  /// struct __tgt_bin_desc{
230  /// int32_t NumDevices; // Number of devices supported.
231  /// __tgt_device_image *DeviceImages; // Arrays of device images
232  /// // (one per device).
233  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
234  /// // entries.
235  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
236  /// // entries (non inclusive).
237  /// };
239  /// \brief Entity that registers the offloading constants that were emitted so
240  /// far.
243 
244  /// \brief Number of entries registered so far.
245  unsigned OffloadingEntriesNum;
246 
247  public:
248  /// \brief Base class of the entries info.
250  public:
251  /// \brief Kind of a given entry. Currently, only target regions are
252  /// supported.
253  enum OffloadingEntryInfoKinds : unsigned {
254  // Entry is a target region.
255  OFFLOAD_ENTRY_INFO_TARGET_REGION = 0,
256  // Invalid entry info.
257  OFFLOAD_ENTRY_INFO_INVALID = ~0u
258  };
259 
260  OffloadEntryInfo() : Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
262  : Order(Order), Kind(Kind) {}
263 
264  bool isValid() const { return Order != ~0u; }
265  unsigned getOrder() const { return Order; }
267  static bool classof(const OffloadEntryInfo *Info) { return true; }
268 
269  protected:
270  // \brief Order this entry was emitted.
271  unsigned Order;
272 
274  };
275 
276  /// \brief Return true if a there are no entries defined.
277  bool empty() const;
278  /// \brief Return number of entries defined so far.
279  unsigned size() const { return OffloadingEntriesNum; }
281  : CGM(CGM), OffloadingEntriesNum(0) {}
282 
283  ///
284  /// Target region entries related.
285  ///
286  /// \brief Target region entries info.
288  // \brief Address of the entity that has to be mapped for offloading.
289  llvm::Constant *Addr;
290  // \brief Address that can be used as the ID of the entry.
291  llvm::Constant *ID;
292 
293  public:
295  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, ~0u),
296  Addr(nullptr), ID(nullptr) {}
297  explicit OffloadEntryInfoTargetRegion(unsigned Order,
298  llvm::Constant *Addr,
299  llvm::Constant *ID)
300  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, Order),
301  Addr(Addr), ID(ID) {}
302 
303  llvm::Constant *getAddress() const { return Addr; }
304  llvm::Constant *getID() const { return ID; }
305  void setAddress(llvm::Constant *V) {
306  assert(!Addr && "Address as been set before!");
307  Addr = V;
308  }
309  void setID(llvm::Constant *V) {
310  assert(!ID && "ID as been set before!");
311  ID = V;
312  }
313  static bool classof(const OffloadEntryInfo *Info) {
314  return Info->getKind() == OFFLOAD_ENTRY_INFO_TARGET_REGION;
315  }
316  };
317  /// \brief Initialize target region entry.
318  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
319  StringRef ParentName, unsigned LineNum,
320  unsigned Order);
321  /// \brief Register target region entry.
322  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
323  StringRef ParentName, unsigned LineNum,
324  llvm::Constant *Addr,
325  llvm::Constant *ID);
326  /// \brief Return true if a target region entry with the provided
327  /// information exists.
328  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
329  StringRef ParentName, unsigned LineNum) const;
330  /// brief Applies action \a Action on all registered entries.
331  typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
332  OffloadEntryInfoTargetRegion &)>
334  void actOnTargetRegionEntriesInfo(
336 
337  private:
338  // Storage for target region entries kind. The storage is to be indexed by
339  // file ID, device ID, parent function name and line number.
340  typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
341  OffloadEntriesTargetRegionPerLine;
342  typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
343  OffloadEntriesTargetRegionPerParentName;
344  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
345  OffloadEntriesTargetRegionPerFile;
346  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
347  OffloadEntriesTargetRegionPerDevice;
348  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
349  OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
350  };
352 
353  /// \brief Creates and registers offloading binary descriptor for the current
354  /// compilation unit. The function that does the registration is returned.
356 
357  /// \brief Creates all the offload entries in the current compilation unit
358  /// along with the associated metadata.
360 
361  /// \brief Loads all the offload entries information from the host IR
362  /// metadata.
364 
365  /// \brief Returns __tgt_offload_entry type.
367 
368  /// \brief Returns __tgt_device_image type.
370 
371  /// \brief Returns __tgt_bin_desc type.
373 
374  /// \brief Start scanning from statement \a S and and emit all target regions
375  /// found along the way.
376  /// \param S Starting statement.
377  /// \param ParentName Name of the function declaration that is being scanned.
378  void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
379 
380  /// \brief Build type kmp_routine_entry_t (if not built yet).
381  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
382 
383  /// \brief Emits object of ident_t type with info for source location.
384  /// \param Flags Flags for OpenMP location.
385  ///
387  unsigned Flags = 0);
388 
389  /// \brief Returns pointer to ident_t type.
391 
392  /// \brief Returns pointer to kmpc_micro type.
394 
395  /// \brief Returns specified OpenMP runtime function.
396  /// \param Function OpenMP runtime function.
397  /// \return Specified function.
398  llvm::Constant *createRuntimeFunction(unsigned Function);
399 
400  /// \brief Returns __kmpc_for_static_init_* runtime function for the specified
401  /// size \a IVSize and sign \a IVSigned.
402  llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
403 
404  /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified
405  /// size \a IVSize and sign \a IVSigned.
406  llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
407 
408  /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified
409  /// size \a IVSize and sign \a IVSigned.
410  llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
411 
412  /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified
413  /// size \a IVSize and sign \a IVSigned.
414  llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
415 
416  /// \brief If the specified mangled name is not in the module, create and
417  /// return threadprivate cache object. This object is a pointer's worth of
418  /// storage that's reserved for use by the OpenMP runtime.
419  /// \param VD Threadprivate variable.
420  /// \return Cache variable for the specified threadprivate.
421  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
422 
423  /// \brief Emits address of the word in a memory where current thread id is
424  /// stored.
426 
427  /// \brief Gets thread id value for the current thread.
428  ///
430 
431  /// \brief Gets (if variable with the given name already exist) or creates
432  /// internal global variable with the specified Name. The created variable has
433  /// linkage CommonLinkage by default and is initialized by null value.
434  /// \param Ty Type of the global variable. If it is exist already the type
435  /// must be the same.
436  /// \param Name Name of the variable.
437  llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
438  const llvm::Twine &Name);
439 
440  /// \brief Set of threadprivate variables with the generated initializer.
441  llvm::SmallPtrSet<const VarDecl *, 4> ThreadPrivateWithDefinition;
442 
443  /// \brief Emits initialization code for the threadprivate variables.
444  /// \param VDAddr Address of the global variable \a VD.
445  /// \param Ctor Pointer to a global init function for \a VD.
446  /// \param CopyCtor Pointer to a global copy function for \a VD.
447  /// \param Dtor Pointer to a global destructor function for \a VD.
448  /// \param Loc Location of threadprivate declaration.
450  llvm::Value *Ctor, llvm::Value *CopyCtor,
451  llvm::Value *Dtor, SourceLocation Loc);
452 
453  /// \brief Returns corresponding lock object for the specified critical region
454  /// name. If the lock object does not exist it is created, otherwise the
455  /// reference to the existing copy is returned.
456  /// \param CriticalName Name of the critical region.
457  ///
458  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
459 
460  struct TaskResultTy {
461  llvm::Value *NewTask = nullptr;
462  llvm::Value *TaskEntry = nullptr;
463  llvm::Value *NewTaskNewTaskTTy = nullptr;
465  RecordDecl *KmpTaskTQTyRD = nullptr;
466  llvm::Value *TaskDupFn = nullptr;
467  };
468  /// Emit task region for the task directive. The task region is emitted in
469  /// several steps:
470  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
471  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
472  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
473  /// function:
474  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
475  /// TaskFunction(gtid, tt->part_id, tt->shareds);
476  /// return 0;
477  /// }
478  /// 2. Copy a list of shared variables to field shareds of the resulting
479  /// structure kmp_task_t returned by the previous call (if any).
480  /// 3. Copy a pointer to destructions function to field destructions of the
481  /// resulting structure kmp_task_t.
482  /// \param D Current task directive.
483  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
484  /// /*part_id*/, captured_struct */*__context*/);
485  /// \param SharedsTy A type which contains references the shared variables.
486  /// \param Shareds Context with the list of shared variables from the \p
487  /// TaskFunction.
488  /// \param Data Additional data for task generation like tiednsee, final
489  /// state, list of privates etc.
491  const OMPExecutableDirective &D,
492  llvm::Value *TaskFunction, QualType SharedsTy,
493  Address Shareds, const OMPTaskDataTy &Data);
494 
495 public:
496  explicit CGOpenMPRuntime(CodeGenModule &CGM);
497  virtual ~CGOpenMPRuntime() {}
498  virtual void clear();
499 
500  /// Emit code for the specified user defined reduction construct.
501  virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
502  const OMPDeclareReductionDecl *D);
503  /// Get combiner/initializer for the specified user-defined reduction, if any.
504  virtual std::pair<llvm::Function *, llvm::Function *>
506  /// \brief Emits outlined function for the specified OpenMP parallel directive
507  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
508  /// kmp_int32 BoundID, struct context_vars*).
509  /// \param D OpenMP directive.
510  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
511  /// \param InnermostKind Kind of innermost directive (for simple directives it
512  /// is a directive itself, for combined - its innermost directive).
513  /// \param CodeGen Code generation sequence for the \a D directive.
515  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
516  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
517 
518  /// \brief Emits outlined function for the OpenMP task directive \a D. This
519  /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
520  /// TaskT).
521  /// \param D OpenMP directive.
522  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
523  /// \param PartIDVar Variable for partition id in the current OpenMP untied
524  /// task region.
525  /// \param TaskTVar Variable for task_t argument.
526  /// \param InnermostKind Kind of innermost directive (for simple directives it
527  /// is a directive itself, for combined - its innermost directive).
528  /// \param CodeGen Code generation sequence for the \a D directive.
529  /// \param Tied true if task is generated for tied task, false otherwise.
530  /// \param NumberOfParts Number of parts in untied task. Ignored for tied
531  /// tasks.
532  ///
534  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
535  const VarDecl *PartIDVar, const VarDecl *TaskTVar,
536  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
537  bool Tied, unsigned &NumberOfParts);
538 
539  /// \brief Cleans up references to the objects in finished function.
540  ///
541  void functionFinished(CodeGenFunction &CGF);
542 
543  /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
544  /// variables captured in a record which address is stored in \a
545  /// CapturedStruct.
546  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
547  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
548  /// \param CapturedVars A pointer to the record with the references to
549  /// variables used in \a OutlinedFn function.
550  /// \param IfCond Condition in the associated 'if' clause, if it was
551  /// specified, nullptr otherwise.
552  ///
553  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
554  llvm::Value *OutlinedFn,
555  ArrayRef<llvm::Value *> CapturedVars,
556  const Expr *IfCond);
557 
558  /// \brief Emits a critical region.
559  /// \param CriticalName Name of the critical region.
560  /// \param CriticalOpGen Generator for the statement associated with the given
561  /// critical region.
562  /// \param Hint Value of the 'hint' clause (optional).
563  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
564  const RegionCodeGenTy &CriticalOpGen,
565  SourceLocation Loc,
566  const Expr *Hint = nullptr);
567 
568  /// \brief Emits a master region.
569  /// \param MasterOpGen Generator for the statement associated with the given
570  /// master region.
571  virtual void emitMasterRegion(CodeGenFunction &CGF,
572  const RegionCodeGenTy &MasterOpGen,
573  SourceLocation Loc);
574 
575  /// \brief Emits code for a taskyield directive.
576  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
577 
578  /// \brief Emit a taskgroup region.
579  /// \param TaskgroupOpGen Generator for the statement associated with the
580  /// given taskgroup region.
581  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
582  const RegionCodeGenTy &TaskgroupOpGen,
583  SourceLocation Loc);
584 
585  /// \brief Emits a single region.
586  /// \param SingleOpGen Generator for the statement associated with the given
587  /// single region.
588  virtual void emitSingleRegion(CodeGenFunction &CGF,
589  const RegionCodeGenTy &SingleOpGen,
590  SourceLocation Loc,
591  ArrayRef<const Expr *> CopyprivateVars,
592  ArrayRef<const Expr *> DestExprs,
593  ArrayRef<const Expr *> SrcExprs,
594  ArrayRef<const Expr *> AssignmentOps);
595 
596  /// \brief Emit an ordered region.
597  /// \param OrderedOpGen Generator for the statement associated with the given
598  /// ordered region.
599  virtual void emitOrderedRegion(CodeGenFunction &CGF,
600  const RegionCodeGenTy &OrderedOpGen,
601  SourceLocation Loc, bool IsThreads);
602 
603  /// \brief Emit an implicit/explicit barrier for OpenMP threads.
604  /// \param Kind Directive for which this implicit barrier call must be
605  /// generated. Must be OMPD_barrier for explicit barrier generation.
606  /// \param EmitChecks true if need to emit checks for cancellation barriers.
607  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
608  /// runtime class decides which one to emit (simple or with cancellation
609  /// checks).
610  ///
611  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
613  bool EmitChecks = true,
614  bool ForceSimpleCall = false);
615 
616  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
617  /// This kind of worksharing directive is emitted without outer loop.
618  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
619  /// \param Chunked True if chunk is specified in the clause.
620  ///
621  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
622  bool Chunked) const;
623 
624  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
625  /// This kind of distribute directive is emitted without outer loop.
626  /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
627  /// \param Chunked True if chunk is specified in the clause.
628  ///
629  virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
630  bool Chunked) const;
631 
632  /// \brief Check if the specified \a ScheduleKind is dynamic.
633  /// This kind of worksharing directive is emitted without outer loop.
634  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
635  ///
636  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
637 
638  virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
639  const OpenMPScheduleTy &ScheduleKind,
640  unsigned IVSize, bool IVSigned, bool Ordered,
641  llvm::Value *UB,
642  llvm::Value *Chunk = nullptr);
643 
644  /// \brief Call the appropriate runtime routine to initialize it before start
645  /// of loop.
646  ///
647  /// Depending on the loop schedule, it is nesessary to call some runtime
648  /// routine before start of the OpenMP loop to get the loop upper / lower
649  /// bounds \a LB and \a UB and stride \a ST.
650  ///
651  /// \param CGF Reference to current CodeGenFunction.
652  /// \param Loc Clang source location.
653  /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
654  /// \param IVSize Size of the iteration variable in bits.
655  /// \param IVSigned Sign of the interation variable.
656  /// \param Ordered true if loop is ordered, false otherwise.
657  /// \param IL Address of the output variable in which the flag of the
658  /// last iteration is returned.
659  /// \param LB Address of the output variable in which the lower iteration
660  /// number is returned.
661  /// \param UB Address of the output variable in which the upper iteration
662  /// number is returned.
663  /// \param ST Address of the output variable in which the stride value is
664  /// returned nesessary to generated the static_chunked scheduled loop.
665  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
666  /// For the default (nullptr) value, the chunk 1 will be used.
667  ///
668  virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
669  const OpenMPScheduleTy &ScheduleKind,
670  unsigned IVSize, bool IVSigned, bool Ordered,
671  Address IL, Address LB, Address UB, Address ST,
672  llvm::Value *Chunk = nullptr);
673 
674  ///
675  /// \param CGF Reference to current CodeGenFunction.
676  /// \param Loc Clang source location.
677  /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
678  /// \param IVSize Size of the iteration variable in bits.
679  /// \param IVSigned Sign of the interation variable.
680  /// \param Ordered true if loop is ordered, false otherwise.
681  /// \param IL Address of the output variable in which the flag of the
682  /// last iteration is returned.
683  /// \param LB Address of the output variable in which the lower iteration
684  /// number is returned.
685  /// \param UB Address of the output variable in which the upper iteration
686  /// number is returned.
687  /// \param ST Address of the output variable in which the stride value is
688  /// returned nesessary to generated the static_chunked scheduled loop.
689  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
690  /// For the default (nullptr) value, the chunk 1 will be used.
691  ///
692  virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
694  unsigned IVSize, bool IVSigned,
695  bool Ordered, Address IL, Address LB,
696  Address UB, Address ST,
697  llvm::Value *Chunk = nullptr);
698 
699  /// \brief Call the appropriate runtime routine to notify that we finished
700  /// iteration of the ordered loop with the dynamic scheduling.
701  ///
702  /// \param CGF Reference to current CodeGenFunction.
703  /// \param Loc Clang source location.
704  /// \param IVSize Size of the iteration variable in bits.
705  /// \param IVSigned Sign of the interation variable.
706  ///
707  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
708  SourceLocation Loc, unsigned IVSize,
709  bool IVSigned);
710 
711  /// \brief Call the appropriate runtime routine to notify that we finished
712  /// all the work with current loop.
713  ///
714  /// \param CGF Reference to current CodeGenFunction.
715  /// \param Loc Clang source location.
716  ///
717  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc);
718 
719  /// Call __kmpc_dispatch_next(
720  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
721  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
722  /// kmp_int[32|64] *p_stride);
723  /// \param IVSize Size of the iteration variable in bits.
724  /// \param IVSigned Sign of the interation variable.
725  /// \param IL Address of the output variable in which the flag of the
726  /// last iteration is returned.
727  /// \param LB Address of the output variable in which the lower iteration
728  /// number is returned.
729  /// \param UB Address of the output variable in which the upper iteration
730  /// number is returned.
731  /// \param ST Address of the output variable in which the stride value is
732  /// returned.
733  virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
734  unsigned IVSize, bool IVSigned,
735  Address IL, Address LB,
736  Address UB, Address ST);
737 
738  /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
739  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
740  /// clause.
741  /// \param NumThreads An integer value of threads.
742  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
743  llvm::Value *NumThreads,
744  SourceLocation Loc);
745 
746  /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
747  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
748  virtual void emitProcBindClause(CodeGenFunction &CGF,
749  OpenMPProcBindClauseKind ProcBind,
750  SourceLocation Loc);
751 
752  /// \brief Returns address of the threadprivate variable for the current
753  /// thread.
754  /// \param VD Threadprivate variable.
755  /// \param VDAddr Address of the global variable \a VD.
756  /// \param Loc Location of the reference to threadprivate var.
757  /// \return Address of the threadprivate variable for the current thread.
758  virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
759  const VarDecl *VD,
760  Address VDAddr,
761  SourceLocation Loc);
762 
763  /// \brief Emit a code for initialization of threadprivate variable. It emits
764  /// a call to runtime library which adds initial value to the newly created
765  /// threadprivate variable (if it is not constant) and registers destructor
766  /// for the variable (if any).
767  /// \param VD Threadprivate variable.
768  /// \param VDAddr Address of the global variable \a VD.
769  /// \param Loc Location of threadprivate declaration.
770  /// \param PerformInit true if initialization expression is not constant.
771  virtual llvm::Function *
772  emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
773  SourceLocation Loc, bool PerformInit,
774  CodeGenFunction *CGF = nullptr);
775 
776  /// \brief Emit flush of the variables specified in 'omp flush' directive.
777  /// \param Vars List of variables to flush.
778  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
779  SourceLocation Loc);
780 
781  /// \brief Emit task region for the task directive. The task region is
782  /// emitted in several steps:
783  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
784  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
785  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
786  /// function:
787  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
788  /// TaskFunction(gtid, tt->part_id, tt->shareds);
789  /// return 0;
790  /// }
791  /// 2. Copy a list of shared variables to field shareds of the resulting
792  /// structure kmp_task_t returned by the previous call (if any).
793  /// 3. Copy a pointer to destructions function to field destructions of the
794  /// resulting structure kmp_task_t.
795  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
796  /// kmp_task_t *new_task), where new_task is a resulting structure from
797  /// previous items.
798  /// \param D Current task directive.
799  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
800  /// /*part_id*/, captured_struct */*__context*/);
801  /// \param SharedsTy A type which contains references the shared variables.
802  /// \param Shareds Context with the list of shared variables from the \p
803  /// TaskFunction.
804  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
805  /// otherwise.
806  /// \param Data Additional data for task generation like tiednsee, final
807  /// state, list of privates etc.
808  virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
809  const OMPExecutableDirective &D,
810  llvm::Value *TaskFunction, QualType SharedsTy,
811  Address Shareds, const Expr *IfCond,
812  const OMPTaskDataTy &Data);
813 
814  /// Emit task region for the taskloop directive. The taskloop region is
815  /// emitted in several steps:
816  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
817  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
818  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
819  /// function:
820  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
821  /// TaskFunction(gtid, tt->part_id, tt->shareds);
822  /// return 0;
823  /// }
824  /// 2. Copy a list of shared variables to field shareds of the resulting
825  /// structure kmp_task_t returned by the previous call (if any).
826  /// 3. Copy a pointer to destructions function to field destructions of the
827  /// resulting structure kmp_task_t.
828  /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
829  /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
830  /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
831  /// is a resulting structure from
832  /// previous items.
833  /// \param D Current task directive.
834  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
835  /// /*part_id*/, captured_struct */*__context*/);
836  /// \param SharedsTy A type which contains references the shared variables.
837  /// \param Shareds Context with the list of shared variables from the \p
838  /// TaskFunction.
839  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
840  /// otherwise.
841  /// \param Data Additional data for task generation like tiednsee, final
842  /// state, list of privates etc.
843  virtual void emitTaskLoopCall(
844  CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D,
845  llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds,
846  const Expr *IfCond, const OMPTaskDataTy &Data);
847 
848  /// \brief Emit code for the directive that does not require outlining.
849  ///
850  /// \param InnermostKind Kind of innermost directive (for simple directives it
851  /// is a directive itself, for combined - its innermost directive).
852  /// \param CodeGen Code generation sequence for the \a D directive.
853  /// \param HasCancel true if region has inner cancel directive, false
854  /// otherwise.
855  virtual void emitInlinedDirective(CodeGenFunction &CGF,
856  OpenMPDirectiveKind InnermostKind,
857  const RegionCodeGenTy &CodeGen,
858  bool HasCancel = false);
859  /// \brief Emit a code for reduction clause. Next code should be emitted for
860  /// reduction:
861  /// \code
862  ///
863  /// static kmp_critical_name lock = { 0 };
864  ///
865  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
866  /// ...
867  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
868  /// ...
869  /// }
870  ///
871  /// ...
872  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
873  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
874  /// RedList, reduce_func, &<lock>)) {
875  /// case 1:
876  /// ...
877  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
878  /// ...
879  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
880  /// break;
881  /// case 2:
882  /// ...
883  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
884  /// ...
885  /// break;
886  /// default:;
887  /// }
888  /// \endcode
889  ///
890  /// \param Privates List of private copies for original reduction arguments.
891  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
892  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
893  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
894  /// or 'operator binop(LHS, RHS)'.
895  /// \param WithNowait true if parent directive has also nowait clause, false
896  /// otherwise.
897  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
899  ArrayRef<const Expr *> LHSExprs,
900  ArrayRef<const Expr *> RHSExprs,
901  ArrayRef<const Expr *> ReductionOps,
902  bool WithNowait, bool SimpleReduction);
903 
904  /// \brief Emit code for 'taskwait' directive.
905  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
906 
907  /// \brief Emit code for 'cancellation point' construct.
908  /// \param CancelRegion Region kind for which the cancellation point must be
909  /// emitted.
910  ///
911  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
912  SourceLocation Loc,
913  OpenMPDirectiveKind CancelRegion);
914 
915  /// \brief Emit code for 'cancel' construct.
916  /// \param IfCond Condition in the associated 'if' clause, if it was
917  /// specified, nullptr otherwise.
918  /// \param CancelRegion Region kind for which the cancel must be emitted.
919  ///
920  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
921  const Expr *IfCond,
922  OpenMPDirectiveKind CancelRegion);
923 
924  /// \brief Emit outilined function for 'target' directive.
925  /// \param D Directive to emit.
926  /// \param ParentName Name of the function that encloses the target region.
927  /// \param OutlinedFn Outlined function value to be defined by this call.
928  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
929  /// \param IsOffloadEntry True if the outlined function is an offload entry.
930  /// \param CodeGen Code generation sequence for the \a D directive.
931  /// An oulined function may not be an entry if, e.g. the if clause always
932  /// evaluates to false.
934  StringRef ParentName,
935  llvm::Function *&OutlinedFn,
936  llvm::Constant *&OutlinedFnID,
937  bool IsOffloadEntry,
938  const RegionCodeGenTy &CodeGen);
939 
940  /// \brief Emit the target offloading code associated with \a D. The emitted
941  /// code attempts offloading the execution to the device, an the event of
942  /// a failure it executes the host version outlined in \a OutlinedFn.
943  /// \param D Directive to emit.
944  /// \param OutlinedFn Host version of the code to be offloaded.
945  /// \param OutlinedFnID ID of host version of the code to be offloaded.
946  /// \param IfCond Expression evaluated in if clause associated with the target
947  /// directive, or null if no if clause is used.
948  /// \param Device Expression evaluated in device clause associated with the
949  /// target directive, or null if no device clause is used.
950  /// \param CapturedVars Values captured in the current region.
951  virtual void emitTargetCall(CodeGenFunction &CGF,
952  const OMPExecutableDirective &D,
953  llvm::Value *OutlinedFn,
954  llvm::Value *OutlinedFnID, const Expr *IfCond,
955  const Expr *Device,
956  ArrayRef<llvm::Value *> CapturedVars);
957 
958  /// \brief Emit the target regions enclosed in \a GD function definition or
959  /// the function itself in case it is a valid device function. Returns true if
960  /// \a GD was dealt with successfully.
961  /// \param GD Function to scan.
962  virtual bool emitTargetFunctions(GlobalDecl GD);
963 
964  /// \brief Emit the global variable if it is a valid device global variable.
965  /// Returns true if \a GD was dealt with successfully.
966  /// \param GD Variable declaration to emit.
967  virtual bool emitTargetGlobalVariable(GlobalDecl GD);
968 
969  /// \brief Emit the global \a GD if it is meaningful for the target. Returns
970  /// if it was emitted succesfully.
971  /// \param GD Global to scan.
972  virtual bool emitTargetGlobal(GlobalDecl GD);
973 
974  /// \brief Creates the offloading descriptor in the event any target region
975  /// was emitted in the current module and return the function that registers
976  /// it.
977  virtual llvm::Function *emitRegistrationFunction();
978 
979  /// \brief Emits code for teams call of the \a OutlinedFn with
980  /// variables captured in a record which address is stored in \a
981  /// CapturedStruct.
982  /// \param OutlinedFn Outlined function to be run by team masters. Type of
983  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
984  /// \param CapturedVars A pointer to the record with the references to
985  /// variables used in \a OutlinedFn function.
986  ///
987  virtual void emitTeamsCall(CodeGenFunction &CGF,
988  const OMPExecutableDirective &D,
989  SourceLocation Loc, llvm::Value *OutlinedFn,
990  ArrayRef<llvm::Value *> CapturedVars);
991 
992  /// \brief Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
993  /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
994  /// for num_teams clause.
995  /// \param NumTeams An integer expression of teams.
996  /// \param ThreadLimit An integer expression of threads.
997  virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
998  const Expr *ThreadLimit, SourceLocation Loc);
999 
1000  /// \brief Emit the target data mapping code associated with \a D.
1001  /// \param D Directive to emit.
1002  /// \param IfCond Expression evaluated in if clause associated with the target
1003  /// directive, or null if no if clause is used.
1004  /// \param Device Expression evaluated in device clause associated with the
1005  /// target directive, or null if no device clause is used.
1006  /// \param CodeGen Function that emits the enclosed region.
1007  virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1008  const OMPExecutableDirective &D,
1009  const Expr *IfCond, const Expr *Device,
1010  const RegionCodeGenTy &CodeGen);
1011 
1012  /// \brief Emit the data mapping/movement code associated with the directive
1013  /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1014  /// \param D Directive to emit.
1015  /// \param IfCond Expression evaluated in if clause associated with the target
1016  /// directive, or null if no if clause is used.
1017  /// \param Device Expression evaluated in device clause associated with the
1018  /// target directive, or null if no device clause is used.
1020  const OMPExecutableDirective &D,
1021  const Expr *IfCond,
1022  const Expr *Device);
1023 
1024  /// Marks function \a Fn with properly mangled versions of vector functions.
1025  /// \param FD Function marked as 'declare simd'.
1026  /// \param Fn LLVM function that must be marked with 'declare simd'
1027  /// attributes.
1028  virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1029  llvm::Function *Fn);
1030 
1031  /// Emit initialization for doacross loop nesting support.
1032  /// \param D Loop-based construct used in doacross nesting construct.
1033  virtual void emitDoacrossInit(CodeGenFunction &CGF,
1034  const OMPLoopDirective &D);
1035 
1036  /// Emit code for doacross ordered directive with 'depend' clause.
1037  /// \param C 'depend' clause with 'sink|source' dependency kind.
1038  virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1039  const OMPDependClause *C);
1040 };
1041 
1042 } // namespace CodeGen
1043 } // namespace clang
1044 
1045 #endif
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, llvm::Value *UB, llvm::Value *Chunk=nullptr)
QualType TgtDeviceImageQTy
struct __tgt_device_image{ void *ImageStart; // Pointer to the target code start. ...
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:124
A (possibly-)qualified type.
Definition: Type.h:598
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
llvm::SmallPtrSet< const VarDecl *, 4 > ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)
Emit code for the specified user defined reduction construct.
C Language Family Type Representation.
QualType getTgtBinaryDescriptorQTy()
Returns __tgt_bin_desc type.
SmallVector< std::pair< OpenMPDependClauseKind, const Expr * >, 4 > Dependences
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
SmallVector< const Expr *, 4 > LastprivateCopies
llvm::Constant * getOrCreateInternalVariable(llvm::Type *Ty, const llvm::Twine &Name)
Gets (if variable with the given name already exist) or creates internal global variable with the spe...
virtual void clear()
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and and emit all target regions found along the way.
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order)
virtual void Exit(CodeGenFunction &CGF)
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata...
QualType getTgtOffloadEntryQTy()
Returns __tgt_offload_entry type.
SmallVector< const Expr *, 4 > PrivateVars
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size)
Creates offloading entry for the provided entry ID ID, address Addr and size Size.
One of these records is kept for each identifier that is lexed.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc)
Emit flush of the variables specified in 'omp flush' directive.
SmallVector< const Expr *, 4 > LastprivateVars
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
FrontendAction * Action
Definition: Tooling.cpp:201
Defines some OpenMP-specific enums and functions.
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc...
Definition: StmtOpenMP.h:293
unsigned size() const
Return number of entries defined so far.
static bool classof(const OffloadEntryInfo *Info)
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:100
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
Call the appropriate runtime routine to initialize it before start of loop.
QualType TgtOffloadEntryQTy
Type struct __tgt_offload_entry{ void *addr; // Pointer to the offload entry info.
virtual std::pair< llvm::Function *, llvm::Function * > getUserDefinedReduction(const OMPDeclareReductionDecl *D)
Get combiner/initializer for the specified user-defined reduction, if any.
SmallVector< const Expr *, 4 > PrivateCopies
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
SmallVector< const Expr *, 4 > FirstprivateCopies
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type...
Definition: opencl-c.h:68
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, bool WithNowait, bool SimpleReduction)
Emit a code for reduction clause.
virtual llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST)
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
virtual llvm::Value * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts)
Emits outlined function for the OpenMP task directive D.
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param Data Additional data for task generation like final list of privates etc *virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
llvm::Constant * createForStaticInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_for_static_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
llvm::Constant * createDispatchFiniFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_fini_* runtime function for the specified size IVSize and sign IVSigned...
QualType getTgtDeviceImageQTy()
Returns __tgt_device_image type.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
RegionCodeGenTy(Callable &&CodeGen, typename std::enable_if< !std::is_same< typename std::remove_reference< Callable >::type, RegionCodeGenTy >::value >::type *=nullptr)
Expr - This represents one expression.
Definition: Expr.h:105
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with 'depend' clause.
void loadOffloadInfoMetadata()
Loads all the offload entries information from the host IR metadata.
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual ~CGOpenMPRuntime()
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
SmallVector< const Expr *, 4 > FirstprivateVars
virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Helper to emit outlined function for 'target' directive.
CGOpenMPRuntime(CodeGenModule &CGM)
*QualType KmpTaskTQTy
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
Definition: OpenMPKinds.h:51
virtual llvm::Function * emitRegistrationFunction()
Creates the offloading descriptor in the event any target region was emitted in the current module an...
llvm::Constant * createDispatchInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc)
Emit code for 'taskwait' directive.
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
virtual void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen)
Emit the target data mapping code associated with D.
QualType TgtBinaryDescriptorQTy
struct __tgt_bin_desc{ int32_t NumDevices; // Number of devices supported.
The l-value was considered opaque, so the alignment was determined from a type.
Kind
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags=0)
Emits object of ident_t type with info for source location.
void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
Encodes a location in the source.
llvm::function_ref< void(unsigned, unsigned, StringRef, unsigned, OffloadEntryInfoTargetRegion &)> OffloadTargetRegionEntryInfoActTy
brief Applies action Action on all registered entries.
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:102
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc)
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams...
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param Data Additional data for task generation like final list of privates etc *virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
const std::string ID
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
OffloadEntryInfoTargetRegion(unsigned Order, llvm::Constant *Addr, llvm::Constant *ID)
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...
virtual void Enter(CodeGenFunction &CGF)
An aligned address.
Definition: Address.h:25
void setAction(PrePostActionTy &Action) const
void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr, llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc)
Emits initialization code for the threadprivate variables.
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final list of privates etc *TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const OMPTaskDataTy &Data)
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
This class organizes the cross-function state that is used while generating LLVM code.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc)
Call the appropriate runtime routine to notify that we finished all the work with current loop...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
llvm::Function * createOffloadingBinaryDescriptorRegistration()
Creates and registers offloading binary descriptor for the current compilation unit.
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Value *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, const Expr *Device, ArrayRef< llvm::Value * > CapturedVars)
Emit the target offloading code associated with D.
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for 'target' directive.
OffloadEntriesInfoManagerTy OffloadEntriesInfoManager
virtual llvm::Value * emitParallelOrTeamsOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP parallel directive D.
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:59
Entity that registers the offloading constants that were emitted so far.
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
llvm::Constant * createDispatchNextFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_next_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
virtual void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars)
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
Defines the clang::SourceLocation class and associated facilities.
llvm::PointerIntPair< llvm::Value *, 1, bool > Schedule
Privates[]
Gets the list of initial values for linear variables.
Definition: OpenMPClause.h:312
virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned)
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
virtual 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)...
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
virtual void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc)
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D)
Emit initialization for doacross loop nesting support.
QualType KmpDimTy
struct kmp_dim { // loop bounds info casted to kmp_int64 kmp_int64 lo; // lower kmp_int64 up; // uppe...
LValue - This represents an lvalue references.
Definition: CGValue.h:152
llvm::Constant * createRuntimeFunction(unsigned Function)
Returns specified OpenMP runtime function.
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
void operator()(CodeGenFunction &CGF) const
virtual void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps)
Emits a single region.
SmallVector< const Expr *, 4 > FirstprivateInits
llvm::Constant * getOrCreateThreadPrivateCache(const VarDecl *VD)
If the specified mangled name is not in the module, create and return threadprivate cache object...
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...