clang  3.7.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 OMPExecutableDirective;
39 class VarDecl;
40 
41 namespace CodeGen {
42 
43 class CodeGenFunction;
45 
46 typedef llvm::function_ref<void(CodeGenFunction &)> RegionCodeGenTy;
47 
49 private:
50  enum OpenMPRTLFunction {
51  /// \brief Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc,
52  /// kmpc_micro microtask, ...);
53  OMPRTL__kmpc_fork_call,
54  /// \brief Call to void *__kmpc_threadprivate_cached(ident_t *loc,
55  /// kmp_int32 global_tid, void *data, size_t size, void ***cache);
56  OMPRTL__kmpc_threadprivate_cached,
57  /// \brief Call to void __kmpc_threadprivate_register( ident_t *,
58  /// void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor);
59  OMPRTL__kmpc_threadprivate_register,
60  // Call to __kmpc_int32 kmpc_global_thread_num(ident_t *loc);
61  OMPRTL__kmpc_global_thread_num,
62  // Call to void __kmpc_critical(ident_t *loc, kmp_int32 global_tid,
63  // kmp_critical_name *crit);
64  OMPRTL__kmpc_critical,
65  // Call to void __kmpc_end_critical(ident_t *loc, kmp_int32 global_tid,
66  // kmp_critical_name *crit);
67  OMPRTL__kmpc_end_critical,
68  // Call to kmp_int32 __kmpc_cancel_barrier(ident_t *loc, kmp_int32
69  // global_tid);
70  OMPRTL__kmpc_cancel_barrier,
71  // Call to void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid);
72  OMPRTL__kmpc_barrier,
73  // Call to void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid);
74  OMPRTL__kmpc_for_static_fini,
75  // Call to void __kmpc_serialized_parallel(ident_t *loc, kmp_int32
76  // global_tid);
77  OMPRTL__kmpc_serialized_parallel,
78  // Call to void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32
79  // global_tid);
80  OMPRTL__kmpc_end_serialized_parallel,
81  // Call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid,
82  // kmp_int32 num_threads);
83  OMPRTL__kmpc_push_num_threads,
84  // Call to void __kmpc_flush(ident_t *loc);
85  OMPRTL__kmpc_flush,
86  // Call to kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
87  OMPRTL__kmpc_master,
88  // Call to void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
89  OMPRTL__kmpc_end_master,
90  // Call to kmp_int32 __kmpc_omp_taskyield(ident_t *, kmp_int32 global_tid,
91  // int end_part);
92  OMPRTL__kmpc_omp_taskyield,
93  // Call to kmp_int32 __kmpc_single(ident_t *, kmp_int32 global_tid);
94  OMPRTL__kmpc_single,
95  // Call to void __kmpc_end_single(ident_t *, kmp_int32 global_tid);
96  OMPRTL__kmpc_end_single,
97  // Call to kmp_task_t * __kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
98  // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
99  // kmp_routine_entry_t *task_entry);
100  OMPRTL__kmpc_omp_task_alloc,
101  // Call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t *
102  // new_task);
103  OMPRTL__kmpc_omp_task,
104  // Call to void __kmpc_copyprivate(ident_t *loc, kmp_int32 global_tid,
105  // size_t cpy_size, void *cpy_data, void(*cpy_func)(void *, void *),
106  // kmp_int32 didit);
107  OMPRTL__kmpc_copyprivate,
108  // Call to kmp_int32 __kmpc_reduce(ident_t *loc, kmp_int32 global_tid,
109  // kmp_int32 num_vars, size_t reduce_size, void *reduce_data, void
110  // (*reduce_func)(void *lhs_data, void *rhs_data), kmp_critical_name *lck);
111  OMPRTL__kmpc_reduce,
112  // Call to kmp_int32 __kmpc_reduce_nowait(ident_t *loc, kmp_int32
113  // global_tid, kmp_int32 num_vars, size_t reduce_size, void *reduce_data,
114  // void (*reduce_func)(void *lhs_data, void *rhs_data), kmp_critical_name
115  // *lck);
116  OMPRTL__kmpc_reduce_nowait,
117  // Call to void __kmpc_end_reduce(ident_t *loc, kmp_int32 global_tid,
118  // kmp_critical_name *lck);
119  OMPRTL__kmpc_end_reduce,
120  // Call to void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
121  // kmp_critical_name *lck);
122  OMPRTL__kmpc_end_reduce_nowait,
123  // Call to void __kmpc_omp_task_begin_if0(ident_t *, kmp_int32 gtid,
124  // kmp_task_t * new_task);
125  OMPRTL__kmpc_omp_task_begin_if0,
126  // Call to void __kmpc_omp_task_complete_if0(ident_t *, kmp_int32 gtid,
127  // kmp_task_t * new_task);
128  OMPRTL__kmpc_omp_task_complete_if0,
129  // Call to void __kmpc_ordered(ident_t *loc, kmp_int32 global_tid);
130  OMPRTL__kmpc_ordered,
131  // Call to void __kmpc_end_ordered(ident_t *loc, kmp_int32 global_tid);
132  OMPRTL__kmpc_end_ordered,
133  // Call to kmp_int32 __kmpc_omp_taskwait(ident_t *loc, kmp_int32
134  // global_tid);
135  OMPRTL__kmpc_omp_taskwait,
136  // Call to void __kmpc_taskgroup(ident_t *loc, kmp_int32 global_tid);
137  OMPRTL__kmpc_taskgroup,
138  // Call to void __kmpc_end_taskgroup(ident_t *loc, kmp_int32 global_tid);
139  OMPRTL__kmpc_end_taskgroup,
140  // Call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid,
141  // int proc_bind);
142  OMPRTL__kmpc_push_proc_bind,
143  // Call to kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32
144  // gtid, kmp_task_t * new_task, kmp_int32 ndeps, kmp_depend_info_t
145  // *dep_list, kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list);
146  OMPRTL__kmpc_omp_task_with_deps,
147  // Call to void __kmpc_omp_wait_deps(ident_t *loc_ref, kmp_int32
148  // gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list, kmp_int32
149  // ndeps_noalias, kmp_depend_info_t *noalias_dep_list);
150  OMPRTL__kmpc_omp_wait_deps,
151  // Call to kmp_int32 __kmpc_cancellationpoint(ident_t *loc, kmp_int32
152  // global_tid, kmp_int32 cncl_kind);
153  OMPRTL__kmpc_cancellationpoint,
154  // Call to kmp_int32 __kmpc_cancel(ident_t *loc, kmp_int32 global_tid,
155  // kmp_int32 cncl_kind);
156  OMPRTL__kmpc_cancel,
157  };
158 
159  /// \brief Values for bit flags used in the ident_t to describe the fields.
160  /// All enumeric elements are named and described in accordance with the code
161  /// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
162  enum OpenMPLocationFlags {
163  /// \brief Use trampoline for internal microtask.
164  OMP_IDENT_IMD = 0x01,
165  /// \brief Use c-style ident structure.
166  OMP_IDENT_KMPC = 0x02,
167  /// \brief Atomic reduction option for kmpc_reduce.
168  OMP_ATOMIC_REDUCE = 0x10,
169  /// \brief Explicit 'barrier' directive.
170  OMP_IDENT_BARRIER_EXPL = 0x20,
171  /// \brief Implicit barrier in code.
172  OMP_IDENT_BARRIER_IMPL = 0x40,
173  /// \brief Implicit barrier in 'for' directive.
174  OMP_IDENT_BARRIER_IMPL_FOR = 0x40,
175  /// \brief Implicit barrier in 'sections' directive.
176  OMP_IDENT_BARRIER_IMPL_SECTIONS = 0xC0,
177  /// \brief Implicit barrier in 'single' directive.
178  OMP_IDENT_BARRIER_IMPL_SINGLE = 0x140
179  };
180  CodeGenModule &CGM;
181  /// \brief Default const ident_t object used for initialization of all other
182  /// ident_t objects.
183  llvm::Constant *DefaultOpenMPPSource;
184  /// \brief Map of flags and corresponding default locations.
185  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
186  OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
187  llvm::Value *getOrCreateDefaultLocation(OpenMPLocationFlags Flags);
188  /// \brief Describes ident structure that describes a source location.
189  /// All descriptions are taken from
190  /// http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
191  /// Original structure:
192  /// typedef struct ident {
193  /// kmp_int32 reserved_1; /**< might be used in Fortran;
194  /// see above */
195  /// kmp_int32 flags; /**< also f.flags; KMP_IDENT_xxx flags;
196  /// KMP_IDENT_KMPC identifies this union
197  /// member */
198  /// kmp_int32 reserved_2; /**< not really used in Fortran any more;
199  /// see above */
200  ///#if USE_ITT_BUILD
201  /// /* but currently used for storing
202  /// region-specific ITT */
203  /// /* contextual information. */
204  ///#endif /* USE_ITT_BUILD */
205  /// kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for
206  /// C++ */
207  /// char const *psource; /**< String describing the source location.
208  /// The string is composed of semi-colon separated
209  // fields which describe the source file,
210  /// the function and a pair of line numbers that
211  /// delimit the construct.
212  /// */
213  /// } ident_t;
215  /// \brief might be used in Fortran
217  /// \brief OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member.
219  /// \brief Not really used in Fortran any more
221  /// \brief Source[4] in Fortran, do not use for C++
223  /// \brief String describing the source location. The string is composed of
224  /// semi-colon separated fields which describe the source file, the function
225  /// and a pair of line numbers that delimit the construct.
227  };
228  llvm::StructType *IdentTy;
229  /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
230  typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
232  /// \brief The type for a microtask which gets passed to __kmpc_fork_call().
233  /// Original representation is:
234  /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
235  llvm::FunctionType *Kmpc_MicroTy;
236  /// \brief Stores debug location and ThreadID for the function.
240  };
241  /// \brief Map of local debug location, ThreadId and functions.
242  typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
245  /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
246  /// kmp_critical_name[8];
247  llvm::ArrayType *KmpCriticalNameTy;
248  /// \brief An ordered map of auto-generated variables to their unique names.
249  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
250  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
251  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
252  /// variables.
253  llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
255  /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
256  llvm::Type *KmpRoutineEntryPtrTy;
258  /// \brief Type typedef struct kmp_task {
259  /// void * shareds; /**< pointer to block of pointers to
260  /// shared vars */
261  /// kmp_routine_entry_t routine; /**< pointer to routine to call for
262  /// executing task */
263  /// kmp_int32 part_id; /**< part id for the task */
264  /// kmp_routine_entry_t destructors; /* pointer to function to invoke
265  /// deconstructors of firstprivate C++ objects */
266  /// } kmp_task_t;
268  /// \brief Type typedef struct kmp_depend_info {
269  /// kmp_intptr_t base_addr;
270  /// size_t len;
271  /// struct {
272  /// bool in:1;
273  /// bool out:1;
274  /// } flags;
275  /// } kmp_depend_info_t;
277 
278 
279  /// \brief Build type kmp_routine_entry_t (if not built yet).
280  void emitKmpRoutineEntryT(QualType KmpInt32Ty);
281 
282  /// \brief Emits object of ident_t type with info for source location.
283  /// \param Flags Flags for OpenMP location.
284  ///
285  llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
286  OpenMPLocationFlags Flags = OMP_IDENT_KMPC);
287 
288  /// \brief Returns pointer to ident_t type.
289  llvm::Type *getIdentTyPointerTy();
290 
291  /// \brief Returns pointer to kmpc_micro type.
292  llvm::Type *getKmpc_MicroPointerTy();
293 
294  /// \brief Returns specified OpenMP runtime function.
295  /// \param Function OpenMP runtime function.
296  /// \return Specified function.
297  llvm::Constant *createRuntimeFunction(OpenMPRTLFunction Function);
298 
299  /// \brief Returns __kmpc_for_static_init_* runtime function for the specified
300  /// size \a IVSize and sign \a IVSigned.
301  llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned);
302 
303  /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified
304  /// size \a IVSize and sign \a IVSigned.
305  llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned);
306 
307  /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified
308  /// size \a IVSize and sign \a IVSigned.
309  llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned);
310 
311  /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified
312  /// size \a IVSize and sign \a IVSigned.
313  llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned);
314 
315  /// \brief If the specified mangled name is not in the module, create and
316  /// return threadprivate cache object. This object is a pointer's worth of
317  /// storage that's reserved for use by the OpenMP runtime.
318  /// \param VD Threadprivate variable.
319  /// \return Cache variable for the specified threadprivate.
320  llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
321 
322  /// \brief Emits address of the word in a memory where current thread id is
323  /// stored.
324  virtual llvm::Value *emitThreadIDAddress(CodeGenFunction &CGF,
325  SourceLocation Loc);
326 
327  /// \brief Gets thread id value for the current thread.
328  ///
329  llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
330 
331  /// \brief Gets (if variable with the given name already exist) or creates
332  /// internal global variable with the specified Name. The created variable has
333  /// linkage CommonLinkage by default and is initialized by null value.
334  /// \param Ty Type of the global variable. If it is exist already the type
335  /// must be the same.
336  /// \param Name Name of the variable.
337  llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
338  const llvm::Twine &Name);
339 
340  /// \brief Set of threadprivate variables with the generated initializer.
342 
343  /// \brief Emits initialization code for the threadprivate variables.
344  /// \param VDAddr Address of the global variable \a VD.
345  /// \param Ctor Pointer to a global init function for \a VD.
346  /// \param CopyCtor Pointer to a global copy function for \a VD.
347  /// \param Dtor Pointer to a global destructor function for \a VD.
348  /// \param Loc Location of threadprivate declaration.
349  void emitThreadPrivateVarInit(CodeGenFunction &CGF, llvm::Value *VDAddr,
350  llvm::Value *Ctor, llvm::Value *CopyCtor,
351  llvm::Value *Dtor, SourceLocation Loc);
352 
353  /// \brief Returns corresponding lock object for the specified critical region
354  /// name. If the lock object does not exist it is created, otherwise the
355  /// reference to the existing copy is returned.
356  /// \param CriticalName Name of the critical region.
357  ///
358  llvm::Value *getCriticalRegionLock(StringRef CriticalName);
359 
360 public:
361  explicit CGOpenMPRuntime(CodeGenModule &CGM);
362  virtual ~CGOpenMPRuntime() {}
363  virtual void clear();
364 
365  /// \brief Emits outlined function for the specified OpenMP parallel directive
366  /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
367  /// kmp_int32 BoundID, struct context_vars*).
368  /// \param D OpenMP directive.
369  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
370  /// \param InnermostKind Kind of innermost directive (for simple directives it
371  /// is a directive itself, for combined - its innermost directive).
372  /// \param CodeGen Code generation sequence for the \a D directive.
374  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
375  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
376 
377  /// \brief Emits outlined function for the OpenMP task directive \a D. This
378  /// outlined function has type void(*)(kmp_int32 ThreadID, kmp_int32
379  /// PartID, struct context_vars*).
380  /// \param D OpenMP directive.
381  /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
382  /// \param InnermostKind Kind of innermost directive (for simple directives it
383  /// is a directive itself, for combined - its innermost directive).
384  /// \param CodeGen Code generation sequence for the \a D directive.
385  ///
387  const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
388  OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen);
389 
390  /// \brief Cleans up references to the objects in finished function.
391  ///
392  void functionFinished(CodeGenFunction &CGF);
393 
394  /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
395  /// variables captured in a record which address is stored in \a
396  /// CapturedStruct.
397  /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
398  /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
399  /// \param CapturedStruct A pointer to the record with the references to
400  /// variables used in \a OutlinedFn function.
401  /// \param IfCond Condition in the associated 'if' clause, if it was
402  /// specified, nullptr otherwise.
403  ///
404  virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
405  llvm::Value *OutlinedFn,
406  llvm::Value *CapturedStruct,
407  const Expr *IfCond);
408 
409  /// \brief Emits a critical region.
410  /// \param CriticalName Name of the critical region.
411  /// \param CriticalOpGen Generator for the statement associated with the given
412  /// critical region.
413  virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
414  const RegionCodeGenTy &CriticalOpGen,
415  SourceLocation Loc);
416 
417  /// \brief Emits a master region.
418  /// \param MasterOpGen Generator for the statement associated with the given
419  /// master region.
420  virtual void emitMasterRegion(CodeGenFunction &CGF,
421  const RegionCodeGenTy &MasterOpGen,
422  SourceLocation Loc);
423 
424  /// \brief Emits code for a taskyield directive.
425  virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
426 
427  /// \brief Emit a taskgroup region.
428  /// \param TaskgroupOpGen Generator for the statement associated with the
429  /// given taskgroup region.
430  virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
431  const RegionCodeGenTy &TaskgroupOpGen,
432  SourceLocation Loc);
433 
434  /// \brief Emits a single region.
435  /// \param SingleOpGen Generator for the statement associated with the given
436  /// single region.
437  virtual void emitSingleRegion(CodeGenFunction &CGF,
438  const RegionCodeGenTy &SingleOpGen,
439  SourceLocation Loc,
440  ArrayRef<const Expr *> CopyprivateVars,
441  ArrayRef<const Expr *> DestExprs,
442  ArrayRef<const Expr *> SrcExprs,
443  ArrayRef<const Expr *> AssignmentOps);
444 
445  /// \brief Emit an ordered region.
446  /// \param OrderedOpGen Generator for the statement associated with the given
447  /// ordered region.
448  virtual void emitOrderedRegion(CodeGenFunction &CGF,
449  const RegionCodeGenTy &OrderedOpGen,
450  SourceLocation Loc);
451 
452  /// \brief Emit an implicit/explicit barrier for OpenMP threads.
453  /// \param Kind Directive for which this implicit barrier call must be
454  /// generated. Must be OMPD_barrier for explicit barrier generation.
455  /// \param CheckForCancel true if check for possible cancellation must be
456  /// performed, false otherwise.
457  ///
458  virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
460  bool CheckForCancel = true);
461 
462  /// \brief Check if the specified \a ScheduleKind is static non-chunked.
463  /// This kind of worksharing directive is emitted without outer loop.
464  /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
465  /// \param Chunked True if chunk is specified in the clause.
466  ///
467  virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
468  bool Chunked) const;
469 
470  /// \brief Check if the specified \a ScheduleKind is dynamic.
471  /// This kind of worksharing directive is emitted without outer loop.
472  /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
473  ///
474  virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
475 
476  /// \brief Call the appropriate runtime routine to initialize it before start
477  /// of loop.
478  ///
479  /// Depending on the loop schedule, it is nesessary to call some runtime
480  /// routine before start of the OpenMP loop to get the loop upper / lower
481  /// bounds \a LB and \a UB and stride \a ST.
482  ///
483  /// \param CGF Reference to current CodeGenFunction.
484  /// \param Loc Clang source location.
485  /// \param SchedKind Schedule kind, specified by the 'schedule' clause.
486  /// \param IVSize Size of the iteration variable in bits.
487  /// \param IVSigned Sign of the interation variable.
488  /// \param Ordered true if loop is ordered, false otherwise.
489  /// \param IL Address of the output variable in which the flag of the
490  /// last iteration is returned.
491  /// \param LB Address of the output variable in which the lower iteration
492  /// number is returned.
493  /// \param UB Address of the output variable in which the upper iteration
494  /// number is returned.
495  /// \param ST Address of the output variable in which the stride value is
496  /// returned nesessary to generated the static_chunked scheduled loop.
497  /// \param Chunk Value of the chunk for the static_chunked scheduled loop.
498  /// For the default (nullptr) value, the chunk 1 will be used.
499  ///
500  virtual void emitForInit(CodeGenFunction &CGF, SourceLocation Loc,
501  OpenMPScheduleClauseKind SchedKind, unsigned IVSize,
502  bool IVSigned, bool Ordered, llvm::Value *IL,
503  llvm::Value *LB, llvm::Value *UB, llvm::Value *ST,
504  llvm::Value *Chunk = nullptr);
505 
506  /// \brief Call the appropriate runtime routine to notify that we finished
507  /// iteration of the ordered loop with the dynamic scheduling.
508  ///
509  /// \param CGF Reference to current CodeGenFunction.
510  /// \param Loc Clang source location.
511  /// \param IVSize Size of the iteration variable in bits.
512  /// \param IVSigned Sign of the interation variable.
513  ///
514  virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF,
515  SourceLocation Loc, unsigned IVSize,
516  bool IVSigned);
517 
518  /// \brief Call the appropriate runtime routine to notify that we finished
519  /// all the work with current loop.
520  ///
521  /// \param CGF Reference to current CodeGenFunction.
522  /// \param Loc Clang source location.
523  ///
524  virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc);
525 
526  /// Call __kmpc_dispatch_next(
527  /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
528  /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
529  /// kmp_int[32|64] *p_stride);
530  /// \param IVSize Size of the iteration variable in bits.
531  /// \param IVSigned Sign of the interation variable.
532  /// \param IL Address of the output variable in which the flag of the
533  /// last iteration is returned.
534  /// \param LB Address of the output variable in which the lower iteration
535  /// number is returned.
536  /// \param UB Address of the output variable in which the upper iteration
537  /// number is returned.
538  /// \param ST Address of the output variable in which the stride value is
539  /// returned.
540  virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
541  unsigned IVSize, bool IVSigned,
542  llvm::Value *IL, llvm::Value *LB,
543  llvm::Value *UB, llvm::Value *ST);
544 
545  /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
546  /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
547  /// clause.
548  /// \param NumThreads An integer value of threads.
549  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
550  llvm::Value *NumThreads,
551  SourceLocation Loc);
552 
553  /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
554  /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
555  virtual void emitProcBindClause(CodeGenFunction &CGF,
556  OpenMPProcBindClauseKind ProcBind,
557  SourceLocation Loc);
558 
559  /// \brief Returns address of the threadprivate variable for the current
560  /// thread.
561  /// \param VD Threadprivate variable.
562  /// \param VDAddr Address of the global variable \a VD.
563  /// \param Loc Location of the reference to threadprivate var.
564  /// \return Address of the threadprivate variable for the current thread.
565  virtual llvm::Value *getAddrOfThreadPrivate(CodeGenFunction &CGF,
566  const VarDecl *VD,
567  llvm::Value *VDAddr,
568  SourceLocation Loc);
569 
570  /// \brief Emit a code for initialization of threadprivate variable. It emits
571  /// a call to runtime library which adds initial value to the newly created
572  /// threadprivate variable (if it is not constant) and registers destructor
573  /// for the variable (if any).
574  /// \param VD Threadprivate variable.
575  /// \param VDAddr Address of the global variable \a VD.
576  /// \param Loc Location of threadprivate declaration.
577  /// \param PerformInit true if initialization expression is not constant.
578  virtual llvm::Function *
579  emitThreadPrivateVarDefinition(const VarDecl *VD, llvm::Value *VDAddr,
580  SourceLocation Loc, bool PerformInit,
581  CodeGenFunction *CGF = nullptr);
582 
583  /// \brief Emit flush of the variables specified in 'omp flush' directive.
584  /// \param Vars List of variables to flush.
585  virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
586  SourceLocation Loc);
587 
588  /// \brief Emit task region for the task directive. The task region is
589  /// emitted in several steps:
590  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
591  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
592  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
593  /// function:
594  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
595  /// TaskFunction(gtid, tt->part_id, tt->shareds);
596  /// return 0;
597  /// }
598  /// 2. Copy a list of shared variables to field shareds of the resulting
599  /// structure kmp_task_t returned by the previous call (if any).
600  /// 3. Copy a pointer to destructions function to field destructions of the
601  /// resulting structure kmp_task_t.
602  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
603  /// kmp_task_t *new_task), where new_task is a resulting structure from
604  /// previous items.
605  /// \param D Current task directive.
606  /// \param Tied true if the task is tied (the task is tied to the thread that
607  /// can suspend its task region), false - untied (the task is not tied to any
608  /// thread).
609  /// \param Final Contains either constant bool value, or llvm::Value * of i1
610  /// type for final clause. If the value is true, the task forces all of its
611  /// child tasks to become final and included tasks.
612  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
613  /// /*part_id*/, captured_struct */*__context*/);
614  /// \param SharedsTy A type which contains references the shared variables.
615  /// \param Shareds Context with the list of shared variables from the \p
616  /// TaskFunction.
617  /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
618  /// otherwise.
619  /// \param PrivateVars List of references to private variables for the task
620  /// directive.
621  /// \param PrivateCopies List of private copies for each private variable in
622  /// \p PrivateVars.
623  /// \param FirstprivateVars List of references to private variables for the
624  /// task directive.
625  /// \param FirstprivateCopies List of private copies for each private variable
626  /// in \p FirstprivateVars.
627  /// \param FirstprivateInits List of references to auto generated variables
628  /// used for initialization of a single array element. Used if firstprivate
629  /// variable is of array type.
630  /// \param Dependences List of dependences for the 'task' construct, including
631  /// original expression and dependency type.
632  virtual void emitTaskCall(
633  CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D,
634  bool Tied, llvm::PointerIntPair<llvm::Value *, 1, bool> Final,
635  llvm::Value *TaskFunction, QualType SharedsTy, llvm::Value *Shareds,
636  const Expr *IfCond, ArrayRef<const Expr *> PrivateVars,
637  ArrayRef<const Expr *> PrivateCopies,
638  ArrayRef<const Expr *> FirstprivateVars,
639  ArrayRef<const Expr *> FirstprivateCopies,
640  ArrayRef<const Expr *> FirstprivateInits,
641  ArrayRef<std::pair<OpenMPDependClauseKind, const Expr *>> Dependences);
642 
643  /// \brief Emit code for the directive that does not require outlining.
644  ///
645  /// \param InnermostKind Kind of innermost directive (for simple directives it
646  /// is a directive itself, for combined - its innermost directive).
647  /// \param CodeGen Code generation sequence for the \a D directive.
648  virtual void emitInlinedDirective(CodeGenFunction &CGF,
649  OpenMPDirectiveKind InnermostKind,
650  const RegionCodeGenTy &CodeGen);
651  /// \brief Emit a code for reduction clause. Next code should be emitted for
652  /// reduction:
653  /// \code
654  ///
655  /// static kmp_critical_name lock = { 0 };
656  ///
657  /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
658  /// ...
659  /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
660  /// ...
661  /// }
662  ///
663  /// ...
664  /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
665  /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
666  /// RedList, reduce_func, &<lock>)) {
667  /// case 1:
668  /// ...
669  /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
670  /// ...
671  /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
672  /// break;
673  /// case 2:
674  /// ...
675  /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
676  /// ...
677  /// break;
678  /// default:;
679  /// }
680  /// \endcode
681  ///
682  /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
683  /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
684  /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
685  /// or 'operator binop(LHS, RHS)'.
686  /// \param WithNowait true if parent directive has also nowait clause, false
687  /// otherwise.
688  virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
689  ArrayRef<const Expr *> LHSExprs,
690  ArrayRef<const Expr *> RHSExprs,
691  ArrayRef<const Expr *> ReductionOps,
692  bool WithNowait, bool SimpleReduction);
693 
694  /// \brief Emit code for 'taskwait' directive.
695  virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
696 
697  /// \brief Emit code for 'cancellation point' construct.
698  /// \param CancelRegion Region kind for which the cancellation point must be
699  /// emitted.
700  ///
701  virtual void emitCancellationPointCall(CodeGenFunction &CGF,
702  SourceLocation Loc,
703  OpenMPDirectiveKind CancelRegion);
704 
705  /// \brief Emit code for 'cancel' construct.
706  /// \param CancelRegion Region kind for which the cancel must be emitted.
707  ///
708  virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
709  OpenMPDirectiveKind CancelRegion);
710 };
711 
712 } // namespace CodeGen
713 } // namespace clang
714 
715 #endif
void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
virtual llvm::Value * emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool CheckForCancel=true)
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. This outlined function has typ...
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
Not really used in Fortran any more.
OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
llvm::StringMap< llvm::AssertingVH< llvm::Constant >, llvm::BumpPtrAllocator > InternalVars
An ordered map of auto-generated variables to their unique names. It stores variables with the follow...
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
*QualType KmpTaskTQTy
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, llvm::Value *CapturedStruct, const Expr *IfCond)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
String describing the source location. The string is composed of semi-colon separated fields which de...
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
Defines some OpenMP-specific enums and functions.
QualType KmpRoutineEntryPtrQTy
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc)
Emits a critical region.
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];.
CGOpenMPRuntime(CodeGenModule &CGM)
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++.
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(). Original representation is: typedef...
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 emitForInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPScheduleClauseKind SchedKind, unsigned IVSize, bool IVSigned, bool Ordered, llvm::Value *IL, llvm::Value *LB, llvm::Value *UB, llvm::Value *ST, llvm::Value *Chunk=nullptr)
Call the appropriate runtime routine to initialize it before start of loop.
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, OpenMPLocationFlags Flags=OMP_IDENT_KMPC)
Emits object of ident_t type with info for source location.
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, bool WithNowait, bool SimpleReduction)
Emit a code for reduction clause. Next code should be emitted for reduction:
llvm::DenseMap< unsigned, llvm::Value * > OpenMPDebugLocMapTy
Map for SourceLocation and OpenMP runtime library debug locations.
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.
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. This kind of worksharing directive is emit...
virtual llvm::Value * getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, llvm::Value *VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
Definition: OpenMPKinds.h:50
Kind
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
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 llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, llvm::Value *VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable. It emits a call to runtime library which ad...
virtual void clear()
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, llvm::Value *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)
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name. If the lock object does not...
llvm::function_ref< void(CodeGenFunction &)> RegionCodeGenTy
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
OpenMPDebugLocMapTy OpenMPDebugLocMap
virtual llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, llvm::Value *IL, llvm::Value *LB, llvm::Value *UB, llvm::Value *ST)
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 emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emit code for the directive that does not require outlining.
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc)
Emit an ordered region.
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...
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. This outlined function has type void(*)(kmp_...
llvm::DenseSet< const VarDecl * > ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
Defines the clang::SourceLocation class and associated facilities.
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 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)...
void emitThreadPrivateVarInit(CodeGenFunction &CGF, llvm::Value *VDAddr, llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc)
Emits initialization code for the threadprivate variables.
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic. This kind of worksharing directive is emitted without...
llvm::Constant * createForStaticInitFunction(unsigned IVSize, bool IVSigned)
Returns __kmpc_for_static_init_* runtime function for the specified size IVSize and sign IVSigned...
Stores debug location and ThreadID for the function.
virtual ~CGOpenMPRuntime()
llvm::StructType * IdentTy