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