• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
19 #include "clang/Basic/OpenMPKinds.h"
20 #include "clang/Basic/SourceLocation.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.
54 class PrePostActionTy {
55 public:
PrePostActionTy()56   explicit PrePostActionTy() {}
Enter(CodeGenFunction & CGF)57   virtual void Enter(CodeGenFunction &CGF) {}
Exit(CodeGenFunction & CGF)58   virtual void Exit(CodeGenFunction &CGF) {}
~PrePostActionTy()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>
CallbackFn(intptr_t CodeGen,CodeGenFunction & CGF,PrePostActionTy & Action)72   static void CallbackFn(intptr_t CodeGen, CodeGenFunction &CGF,
73                          PrePostActionTy &Action) {
74     return (*reinterpret_cast<Callable *>(CodeGen))(CGF, Action);
75   }
76 
77 public:
78   template <typename Callable>
79   RegionCodeGenTy(
80       Callable &&CodeGen,
81       typename std::enable_if<
82           !std::is_same<typename std::remove_reference<Callable>::type,
83                         RegionCodeGenTy>::value>::type * = nullptr)
CodeGen(reinterpret_cast<intptr_t> (& CodeGen))84       : CodeGen(reinterpret_cast<intptr_t>(&CodeGen)),
85         Callback(CallbackFn<typename std::remove_reference<Callable>::type>),
86         PrePostAction(nullptr) {}
setAction(PrePostActionTy & Action)87   void setAction(PrePostActionTy &Action) const { PrePostAction = &Action; }
88   void operator()(CodeGenFunction &CGF) const;
89 };
90 
91 struct OMPTaskDataTy final {
92   SmallVector<const Expr *, 4> PrivateVars;
93   SmallVector<const Expr *, 4> PrivateCopies;
94   SmallVector<const Expr *, 4> FirstprivateVars;
95   SmallVector<const Expr *, 4> FirstprivateCopies;
96   SmallVector<const Expr *, 4> FirstprivateInits;
97   SmallVector<const Expr *, 4> LastprivateVars;
98   SmallVector<const Expr *, 4> LastprivateCopies;
99   SmallVector<std::pair<OpenMPDependClauseKind, const Expr *>, 4> Dependences;
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 
108 class CGOpenMPRuntime {
109 protected:
110   CodeGenModule &CGM;
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.
126   virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D,
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 *,
166                          SmallVector<const OMPDeclareReductionDecl *, 4>>
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;
195   QualType KmpTaskTQTy;
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;
204   QualType KmpDependInfoTy;
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   /// };
210   QualType KmpDimTy;
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   /// };
217   QualType TgtOffloadEntryQTy;
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   /// };
228   QualType TgtDeviceImageQTy;
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   /// };
238   QualType TgtBinaryDescriptorQTy;
239   /// \brief Entity that registers the offloading constants that were emitted so
240   /// far.
241   class OffloadEntriesInfoManagerTy {
242     CodeGenModule &CGM;
243 
244     /// \brief Number of entries registered so far.
245     unsigned OffloadingEntriesNum;
246 
247   public:
248     /// \brief Base class of the entries info.
249     class OffloadEntryInfo {
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 
OffloadEntryInfo()260       OffloadEntryInfo() : Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
OffloadEntryInfo(OffloadingEntryInfoKinds Kind,unsigned Order)261       explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order)
262           : Order(Order), Kind(Kind) {}
263 
isValid()264       bool isValid() const { return Order != ~0u; }
getOrder()265       unsigned getOrder() const { return Order; }
getKind()266       OffloadingEntryInfoKinds getKind() const { return Kind; }
classof(const OffloadEntryInfo * Info)267       static bool classof(const OffloadEntryInfo *Info) { return true; }
268 
269     protected:
270       // \brief Order this entry was emitted.
271       unsigned Order;
272 
273       OffloadingEntryInfoKinds Kind;
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.
size()279     unsigned size() const { return OffloadingEntriesNum; }
OffloadEntriesInfoManagerTy(CodeGenModule & CGM)280     OffloadEntriesInfoManagerTy(CodeGenModule &CGM)
281         : CGM(CGM), OffloadingEntriesNum(0) {}
282 
283     ///
284     /// Target region entries related.
285     ///
286     /// \brief Target region entries info.
287     class OffloadEntryInfoTargetRegion : public OffloadEntryInfo {
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:
OffloadEntryInfoTargetRegion()294       OffloadEntryInfoTargetRegion()
295           : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, ~0u),
296             Addr(nullptr), ID(nullptr) {}
OffloadEntryInfoTargetRegion(unsigned Order,llvm::Constant * Addr,llvm::Constant * ID)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 
getAddress()303       llvm::Constant *getAddress() const { return Addr; }
getID()304       llvm::Constant *getID() const { return ID; }
setAddress(llvm::Constant * V)305       void setAddress(llvm::Constant *V) {
306         assert(!Addr && "Address as been set before!");
307         Addr = V;
308       }
setID(llvm::Constant * V)309       void setID(llvm::Constant *V) {
310         assert(!ID && "ID as been set before!");
311         ID = V;
312       }
classof(const OffloadEntryInfo * Info)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 &)>
333         OffloadTargetRegionEntryInfoActTy;
334     void actOnTargetRegionEntriesInfo(
335         const OffloadTargetRegionEntryInfoActTy &Action);
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   };
351   OffloadEntriesInfoManagerTy OffloadEntriesInfoManager;
352 
353   /// \brief Creates and registers offloading binary descriptor for the current
354   /// compilation unit. The function that does the registration is returned.
355   llvm::Function *createOffloadingBinaryDescriptorRegistration();
356 
357   /// \brief Creates all the offload entries in the current compilation unit
358   /// along with the associated metadata.
359   void createOffloadEntriesAndInfoMetadata();
360 
361   /// \brief Loads all the offload entries information from the host IR
362   /// metadata.
363   void loadOffloadInfoMetadata();
364 
365   /// \brief Returns __tgt_offload_entry type.
366   QualType getTgtOffloadEntryQTy();
367 
368   /// \brief Returns __tgt_device_image type.
369   QualType getTgtDeviceImageQTy();
370 
371   /// \brief Returns __tgt_bin_desc type.
372   QualType getTgtBinaryDescriptorQTy();
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   ///
386   llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
387                                   unsigned Flags = 0);
388 
389   /// \brief Returns pointer to ident_t type.
390   llvm::Type *getIdentTyPointerTy();
391 
392   /// \brief Returns pointer to kmpc_micro type.
393   llvm::Type *getKmpc_MicroPointerTy();
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.
425   virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
426 
427   /// \brief Gets thread id value for the current thread.
428   ///
429   llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
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.
449   void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
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;
464     LValue TDBase;
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.
490   TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
491                             const OMPExecutableDirective &D,
492                             llvm::Value *TaskFunction, QualType SharedsTy,
493                             Address Shareds, const OMPTaskDataTy &Data);
494 
495 public:
496   explicit CGOpenMPRuntime(CodeGenModule &CGM);
~CGOpenMPRuntime()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 *>
505   getUserDefinedReduction(const OMPDeclareReductionDecl *D);
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.
514   virtual llvm::Value *emitParallelOrTeamsOutlinedFunction(
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   ///
533   virtual llvm::Value *emitTaskOutlinedFunction(
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,
612                                OpenMPDirectiveKind Kind,
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,
693                                         OpenMPDistScheduleClauseKind SchedKind,
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,
898                              ArrayRef<const Expr *> Privates,
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.
933   virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
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.
1019   virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF,
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
1046