clang  3.8.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 "clang/AST/Type.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/DenseSet.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/IR/ValueHandle.h"
24 
25 namespace llvm {
26 class ArrayType;
27 class Constant;
28 class Function;
29 class FunctionType;
30 class GlobalVariable;
31 class StructType;
32 class Type;
33 class Value;
34 } // namespace llvm
35 
36 namespace clang {
37 class Expr;
38 class GlobalDecl;
39 class OMPExecutableDirective;
40 class VarDecl;
41 
42 namespace CodeGen {
43 class Address;
44 class CodeGenFunction;
46 
47 typedef llvm::function_ref<void(CodeGenFunction &)> RegionCodeGenTy;
48 
50 private:
51  enum OpenMPRTLFunction {
52  /// \brief Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc,
53  /// kmpc_micro microtask, ...);
54  OMPRTL__kmpc_fork_call,
55  /// \brief Call to void *__kmpc_threadprivate_cached(ident_t *loc,
56  /// kmp_int32 global_tid, void *data, size_t size, void ***cache);
57  OMPRTL__kmpc_threadprivate_cached,
58  /// \brief Call to void __kmpc_threadprivate_register( ident_t *,
59  /// void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor);
60  OMPRTL__kmpc_threadprivate_register,
61  // Call to __kmpc_int32 kmpc_global_thread_num(ident_t *loc);
62  OMPRTL__kmpc_global_thread_num,
63  // Call to void __kmpc_critical(ident_t *loc, kmp_int32 global_tid,
64  // kmp_critical_name *crit);
65  OMPRTL__kmpc_critical,
66  // Call to void __kmpc_critical_with_hint(ident_t *loc, kmp_int32
67  // global_tid, kmp_critical_name *crit, uintptr_t hint);
68  OMPRTL__kmpc_critical_with_hint,
69  // Call to void __kmpc_end_critical(ident_t *loc, kmp_int32 global_tid,
70  // kmp_critical_name *crit);
71  OMPRTL__kmpc_end_critical,
72  // Call to kmp_int32 __kmpc_cancel_barrier(ident_t *loc, kmp_int32
73  // global_tid);
74  OMPRTL__kmpc_cancel_barrier,
75  // Call to void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid);
76  OMPRTL__kmpc_barrier,
77  // Call to void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid);
78  OMPRTL__kmpc_for_static_fini,
79  // Call to void __kmpc_serialized_parallel(ident_t *loc, kmp_int32
80  // global_tid);
81  OMPRTL__kmpc_serialized_parallel,
82  // Call to void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32
83  // global_tid);
84  OMPRTL__kmpc_end_serialized_parallel,
85  // Call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid,
86  // kmp_int32 num_threads);
87  OMPRTL__kmpc_push_num_threads,
88  // Call to void __kmpc_flush(ident_t *loc);
89  OMPRTL__kmpc_flush,
90  // Call to kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
91  OMPRTL__kmpc_master,
92  // Call to void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
93  OMPRTL__kmpc_end_master,
94  // Call to kmp_int32 __kmpc_omp_taskyield(ident_t *, kmp_int32 global_tid,
95  // int end_part);
96  OMPRTL__kmpc_omp_taskyield,
97  // Call to kmp_int32 __kmpc_single(ident_t *, kmp_int32 global_tid);
98  OMPRTL__kmpc_single,
99  // Call to void __kmpc_end_single(ident_t *, kmp_int32 global_tid);
100  OMPRTL__kmpc_end_single,
101  // Call to kmp_task_t * __kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
102  // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
103  // kmp_routine_entry_t *task_entry);
104  OMPRTL__kmpc_omp_task_alloc,
105  // Call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t *
106  // new_task);
107  OMPRTL__kmpc_omp_task,
108  // Call to void __kmpc_copyprivate(ident_t *loc, kmp_int32 global_tid,
109  // size_t cpy_size, void *cpy_data, void(*cpy_func)(void *, void *),
110  // kmp_int32 didit);
111  OMPRTL__kmpc_copyprivate,
112  // Call to kmp_int32 __kmpc_reduce(ident_t *loc, kmp_int32 global_tid,
113  // kmp_int32 num_vars, size_t reduce_size, void *reduce_data, void
114  // (*reduce_func)(void *lhs_data, void *rhs_data), kmp_critical_name *lck);
115  OMPRTL__kmpc_reduce,
116  // Call to kmp_int32 __kmpc_reduce_nowait(ident_t *loc, kmp_int32
117  // global_tid, kmp_int32 num_vars, size_t reduce_size, void *reduce_data,
118  // void (*reduce_func)(void *lhs_data, void *rhs_data), kmp_critical_name
119  // *lck);
120  OMPRTL__kmpc_reduce_nowait,
121  // Call to void __kmpc_end_reduce(ident_t *loc, kmp_int32 global_tid,
122  // kmp_critical_name *lck);
123  OMPRTL__kmpc_end_reduce,
124  // Call to void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
125  // kmp_critical_name *lck);
126  OMPRTL__kmpc_end_reduce_nowait,
127  // Call to void __kmpc_omp_task_begin_if0(ident_t *, kmp_int32 gtid,
128  // kmp_task_t * new_task);
129  OMPRTL__kmpc_omp_task_begin_if0,
130  // Call to void __kmpc_omp_task_complete_if0(ident_t *, kmp_int32 gtid,
131  // kmp_task_t * new_task);
132  OMPRTL__kmpc_omp_task_complete_if0,
133  // Call to void __kmpc_ordered(ident_t *loc, kmp_int32 global_tid);
134  OMPRTL__kmpc_ordered,
135  // Call to void __kmpc_end_ordered(ident_t *loc, kmp_int32 global_tid);
136  OMPRTL__kmpc_end_ordered,
137  // Call to kmp_int32 __kmpc_omp_taskwait(ident_t *loc, kmp_int32
138  // global_tid);
139  OMPRTL__kmpc_omp_taskwait,
140  // Call to void __kmpc_taskgroup(ident_t *loc, kmp_int32 global_tid);
141  OMPRTL__kmpc_taskgroup,
142  // Call to void __kmpc_end_taskgroup(ident_t *loc, kmp_int32 global_tid);
143  OMPRTL__kmpc_end_taskgroup,
144  // Call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid,
145  // int proc_bind);
146  OMPRTL__kmpc_push_proc_bind,
147  // Call to kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32
148  // gtid, kmp_task_t * new_task, kmp_int32 ndeps, kmp_depend_info_t
149  // *dep_list, kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list);
150  OMPRTL__kmpc_omp_task_with_deps,
151  // Call to void __kmpc_omp_wait_deps(ident_t *loc_ref, kmp_int32
152  // gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list, kmp_int32
153  // ndeps_noalias, kmp_depend_info_t *noalias_dep_list);
154  OMPRTL__kmpc_omp_wait_deps,
155  // Call to kmp_int32 __kmpc_cancellationpoint(ident_t *loc, kmp_int32
156  // global_tid, kmp_int32 cncl_kind);
157  OMPRTL__kmpc_cancellationpoint,
158  // Call to kmp_int32 __kmpc_cancel(ident_t *loc, kmp_int32 global_tid,
159  // kmp_int32 cncl_kind);
160  OMPRTL__kmpc_cancel,
161 
162  //
163  // Offloading related calls
164  //
165  // Call to int32_t __tgt_target(int32_t device_id, void *host_ptr, int32_t
166  // arg_num, void** args_base, void **args, size_t *arg_sizes, int32_t
167  // *arg_types);
168  OMPRTL__tgt_target,
169  // Call to void __tgt_register_lib(__tgt_bin_desc *desc);
170  OMPRTL__tgt_register_lib,
171  // Call to void __tgt_unregister_lib(__tgt_bin_desc *desc);
172  OMPRTL__tgt_unregister_lib,
173  };
174 
175  /// \brief Values for bit flags used in the ident_t to describe the fields.
176  /// All enumeric elements are named and described in accordance with the code
177  /// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
178  enum OpenMPLocationFlags {
179  /// \brief Use trampoline for internal microtask.
180  OMP_IDENT_IMD = 0x01,
181  /// \brief Use c-style ident structure.
182  OMP_IDENT_KMPC = 0x02,
183  /// \brief Atomic reduction option for kmpc_reduce.
184  OMP_ATOMIC_REDUCE = 0x10,
185  /// \brief Explicit 'barrier' directive.
186  OMP_IDENT_BARRIER_EXPL = 0x20,
187  /// \brief Implicit barrier in code.
188  OMP_IDENT_BARRIER_IMPL = 0x40,
189  /// \brief Implicit barrier in 'for' directive.
190  OMP_IDENT_BARRIER_IMPL_FOR = 0x40,
191  /// \brief Implicit barrier in 'sections' directive.
192  OMP_IDENT_BARRIER_IMPL_SECTIONS = 0xC0,
193  /// \brief Implicit barrier in 'single' directive.
194  OMP_IDENT_BARRIER_IMPL_SINGLE = 0x140
195  };
196  CodeGenModule &CGM;
197  /// \brief Default const ident_t object used for initialization of all other
198  /// ident_t objects.
199  llvm::Constant *DefaultOpenMPPSource;
200  /// \brief Map of flags and corresponding default locations.
201  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
202  OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
203  Address getOrCreateDefaultLocation(OpenMPLocationFlags Flags);
204 
205 public:
206  /// \brief Describes ident structure that describes a source location.
207  /// All descriptions are taken from
208  /// http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
209  /// Original structure:
210  /// typedef struct ident {
211  /// kmp_int32 reserved_1; /**< might be used in Fortran;
212  /// see above */
213  /// kmp_int32 flags; /**< also f.flags; KMP_IDENT_xxx flags;
214  /// KMP_IDENT_KMPC identifies this union
215  /// member */
216  /// kmp_int32 reserved_2; /**< not really used in Fortran any more;
217  /// see above */
218  ///#if USE_ITT_BUILD
219  /// /* but currently used for storing
220  /// region-specific ITT */
221  /// /* contextual information. */
222  ///#endif /* USE_ITT_BUILD */
223  /// kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for
224  /// C++ */
225  /// char const *psource; /**< String describing the source location.
226  /// The string is composed of semi-colon separated
227  // fields which describe the source file,
228  /// the function and a pair of line numbers that
229  /// delimit the construct.
230  /// */
231  /// } ident_t;
233  /// \brief might be used in Fortran
235  /// \brief OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member.
237  /// \brief Not really used in Fortran any more
239  /// \brief Source[4] in Fortran, do not use for C++
241  /// \brief String describing the source location. The string is composed of
242  /// semi-colon separated fields which describe the source file, the function
243  /// and a pair of line numbers that delimit the construct.
245  };
246 private:
247  llvm::StructType *IdentTy;
248  /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
249  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
251  /// \brief The type for a microtask which gets passed to __kmpc_fork_call().
252  /// Original representation is:
253  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
254  llvm::FunctionType *Kmpc_MicroTy;
255  /// \brief Stores debug location and ThreadID for the function.
256  struct DebugLocThreadIdTy {
257  llvm::Value *DebugLoc;
258  llvm::Value *ThreadID;
259  };
260  /// \brief Map of local debug location, ThreadId and functions.
261  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
264  /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
265  /// kmp_critical_name[8];
266  llvm::ArrayType *KmpCriticalNameTy;
267  /// \brief An ordered map of auto-generated variables to their unique names.
268  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
269  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
270  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
271  /// variables.
272  llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
274  /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
277  /// \brief Type typedef struct kmp_task {
278  /// void * shareds; /**< pointer to block of pointers to
279  /// shared vars */
280  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
281  /// executing task */
282  /// kmp_int32 part_id; /**< part id for the task */
283  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
284  /// deconstructors of firstprivate C++ objects */
285  /// } kmp_task_t;
287  /// \brief Type typedef struct kmp_depend_info {
288  /// kmp_intptr_t base_addr;
289  /// size_t len;
290  /// struct {
291  /// bool in:1;
292  /// bool out:1;
293  /// } flags;
294  /// } kmp_depend_info_t;
296  /// \brief Type struct __tgt_offload_entry{
297  /// void *addr; // Pointer to the offload entry info.
298  /// // (function or global)
299  /// char *name; // Name of the function or global.
300  /// size_t size; // Size of the entry info (0 if it a function).
301  /// };
303  /// struct __tgt_device_image{
304  /// void *ImageStart; // Pointer to the target code start.
305  /// void *ImageEnd; // Pointer to the target code end.
306  /// // We also add the host entries to the device image, as it may be useful
307  /// // for the target runtime to have access to that information.
308  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all
309  /// // the entries.
310  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
311  /// // entries (non inclusive).
312  /// };
314  /// struct __tgt_bin_desc{
315  /// int32_t NumDevices; // Number of devices supported.
316  /// __tgt_device_image *DeviceImages; // Arrays of device images
317  /// // (one per device).
318  /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the
319  /// // entries.
320  /// __tgt_offload_entry *EntriesEnd; // End of the table with all the
321  /// // entries (non inclusive).
322  /// };
324  /// \brief Entity that registers the offloading constants that were emitted so
325  /// far.
327  CodeGenModule &CGM;
328 
329  /// \brief Number of entries registered so far.
330  unsigned OffloadingEntriesNum;
331 
332  public:
333  /// \brief Base class of the entries info.
335  public:
336  /// \brief Kind of a given entry. Currently, only target regions are
337  /// supported.
338  enum OffloadingEntryInfoKinds : unsigned {
339  // Entry is a target region.
340  OFFLOAD_ENTRY_INFO_TARGET_REGION = 0,
341  // Invalid entry info.
342  OFFLOAD_ENTRY_INFO_INVALID = ~0u
343  };
344 
345  OffloadEntryInfo() : Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
347  : Order(Order), Kind(Kind) {}
348 
349  bool isValid() const { return Order != ~0u; }
350  unsigned getOrder() const { return Order; }
352  static bool classof(const OffloadEntryInfo *Info) { return true; }
353 
354  protected:
355  // \brief Order this entry was emitted.
356  unsigned Order;
357 
359  };
360 
361  /// \brief Return true if a there are no entries defined.
362  bool empty() const;
363  /// \brief Return number of entries defined so far.
364  unsigned size() const { return OffloadingEntriesNum; }
365  OffloadEntriesInfoManagerTy(CodeGenModule &CGM)
366  : CGM(CGM), OffloadingEntriesNum(0) {}
367 
368  ///
369  /// Target region entries related.
370  ///
371  /// \brief Target region entries info.
373  // \brief Address of the entity that has to be mapped for offloading.
374  llvm::Constant *Addr;
375  // \brief Address that can be used as the ID of the entry.
376  llvm::Constant *ID;
377 
378  public:
380  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, ~0u),
381  Addr(nullptr), ID(nullptr) {}
382  explicit OffloadEntryInfoTargetRegion(unsigned Order,
383  llvm::Constant *Addr,
384  llvm::Constant *ID)
385  : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_TARGET_REGION, Order),
386  Addr(Addr), ID(ID) {}
387 
388  llvm::Constant *getAddress() const { return Addr; }
389  llvm::Constant *getID() const { return ID; }
390  void setAddress(llvm::Constant *V) {
391  assert(!Addr && "Address as been set before!");
392  Addr = V;
393  }
394  void setID(llvm::Constant *V) {
395  assert(!ID && "ID as been set before!");
396  ID = V;
397  }
398  static bool classof(const OffloadEntryInfo *Info) {
399  return Info->getKind() == OFFLOAD_ENTRY_INFO_TARGET_REGION;
400  }
401  };
402  /// \brief Initialize target region entry.
403  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
404  StringRef ParentName, unsigned LineNum,
405  unsigned ColNum, unsigned Order);
406  /// \brief Register target region entry.
407  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
408  StringRef ParentName, unsigned LineNum,
409  unsigned ColNum, llvm::Constant *Addr,
410  llvm::Constant *ID);
411  /// \brief Return true if a target region entry with the provided
412  /// information exists.
413  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
414  StringRef ParentName, unsigned LineNum,
415  unsigned ColNum) const;
416  /// brief Applies action \a Action on all registered entries.
417  typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
418  unsigned, OffloadEntryInfoTargetRegion &)>
420  void actOnTargetRegionEntriesInfo(
422 
423  private:
424  // Storage for target region entries kind. The storage is to be indexed by
425  // file ID, device ID, parent function name, lane number, and column number.
426  typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
427  OffloadEntriesTargetRegionPerColumn;
428  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerColumn>
429  OffloadEntriesTargetRegionPerLine;
430  typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
431  OffloadEntriesTargetRegionPerParentName;
432  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
433  OffloadEntriesTargetRegionPerFile;
434  typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
435  OffloadEntriesTargetRegionPerDevice;
436  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
437  OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
438  };
440 
441  /// \brief Creates and registers offloading binary descriptor for the current
442  /// compilation unit. The function that does the registration is returned.
444 
445  /// \brief Creates offloading entry for the provided address \a Addr,
446  /// name \a Name and size \a Size.
447  void createOffloadEntry(llvm::Constant *Addr, StringRef Name, uint64_t Size);
448 
449  /// \brief Creates all the offload entries in the current compilation unit
450  /// along with the associated metadata.
452 
453  /// \brief Loads all the offload entries information from the host IR
454  /// metadata.
456 
457  /// \brief Returns __tgt_offload_entry type.
459 
460  /// \brief Returns __tgt_device_image type.
462 
463  /// \brief Returns __tgt_bin_desc type.
465 
466  /// \brief Start scanning from statement \a S and and emit all target regions
467  /// found along the way.
468  /// \param S Starting statement.
469  /// \param ParentName Name of the function declaration that is being scanned.
470  void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
471 
472  /// \brief Build type kmp_routine_entry_t (if not built yet).
473  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
474 
475  /// \brief Emits object of ident_t type with info for source location.
476  /// \param Flags Flags for OpenMP location.
477  ///
478  llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
479  OpenMPLocationFlags Flags = OMP_IDENT_KMPC);
480 
481  /// \brief Returns pointer to ident_t type.
483 
484  /// \brief Returns pointer to kmpc_micro type.
486 
487  /// \brief Returns specified OpenMP runtime function.
488  /// \param Function OpenMP runtime function.
489  /// \return Specified function.
490  llvm::Constant *createRuntimeFunction(OpenMPRTLFunction Function);
491 
492  /// \brief Returns __kmpc_for_static_init_* runtime function for the specified
493  /// size \a IVSize and sign \a IVSigned.
494  llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
495 
496  /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified
497  /// size \a IVSize and sign \a IVSigned.
498  llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
499 
500  /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified
501  /// size \a IVSize and sign \a IVSigned.
502  llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
503 
504  /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified
505  /// size \a IVSize and sign \a IVSigned.
506  llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
507 
508  /// \brief If the specified mangled name is not in the module, create and
509  /// return threadprivate cache object. This object is a pointer's worth of
510  /// storage that's reserved for use by the OpenMP runtime.
511  /// \param VD Threadprivate variable.
512  /// \return Cache variable for the specified threadprivate.
513  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
514 
515  /// \brief Emits address of the word in a memory where current thread id is
516  /// stored.
517  virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
518 
519  /// \brief Gets thread id value for the current thread.
520  ///
521  llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
522 
523  /// \brief Gets (if variable with the given name already exist) or creates
524  /// internal global variable with the specified Name. The created variable has
525  /// linkage CommonLinkage by default and is initialized by null value.
526  /// \param Ty Type of the global variable. If it is exist already the type
527  /// must be the same.
528  /// \param Name Name of the variable.
529  llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
530  const llvm::Twine &Name);
531 
532  /// \brief Set of threadprivate variables with the generated initializer.
534 
535  /// \brief Emits initialization code for the threadprivate variables.
536  /// \param VDAddr Address of the global variable \a VD.
537  /// \param Ctor Pointer to a global init function for \a VD.
538  /// \param CopyCtor Pointer to a global copy function for \a VD.
539  /// \param Dtor Pointer to a global destructor function for \a VD.
540  /// \param Loc Location of threadprivate declaration.
541  void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
542  llvm::Value *Ctor, llvm::Value *CopyCtor,
543  llvm::Value *Dtor, SourceLocation Loc);
544 
545  /// \brief Returns corresponding lock object for the specified critical region
546  /// name. If the lock object does not exist it is created, otherwise the
547  /// reference to the existing copy is returned.
548  /// \param CriticalName Name of the critical region.
549  ///
550  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
551 
552 public:
553  explicit CGOpenMPRuntime(CodeGenModule &CGM);
554  virtual ~CGOpenMPRuntime() {}
555  virtual void clear();
556 
557  /// \brief Emits outlined function for the specified OpenMP parallel directive
558  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
559  /// kmp_int32 BoundID, struct context_vars*).
560  /// \param D OpenMP directive.
561  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
562  /// \param InnermostKind Kind of innermost directive (for simple directives it
563  /// is a directive itself, for combined - its innermost directive).
564  /// \param CodeGen Code generation sequence for the \a D directive.
566  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
567  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
568 
569  /// \brief Emits outlined function for the OpenMP task directive \a D. This
570  /// outlined function has type void(*)(kmp_int32 ThreadID, kmp_int32
571  /// PartID, struct context_vars*).
572  /// \param D OpenMP directive.
573  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
574  /// \param InnermostKind Kind of innermost directive (for simple directives it
575  /// is a directive itself, for combined - its innermost directive).
576  /// \param CodeGen Code generation sequence for the \a D directive.
577  ///
579  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
580  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
581 
582  /// \brief Cleans up references to the objects in finished function.
583  ///
584  void functionFinished(CodeGenFunction &CGF);
585 
586  /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
587  /// variables captured in a record which address is stored in \a
588  /// CapturedStruct.
589  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
590  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
591  /// \param CapturedVars A pointer to the record with the references to
592  /// variables used in \a OutlinedFn function.
593  /// \param IfCond Condition in the associated 'if' clause, if it was
594  /// specified, nullptr otherwise.
595  ///
596  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
597  llvm::Value *OutlinedFn,
598  ArrayRef<llvm::Value *> CapturedVars,
599  const Expr *IfCond);
600 
601  /// \brief Emits a critical region.
602  /// \param CriticalName Name of the critical region.
603  /// \param CriticalOpGen Generator for the statement associated with the given
604  /// critical region.
605  /// \param Hint Value of the 'hint' clause (optional).
606  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
607  const RegionCodeGenTy &CriticalOpGen,
608  SourceLocation Loc,
609  const Expr *Hint = nullptr);
610 
611  /// \brief Emits a master region.
612  /// \param MasterOpGen Generator for the statement associated with the given
613  /// master region.
614  virtual void emitMasterRegion(CodeGenFunction &CGF,
615  const RegionCodeGenTy &MasterOpGen,
616  SourceLocation Loc);
617 
618  /// \brief Emits code for a taskyield directive.
619  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
620 
621  /// \brief Emit a taskgroup region.
622  /// \param TaskgroupOpGen Generator for the statement associated with the
623  /// given taskgroup region.
624  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
625  const RegionCodeGenTy &TaskgroupOpGen,
626  SourceLocation Loc);
627 
628  /// \brief Emits a single region.
629  /// \param SingleOpGen Generator for the statement associated with the given
630  /// single region.
631  virtual void emitSingleRegion(CodeGenFunction &CGF,
632  const RegionCodeGenTy &SingleOpGen,
633  SourceLocation Loc,
634  ArrayRef<const Expr *> CopyprivateVars,
635  ArrayRef<const Expr *> DestExprs,
636  ArrayRef<const Expr *> SrcExprs,
637  ArrayRef<const Expr *> AssignmentOps);
638 
639  /// \brief Emit an ordered region.
640  /// \param OrderedOpGen Generator for the statement associated with the given
641  /// ordered region.
642  virtual void emitOrderedRegion(CodeGenFunction &CGF,
643  const RegionCodeGenTy &OrderedOpGen,
644  SourceLocation Loc, bool IsThreads);
645 
646  /// \brief Emit an implicit/explicit barrier for OpenMP threads.
647  /// \param Kind Directive for which this implicit barrier call must be
648  /// generated. Must be OMPD_barrier for explicit barrier generation.
649  /// \param EmitChecks true if need to emit checks for cancellation barriers.
650  /// \param ForceSimpleCall true simple barrier call must be emitted, false if
651  /// runtime class decides which one to emit (simple or with cancellation
652  /// checks).
653  ///
654  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
656  bool EmitChecks = true,
657  bool ForceSimpleCall = false);
658 
659  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
660  /// This kind of worksharing directive is emitted without outer loop.
661  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
662  /// \param Chunked True if chunk is specified in the clause.
663  ///
664  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
665  bool Chunked) const;
666 
667  /// \brief Check if the specified \a ScheduleKind is dynamic.
668  /// This kind of worksharing directive is emitted without outer loop.
669  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
670  ///
671  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
672 
673  virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc,
674  OpenMPScheduleClauseKind SchedKind,
675  unsigned IVSize, bool IVSigned,
676  bool Ordered, llvm::Value *UB,
677  llvm::Value *Chunk = nullptr);
678 
679  /// \brief Call the appropriate runtime routine to initialize it before start
680  /// of loop.
681  ///
682  /// Depending on the loop schedule, it is nesessary to call some runtime
683  /// routine before start of the OpenMP loop to get the loop upper / lower
684  /// bounds \a LB and \a UB and stride \a ST.
685  ///
686  /// \param CGF Reference to current CodeGenFunction.
687  /// \param Loc Clang source location.
688  /// \param SchedKind Schedule kind, specified by the 'schedule' clause.
689  /// \param IVSize Size of the iteration variable in bits.
690  /// \param IVSigned Sign of the interation variable.
691  /// \param Ordered true if loop is ordered, false otherwise.
692  /// \param IL Address of the output variable in which the flag of the
693  /// last iteration is returned.
694  /// \param LB Address of the output variable in which the lower iteration
695  /// number is returned.
696  /// \param UB Address of the output variable in which the upper iteration
697  /// number is returned.
698  /// \param ST Address of the output variable in which the stride value is
699  /// returned nesessary to generated the static_chunked scheduled loop.
700  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
701  /// For the default (nullptr) value, the chunk 1 will be used.
702  ///
703  virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
704  OpenMPScheduleClauseKind SchedKind,
705  unsigned IVSize, bool IVSigned, bool Ordered,
706  Address IL, Address LB,
707  Address UB, Address ST,
708  llvm::Value *Chunk = nullptr);
709 
710  /// \brief Call the appropriate runtime routine to notify that we finished
711  /// iteration of the ordered loop with the dynamic scheduling.
712  ///
713  /// \param CGF Reference to current CodeGenFunction.
714  /// \param Loc Clang source location.
715  /// \param IVSize Size of the iteration variable in bits.
716  /// \param IVSigned Sign of the interation variable.
717  ///
718  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
719  SourceLocation Loc, unsigned IVSize,
720  bool IVSigned);
721 
722  /// \brief Call the appropriate runtime routine to notify that we finished
723  /// all the work with current loop.
724  ///
725  /// \param CGF Reference to current CodeGenFunction.
726  /// \param Loc Clang source location.
727  ///
728  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc);
729 
730  /// Call __kmpc_dispatch_next(
731  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
732  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
733  /// kmp_int[32|64] *p_stride);
734  /// \param IVSize Size of the iteration variable in bits.
735  /// \param IVSigned Sign of the interation variable.
736  /// \param IL Address of the output variable in which the flag of the
737  /// last iteration is returned.
738  /// \param LB Address of the output variable in which the lower iteration
739  /// number is returned.
740  /// \param UB Address of the output variable in which the upper iteration
741  /// number is returned.
742  /// \param ST Address of the output variable in which the stride value is
743  /// returned.
744  virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
745  unsigned IVSize, bool IVSigned,
746  Address IL, Address LB,
747  Address UB, Address ST);
748 
749  /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
750  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
751  /// clause.
752  /// \param NumThreads An integer value of threads.
753  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
754  llvm::Value *NumThreads,
755  SourceLocation Loc);
756 
757  /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
758  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
759  virtual void emitProcBindClause(CodeGenFunction &CGF,
760  OpenMPProcBindClauseKind ProcBind,
761  SourceLocation Loc);
762 
763  /// \brief Returns address of the threadprivate variable for the current
764  /// thread.
765  /// \param VD Threadprivate variable.
766  /// \param VDAddr Address of the global variable \a VD.
767  /// \param Loc Location of the reference to threadprivate var.
768  /// \return Address of the threadprivate variable for the current thread.
769  virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
770  const VarDecl *VD,
771  Address VDAddr,
772  SourceLocation Loc);
773 
774  /// \brief Emit a code for initialization of threadprivate variable. It emits
775  /// a call to runtime library which adds initial value to the newly created
776  /// threadprivate variable (if it is not constant) and registers destructor
777  /// for the variable (if any).
778  /// \param VD Threadprivate variable.
779  /// \param VDAddr Address of the global variable \a VD.
780  /// \param Loc Location of threadprivate declaration.
781  /// \param PerformInit true if initialization expression is not constant.
782  virtual llvm::Function *
783  emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
784  SourceLocation Loc, bool PerformInit,
785  CodeGenFunction *CGF = nullptr);
786 
787  /// \brief Emit flush of the variables specified in 'omp flush' directive.
788  /// \param Vars List of variables to flush.
789  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
790  SourceLocation Loc);
791 
792  /// \brief Emit task region for the task directive. The task region is
793  /// emitted in several steps:
794  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
795  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
796  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
797  /// function:
798  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
799  /// TaskFunction(gtid, tt->part_id, tt->shareds);
800  /// return 0;
801  /// }
802  /// 2. Copy a list of shared variables to field shareds of the resulting
803  /// structure kmp_task_t returned by the previous call (if any).
804  /// 3. Copy a pointer to destructions function to field destructions of the
805  /// resulting structure kmp_task_t.
806  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
807  /// kmp_task_t *new_task), where new_task is a resulting structure from
808  /// previous items.
809  /// \param D Current task directive.
810  /// \param Tied true if the task is tied (the task is tied to the thread that
811  /// can suspend its task region), false - untied (the task is not tied to any
812  /// thread).
813  /// \param Final Contains either constant bool value, or llvm::Value * of i1
814  /// type for final clause. If the value is true, the task forces all of its
815  /// child tasks to become final and included tasks.
816  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
817  /// /*part_id*/, captured_struct */*__context*/);
818  /// \param SharedsTy A type which contains references the shared variables.
819  /// \param Shareds Context with the list of shared variables from the \p
820  /// TaskFunction.
821  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
822  /// otherwise.
823  /// \param PrivateVars List of references to private variables for the task
824  /// directive.
825  /// \param PrivateCopies List of private copies for each private variable in
826  /// \p PrivateVars.
827  /// \param FirstprivateVars List of references to private variables for the
828  /// task directive.
829  /// \param FirstprivateCopies List of private copies for each private variable
830  /// in \p FirstprivateVars.
831  /// \param FirstprivateInits List of references to auto generated variables
832  /// used for initialization of a single array element. Used if firstprivate
833  /// variable is of array type.
834  /// \param Dependences List of dependences for the 'task' construct, including
835  /// original expression and dependency type.
836  virtual void emitTaskCall(
837  CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D,
838  bool Tied, llvm::PointerIntPair<llvm::Value *, 1, bool> Final,
839  llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds,
840  const Expr *IfCond, ArrayRef<const Expr *> PrivateVars,
841  ArrayRef<const Expr *> PrivateCopies,
842  ArrayRef<const Expr *> FirstprivateVars,
843  ArrayRef<const Expr *> FirstprivateCopies,
844  ArrayRef<const Expr *> FirstprivateInits,
845  ArrayRef<std::pair<OpenMPDependClauseKind, const Expr *>> Dependences);
846 
847  /// \brief Emit code for the directive that does not require outlining.
848  ///
849  /// \param InnermostKind Kind of innermost directive (for simple directives it
850  /// is a directive itself, for combined - its innermost directive).
851  /// \param CodeGen Code generation sequence for the \a D directive.
852  /// \param HasCancel true if region has inner cancel directive, false
853  /// otherwise.
854  virtual void emitInlinedDirective(CodeGenFunction &CGF,
855  OpenMPDirectiveKind InnermostKind,
856  const RegionCodeGenTy &CodeGen,
857  bool HasCancel = false);
858  /// \brief Emit a code for reduction clause. Next code should be emitted for
859  /// reduction:
860  /// \code
861  ///
862  /// static kmp_critical_name lock = { 0 };
863  ///
864  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
865  /// ...
866  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
867  /// ...
868  /// }
869  ///
870  /// ...
871  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
872  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
873  /// RedList, reduce_func, &<lock>)) {
874  /// case 1:
875  /// ...
876  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
877  /// ...
878  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
879  /// break;
880  /// case 2:
881  /// ...
882  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
883  /// ...
884  /// break;
885  /// default:;
886  /// }
887  /// \endcode
888  ///
889  /// \param Privates List of private copies for original reduction arguments.
890  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
891  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
892  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
893  /// or 'operator binop(LHS, RHS)'.
894  /// \param WithNowait true if parent directive has also nowait clause, false
895  /// otherwise.
896  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
898  ArrayRef<const Expr *> LHSExprs,
899  ArrayRef<const Expr *> RHSExprs,
900  ArrayRef<const Expr *> ReductionOps,
901  bool WithNowait, bool SimpleReduction);
902 
903  /// \brief Emit code for 'taskwait' directive.
904  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
905 
906  /// \brief Emit code for 'cancellation point' construct.
907  /// \param CancelRegion Region kind for which the cancellation point must be
908  /// emitted.
909  ///
910  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
911  SourceLocation Loc,
912  OpenMPDirectiveKind CancelRegion);
913 
914  /// \brief Emit code for 'cancel' construct.
915  /// \param IfCond Condition in the associated 'if' clause, if it was
916  /// specified, nullptr otherwise.
917  /// \param CancelRegion Region kind for which the cancel must be emitted.
918  ///
919  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
920  const Expr *IfCond,
921  OpenMPDirectiveKind CancelRegion);
922 
923  /// \brief Emit outilined function for 'target' directive.
924  /// \param D Directive to emit.
925  /// \param ParentName Name of the function that encloses the target region.
926  /// \param OutlinedFn Outlined function value to be defined by this call.
927  /// \param OutlinedFnID Outlined function ID value to be defined by this call.
928  /// \param IsOffloadEntry True if the outlined function is an offload entry.
929  /// An oulined function may not be an entry if, e.g. the if clause always
930  /// evaluates to false.
932  StringRef ParentName,
933  llvm::Function *&OutlinedFn,
934  llvm::Constant *&OutlinedFnID,
935  bool IsOffloadEntry);
936 
937  /// \brief Emit the target offloading code associated with \a D. The emitted
938  /// code attempts offloading the execution to the device, an the event of
939  /// a failure it executes the host version outlined in \a OutlinedFn.
940  /// \param D Directive to emit.
941  /// \param OutlinedFn Host version of the code to be offloaded.
942  /// \param OutlinedFnID ID of host version of the code to be offloaded.
943  /// \param IfCond Expression evaluated in if clause associated with the target
944  /// directive, or null if no if clause is used.
945  /// \param Device Expression evaluated in device clause associated with the
946  /// target directive, or null if no device clause is used.
947  /// \param CapturedVars Values captured in the current region.
948  virtual void emitTargetCall(CodeGenFunction &CGF,
949  const OMPExecutableDirective &D,
950  llvm::Value *OutlinedFn,
951  llvm::Value *OutlinedFnID, const Expr *IfCond,
952  const Expr *Device,
953  ArrayRef<llvm::Value *> CapturedVars);
954 
955  /// \brief Emit the target regions enclosed in \a GD function definition or
956  /// the function itself in case it is a valid device function. Returns true if
957  /// \a GD was dealt with successfully.
958  /// \param GD Function to scan.
959  virtual bool emitTargetFunctions(GlobalDecl GD);
960 
961  /// \brief Emit the global variable if it is a valid device global variable.
962  /// Returns true if \a GD was dealt with successfully.
963  /// \param GD Variable declaration to emit.
964  virtual bool emitTargetGlobalVariable(GlobalDecl GD);
965 
966  /// \brief Emit the global \a GD if it is meaningful for the target. Returns
967  /// if it was emitted succesfully.
968  /// \param GD Global to scan.
969  virtual bool emitTargetGlobal(GlobalDecl GD);
970 
971  /// \brief Creates the offloading descriptor in the event any target region
972  /// was emitted in the current module and return the function that registers
973  /// it.
974  virtual llvm::Function *emitRegistrationFunction();
975 };
976 
977 } // namespace CodeGen
978 } // namespace clang
979 
980 #endif
void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
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.
A (possibly-)qualified type.
Definition: Type.h:575
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
virtual void 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 llvm::Value * emitParallelOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP parallel directive D.
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
Not really used in Fortran any more.
OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap
C Language Family Type Representation.
QualType getTgtDeviceImageQTy()
Returns __tgt_device_image type.
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
QualType TgtOffloadEntryQTy
Type struct __tgt_offload_entry{ void *addr; // Pointer to the offload entry info.
llvm::function_ref< void(unsigned, unsigned, StringRef, unsigned, unsigned, OffloadEntryInfoTargetRegion &)> OffloadTargetRegionEntryInfoActTy
brief Applies action Action on all registered entries.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:699
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...
OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order)
llvm::StringMap< llvm::AssertingVH< llvm::Constant >, llvm::BumpPtrAllocator > InternalVars
An ordered map of auto-generated variables to their unique names.
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
*QualType KmpTaskTQTy
String describing the source location.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPScheduleClauseKind SchedKind, 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.
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
FrontendAction * Action
Definition: Tooling.cpp:195
Defines some OpenMP-specific enums and functions.
QualType KmpRoutineEntryPtrQTy
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata...
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and and emit all target regions found along the way.
llvm::DenseMap< llvm::Function *, DebugLocThreadIdTy > OpenMPLocThreadIDMapTy
Map of local debug location, ThreadId and functions.
llvm::ArrayType * KmpCriticalNameTy
Type kmp_critical_name, originally defined as typedef kmp_int32 kmp_critical_name[8];.
llvm::Function * createOffloadingBinaryDescriptorRegistration()
Creates and registers offloading binary descriptor for the current compilation unit.
CGOpenMPRuntime(CodeGenModule &CGM)
OffloadEntriesInfoManagerTy OffloadEntriesInfoManager
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
llvm::Constant * getOrCreateThreadPrivateCache(const VarDecl *VD)
If the specified mangled name is not in the module, create and return threadprivate cache object...
Source[4] in Fortran, do not use for C++.
QualType TgtDeviceImageQTy
struct __tgt_device_image{ void *ImageStart; // Pointer to the target code start. ...
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc)
Call the appropriate runtime routine to notify that we finished all the work with current loop...
OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member.
llvm::FunctionType * Kmpc_MicroTy
The type for a microtask which gets passed to __kmpc_fork_call().
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
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...
llvm::Constant * createDispatchInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPScheduleClauseKind SchedKind, unsigned IVSize, bool IVSigned, bool Ordered, llvm::Value *UB, llvm::Value *Chunk=nullptr)
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 IfCond Not a nullptr if if clause was nullptr *otherwise *param PrivateVars List of references to private variables for the task *directive *param PrivateCopies List of private copies for each private variable in *p PrivateVars *param FirstprivateVars List of references to private variables for the *task directive *param FirstprivateCopies List of private copies for each private variable *in p FirstprivateVars *param FirstprivateInits List of references to auto generated variables *used for initialization of a single array element Used if firstprivate *variable is of array type *param Dependences List of dependences for the task including *original expression and dependency type *virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, bool Tied, llvm::PointerIntPair< llvm::Value *, 1, bool > Final, llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, ArrayRef< const Expr * > PrivateVars, ArrayRef< const Expr * > PrivateCopies, ArrayRef< const Expr * > FirstprivateVars, ArrayRef< const Expr * > FirstprivateCopies, ArrayRef< const Expr * > FirstprivateInits, ArrayRef< std::pair< OpenMPDependClauseKind, const Expr * >> Dependences)
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, OpenMPLocationFlags Flags=OMP_IDENT_KMPC)
Emits object of ident_t type with info for source location.
llvm::DenseMap< unsigned, llvm::Value * > OpenMPDebugLocMapTy
Map for SourceLocation and OpenMP runtime library debug locations.
Expr - This represents one expression.
Definition: Expr.h:104
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.
QualType getTgtBinaryDescriptorQTy()
Returns __tgt_bin_desc type.
llvm::Constant * createRuntimeFunction(OpenMPRTLFunction Function)
Returns specified OpenMP runtime function.
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
Entity that registers the offloading constants that were emitted so far.
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
QualType getTgtOffloadEntryQTy()
Returns __tgt_offload_entry type.
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
Definition: OpenMPKinds.h:50
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:28
The l-value was considered opaque, so the alignment was determined from a type.
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
Kind
Encodes a location in the source.
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
llvm::Constant * createDispatchFiniFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_fini_* runtime function for the specified size IVSize and sign IVSigned...
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc)
Emit code for 'taskwait' directive.
llvm::Constant * createDispatchNextFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_dispatch_next_* runtime function for the specified size IVSize and sign IVSigned...
virtual void clear()
An aligned address.
Definition: Address.h:25
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
llvm::function_ref< void(CodeGenFunction &)> RegionCodeGenTy
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
OpenMPDebugLocMapTy OpenMPDebugLocMap
static bool classof(const OffloadEntryInfo *Info)
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.
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
llvm::Type * KmpRoutineEntryPtrTy
Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);.
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry)
Emit outilined function for 'target' directive.
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
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...
unsigned size() const
Return number of entries defined so far.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:58
virtual llvm::Value * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the OpenMP task directive D.
llvm::DenseSet< const VarDecl * > ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
void createOffloadEntry(llvm::Constant *Addr, StringRef Name, uint64_t Size)
Creates offloading entry for the provided address Addr, name Name and size Size.
Defines the clang::SourceLocation class and associated facilities.
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 bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
void loadOffloadInfoMetadata()
Loads all the offload entries information from the host IR metadata.
Privates[]
Gets the list of initial values for linear variables.
Definition: OpenMPClause.h:310
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...
OffloadEntryInfoTargetRegion(unsigned Order, llvm::Constant *Addr, llvm::Constant *ID)
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc)
Emit flush of the variables specified in 'omp flush' directive.
virtual llvm::Function * emitRegistrationFunction()
Creates the offloading descriptor in the event any target region was emitted in the current module an...
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)...
OffloadEntriesInfoManagerTy(CodeGenModule &CGM)
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
llvm::Constant * createForStaticInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_for_static_init_* runtime function for the specified size IVSize and sign IVSigned...
virtual ~CGOpenMPRuntime()
llvm::StructType * IdentTy
QualType TgtBinaryDescriptorQTy
struct __tgt_bin_desc{ int32_t NumDevices; // Number of devices supported.