contrib/llvm/tools/clang/lib/CodeGen/CGOpenMPRuntime.h

   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"
  18 #include "clang/Basic/OpenMPKinds.h"
  19 #include "clang/Basic/SourceLocation.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;
  44 class CodeGenModule;
  45
  46 typedef llvm::function_ref<void(CodeGenFunction &)> RegionCodeGenTy;
  47
  48 class CGOpenMPRuntime {
  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;
 214   enum IdentFieldIndex {
 215     /// \brief might be used in Fortran
 216     IdentField_Reserved_1,
 217     /// \brief OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member.
 218     IdentField_Flags,
 219     /// \brief Not really used in Fortran any more
 220     IdentField_Reserved_2,
 221     /// \brief Source[4] in Fortran, do not use for C++
 222     IdentField_Reserved_3,
 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.
 226     IdentField_PSource
 227   };
 228   llvm::StructType *IdentTy;
 229   /// \brief Map for SourceLocation and OpenMP runtime library debug locations.
 230   typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
 231   OpenMPDebugLocMapTy OpenMPDebugLocMap;
 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.
 237   struct DebugLocThreadIdTy {
 238     llvm::Value *DebugLoc;
 239     llvm::Value *ThreadID;
 240   };
 241   /// \brief Map of local debug location, ThreadId and functions.
 242   typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
 243       OpenMPLocThreadIDMapTy;
 244   OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
 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>
 254       InternalVars;
 255   /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
 256   llvm::Type *KmpRoutineEntryPtrTy;
 257   QualType KmpRoutineEntryPtrQTy;
 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;
 267   QualType KmpTaskTQTy;
 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;
 276   QualType KmpDependInfoTy;
 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.
 341   llvm::DenseSet<const VarDecl *> ThreadPrivateWithDefinition;
 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.
 373   virtual llvm::Value *emitParallelOutlinedFunction(
 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   ///
 386   virtual llvm::Value *emitTaskOutlinedFunction(
 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,
 459                                OpenMPDirectiveKind Kind,
 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