1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This provides a class for OpenMP runtime code generation. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H 14 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H 15 16 #include "CGValue.h" 17 #include "clang/AST/DeclOpenMP.h" 18 #include "clang/AST/Type.h" 19 #include "clang/Basic/OpenMPKinds.h" 20 #include "clang/Basic/SourceLocation.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/ADT/StringMap.h" 23 #include "llvm/ADT/StringSet.h" 24 #include "llvm/IR/Function.h" 25 #include "llvm/IR/ValueHandle.h" 26 27 namespace llvm { 28 class ArrayType; 29 class Constant; 30 class FunctionType; 31 class GlobalVariable; 32 class StructType; 33 class Type; 34 class Value; 35 } // namespace llvm 36 37 namespace clang { 38 class Expr; 39 class GlobalDecl; 40 class OMPDependClause; 41 class OMPExecutableDirective; 42 class OMPLoopDirective; 43 class VarDecl; 44 class OMPDeclareReductionDecl; 45 class IdentifierInfo; 46 47 namespace CodeGen { 48 class Address; 49 class CodeGenFunction; 50 class CodeGenModule; 51 52 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP 53 /// region. 54 class PrePostActionTy { 55 public: 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<const Expr *, 4> ReductionVars; 100 SmallVector<const Expr *, 4> ReductionCopies; 101 SmallVector<const Expr *, 4> ReductionOps; 102 SmallVector<std::pair<OpenMPDependClauseKind, const Expr *>, 4> Dependences; 103 llvm::PointerIntPair<llvm::Value *, 1, bool> Final; 104 llvm::PointerIntPair<llvm::Value *, 1, bool> Schedule; 105 llvm::PointerIntPair<llvm::Value *, 1, bool> Priority; 106 llvm::Value *Reductions = nullptr; 107 unsigned NumberOfParts = 0; 108 bool Tied = true; 109 bool Nogroup = false; 110 }; 111 112 /// Class intended to support codegen of all kind of the reduction clauses. 113 class ReductionCodeGen { 114 private: 115 /// Data required for codegen of reduction clauses. 116 struct ReductionData { 117 /// Reference to the original shared item. 118 const Expr *Ref = nullptr; 119 /// Helper expression for generation of private copy. 120 const Expr *Private = nullptr; 121 /// Helper expression for generation reduction operation. 122 const Expr *ReductionOp = nullptr; 123 ReductionData(const Expr *Ref, const Expr *Private, const Expr *ReductionOp) 124 : Ref(Ref), Private(Private), ReductionOp(ReductionOp) {} 125 }; 126 /// List of reduction-based clauses. 127 SmallVector<ReductionData, 4> ClausesData; 128 129 /// List of addresses of original shared variables/expressions. 130 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses; 131 /// Sizes of the reduction items in chars. 132 SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes; 133 /// Base declarations for the reduction items. 134 SmallVector<const VarDecl *, 4> BaseDecls; 135 136 /// Emits lvalue for shared expression. 137 LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E); 138 /// Emits upper bound for shared expression (if array section). 139 LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E); 140 /// Performs aggregate initialization. 141 /// \param N Number of reduction item in the common list. 142 /// \param PrivateAddr Address of the corresponding private item. 143 /// \param SharedLVal Address of the original shared variable. 144 /// \param DRD Declare reduction construct used for reduction item. 145 void emitAggregateInitialization(CodeGenFunction &CGF, unsigned N, 146 Address PrivateAddr, LValue SharedLVal, 147 const OMPDeclareReductionDecl *DRD); 148 149 public: 150 ReductionCodeGen(ArrayRef<const Expr *> Shareds, 151 ArrayRef<const Expr *> Privates, 152 ArrayRef<const Expr *> ReductionOps); 153 /// Emits lvalue for a reduction item. 154 /// \param N Number of the reduction item. 155 void emitSharedLValue(CodeGenFunction &CGF, unsigned N); 156 /// Emits the code for the variable-modified type, if required. 157 /// \param N Number of the reduction item. 158 void emitAggregateType(CodeGenFunction &CGF, unsigned N); 159 /// Emits the code for the variable-modified type, if required. 160 /// \param N Number of the reduction item. 161 /// \param Size Size of the type in chars. 162 void emitAggregateType(CodeGenFunction &CGF, unsigned N, llvm::Value *Size); 163 /// Performs initialization of the private copy for the reduction item. 164 /// \param N Number of the reduction item. 165 /// \param PrivateAddr Address of the corresponding private item. 166 /// \param DefaultInit Default initialization sequence that should be 167 /// performed if no reduction specific initialization is found. 168 /// \param SharedLVal Address of the original shared variable. 169 void 170 emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr, 171 LValue SharedLVal, 172 llvm::function_ref<bool(CodeGenFunction &)> DefaultInit); 173 /// Returns true if the private copy requires cleanups. 174 bool needCleanups(unsigned N); 175 /// Emits cleanup code for the reduction item. 176 /// \param N Number of the reduction item. 177 /// \param PrivateAddr Address of the corresponding private item. 178 void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr); 179 /// Adjusts \p PrivatedAddr for using instead of the original variable 180 /// address in normal operations. 181 /// \param N Number of the reduction item. 182 /// \param PrivateAddr Address of the corresponding private item. 183 Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N, 184 Address PrivateAddr); 185 /// Returns LValue for the reduction item. 186 LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; } 187 /// Returns the size of the reduction item (in chars and total number of 188 /// elements in the item), or nullptr, if the size is a constant. 189 std::pair<llvm::Value *, llvm::Value *> getSizes(unsigned N) const { 190 return Sizes[N]; 191 } 192 /// Returns the base declaration of the reduction item. 193 const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; } 194 /// Returns the base declaration of the reduction item. 195 const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; } 196 /// Returns true if the initialization of the reduction item uses initializer 197 /// from declare reduction construct. 198 bool usesReductionInitializer(unsigned N) const; 199 }; 200 201 class CGOpenMPRuntime { 202 public: 203 /// Allows to disable automatic handling of functions used in target regions 204 /// as those marked as `omp declare target`. 205 class DisableAutoDeclareTargetRAII { 206 CodeGenModule &CGM; 207 bool SavedShouldMarkAsGlobal; 208 209 public: 210 DisableAutoDeclareTargetRAII(CodeGenModule &CGM); 211 ~DisableAutoDeclareTargetRAII(); 212 }; 213 214 protected: 215 CodeGenModule &CGM; 216 StringRef FirstSeparator, Separator; 217 218 /// Constructor allowing to redefine the name separator for the variables. 219 explicit CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator, 220 StringRef Separator); 221 222 /// Creates offloading entry for the provided entry ID \a ID, 223 /// address \a Addr, size \a Size, and flags \a Flags. 224 virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, 225 uint64_t Size, int32_t Flags, 226 llvm::GlobalValue::LinkageTypes Linkage); 227 228 /// Helper to emit outlined function for 'target' directive. 229 /// \param D Directive to emit. 230 /// \param ParentName Name of the function that encloses the target region. 231 /// \param OutlinedFn Outlined function value to be defined by this call. 232 /// \param OutlinedFnID Outlined function ID value to be defined by this call. 233 /// \param IsOffloadEntry True if the outlined function is an offload entry. 234 /// \param CodeGen Lambda codegen specific to an accelerator device. 235 /// An outlined function may not be an entry if, e.g. the if clause always 236 /// evaluates to false. 237 virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, 238 StringRef ParentName, 239 llvm::Function *&OutlinedFn, 240 llvm::Constant *&OutlinedFnID, 241 bool IsOffloadEntry, 242 const RegionCodeGenTy &CodeGen); 243 244 /// Emits code for OpenMP 'if' clause using specified \a CodeGen 245 /// function. Here is the logic: 246 /// if (Cond) { 247 /// ThenGen(); 248 /// } else { 249 /// ElseGen(); 250 /// } 251 void emitOMPIfClause(CodeGenFunction &CGF, const Expr *Cond, 252 const RegionCodeGenTy &ThenGen, 253 const RegionCodeGenTy &ElseGen); 254 255 /// Emits object of ident_t type with info for source location. 256 /// \param Flags Flags for OpenMP location. 257 /// 258 llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, 259 unsigned Flags = 0); 260 261 /// Returns pointer to ident_t type. 262 llvm::Type *getIdentTyPointerTy(); 263 264 /// Gets thread id value for the current thread. 265 /// 266 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc); 267 268 /// Get the function name of an outlined region. 269 // The name can be customized depending on the target. 270 // 271 virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; } 272 273 /// Emits \p Callee function call with arguments \p Args with location \p Loc. 274 void emitCall(CodeGenFunction &CGF, SourceLocation Loc, 275 llvm::FunctionCallee Callee, 276 ArrayRef<llvm::Value *> Args = llvm::None) const; 277 278 /// Emits address of the word in a memory where current thread id is 279 /// stored. 280 virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc); 281 282 void setLocThreadIdInsertPt(CodeGenFunction &CGF, 283 bool AtCurrentPoint = false); 284 void clearLocThreadIdInsertPt(CodeGenFunction &CGF); 285 286 /// Check if the default location must be constant. 287 /// Default is false to support OMPT/OMPD. 288 virtual bool isDefaultLocationConstant() const { return false; } 289 290 /// Returns additional flags that can be stored in reserved_2 field of the 291 /// default location. 292 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; } 293 294 /// Returns default flags for the barriers depending on the directive, for 295 /// which this barier is going to be emitted. 296 static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind); 297 298 /// Get the LLVM type for the critical name. 299 llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;} 300 301 /// Returns corresponding lock object for the specified critical region 302 /// name. If the lock object does not exist it is created, otherwise the 303 /// reference to the existing copy is returned. 304 /// \param CriticalName Name of the critical region. 305 /// 306 llvm::Value *getCriticalRegionLock(StringRef CriticalName); 307 308 private: 309 /// Default const ident_t object used for initialization of all other 310 /// ident_t objects. 311 llvm::Constant *DefaultOpenMPPSource = nullptr; 312 using FlagsTy = std::pair<unsigned, unsigned>; 313 /// Map of flags and corresponding default locations. 314 using OpenMPDefaultLocMapTy = llvm::DenseMap<FlagsTy, llvm::Value *>; 315 OpenMPDefaultLocMapTy OpenMPDefaultLocMap; 316 Address getOrCreateDefaultLocation(unsigned Flags); 317 318 QualType IdentQTy; 319 llvm::StructType *IdentTy = nullptr; 320 /// Map for SourceLocation and OpenMP runtime library debug locations. 321 typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy; 322 OpenMPDebugLocMapTy OpenMPDebugLocMap; 323 /// The type for a microtask which gets passed to __kmpc_fork_call(). 324 /// Original representation is: 325 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...); 326 llvm::FunctionType *Kmpc_MicroTy = nullptr; 327 /// Stores debug location and ThreadID for the function. 328 struct DebugLocThreadIdTy { 329 llvm::Value *DebugLoc; 330 llvm::Value *ThreadID; 331 /// Insert point for the service instructions. 332 llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr; 333 }; 334 /// Map of local debug location, ThreadId and functions. 335 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy> 336 OpenMPLocThreadIDMapTy; 337 OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap; 338 /// Map of UDRs and corresponding combiner/initializer. 339 typedef llvm::DenseMap<const OMPDeclareReductionDecl *, 340 std::pair<llvm::Function *, llvm::Function *>> 341 UDRMapTy; 342 UDRMapTy UDRMap; 343 /// Map of functions and locally defined UDRs. 344 typedef llvm::DenseMap<llvm::Function *, 345 SmallVector<const OMPDeclareReductionDecl *, 4>> 346 FunctionUDRMapTy; 347 FunctionUDRMapTy FunctionUDRMap; 348 /// Type kmp_critical_name, originally defined as typedef kmp_int32 349 /// kmp_critical_name[8]; 350 llvm::ArrayType *KmpCriticalNameTy; 351 /// An ordered map of auto-generated variables to their unique names. 352 /// It stores variables with the following names: 1) ".gomp_critical_user_" + 353 /// <critical_section_name> + ".var" for "omp critical" directives; 2) 354 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate 355 /// variables. 356 llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator> 357 InternalVars; 358 /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *); 359 llvm::Type *KmpRoutineEntryPtrTy = nullptr; 360 QualType KmpRoutineEntryPtrQTy; 361 /// Type typedef struct kmp_task { 362 /// void * shareds; /**< pointer to block of pointers to 363 /// shared vars */ 364 /// kmp_routine_entry_t routine; /**< pointer to routine to call for 365 /// executing task */ 366 /// kmp_int32 part_id; /**< part id for the task */ 367 /// kmp_routine_entry_t destructors; /* pointer to function to invoke 368 /// deconstructors of firstprivate C++ objects */ 369 /// } kmp_task_t; 370 QualType KmpTaskTQTy; 371 /// Saved kmp_task_t for task directive. 372 QualType SavedKmpTaskTQTy; 373 /// Saved kmp_task_t for taskloop-based directive. 374 QualType SavedKmpTaskloopTQTy; 375 /// Type typedef struct kmp_depend_info { 376 /// kmp_intptr_t base_addr; 377 /// size_t len; 378 /// struct { 379 /// bool in:1; 380 /// bool out:1; 381 /// } flags; 382 /// } kmp_depend_info_t; 383 QualType KmpDependInfoTy; 384 /// struct kmp_dim { // loop bounds info casted to kmp_int64 385 /// kmp_int64 lo; // lower 386 /// kmp_int64 up; // upper 387 /// kmp_int64 st; // stride 388 /// }; 389 QualType KmpDimTy; 390 /// Type struct __tgt_offload_entry{ 391 /// void *addr; // Pointer to the offload entry info. 392 /// // (function or global) 393 /// char *name; // Name of the function or global. 394 /// size_t size; // Size of the entry info (0 if it a function). 395 /// }; 396 QualType TgtOffloadEntryQTy; 397 /// struct __tgt_device_image{ 398 /// void *ImageStart; // Pointer to the target code start. 399 /// void *ImageEnd; // Pointer to the target code end. 400 /// // We also add the host entries to the device image, as it may be useful 401 /// // for the target runtime to have access to that information. 402 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all 403 /// // the entries. 404 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the 405 /// // entries (non inclusive). 406 /// }; 407 QualType TgtDeviceImageQTy; 408 /// struct __tgt_bin_desc{ 409 /// int32_t NumDevices; // Number of devices supported. 410 /// __tgt_device_image *DeviceImages; // Arrays of device images 411 /// // (one per device). 412 /// __tgt_offload_entry *EntriesBegin; // Begin of the table with all the 413 /// // entries. 414 /// __tgt_offload_entry *EntriesEnd; // End of the table with all the 415 /// // entries (non inclusive). 416 /// }; 417 QualType TgtBinaryDescriptorQTy; 418 /// Entity that registers the offloading constants that were emitted so 419 /// far. 420 class OffloadEntriesInfoManagerTy { 421 CodeGenModule &CGM; 422 423 /// Number of entries registered so far. 424 unsigned OffloadingEntriesNum = 0; 425 426 public: 427 /// Base class of the entries info. 428 class OffloadEntryInfo { 429 public: 430 /// Kind of a given entry. 431 enum OffloadingEntryInfoKinds : unsigned { 432 /// Entry is a target region. 433 OffloadingEntryInfoTargetRegion = 0, 434 /// Entry is a declare target variable. 435 OffloadingEntryInfoDeviceGlobalVar = 1, 436 /// Invalid entry info. 437 OffloadingEntryInfoInvalid = ~0u 438 }; 439 440 protected: 441 OffloadEntryInfo() = delete; 442 explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind) : Kind(Kind) {} 443 explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order, 444 uint32_t Flags) 445 : Flags(Flags), Order(Order), Kind(Kind) {} 446 ~OffloadEntryInfo() = default; 447 448 public: 449 bool isValid() const { return Order != ~0u; } 450 unsigned getOrder() const { return Order; } 451 OffloadingEntryInfoKinds getKind() const { return Kind; } 452 uint32_t getFlags() const { return Flags; } 453 void setFlags(uint32_t NewFlags) { Flags = NewFlags; } 454 llvm::Constant *getAddress() const { 455 return cast_or_null<llvm::Constant>(Addr); 456 } 457 void setAddress(llvm::Constant *V) { 458 assert(!Addr.pointsToAliveValue() && "Address has been set before!"); 459 Addr = V; 460 } 461 static bool classof(const OffloadEntryInfo *Info) { return true; } 462 463 private: 464 /// Address of the entity that has to be mapped for offloading. 465 llvm::WeakTrackingVH Addr; 466 467 /// Flags associated with the device global. 468 uint32_t Flags = 0u; 469 470 /// Order this entry was emitted. 471 unsigned Order = ~0u; 472 473 OffloadingEntryInfoKinds Kind = OffloadingEntryInfoInvalid; 474 }; 475 476 /// Return true if a there are no entries defined. 477 bool empty() const; 478 /// Return number of entries defined so far. 479 unsigned size() const { return OffloadingEntriesNum; } 480 OffloadEntriesInfoManagerTy(CodeGenModule &CGM) : CGM(CGM) {} 481 482 // 483 // Target region entries related. 484 // 485 486 /// Kind of the target registry entry. 487 enum OMPTargetRegionEntryKind : uint32_t { 488 /// Mark the entry as target region. 489 OMPTargetRegionEntryTargetRegion = 0x0, 490 /// Mark the entry as a global constructor. 491 OMPTargetRegionEntryCtor = 0x02, 492 /// Mark the entry as a global destructor. 493 OMPTargetRegionEntryDtor = 0x04, 494 }; 495 496 /// Target region entries info. 497 class OffloadEntryInfoTargetRegion final : public OffloadEntryInfo { 498 /// Address that can be used as the ID of the entry. 499 llvm::Constant *ID = nullptr; 500 501 public: 502 OffloadEntryInfoTargetRegion() 503 : OffloadEntryInfo(OffloadingEntryInfoTargetRegion) {} 504 explicit OffloadEntryInfoTargetRegion(unsigned Order, 505 llvm::Constant *Addr, 506 llvm::Constant *ID, 507 OMPTargetRegionEntryKind Flags) 508 : OffloadEntryInfo(OffloadingEntryInfoTargetRegion, Order, Flags), 509 ID(ID) { 510 setAddress(Addr); 511 } 512 513 llvm::Constant *getID() const { return ID; } 514 void setID(llvm::Constant *V) { 515 assert(!ID && "ID has been set before!"); 516 ID = V; 517 } 518 static bool classof(const OffloadEntryInfo *Info) { 519 return Info->getKind() == OffloadingEntryInfoTargetRegion; 520 } 521 }; 522 523 /// Initialize target region entry. 524 void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID, 525 StringRef ParentName, unsigned LineNum, 526 unsigned Order); 527 /// Register target region entry. 528 void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID, 529 StringRef ParentName, unsigned LineNum, 530 llvm::Constant *Addr, llvm::Constant *ID, 531 OMPTargetRegionEntryKind Flags); 532 /// Return true if a target region entry with the provided information 533 /// exists. 534 bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID, 535 StringRef ParentName, unsigned LineNum) const; 536 /// brief Applies action \a Action on all registered entries. 537 typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned, 538 const OffloadEntryInfoTargetRegion &)> 539 OffloadTargetRegionEntryInfoActTy; 540 void actOnTargetRegionEntriesInfo( 541 const OffloadTargetRegionEntryInfoActTy &Action); 542 543 // 544 // Device global variable entries related. 545 // 546 547 /// Kind of the global variable entry.. 548 enum OMPTargetGlobalVarEntryKind : uint32_t { 549 /// Mark the entry as a to declare target. 550 OMPTargetGlobalVarEntryTo = 0x0, 551 /// Mark the entry as a to declare target link. 552 OMPTargetGlobalVarEntryLink = 0x1, 553 }; 554 555 /// Device global variable entries info. 556 class OffloadEntryInfoDeviceGlobalVar final : public OffloadEntryInfo { 557 /// Type of the global variable. 558 CharUnits VarSize; 559 llvm::GlobalValue::LinkageTypes Linkage; 560 561 public: 562 OffloadEntryInfoDeviceGlobalVar() 563 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar) {} 564 explicit OffloadEntryInfoDeviceGlobalVar(unsigned Order, 565 OMPTargetGlobalVarEntryKind Flags) 566 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags) {} 567 explicit OffloadEntryInfoDeviceGlobalVar( 568 unsigned Order, llvm::Constant *Addr, CharUnits VarSize, 569 OMPTargetGlobalVarEntryKind Flags, 570 llvm::GlobalValue::LinkageTypes Linkage) 571 : OffloadEntryInfo(OffloadingEntryInfoDeviceGlobalVar, Order, Flags), 572 VarSize(VarSize), Linkage(Linkage) { 573 setAddress(Addr); 574 } 575 576 CharUnits getVarSize() const { return VarSize; } 577 void setVarSize(CharUnits Size) { VarSize = Size; } 578 llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; } 579 void setLinkage(llvm::GlobalValue::LinkageTypes LT) { Linkage = LT; } 580 static bool classof(const OffloadEntryInfo *Info) { 581 return Info->getKind() == OffloadingEntryInfoDeviceGlobalVar; 582 } 583 }; 584 585 /// Initialize device global variable entry. 586 void initializeDeviceGlobalVarEntryInfo(StringRef Name, 587 OMPTargetGlobalVarEntryKind Flags, 588 unsigned Order); 589 590 /// Register device global variable entry. 591 void 592 registerDeviceGlobalVarEntryInfo(StringRef VarName, llvm::Constant *Addr, 593 CharUnits VarSize, 594 OMPTargetGlobalVarEntryKind Flags, 595 llvm::GlobalValue::LinkageTypes Linkage); 596 /// Checks if the variable with the given name has been registered already. 597 bool hasDeviceGlobalVarEntryInfo(StringRef VarName) const { 598 return OffloadEntriesDeviceGlobalVar.count(VarName) > 0; 599 } 600 /// Applies action \a Action on all registered entries. 601 typedef llvm::function_ref<void(StringRef, 602 const OffloadEntryInfoDeviceGlobalVar &)> 603 OffloadDeviceGlobalVarEntryInfoActTy; 604 void actOnDeviceGlobalVarEntriesInfo( 605 const OffloadDeviceGlobalVarEntryInfoActTy &Action); 606 607 private: 608 // Storage for target region entries kind. The storage is to be indexed by 609 // file ID, device ID, parent function name and line number. 610 typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion> 611 OffloadEntriesTargetRegionPerLine; 612 typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine> 613 OffloadEntriesTargetRegionPerParentName; 614 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName> 615 OffloadEntriesTargetRegionPerFile; 616 typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile> 617 OffloadEntriesTargetRegionPerDevice; 618 typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy; 619 OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion; 620 /// Storage for device global variable entries kind. The storage is to be 621 /// indexed by mangled name. 622 typedef llvm::StringMap<OffloadEntryInfoDeviceGlobalVar> 623 OffloadEntriesDeviceGlobalVarTy; 624 OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar; 625 }; 626 OffloadEntriesInfoManagerTy OffloadEntriesInfoManager; 627 628 bool ShouldMarkAsGlobal = true; 629 /// List of the emitted functions. 630 llvm::StringSet<> AlreadyEmittedTargetFunctions; 631 /// List of the global variables with their addresses that should not be 632 /// emitted for the target. 633 llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables; 634 635 /// List of variables that can become declare target implicitly and, thus, 636 /// must be emitted. 637 llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables; 638 639 /// Flag for keeping track of weather a requires unified_shared_memory 640 /// directive is present. 641 bool HasRequiresUnifiedSharedMemory = false; 642 643 /// Flag for keeping track of weather a target region has been emitted. 644 bool HasEmittedTargetRegion = false; 645 646 /// Flag for keeping track of weather a device routine has been emitted. 647 /// Device routines are specific to the 648 bool HasEmittedDeclareTargetRegion = false; 649 650 /// Creates and registers offloading binary descriptor for the current 651 /// compilation unit. The function that does the registration is returned. 652 llvm::Function *createOffloadingBinaryDescriptorRegistration(); 653 654 /// Creates all the offload entries in the current compilation unit 655 /// along with the associated metadata. 656 void createOffloadEntriesAndInfoMetadata(); 657 658 /// Loads all the offload entries information from the host IR 659 /// metadata. 660 void loadOffloadInfoMetadata(); 661 662 /// Returns __tgt_offload_entry type. 663 QualType getTgtOffloadEntryQTy(); 664 665 /// Returns __tgt_device_image type. 666 QualType getTgtDeviceImageQTy(); 667 668 /// Returns __tgt_bin_desc type. 669 QualType getTgtBinaryDescriptorQTy(); 670 671 /// Start scanning from statement \a S and and emit all target regions 672 /// found along the way. 673 /// \param S Starting statement. 674 /// \param ParentName Name of the function declaration that is being scanned. 675 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName); 676 677 /// Build type kmp_routine_entry_t (if not built yet). 678 void emitKmpRoutineEntryT(QualType KmpInt32Ty); 679 680 /// Returns pointer to kmpc_micro type. 681 llvm::Type *getKmpc_MicroPointerTy(); 682 683 /// Returns specified OpenMP runtime function. 684 /// \param Function OpenMP runtime function. 685 /// \return Specified function. 686 llvm::FunctionCallee createRuntimeFunction(unsigned Function); 687 688 /// Returns __kmpc_for_static_init_* runtime function for the specified 689 /// size \a IVSize and sign \a IVSigned. 690 llvm::FunctionCallee createForStaticInitFunction(unsigned IVSize, 691 bool IVSigned); 692 693 /// Returns __kmpc_dispatch_init_* runtime function for the specified 694 /// size \a IVSize and sign \a IVSigned. 695 llvm::FunctionCallee createDispatchInitFunction(unsigned IVSize, 696 bool IVSigned); 697 698 /// Returns __kmpc_dispatch_next_* runtime function for the specified 699 /// size \a IVSize and sign \a IVSigned. 700 llvm::FunctionCallee createDispatchNextFunction(unsigned IVSize, 701 bool IVSigned); 702 703 /// Returns __kmpc_dispatch_fini_* runtime function for the specified 704 /// size \a IVSize and sign \a IVSigned. 705 llvm::FunctionCallee createDispatchFiniFunction(unsigned IVSize, 706 bool IVSigned); 707 708 /// If the specified mangled name is not in the module, create and 709 /// return threadprivate cache object. This object is a pointer's worth of 710 /// storage that's reserved for use by the OpenMP runtime. 711 /// \param VD Threadprivate variable. 712 /// \return Cache variable for the specified threadprivate. 713 llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD); 714 715 /// Gets (if variable with the given name already exist) or creates 716 /// internal global variable with the specified Name. The created variable has 717 /// linkage CommonLinkage by default and is initialized by null value. 718 /// \param Ty Type of the global variable. If it is exist already the type 719 /// must be the same. 720 /// \param Name Name of the variable. 721 llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty, 722 const llvm::Twine &Name, 723 unsigned AddressSpace = 0); 724 725 /// Set of threadprivate variables with the generated initializer. 726 llvm::StringSet<> ThreadPrivateWithDefinition; 727 728 /// Set of declare target variables with the generated initializer. 729 llvm::StringSet<> DeclareTargetWithDefinition; 730 731 /// Emits initialization code for the threadprivate variables. 732 /// \param VDAddr Address of the global variable \a VD. 733 /// \param Ctor Pointer to a global init function for \a VD. 734 /// \param CopyCtor Pointer to a global copy function for \a VD. 735 /// \param Dtor Pointer to a global destructor function for \a VD. 736 /// \param Loc Location of threadprivate declaration. 737 void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr, 738 llvm::Value *Ctor, llvm::Value *CopyCtor, 739 llvm::Value *Dtor, SourceLocation Loc); 740 741 struct TaskResultTy { 742 llvm::Value *NewTask = nullptr; 743 llvm::Function *TaskEntry = nullptr; 744 llvm::Value *NewTaskNewTaskTTy = nullptr; 745 LValue TDBase; 746 const RecordDecl *KmpTaskTQTyRD = nullptr; 747 llvm::Value *TaskDupFn = nullptr; 748 }; 749 /// Emit task region for the task directive. The task region is emitted in 750 /// several steps: 751 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 752 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, 753 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the 754 /// function: 755 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { 756 /// TaskFunction(gtid, tt->part_id, tt->shareds); 757 /// return 0; 758 /// } 759 /// 2. Copy a list of shared variables to field shareds of the resulting 760 /// structure kmp_task_t returned by the previous call (if any). 761 /// 3. Copy a pointer to destructions function to field destructions of the 762 /// resulting structure kmp_task_t. 763 /// \param D Current task directive. 764 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 765 /// /*part_id*/, captured_struct */*__context*/); 766 /// \param SharedsTy A type which contains references the shared variables. 767 /// \param Shareds Context with the list of shared variables from the \p 768 /// TaskFunction. 769 /// \param Data Additional data for task generation like tiednsee, final 770 /// state, list of privates etc. 771 TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc, 772 const OMPExecutableDirective &D, 773 llvm::Function *TaskFunction, QualType SharedsTy, 774 Address Shareds, const OMPTaskDataTy &Data); 775 776 /// Returns default address space for the constant firstprivates, 0 by 777 /// default. 778 virtual unsigned getDefaultFirstprivateAddressSpace() const { return 0; } 779 780 public: 781 explicit CGOpenMPRuntime(CodeGenModule &CGM) 782 : CGOpenMPRuntime(CGM, ".", ".") {} 783 virtual ~CGOpenMPRuntime() {} 784 virtual void clear(); 785 786 /// Checks if the \p Body is the \a CompoundStmt and returns its child 787 /// statement iff there is only one that is not evaluatable at the compile 788 /// time. 789 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body); 790 791 /// Get the platform-specific name separator. 792 std::string getName(ArrayRef<StringRef> Parts) const; 793 794 /// Emit code for the specified user defined reduction construct. 795 virtual void emitUserDefinedReduction(CodeGenFunction *CGF, 796 const OMPDeclareReductionDecl *D); 797 /// Get combiner/initializer for the specified user-defined reduction, if any. 798 virtual std::pair<llvm::Function *, llvm::Function *> 799 getUserDefinedReduction(const OMPDeclareReductionDecl *D); 800 801 /// Emits outlined function for the specified OpenMP parallel directive 802 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, 803 /// kmp_int32 BoundID, struct context_vars*). 804 /// \param D OpenMP directive. 805 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 806 /// \param InnermostKind Kind of innermost directive (for simple directives it 807 /// is a directive itself, for combined - its innermost directive). 808 /// \param CodeGen Code generation sequence for the \a D directive. 809 virtual llvm::Function *emitParallelOutlinedFunction( 810 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, 811 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); 812 813 /// Emits outlined function for the specified OpenMP teams directive 814 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, 815 /// kmp_int32 BoundID, struct context_vars*). 816 /// \param D OpenMP directive. 817 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 818 /// \param InnermostKind Kind of innermost directive (for simple directives it 819 /// is a directive itself, for combined - its innermost directive). 820 /// \param CodeGen Code generation sequence for the \a D directive. 821 virtual llvm::Function *emitTeamsOutlinedFunction( 822 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, 823 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); 824 825 /// Emits outlined function for the OpenMP task directive \a D. This 826 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t* 827 /// TaskT). 828 /// \param D OpenMP directive. 829 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 830 /// \param PartIDVar Variable for partition id in the current OpenMP untied 831 /// task region. 832 /// \param TaskTVar Variable for task_t argument. 833 /// \param InnermostKind Kind of innermost directive (for simple directives it 834 /// is a directive itself, for combined - its innermost directive). 835 /// \param CodeGen Code generation sequence for the \a D directive. 836 /// \param Tied true if task is generated for tied task, false otherwise. 837 /// \param NumberOfParts Number of parts in untied task. Ignored for tied 838 /// tasks. 839 /// 840 virtual llvm::Function *emitTaskOutlinedFunction( 841 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, 842 const VarDecl *PartIDVar, const VarDecl *TaskTVar, 843 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, 844 bool Tied, unsigned &NumberOfParts); 845 846 /// Cleans up references to the objects in finished function. 847 /// 848 virtual void functionFinished(CodeGenFunction &CGF); 849 850 /// Emits code for parallel or serial call of the \a OutlinedFn with 851 /// variables captured in a record which address is stored in \a 852 /// CapturedStruct. 853 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of 854 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*). 855 /// \param CapturedVars A pointer to the record with the references to 856 /// variables used in \a OutlinedFn function. 857 /// \param IfCond Condition in the associated 'if' clause, if it was 858 /// specified, nullptr otherwise. 859 /// 860 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, 861 llvm::Function *OutlinedFn, 862 ArrayRef<llvm::Value *> CapturedVars, 863 const Expr *IfCond); 864 865 /// Emits a critical region. 866 /// \param CriticalName Name of the critical region. 867 /// \param CriticalOpGen Generator for the statement associated with the given 868 /// critical region. 869 /// \param Hint Value of the 'hint' clause (optional). 870 virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, 871 const RegionCodeGenTy &CriticalOpGen, 872 SourceLocation Loc, 873 const Expr *Hint = nullptr); 874 875 /// Emits a master region. 876 /// \param MasterOpGen Generator for the statement associated with the given 877 /// master region. 878 virtual void emitMasterRegion(CodeGenFunction &CGF, 879 const RegionCodeGenTy &MasterOpGen, 880 SourceLocation Loc); 881 882 /// Emits code for a taskyield directive. 883 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc); 884 885 /// Emit a taskgroup region. 886 /// \param TaskgroupOpGen Generator for the statement associated with the 887 /// given taskgroup region. 888 virtual void emitTaskgroupRegion(CodeGenFunction &CGF, 889 const RegionCodeGenTy &TaskgroupOpGen, 890 SourceLocation Loc); 891 892 /// Emits a single region. 893 /// \param SingleOpGen Generator for the statement associated with the given 894 /// single region. 895 virtual void emitSingleRegion(CodeGenFunction &CGF, 896 const RegionCodeGenTy &SingleOpGen, 897 SourceLocation Loc, 898 ArrayRef<const Expr *> CopyprivateVars, 899 ArrayRef<const Expr *> DestExprs, 900 ArrayRef<const Expr *> SrcExprs, 901 ArrayRef<const Expr *> AssignmentOps); 902 903 /// Emit an ordered region. 904 /// \param OrderedOpGen Generator for the statement associated with the given 905 /// ordered region. 906 virtual void emitOrderedRegion(CodeGenFunction &CGF, 907 const RegionCodeGenTy &OrderedOpGen, 908 SourceLocation Loc, bool IsThreads); 909 910 /// Emit an implicit/explicit barrier for OpenMP threads. 911 /// \param Kind Directive for which this implicit barrier call must be 912 /// generated. Must be OMPD_barrier for explicit barrier generation. 913 /// \param EmitChecks true if need to emit checks for cancellation barriers. 914 /// \param ForceSimpleCall true simple barrier call must be emitted, false if 915 /// runtime class decides which one to emit (simple or with cancellation 916 /// checks). 917 /// 918 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, 919 OpenMPDirectiveKind Kind, 920 bool EmitChecks = true, 921 bool ForceSimpleCall = false); 922 923 /// Check if the specified \a ScheduleKind is static non-chunked. 924 /// This kind of worksharing directive is emitted without outer loop. 925 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause. 926 /// \param Chunked True if chunk is specified in the clause. 927 /// 928 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, 929 bool Chunked) const; 930 931 /// Check if the specified \a ScheduleKind is static non-chunked. 932 /// This kind of distribute directive is emitted without outer loop. 933 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause. 934 /// \param Chunked True if chunk is specified in the clause. 935 /// 936 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind, 937 bool Chunked) const; 938 939 /// Check if the specified \a ScheduleKind is static chunked. 940 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause. 941 /// \param Chunked True if chunk is specified in the clause. 942 /// 943 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind, 944 bool Chunked) const; 945 946 /// Check if the specified \a ScheduleKind is static non-chunked. 947 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause. 948 /// \param Chunked True if chunk is specified in the clause. 949 /// 950 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind, 951 bool Chunked) const; 952 953 /// Check if the specified \a ScheduleKind is dynamic. 954 /// This kind of worksharing directive is emitted without outer loop. 955 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause. 956 /// 957 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const; 958 959 /// struct with the values to be passed to the dispatch runtime function 960 struct DispatchRTInput { 961 /// Loop lower bound 962 llvm::Value *LB = nullptr; 963 /// Loop upper bound 964 llvm::Value *UB = nullptr; 965 /// Chunk size specified using 'schedule' clause (nullptr if chunk 966 /// was not specified) 967 llvm::Value *Chunk = nullptr; 968 DispatchRTInput() = default; 969 DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk) 970 : LB(LB), UB(UB), Chunk(Chunk) {} 971 }; 972 973 /// Call the appropriate runtime routine to initialize it before start 974 /// of loop. 975 976 /// This is used for non static scheduled types and when the ordered 977 /// clause is present on the loop construct. 978 /// Depending on the loop schedule, it is necessary to call some runtime 979 /// routine before start of the OpenMP loop to get the loop upper / lower 980 /// bounds \a LB and \a UB and stride \a ST. 981 /// 982 /// \param CGF Reference to current CodeGenFunction. 983 /// \param Loc Clang source location. 984 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause. 985 /// \param IVSize Size of the iteration variable in bits. 986 /// \param IVSigned Sign of the iteration variable. 987 /// \param Ordered true if loop is ordered, false otherwise. 988 /// \param DispatchValues struct containing llvm values for lower bound, upper 989 /// bound, and chunk expression. 990 /// For the default (nullptr) value, the chunk 1 will be used. 991 /// 992 virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, 993 const OpenMPScheduleTy &ScheduleKind, 994 unsigned IVSize, bool IVSigned, bool Ordered, 995 const DispatchRTInput &DispatchValues); 996 997 /// Struct with the values to be passed to the static runtime function 998 struct StaticRTInput { 999 /// Size of the iteration variable in bits. 1000 unsigned IVSize = 0; 1001 /// Sign of the iteration variable. 1002 bool IVSigned = false; 1003 /// true if loop is ordered, false otherwise. 1004 bool Ordered = false; 1005 /// Address of the output variable in which the flag of the last iteration 1006 /// is returned. 1007 Address IL = Address::invalid(); 1008 /// Address of the output variable in which the lower iteration number is 1009 /// returned. 1010 Address LB = Address::invalid(); 1011 /// Address of the output variable in which the upper iteration number is 1012 /// returned. 1013 Address UB = Address::invalid(); 1014 /// Address of the output variable in which the stride value is returned 1015 /// necessary to generated the static_chunked scheduled loop. 1016 Address ST = Address::invalid(); 1017 /// Value of the chunk for the static_chunked scheduled loop. For the 1018 /// default (nullptr) value, the chunk 1 will be used. 1019 llvm::Value *Chunk = nullptr; 1020 StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL, 1021 Address LB, Address UB, Address ST, 1022 llvm::Value *Chunk = nullptr) 1023 : IVSize(IVSize), IVSigned(IVSigned), Ordered(Ordered), IL(IL), LB(LB), 1024 UB(UB), ST(ST), Chunk(Chunk) {} 1025 }; 1026 /// Call the appropriate runtime routine to initialize it before start 1027 /// of loop. 1028 /// 1029 /// This is used only in case of static schedule, when the user did not 1030 /// specify a ordered clause on the loop construct. 1031 /// Depending on the loop schedule, it is necessary to call some runtime 1032 /// routine before start of the OpenMP loop to get the loop upper / lower 1033 /// bounds LB and UB and stride ST. 1034 /// 1035 /// \param CGF Reference to current CodeGenFunction. 1036 /// \param Loc Clang source location. 1037 /// \param DKind Kind of the directive. 1038 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause. 1039 /// \param Values Input arguments for the construct. 1040 /// 1041 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, 1042 OpenMPDirectiveKind DKind, 1043 const OpenMPScheduleTy &ScheduleKind, 1044 const StaticRTInput &Values); 1045 1046 /// 1047 /// \param CGF Reference to current CodeGenFunction. 1048 /// \param Loc Clang source location. 1049 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause. 1050 /// \param Values Input arguments for the construct. 1051 /// 1052 virtual void emitDistributeStaticInit(CodeGenFunction &CGF, 1053 SourceLocation Loc, 1054 OpenMPDistScheduleClauseKind SchedKind, 1055 const StaticRTInput &Values); 1056 1057 /// Call the appropriate runtime routine to notify that we finished 1058 /// iteration of the ordered loop with the dynamic scheduling. 1059 /// 1060 /// \param CGF Reference to current CodeGenFunction. 1061 /// \param Loc Clang source location. 1062 /// \param IVSize Size of the iteration variable in bits. 1063 /// \param IVSigned Sign of the iteration variable. 1064 /// 1065 virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, 1066 SourceLocation Loc, unsigned IVSize, 1067 bool IVSigned); 1068 1069 /// Call the appropriate runtime routine to notify that we finished 1070 /// all the work with current loop. 1071 /// 1072 /// \param CGF Reference to current CodeGenFunction. 1073 /// \param Loc Clang source location. 1074 /// \param DKind Kind of the directive for which the static finish is emitted. 1075 /// 1076 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, 1077 OpenMPDirectiveKind DKind); 1078 1079 /// Call __kmpc_dispatch_next( 1080 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, 1081 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper, 1082 /// kmp_int[32|64] *p_stride); 1083 /// \param IVSize Size of the iteration variable in bits. 1084 /// \param IVSigned Sign of the iteration variable. 1085 /// \param IL Address of the output variable in which the flag of the 1086 /// last iteration is returned. 1087 /// \param LB Address of the output variable in which the lower iteration 1088 /// number is returned. 1089 /// \param UB Address of the output variable in which the upper iteration 1090 /// number is returned. 1091 /// \param ST Address of the output variable in which the stride value is 1092 /// returned. 1093 virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc, 1094 unsigned IVSize, bool IVSigned, 1095 Address IL, Address LB, 1096 Address UB, Address ST); 1097 1098 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 1099 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads' 1100 /// clause. 1101 /// \param NumThreads An integer value of threads. 1102 virtual void emitNumThreadsClause(CodeGenFunction &CGF, 1103 llvm::Value *NumThreads, 1104 SourceLocation Loc); 1105 1106 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 1107 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. 1108 virtual void emitProcBindClause(CodeGenFunction &CGF, 1109 OpenMPProcBindClauseKind ProcBind, 1110 SourceLocation Loc); 1111 1112 /// Returns address of the threadprivate variable for the current 1113 /// thread. 1114 /// \param VD Threadprivate variable. 1115 /// \param VDAddr Address of the global variable \a VD. 1116 /// \param Loc Location of the reference to threadprivate var. 1117 /// \return Address of the threadprivate variable for the current thread. 1118 virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, 1119 const VarDecl *VD, 1120 Address VDAddr, 1121 SourceLocation Loc); 1122 1123 /// Returns the address of the variable marked as declare target with link 1124 /// clause OR as declare target with to clause and unified memory. 1125 virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD); 1126 1127 /// Emit a code for initialization of threadprivate variable. It emits 1128 /// a call to runtime library which adds initial value to the newly created 1129 /// threadprivate variable (if it is not constant) and registers destructor 1130 /// for the variable (if any). 1131 /// \param VD Threadprivate variable. 1132 /// \param VDAddr Address of the global variable \a VD. 1133 /// \param Loc Location of threadprivate declaration. 1134 /// \param PerformInit true if initialization expression is not constant. 1135 virtual llvm::Function * 1136 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, 1137 SourceLocation Loc, bool PerformInit, 1138 CodeGenFunction *CGF = nullptr); 1139 1140 /// Emit a code for initialization of declare target variable. 1141 /// \param VD Declare target variable. 1142 /// \param Addr Address of the global variable \a VD. 1143 /// \param PerformInit true if initialization expression is not constant. 1144 virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD, 1145 llvm::GlobalVariable *Addr, 1146 bool PerformInit); 1147 1148 /// Creates artificial threadprivate variable with name \p Name and type \p 1149 /// VarType. 1150 /// \param VarType Type of the artificial threadprivate variable. 1151 /// \param Name Name of the artificial threadprivate variable. 1152 virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, 1153 QualType VarType, 1154 StringRef Name); 1155 1156 /// Emit flush of the variables specified in 'omp flush' directive. 1157 /// \param Vars List of variables to flush. 1158 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars, 1159 SourceLocation Loc); 1160 1161 /// Emit task region for the task directive. The task region is 1162 /// emitted in several steps: 1163 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 1164 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, 1165 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the 1166 /// function: 1167 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { 1168 /// TaskFunction(gtid, tt->part_id, tt->shareds); 1169 /// return 0; 1170 /// } 1171 /// 2. Copy a list of shared variables to field shareds of the resulting 1172 /// structure kmp_task_t returned by the previous call (if any). 1173 /// 3. Copy a pointer to destructions function to field destructions of the 1174 /// resulting structure kmp_task_t. 1175 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, 1176 /// kmp_task_t *new_task), where new_task is a resulting structure from 1177 /// previous items. 1178 /// \param D Current task directive. 1179 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 1180 /// /*part_id*/, captured_struct */*__context*/); 1181 /// \param SharedsTy A type which contains references the shared variables. 1182 /// \param Shareds Context with the list of shared variables from the \p 1183 /// TaskFunction. 1184 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr 1185 /// otherwise. 1186 /// \param Data Additional data for task generation like tiednsee, final 1187 /// state, list of privates etc. 1188 virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, 1189 const OMPExecutableDirective &D, 1190 llvm::Function *TaskFunction, QualType SharedsTy, 1191 Address Shareds, const Expr *IfCond, 1192 const OMPTaskDataTy &Data); 1193 1194 /// Emit task region for the taskloop directive. The taskloop region is 1195 /// emitted in several steps: 1196 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 1197 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, 1198 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the 1199 /// function: 1200 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { 1201 /// TaskFunction(gtid, tt->part_id, tt->shareds); 1202 /// return 0; 1203 /// } 1204 /// 2. Copy a list of shared variables to field shareds of the resulting 1205 /// structure kmp_task_t returned by the previous call (if any). 1206 /// 3. Copy a pointer to destructions function to field destructions of the 1207 /// resulting structure kmp_task_t. 1208 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t 1209 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int 1210 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task 1211 /// is a resulting structure from 1212 /// previous items. 1213 /// \param D Current task directive. 1214 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 1215 /// /*part_id*/, captured_struct */*__context*/); 1216 /// \param SharedsTy A type which contains references the shared variables. 1217 /// \param Shareds Context with the list of shared variables from the \p 1218 /// TaskFunction. 1219 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr 1220 /// otherwise. 1221 /// \param Data Additional data for task generation like tiednsee, final 1222 /// state, list of privates etc. 1223 virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, 1224 const OMPLoopDirective &D, 1225 llvm::Function *TaskFunction, 1226 QualType SharedsTy, Address Shareds, 1227 const Expr *IfCond, const OMPTaskDataTy &Data); 1228 1229 /// Emit code for the directive that does not require outlining. 1230 /// 1231 /// \param InnermostKind Kind of innermost directive (for simple directives it 1232 /// is a directive itself, for combined - its innermost directive). 1233 /// \param CodeGen Code generation sequence for the \a D directive. 1234 /// \param HasCancel true if region has inner cancel directive, false 1235 /// otherwise. 1236 virtual void emitInlinedDirective(CodeGenFunction &CGF, 1237 OpenMPDirectiveKind InnermostKind, 1238 const RegionCodeGenTy &CodeGen, 1239 bool HasCancel = false); 1240 1241 /// Emits reduction function. 1242 /// \param ArgsType Array type containing pointers to reduction variables. 1243 /// \param Privates List of private copies for original reduction arguments. 1244 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations. 1245 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations. 1246 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS' 1247 /// or 'operator binop(LHS, RHS)'. 1248 llvm::Function *emitReductionFunction(SourceLocation Loc, 1249 llvm::Type *ArgsType, 1250 ArrayRef<const Expr *> Privates, 1251 ArrayRef<const Expr *> LHSExprs, 1252 ArrayRef<const Expr *> RHSExprs, 1253 ArrayRef<const Expr *> ReductionOps); 1254 1255 /// Emits single reduction combiner 1256 void emitSingleReductionCombiner(CodeGenFunction &CGF, 1257 const Expr *ReductionOp, 1258 const Expr *PrivateRef, 1259 const DeclRefExpr *LHS, 1260 const DeclRefExpr *RHS); 1261 1262 struct ReductionOptionsTy { 1263 bool WithNowait; 1264 bool SimpleReduction; 1265 OpenMPDirectiveKind ReductionKind; 1266 }; 1267 /// Emit a code for reduction clause. Next code should be emitted for 1268 /// reduction: 1269 /// \code 1270 /// 1271 /// static kmp_critical_name lock = { 0 }; 1272 /// 1273 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) { 1274 /// ... 1275 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]); 1276 /// ... 1277 /// } 1278 /// 1279 /// ... 1280 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]}; 1281 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList), 1282 /// RedList, reduce_func, &<lock>)) { 1283 /// case 1: 1284 /// ... 1285 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]); 1286 /// ... 1287 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>); 1288 /// break; 1289 /// case 2: 1290 /// ... 1291 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i])); 1292 /// ... 1293 /// break; 1294 /// default:; 1295 /// } 1296 /// \endcode 1297 /// 1298 /// \param Privates List of private copies for original reduction arguments. 1299 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations. 1300 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations. 1301 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS' 1302 /// or 'operator binop(LHS, RHS)'. 1303 /// \param Options List of options for reduction codegen: 1304 /// WithNowait true if parent directive has also nowait clause, false 1305 /// otherwise. 1306 /// SimpleReduction Emit reduction operation only. Used for omp simd 1307 /// directive on the host. 1308 /// ReductionKind The kind of reduction to perform. 1309 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, 1310 ArrayRef<const Expr *> Privates, 1311 ArrayRef<const Expr *> LHSExprs, 1312 ArrayRef<const Expr *> RHSExprs, 1313 ArrayRef<const Expr *> ReductionOps, 1314 ReductionOptionsTy Options); 1315 1316 /// Emit a code for initialization of task reduction clause. Next code 1317 /// should be emitted for reduction: 1318 /// \code 1319 /// 1320 /// _task_red_item_t red_data[n]; 1321 /// ... 1322 /// red_data[i].shar = &origs[i]; 1323 /// red_data[i].size = sizeof(origs[i]); 1324 /// red_data[i].f_init = (void*)RedInit<i>; 1325 /// red_data[i].f_fini = (void*)RedDest<i>; 1326 /// red_data[i].f_comb = (void*)RedOp<i>; 1327 /// red_data[i].flags = <Flag_i>; 1328 /// ... 1329 /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data); 1330 /// \endcode 1331 /// 1332 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations. 1333 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations. 1334 /// \param Data Additional data for task generation like tiedness, final 1335 /// state, list of privates, reductions etc. 1336 virtual llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, 1337 SourceLocation Loc, 1338 ArrayRef<const Expr *> LHSExprs, 1339 ArrayRef<const Expr *> RHSExprs, 1340 const OMPTaskDataTy &Data); 1341 1342 /// Required to resolve existing problems in the runtime. Emits threadprivate 1343 /// variables to store the size of the VLAs/array sections for 1344 /// initializer/combiner/finalizer functions + emits threadprivate variable to 1345 /// store the pointer to the original reduction item for the custom 1346 /// initializer defined by declare reduction construct. 1347 /// \param RCG Allows to reuse an existing data for the reductions. 1348 /// \param N Reduction item for which fixups must be emitted. 1349 virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, 1350 ReductionCodeGen &RCG, unsigned N); 1351 1352 /// Get the address of `void *` type of the privatue copy of the reduction 1353 /// item specified by the \p SharedLVal. 1354 /// \param ReductionsPtr Pointer to the reduction data returned by the 1355 /// emitTaskReductionInit function. 1356 /// \param SharedLVal Address of the original reduction item. 1357 virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, 1358 llvm::Value *ReductionsPtr, 1359 LValue SharedLVal); 1360 1361 /// Emit code for 'taskwait' directive. 1362 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc); 1363 1364 /// Emit code for 'cancellation point' construct. 1365 /// \param CancelRegion Region kind for which the cancellation point must be 1366 /// emitted. 1367 /// 1368 virtual void emitCancellationPointCall(CodeGenFunction &CGF, 1369 SourceLocation Loc, 1370 OpenMPDirectiveKind CancelRegion); 1371 1372 /// Emit code for 'cancel' construct. 1373 /// \param IfCond Condition in the associated 'if' clause, if it was 1374 /// specified, nullptr otherwise. 1375 /// \param CancelRegion Region kind for which the cancel must be emitted. 1376 /// 1377 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, 1378 const Expr *IfCond, 1379 OpenMPDirectiveKind CancelRegion); 1380 1381 /// Emit outilined function for 'target' directive. 1382 /// \param D Directive to emit. 1383 /// \param ParentName Name of the function that encloses the target region. 1384 /// \param OutlinedFn Outlined function value to be defined by this call. 1385 /// \param OutlinedFnID Outlined function ID value to be defined by this call. 1386 /// \param IsOffloadEntry True if the outlined function is an offload entry. 1387 /// \param CodeGen Code generation sequence for the \a D directive. 1388 /// An outlined function may not be an entry if, e.g. the if clause always 1389 /// evaluates to false. 1390 virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, 1391 StringRef ParentName, 1392 llvm::Function *&OutlinedFn, 1393 llvm::Constant *&OutlinedFnID, 1394 bool IsOffloadEntry, 1395 const RegionCodeGenTy &CodeGen); 1396 1397 /// Emit code that pushes the trip count of loops associated with constructs 1398 /// 'target teams distribute' and 'teams distribute parallel for'. 1399 /// \param SizeEmitter Emits the int64 value for the number of iterations of 1400 /// the associated loop. 1401 virtual void emitTargetNumIterationsCall( 1402 CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *Device, 1403 const llvm::function_ref<llvm::Value *( 1404 CodeGenFunction &CGF, const OMPLoopDirective &D)> &SizeEmitter); 1405 1406 /// Emit the target offloading code associated with \a D. The emitted 1407 /// code attempts offloading the execution to the device, an the event of 1408 /// a failure it executes the host version outlined in \a OutlinedFn. 1409 /// \param D Directive to emit. 1410 /// \param OutlinedFn Host version of the code to be offloaded. 1411 /// \param OutlinedFnID ID of host version of the code to be offloaded. 1412 /// \param IfCond Expression evaluated in if clause associated with the target 1413 /// directive, or null if no if clause is used. 1414 /// \param Device Expression evaluated in device clause associated with the 1415 /// target directive, or null if no device clause is used. 1416 virtual void emitTargetCall(CodeGenFunction &CGF, 1417 const OMPExecutableDirective &D, 1418 llvm::Function *OutlinedFn, 1419 llvm::Value *OutlinedFnID, const Expr *IfCond, 1420 const Expr *Device); 1421 1422 /// Emit the target regions enclosed in \a GD function definition or 1423 /// the function itself in case it is a valid device function. Returns true if 1424 /// \a GD was dealt with successfully. 1425 /// \param GD Function to scan. 1426 virtual bool emitTargetFunctions(GlobalDecl GD); 1427 1428 /// Emit the global variable if it is a valid device global variable. 1429 /// Returns true if \a GD was dealt with successfully. 1430 /// \param GD Variable declaration to emit. 1431 virtual bool emitTargetGlobalVariable(GlobalDecl GD); 1432 1433 /// Checks if the provided global decl \a GD is a declare target variable and 1434 /// registers it when emitting code for the host. 1435 virtual void registerTargetGlobalVariable(const VarDecl *VD, 1436 llvm::Constant *Addr); 1437 1438 /// Registers provided target firstprivate variable as global on the 1439 /// target. 1440 llvm::Constant *registerTargetFirstprivateCopy(CodeGenFunction &CGF, 1441 const VarDecl *VD); 1442 1443 /// Emit the global \a GD if it is meaningful for the target. Returns 1444 /// if it was emitted successfully. 1445 /// \param GD Global to scan. 1446 virtual bool emitTargetGlobal(GlobalDecl GD); 1447 1448 /// Creates and returns a registration function for when at least one 1449 /// requires directives was used in the current module. 1450 llvm::Function *emitRequiresDirectiveRegFun(); 1451 1452 /// Creates the offloading descriptor in the event any target region 1453 /// was emitted in the current module and return the function that registers 1454 /// it. 1455 virtual llvm::Function *emitRegistrationFunction(); 1456 1457 /// Emits code for teams call of the \a OutlinedFn with 1458 /// variables captured in a record which address is stored in \a 1459 /// CapturedStruct. 1460 /// \param OutlinedFn Outlined function to be run by team masters. Type of 1461 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*). 1462 /// \param CapturedVars A pointer to the record with the references to 1463 /// variables used in \a OutlinedFn function. 1464 /// 1465 virtual void emitTeamsCall(CodeGenFunction &CGF, 1466 const OMPExecutableDirective &D, 1467 SourceLocation Loc, llvm::Function *OutlinedFn, 1468 ArrayRef<llvm::Value *> CapturedVars); 1469 1470 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 1471 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code 1472 /// for num_teams clause. 1473 /// \param NumTeams An integer expression of teams. 1474 /// \param ThreadLimit An integer expression of threads. 1475 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, 1476 const Expr *ThreadLimit, SourceLocation Loc); 1477 1478 /// Struct that keeps all the relevant information that should be kept 1479 /// throughout a 'target data' region. 1480 class TargetDataInfo { 1481 /// Set to true if device pointer information have to be obtained. 1482 bool RequiresDevicePointerInfo = false; 1483 1484 public: 1485 /// The array of base pointer passed to the runtime library. 1486 llvm::Value *BasePointersArray = nullptr; 1487 /// The array of section pointers passed to the runtime library. 1488 llvm::Value *PointersArray = nullptr; 1489 /// The array of sizes passed to the runtime library. 1490 llvm::Value *SizesArray = nullptr; 1491 /// The array of map types passed to the runtime library. 1492 llvm::Value *MapTypesArray = nullptr; 1493 /// The total number of pointers passed to the runtime library. 1494 unsigned NumberOfPtrs = 0u; 1495 /// Map between the a declaration of a capture and the corresponding base 1496 /// pointer address where the runtime returns the device pointers. 1497 llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap; 1498 1499 explicit TargetDataInfo() {} 1500 explicit TargetDataInfo(bool RequiresDevicePointerInfo) 1501 : RequiresDevicePointerInfo(RequiresDevicePointerInfo) {} 1502 /// Clear information about the data arrays. 1503 void clearArrayInfo() { 1504 BasePointersArray = nullptr; 1505 PointersArray = nullptr; 1506 SizesArray = nullptr; 1507 MapTypesArray = nullptr; 1508 NumberOfPtrs = 0u; 1509 } 1510 /// Return true if the current target data information has valid arrays. 1511 bool isValid() { 1512 return BasePointersArray && PointersArray && SizesArray && 1513 MapTypesArray && NumberOfPtrs; 1514 } 1515 bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; } 1516 }; 1517 1518 /// Emit the target data mapping code associated with \a D. 1519 /// \param D Directive to emit. 1520 /// \param IfCond Expression evaluated in if clause associated with the 1521 /// target directive, or null if no device clause is used. 1522 /// \param Device Expression evaluated in device clause associated with the 1523 /// target directive, or null if no device clause is used. 1524 /// \param Info A record used to store information that needs to be preserved 1525 /// until the region is closed. 1526 virtual void emitTargetDataCalls(CodeGenFunction &CGF, 1527 const OMPExecutableDirective &D, 1528 const Expr *IfCond, const Expr *Device, 1529 const RegionCodeGenTy &CodeGen, 1530 TargetDataInfo &Info); 1531 1532 /// Emit the data mapping/movement code associated with the directive 1533 /// \a D that should be of the form 'target [{enter|exit} data | update]'. 1534 /// \param D Directive to emit. 1535 /// \param IfCond Expression evaluated in if clause associated with the target 1536 /// directive, or null if no if clause is used. 1537 /// \param Device Expression evaluated in device clause associated with the 1538 /// target directive, or null if no device clause is used. 1539 virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF, 1540 const OMPExecutableDirective &D, 1541 const Expr *IfCond, 1542 const Expr *Device); 1543 1544 /// Marks function \a Fn with properly mangled versions of vector functions. 1545 /// \param FD Function marked as 'declare simd'. 1546 /// \param Fn LLVM function that must be marked with 'declare simd' 1547 /// attributes. 1548 virtual void emitDeclareSimdFunction(const FunctionDecl *FD, 1549 llvm::Function *Fn); 1550 1551 /// Emit initialization for doacross loop nesting support. 1552 /// \param D Loop-based construct used in doacross nesting construct. 1553 virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, 1554 ArrayRef<Expr *> NumIterations); 1555 1556 /// Emit code for doacross ordered directive with 'depend' clause. 1557 /// \param C 'depend' clause with 'sink|source' dependency kind. 1558 virtual void emitDoacrossOrdered(CodeGenFunction &CGF, 1559 const OMPDependClause *C); 1560 1561 /// Translates the native parameter of outlined function if this is required 1562 /// for target. 1563 /// \param FD Field decl from captured record for the parameter. 1564 /// \param NativeParam Parameter itself. 1565 virtual const VarDecl *translateParameter(const FieldDecl *FD, 1566 const VarDecl *NativeParam) const { 1567 return NativeParam; 1568 } 1569 1570 /// Gets the address of the native argument basing on the address of the 1571 /// target-specific parameter. 1572 /// \param NativeParam Parameter itself. 1573 /// \param TargetParam Corresponding target-specific parameter. 1574 virtual Address getParameterAddress(CodeGenFunction &CGF, 1575 const VarDecl *NativeParam, 1576 const VarDecl *TargetParam) const; 1577 1578 /// Choose default schedule type and chunk value for the 1579 /// dist_schedule clause. 1580 virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF, 1581 const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind, 1582 llvm::Value *&Chunk) const {} 1583 1584 /// Choose default schedule type and chunk value for the 1585 /// schedule clause. 1586 virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF, 1587 const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind, 1588 const Expr *&ChunkExpr) const; 1589 1590 /// Emits call of the outlined function with the provided arguments, 1591 /// translating these arguments to correct target-specific arguments. 1592 virtual void 1593 emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc, 1594 llvm::FunctionCallee OutlinedFn, 1595 ArrayRef<llvm::Value *> Args = llvm::None) const; 1596 1597 /// Emits OpenMP-specific function prolog. 1598 /// Required for device constructs. 1599 virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D); 1600 1601 /// Gets the OpenMP-specific address of the local variable. 1602 virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, 1603 const VarDecl *VD); 1604 1605 /// Marks the declaration as already emitted for the device code and returns 1606 /// true, if it was marked already, and false, otherwise. 1607 bool markAsGlobalTarget(GlobalDecl GD); 1608 1609 /// Emit deferred declare target variables marked for deferred emission. 1610 void emitDeferredTargetDecls() const; 1611 1612 /// Adjust some parameters for the target-based directives, like addresses of 1613 /// the variables captured by reference in lambdas. 1614 virtual void 1615 adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF, 1616 const OMPExecutableDirective &D) const; 1617 1618 /// Perform check on requires decl to ensure that target architecture 1619 /// supports unified addressing 1620 virtual void checkArchForUnifiedAddressing(const OMPRequiresDecl *D); 1621 1622 /// Checks if the variable has associated OMPAllocateDeclAttr attribute with 1623 /// the predefined allocator and translates it into the corresponding address 1624 /// space. 1625 virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS); 1626 1627 /// Return whether the unified_shared_memory has been specified. 1628 bool hasRequiresUnifiedSharedMemory() const; 1629 }; 1630 1631 /// Class supports emissionof SIMD-only code. 1632 class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime { 1633 public: 1634 explicit CGOpenMPSIMDRuntime(CodeGenModule &CGM) : CGOpenMPRuntime(CGM) {} 1635 ~CGOpenMPSIMDRuntime() override {} 1636 1637 /// Emits outlined function for the specified OpenMP parallel directive 1638 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, 1639 /// kmp_int32 BoundID, struct context_vars*). 1640 /// \param D OpenMP directive. 1641 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 1642 /// \param InnermostKind Kind of innermost directive (for simple directives it 1643 /// is a directive itself, for combined - its innermost directive). 1644 /// \param CodeGen Code generation sequence for the \a D directive. 1645 llvm::Function * 1646 emitParallelOutlinedFunction(const OMPExecutableDirective &D, 1647 const VarDecl *ThreadIDVar, 1648 OpenMPDirectiveKind InnermostKind, 1649 const RegionCodeGenTy &CodeGen) override; 1650 1651 /// Emits outlined function for the specified OpenMP teams directive 1652 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, 1653 /// kmp_int32 BoundID, struct context_vars*). 1654 /// \param D OpenMP directive. 1655 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 1656 /// \param InnermostKind Kind of innermost directive (for simple directives it 1657 /// is a directive itself, for combined - its innermost directive). 1658 /// \param CodeGen Code generation sequence for the \a D directive. 1659 llvm::Function * 1660 emitTeamsOutlinedFunction(const OMPExecutableDirective &D, 1661 const VarDecl *ThreadIDVar, 1662 OpenMPDirectiveKind InnermostKind, 1663 const RegionCodeGenTy &CodeGen) override; 1664 1665 /// Emits outlined function for the OpenMP task directive \a D. This 1666 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t* 1667 /// TaskT). 1668 /// \param D OpenMP directive. 1669 /// \param ThreadIDVar Variable for thread id in the current OpenMP region. 1670 /// \param PartIDVar Variable for partition id in the current OpenMP untied 1671 /// task region. 1672 /// \param TaskTVar Variable for task_t argument. 1673 /// \param InnermostKind Kind of innermost directive (for simple directives it 1674 /// is a directive itself, for combined - its innermost directive). 1675 /// \param CodeGen Code generation sequence for the \a D directive. 1676 /// \param Tied true if task is generated for tied task, false otherwise. 1677 /// \param NumberOfParts Number of parts in untied task. Ignored for tied 1678 /// tasks. 1679 /// 1680 llvm::Function *emitTaskOutlinedFunction( 1681 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, 1682 const VarDecl *PartIDVar, const VarDecl *TaskTVar, 1683 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, 1684 bool Tied, unsigned &NumberOfParts) override; 1685 1686 /// Emits code for parallel or serial call of the \a OutlinedFn with 1687 /// variables captured in a record which address is stored in \a 1688 /// CapturedStruct. 1689 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of 1690 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*). 1691 /// \param CapturedVars A pointer to the record with the references to 1692 /// variables used in \a OutlinedFn function. 1693 /// \param IfCond Condition in the associated 'if' clause, if it was 1694 /// specified, nullptr otherwise. 1695 /// 1696 void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, 1697 llvm::Function *OutlinedFn, 1698 ArrayRef<llvm::Value *> CapturedVars, 1699 const Expr *IfCond) override; 1700 1701 /// Emits a critical region. 1702 /// \param CriticalName Name of the critical region. 1703 /// \param CriticalOpGen Generator for the statement associated with the given 1704 /// critical region. 1705 /// \param Hint Value of the 'hint' clause (optional). 1706 void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, 1707 const RegionCodeGenTy &CriticalOpGen, 1708 SourceLocation Loc, 1709 const Expr *Hint = nullptr) override; 1710 1711 /// Emits a master region. 1712 /// \param MasterOpGen Generator for the statement associated with the given 1713 /// master region. 1714 void emitMasterRegion(CodeGenFunction &CGF, 1715 const RegionCodeGenTy &MasterOpGen, 1716 SourceLocation Loc) override; 1717 1718 /// Emits code for a taskyield directive. 1719 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override; 1720 1721 /// Emit a taskgroup region. 1722 /// \param TaskgroupOpGen Generator for the statement associated with the 1723 /// given taskgroup region. 1724 void emitTaskgroupRegion(CodeGenFunction &CGF, 1725 const RegionCodeGenTy &TaskgroupOpGen, 1726 SourceLocation Loc) override; 1727 1728 /// Emits a single region. 1729 /// \param SingleOpGen Generator for the statement associated with the given 1730 /// single region. 1731 void emitSingleRegion(CodeGenFunction &CGF, 1732 const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, 1733 ArrayRef<const Expr *> CopyprivateVars, 1734 ArrayRef<const Expr *> DestExprs, 1735 ArrayRef<const Expr *> SrcExprs, 1736 ArrayRef<const Expr *> AssignmentOps) override; 1737 1738 /// Emit an ordered region. 1739 /// \param OrderedOpGen Generator for the statement associated with the given 1740 /// ordered region. 1741 void emitOrderedRegion(CodeGenFunction &CGF, 1742 const RegionCodeGenTy &OrderedOpGen, 1743 SourceLocation Loc, bool IsThreads) override; 1744 1745 /// Emit an implicit/explicit barrier for OpenMP threads. 1746 /// \param Kind Directive for which this implicit barrier call must be 1747 /// generated. Must be OMPD_barrier for explicit barrier generation. 1748 /// \param EmitChecks true if need to emit checks for cancellation barriers. 1749 /// \param ForceSimpleCall true simple barrier call must be emitted, false if 1750 /// runtime class decides which one to emit (simple or with cancellation 1751 /// checks). 1752 /// 1753 void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, 1754 OpenMPDirectiveKind Kind, bool EmitChecks = true, 1755 bool ForceSimpleCall = false) override; 1756 1757 /// This is used for non static scheduled types and when the ordered 1758 /// clause is present on the loop construct. 1759 /// Depending on the loop schedule, it is necessary to call some runtime 1760 /// routine before start of the OpenMP loop to get the loop upper / lower 1761 /// bounds \a LB and \a UB and stride \a ST. 1762 /// 1763 /// \param CGF Reference to current CodeGenFunction. 1764 /// \param Loc Clang source location. 1765 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause. 1766 /// \param IVSize Size of the iteration variable in bits. 1767 /// \param IVSigned Sign of the iteration variable. 1768 /// \param Ordered true if loop is ordered, false otherwise. 1769 /// \param DispatchValues struct containing llvm values for lower bound, upper 1770 /// bound, and chunk expression. 1771 /// For the default (nullptr) value, the chunk 1 will be used. 1772 /// 1773 void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, 1774 const OpenMPScheduleTy &ScheduleKind, 1775 unsigned IVSize, bool IVSigned, bool Ordered, 1776 const DispatchRTInput &DispatchValues) override; 1777 1778 /// Call the appropriate runtime routine to initialize it before start 1779 /// of loop. 1780 /// 1781 /// This is used only in case of static schedule, when the user did not 1782 /// specify a ordered clause on the loop construct. 1783 /// Depending on the loop schedule, it is necessary to call some runtime 1784 /// routine before start of the OpenMP loop to get the loop upper / lower 1785 /// bounds LB and UB and stride ST. 1786 /// 1787 /// \param CGF Reference to current CodeGenFunction. 1788 /// \param Loc Clang source location. 1789 /// \param DKind Kind of the directive. 1790 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause. 1791 /// \param Values Input arguments for the construct. 1792 /// 1793 void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, 1794 OpenMPDirectiveKind DKind, 1795 const OpenMPScheduleTy &ScheduleKind, 1796 const StaticRTInput &Values) override; 1797 1798 /// 1799 /// \param CGF Reference to current CodeGenFunction. 1800 /// \param Loc Clang source location. 1801 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause. 1802 /// \param Values Input arguments for the construct. 1803 /// 1804 void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, 1805 OpenMPDistScheduleClauseKind SchedKind, 1806 const StaticRTInput &Values) override; 1807 1808 /// Call the appropriate runtime routine to notify that we finished 1809 /// iteration of the ordered loop with the dynamic scheduling. 1810 /// 1811 /// \param CGF Reference to current CodeGenFunction. 1812 /// \param Loc Clang source location. 1813 /// \param IVSize Size of the iteration variable in bits. 1814 /// \param IVSigned Sign of the iteration variable. 1815 /// 1816 void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, 1817 unsigned IVSize, bool IVSigned) override; 1818 1819 /// Call the appropriate runtime routine to notify that we finished 1820 /// all the work with current loop. 1821 /// 1822 /// \param CGF Reference to current CodeGenFunction. 1823 /// \param Loc Clang source location. 1824 /// \param DKind Kind of the directive for which the static finish is emitted. 1825 /// 1826 void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, 1827 OpenMPDirectiveKind DKind) override; 1828 1829 /// Call __kmpc_dispatch_next( 1830 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, 1831 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper, 1832 /// kmp_int[32|64] *p_stride); 1833 /// \param IVSize Size of the iteration variable in bits. 1834 /// \param IVSigned Sign of the iteration variable. 1835 /// \param IL Address of the output variable in which the flag of the 1836 /// last iteration is returned. 1837 /// \param LB Address of the output variable in which the lower iteration 1838 /// number is returned. 1839 /// \param UB Address of the output variable in which the upper iteration 1840 /// number is returned. 1841 /// \param ST Address of the output variable in which the stride value is 1842 /// returned. 1843 llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc, 1844 unsigned IVSize, bool IVSigned, Address IL, 1845 Address LB, Address UB, Address ST) override; 1846 1847 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 1848 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads' 1849 /// clause. 1850 /// \param NumThreads An integer value of threads. 1851 void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, 1852 SourceLocation Loc) override; 1853 1854 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 1855 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. 1856 void emitProcBindClause(CodeGenFunction &CGF, 1857 OpenMPProcBindClauseKind ProcBind, 1858 SourceLocation Loc) override; 1859 1860 /// Returns address of the threadprivate variable for the current 1861 /// thread. 1862 /// \param VD Threadprivate variable. 1863 /// \param VDAddr Address of the global variable \a VD. 1864 /// \param Loc Location of the reference to threadprivate var. 1865 /// \return Address of the threadprivate variable for the current thread. 1866 Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, 1867 Address VDAddr, SourceLocation Loc) override; 1868 1869 /// Emit a code for initialization of threadprivate variable. It emits 1870 /// a call to runtime library which adds initial value to the newly created 1871 /// threadprivate variable (if it is not constant) and registers destructor 1872 /// for the variable (if any). 1873 /// \param VD Threadprivate variable. 1874 /// \param VDAddr Address of the global variable \a VD. 1875 /// \param Loc Location of threadprivate declaration. 1876 /// \param PerformInit true if initialization expression is not constant. 1877 llvm::Function * 1878 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, 1879 SourceLocation Loc, bool PerformInit, 1880 CodeGenFunction *CGF = nullptr) override; 1881 1882 /// Creates artificial threadprivate variable with name \p Name and type \p 1883 /// VarType. 1884 /// \param VarType Type of the artificial threadprivate variable. 1885 /// \param Name Name of the artificial threadprivate variable. 1886 Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, 1887 QualType VarType, 1888 StringRef Name) override; 1889 1890 /// Emit flush of the variables specified in 'omp flush' directive. 1891 /// \param Vars List of variables to flush. 1892 void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars, 1893 SourceLocation Loc) override; 1894 1895 /// Emit task region for the task directive. The task region is 1896 /// emitted in several steps: 1897 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 1898 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, 1899 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the 1900 /// function: 1901 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { 1902 /// TaskFunction(gtid, tt->part_id, tt->shareds); 1903 /// return 0; 1904 /// } 1905 /// 2. Copy a list of shared variables to field shareds of the resulting 1906 /// structure kmp_task_t returned by the previous call (if any). 1907 /// 3. Copy a pointer to destructions function to field destructions of the 1908 /// resulting structure kmp_task_t. 1909 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, 1910 /// kmp_task_t *new_task), where new_task is a resulting structure from 1911 /// previous items. 1912 /// \param D Current task directive. 1913 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 1914 /// /*part_id*/, captured_struct */*__context*/); 1915 /// \param SharedsTy A type which contains references the shared variables. 1916 /// \param Shareds Context with the list of shared variables from the \p 1917 /// TaskFunction. 1918 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr 1919 /// otherwise. 1920 /// \param Data Additional data for task generation like tiednsee, final 1921 /// state, list of privates etc. 1922 void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, 1923 const OMPExecutableDirective &D, 1924 llvm::Function *TaskFunction, QualType SharedsTy, 1925 Address Shareds, const Expr *IfCond, 1926 const OMPTaskDataTy &Data) override; 1927 1928 /// Emit task region for the taskloop directive. The taskloop region is 1929 /// emitted in several steps: 1930 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 1931 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, 1932 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the 1933 /// function: 1934 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { 1935 /// TaskFunction(gtid, tt->part_id, tt->shareds); 1936 /// return 0; 1937 /// } 1938 /// 2. Copy a list of shared variables to field shareds of the resulting 1939 /// structure kmp_task_t returned by the previous call (if any). 1940 /// 3. Copy a pointer to destructions function to field destructions of the 1941 /// resulting structure kmp_task_t. 1942 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t 1943 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int 1944 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task 1945 /// is a resulting structure from 1946 /// previous items. 1947 /// \param D Current task directive. 1948 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 1949 /// /*part_id*/, captured_struct */*__context*/); 1950 /// \param SharedsTy A type which contains references the shared variables. 1951 /// \param Shareds Context with the list of shared variables from the \p 1952 /// TaskFunction. 1953 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr 1954 /// otherwise. 1955 /// \param Data Additional data for task generation like tiednsee, final 1956 /// state, list of privates etc. 1957 void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, 1958 const OMPLoopDirective &D, llvm::Function *TaskFunction, 1959 QualType SharedsTy, Address Shareds, const Expr *IfCond, 1960 const OMPTaskDataTy &Data) override; 1961 1962 /// Emit a code for reduction clause. Next code should be emitted for 1963 /// reduction: 1964 /// \code 1965 /// 1966 /// static kmp_critical_name lock = { 0 }; 1967 /// 1968 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) { 1969 /// ... 1970 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]); 1971 /// ... 1972 /// } 1973 /// 1974 /// ... 1975 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]}; 1976 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList), 1977 /// RedList, reduce_func, &<lock>)) { 1978 /// case 1: 1979 /// ... 1980 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]); 1981 /// ... 1982 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>); 1983 /// break; 1984 /// case 2: 1985 /// ... 1986 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i])); 1987 /// ... 1988 /// break; 1989 /// default:; 1990 /// } 1991 /// \endcode 1992 /// 1993 /// \param Privates List of private copies for original reduction arguments. 1994 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations. 1995 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations. 1996 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS' 1997 /// or 'operator binop(LHS, RHS)'. 1998 /// \param Options List of options for reduction codegen: 1999 /// WithNowait true if parent directive has also nowait clause, false 2000 /// otherwise. 2001 /// SimpleReduction Emit reduction operation only. Used for omp simd 2002 /// directive on the host. 2003 /// ReductionKind The kind of reduction to perform. 2004 void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, 2005 ArrayRef<const Expr *> Privates, 2006 ArrayRef<const Expr *> LHSExprs, 2007 ArrayRef<const Expr *> RHSExprs, 2008 ArrayRef<const Expr *> ReductionOps, 2009 ReductionOptionsTy Options) override; 2010 2011 /// Emit a code for initialization of task reduction clause. Next code 2012 /// should be emitted for reduction: 2013 /// \code 2014 /// 2015 /// _task_red_item_t red_data[n]; 2016 /// ... 2017 /// red_data[i].shar = &origs[i]; 2018 /// red_data[i].size = sizeof(origs[i]); 2019 /// red_data[i].f_init = (void*)RedInit<i>; 2020 /// red_data[i].f_fini = (void*)RedDest<i>; 2021 /// red_data[i].f_comb = (void*)RedOp<i>; 2022 /// red_data[i].flags = <Flag_i>; 2023 /// ... 2024 /// void* tg1 = __kmpc_task_reduction_init(gtid, n, red_data); 2025 /// \endcode 2026 /// 2027 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations. 2028 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations. 2029 /// \param Data Additional data for task generation like tiedness, final 2030 /// state, list of privates, reductions etc. 2031 llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, 2032 ArrayRef<const Expr *> LHSExprs, 2033 ArrayRef<const Expr *> RHSExprs, 2034 const OMPTaskDataTy &Data) override; 2035 2036 /// Required to resolve existing problems in the runtime. Emits threadprivate 2037 /// variables to store the size of the VLAs/array sections for 2038 /// initializer/combiner/finalizer functions + emits threadprivate variable to 2039 /// store the pointer to the original reduction item for the custom 2040 /// initializer defined by declare reduction construct. 2041 /// \param RCG Allows to reuse an existing data for the reductions. 2042 /// \param N Reduction item for which fixups must be emitted. 2043 void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, 2044 ReductionCodeGen &RCG, unsigned N) override; 2045 2046 /// Get the address of `void *` type of the privatue copy of the reduction 2047 /// item specified by the \p SharedLVal. 2048 /// \param ReductionsPtr Pointer to the reduction data returned by the 2049 /// emitTaskReductionInit function. 2050 /// \param SharedLVal Address of the original reduction item. 2051 Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, 2052 llvm::Value *ReductionsPtr, 2053 LValue SharedLVal) override; 2054 2055 /// Emit code for 'taskwait' directive. 2056 void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc) override; 2057 2058 /// Emit code for 'cancellation point' construct. 2059 /// \param CancelRegion Region kind for which the cancellation point must be 2060 /// emitted. 2061 /// 2062 void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, 2063 OpenMPDirectiveKind CancelRegion) override; 2064 2065 /// Emit code for 'cancel' construct. 2066 /// \param IfCond Condition in the associated 'if' clause, if it was 2067 /// specified, nullptr otherwise. 2068 /// \param CancelRegion Region kind for which the cancel must be emitted. 2069 /// 2070 void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, 2071 const Expr *IfCond, 2072 OpenMPDirectiveKind CancelRegion) override; 2073 2074 /// Emit outilined function for 'target' directive. 2075 /// \param D Directive to emit. 2076 /// \param ParentName Name of the function that encloses the target region. 2077 /// \param OutlinedFn Outlined function value to be defined by this call. 2078 /// \param OutlinedFnID Outlined function ID value to be defined by this call. 2079 /// \param IsOffloadEntry True if the outlined function is an offload entry. 2080 /// \param CodeGen Code generation sequence for the \a D directive. 2081 /// An outlined function may not be an entry if, e.g. the if clause always 2082 /// evaluates to false. 2083 void emitTargetOutlinedFunction(const OMPExecutableDirective &D, 2084 StringRef ParentName, 2085 llvm::Function *&OutlinedFn, 2086 llvm::Constant *&OutlinedFnID, 2087 bool IsOffloadEntry, 2088 const RegionCodeGenTy &CodeGen) override; 2089 2090 /// Emit the target offloading code associated with \a D. The emitted 2091 /// code attempts offloading the execution to the device, an the event of 2092 /// a failure it executes the host version outlined in \a OutlinedFn. 2093 /// \param D Directive to emit. 2094 /// \param OutlinedFn Host version of the code to be offloaded. 2095 /// \param OutlinedFnID ID of host version of the code to be offloaded. 2096 /// \param IfCond Expression evaluated in if clause associated with the target 2097 /// directive, or null if no if clause is used. 2098 /// \param Device Expression evaluated in device clause associated with the 2099 /// target directive, or null if no device clause is used. 2100 void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, 2101 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, 2102 const Expr *IfCond, const Expr *Device) override; 2103 2104 /// Emit the target regions enclosed in \a GD function definition or 2105 /// the function itself in case it is a valid device function. Returns true if 2106 /// \a GD was dealt with successfully. 2107 /// \param GD Function to scan. 2108 bool emitTargetFunctions(GlobalDecl GD) override; 2109 2110 /// Emit the global variable if it is a valid device global variable. 2111 /// Returns true if \a GD was dealt with successfully. 2112 /// \param GD Variable declaration to emit. 2113 bool emitTargetGlobalVariable(GlobalDecl GD) override; 2114 2115 /// Emit the global \a GD if it is meaningful for the target. Returns 2116 /// if it was emitted successfully. 2117 /// \param GD Global to scan. 2118 bool emitTargetGlobal(GlobalDecl GD) override; 2119 2120 /// Creates the offloading descriptor in the event any target region 2121 /// was emitted in the current module and return the function that registers 2122 /// it. 2123 llvm::Function *emitRegistrationFunction() override; 2124 2125 /// Emits code for teams call of the \a OutlinedFn with 2126 /// variables captured in a record which address is stored in \a 2127 /// CapturedStruct. 2128 /// \param OutlinedFn Outlined function to be run by team masters. Type of 2129 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*). 2130 /// \param CapturedVars A pointer to the record with the references to 2131 /// variables used in \a OutlinedFn function. 2132 /// 2133 void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, 2134 SourceLocation Loc, llvm::Function *OutlinedFn, 2135 ArrayRef<llvm::Value *> CapturedVars) override; 2136 2137 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 2138 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code 2139 /// for num_teams clause. 2140 /// \param NumTeams An integer expression of teams. 2141 /// \param ThreadLimit An integer expression of threads. 2142 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, 2143 const Expr *ThreadLimit, SourceLocation Loc) override; 2144 2145 /// Emit the target data mapping code associated with \a D. 2146 /// \param D Directive to emit. 2147 /// \param IfCond Expression evaluated in if clause associated with the 2148 /// target directive, or null if no device clause is used. 2149 /// \param Device Expression evaluated in device clause associated with the 2150 /// target directive, or null if no device clause is used. 2151 /// \param Info A record used to store information that needs to be preserved 2152 /// until the region is closed. 2153 void emitTargetDataCalls(CodeGenFunction &CGF, 2154 const OMPExecutableDirective &D, const Expr *IfCond, 2155 const Expr *Device, const RegionCodeGenTy &CodeGen, 2156 TargetDataInfo &Info) override; 2157 2158 /// Emit the data mapping/movement code associated with the directive 2159 /// \a D that should be of the form 'target [{enter|exit} data | update]'. 2160 /// \param D Directive to emit. 2161 /// \param IfCond Expression evaluated in if clause associated with the target 2162 /// directive, or null if no if clause is used. 2163 /// \param Device Expression evaluated in device clause associated with the 2164 /// target directive, or null if no device clause is used. 2165 void emitTargetDataStandAloneCall(CodeGenFunction &CGF, 2166 const OMPExecutableDirective &D, 2167 const Expr *IfCond, 2168 const Expr *Device) override; 2169 2170 /// Emit initialization for doacross loop nesting support. 2171 /// \param D Loop-based construct used in doacross nesting construct. 2172 void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, 2173 ArrayRef<Expr *> NumIterations) override; 2174 2175 /// Emit code for doacross ordered directive with 'depend' clause. 2176 /// \param C 'depend' clause with 'sink|source' dependency kind. 2177 void emitDoacrossOrdered(CodeGenFunction &CGF, 2178 const OMPDependClause *C) override; 2179 2180 /// Translates the native parameter of outlined function if this is required 2181 /// for target. 2182 /// \param FD Field decl from captured record for the parameter. 2183 /// \param NativeParam Parameter itself. 2184 const VarDecl *translateParameter(const FieldDecl *FD, 2185 const VarDecl *NativeParam) const override; 2186 2187 /// Gets the address of the native argument basing on the address of the 2188 /// target-specific parameter. 2189 /// \param NativeParam Parameter itself. 2190 /// \param TargetParam Corresponding target-specific parameter. 2191 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, 2192 const VarDecl *TargetParam) const override; 2193 2194 /// Gets the OpenMP-specific address of the local variable. 2195 Address getAddressOfLocalVariable(CodeGenFunction &CGF, 2196 const VarDecl *VD) override { 2197 return Address::invalid(); 2198 } 2199 }; 2200 2201 } // namespace CodeGen 2202 } // namespace clang 2203 2204 #endif 2205