1 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This provides a class for OpenMP runtime code generation.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
14 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/AST/GlobalDecl.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/OpenMPKinds.h"
21 #include "clang/Basic/SourceLocation.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/SmallPtrSet.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/StringSet.h"
27 #include "llvm/Frontend/OpenMP/OMPConstants.h"
28 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/ValueHandle.h"
31 #include "llvm/Support/AtomicOrdering.h"
40 class OpenMPIRBuilder
;
45 class OMPDependClause
;
46 class OMPExecutableDirective
;
47 class OMPLoopDirective
;
49 class OMPDeclareReductionDecl
;
53 class CodeGenFunction
;
56 /// A basic class for pre|post-action for advanced codegen sequence for OpenMP
58 class PrePostActionTy
{
60 explicit PrePostActionTy() {}
61 virtual void Enter(CodeGenFunction
&CGF
) {}
62 virtual void Exit(CodeGenFunction
&CGF
) {}
63 virtual ~PrePostActionTy() {}
66 /// Class provides a way to call simple version of codegen for OpenMP region, or
67 /// an advanced with possible pre|post-actions in codegen.
68 class RegionCodeGenTy final
{
70 typedef void (*CodeGenTy
)(intptr_t, CodeGenFunction
&, PrePostActionTy
&);
72 mutable PrePostActionTy
*PrePostAction
;
73 RegionCodeGenTy() = delete;
74 template <typename Callable
>
75 static void CallbackFn(intptr_t CodeGen
, CodeGenFunction
&CGF
,
76 PrePostActionTy
&Action
) {
77 return (*reinterpret_cast<Callable
*>(CodeGen
))(CGF
, Action
);
81 template <typename Callable
>
84 std::enable_if_t
<!std::is_same
<std::remove_reference_t
<Callable
>,
85 RegionCodeGenTy
>::value
> * = nullptr)
86 : CodeGen(reinterpret_cast<intptr_t>(&CodeGen
)),
87 Callback(CallbackFn
<std::remove_reference_t
<Callable
>>),
88 PrePostAction(nullptr) {}
89 void setAction(PrePostActionTy
&Action
) const { PrePostAction
= &Action
; }
90 void operator()(CodeGenFunction
&CGF
) const;
93 struct OMPTaskDataTy final
{
94 SmallVector
<const Expr
*, 4> PrivateVars
;
95 SmallVector
<const Expr
*, 4> PrivateCopies
;
96 SmallVector
<const Expr
*, 4> FirstprivateVars
;
97 SmallVector
<const Expr
*, 4> FirstprivateCopies
;
98 SmallVector
<const Expr
*, 4> FirstprivateInits
;
99 SmallVector
<const Expr
*, 4> LastprivateVars
;
100 SmallVector
<const Expr
*, 4> LastprivateCopies
;
101 SmallVector
<const Expr
*, 4> ReductionVars
;
102 SmallVector
<const Expr
*, 4> ReductionOrigs
;
103 SmallVector
<const Expr
*, 4> ReductionCopies
;
104 SmallVector
<const Expr
*, 4> ReductionOps
;
105 SmallVector
<CanonicalDeclPtr
<const VarDecl
>, 4> PrivateLocals
;
107 OpenMPDependClauseKind DepKind
= OMPC_DEPEND_unknown
;
108 const Expr
*IteratorExpr
= nullptr;
109 SmallVector
<const Expr
*, 4> DepExprs
;
110 explicit DependData() = default;
111 DependData(OpenMPDependClauseKind DepKind
, const Expr
*IteratorExpr
)
112 : DepKind(DepKind
), IteratorExpr(IteratorExpr
) {}
114 SmallVector
<DependData
, 4> Dependences
;
115 llvm::PointerIntPair
<llvm::Value
*, 1, bool> Final
;
116 llvm::PointerIntPair
<llvm::Value
*, 1, bool> Schedule
;
117 llvm::PointerIntPair
<llvm::Value
*, 1, bool> Priority
;
118 llvm::Value
*Reductions
= nullptr;
119 unsigned NumberOfParts
= 0;
121 bool Nogroup
= false;
122 bool IsReductionWithTaskMod
= false;
123 bool IsWorksharingReduction
= false;
124 bool HasNowaitClause
= false;
127 /// Class intended to support codegen of all kind of the reduction clauses.
128 class ReductionCodeGen
{
130 /// Data required for codegen of reduction clauses.
131 struct ReductionData
{
132 /// Reference to the item shared between tasks to reduce into.
133 const Expr
*Shared
= nullptr;
134 /// Reference to the original item.
135 const Expr
*Ref
= nullptr;
136 /// Helper expression for generation of private copy.
137 const Expr
*Private
= nullptr;
138 /// Helper expression for generation reduction operation.
139 const Expr
*ReductionOp
= nullptr;
140 ReductionData(const Expr
*Shared
, const Expr
*Ref
, const Expr
*Private
,
141 const Expr
*ReductionOp
)
142 : Shared(Shared
), Ref(Ref
), Private(Private
), ReductionOp(ReductionOp
) {
145 /// List of reduction-based clauses.
146 SmallVector
<ReductionData
, 4> ClausesData
;
148 /// List of addresses of shared variables/expressions.
149 SmallVector
<std::pair
<LValue
, LValue
>, 4> SharedAddresses
;
150 /// List of addresses of original variables/expressions.
151 SmallVector
<std::pair
<LValue
, LValue
>, 4> OrigAddresses
;
152 /// Sizes of the reduction items in chars.
153 SmallVector
<std::pair
<llvm::Value
*, llvm::Value
*>, 4> Sizes
;
154 /// Base declarations for the reduction items.
155 SmallVector
<const VarDecl
*, 4> BaseDecls
;
157 /// Emits lvalue for shared expression.
158 LValue
emitSharedLValue(CodeGenFunction
&CGF
, const Expr
*E
);
159 /// Emits upper bound for shared expression (if array section).
160 LValue
emitSharedLValueUB(CodeGenFunction
&CGF
, const Expr
*E
);
161 /// Performs aggregate initialization.
162 /// \param N Number of reduction item in the common list.
163 /// \param PrivateAddr Address of the corresponding private item.
164 /// \param SharedAddr Address of the original shared variable.
165 /// \param DRD Declare reduction construct used for reduction item.
166 void emitAggregateInitialization(CodeGenFunction
&CGF
, unsigned N
,
167 Address PrivateAddr
, Address SharedAddr
,
168 const OMPDeclareReductionDecl
*DRD
);
171 ReductionCodeGen(ArrayRef
<const Expr
*> Shareds
, ArrayRef
<const Expr
*> Origs
,
172 ArrayRef
<const Expr
*> Privates
,
173 ArrayRef
<const Expr
*> ReductionOps
);
174 /// Emits lvalue for the shared and original reduction item.
175 /// \param N Number of the reduction item.
176 void emitSharedOrigLValue(CodeGenFunction
&CGF
, unsigned N
);
177 /// Emits the code for the variable-modified type, if required.
178 /// \param N Number of the reduction item.
179 void emitAggregateType(CodeGenFunction
&CGF
, unsigned N
);
180 /// Emits the code for the variable-modified type, if required.
181 /// \param N Number of the reduction item.
182 /// \param Size Size of the type in chars.
183 void emitAggregateType(CodeGenFunction
&CGF
, unsigned N
, llvm::Value
*Size
);
184 /// Performs initialization of the private copy for the reduction item.
185 /// \param N Number of the reduction item.
186 /// \param PrivateAddr Address of the corresponding private item.
187 /// \param DefaultInit Default initialization sequence that should be
188 /// performed if no reduction specific initialization is found.
189 /// \param SharedAddr Address of the original shared variable.
191 emitInitialization(CodeGenFunction
&CGF
, unsigned N
, Address PrivateAddr
,
193 llvm::function_ref
<bool(CodeGenFunction
&)> DefaultInit
);
194 /// Returns true if the private copy requires cleanups.
195 bool needCleanups(unsigned N
);
196 /// Emits cleanup code for the reduction item.
197 /// \param N Number of the reduction item.
198 /// \param PrivateAddr Address of the corresponding private item.
199 void emitCleanups(CodeGenFunction
&CGF
, unsigned N
, Address PrivateAddr
);
200 /// Adjusts \p PrivatedAddr for using instead of the original variable
201 /// address in normal operations.
202 /// \param N Number of the reduction item.
203 /// \param PrivateAddr Address of the corresponding private item.
204 Address
adjustPrivateAddress(CodeGenFunction
&CGF
, unsigned N
,
205 Address PrivateAddr
);
206 /// Returns LValue for the reduction item.
207 LValue
getSharedLValue(unsigned N
) const { return SharedAddresses
[N
].first
; }
208 /// Returns LValue for the original reduction item.
209 LValue
getOrigLValue(unsigned N
) const { return OrigAddresses
[N
].first
; }
210 /// Returns the size of the reduction item (in chars and total number of
211 /// elements in the item), or nullptr, if the size is a constant.
212 std::pair
<llvm::Value
*, llvm::Value
*> getSizes(unsigned N
) const {
215 /// Returns the base declaration of the reduction item.
216 const VarDecl
*getBaseDecl(unsigned N
) const { return BaseDecls
[N
]; }
217 /// Returns the base declaration of the reduction item.
218 const Expr
*getRefExpr(unsigned N
) const { return ClausesData
[N
].Ref
; }
219 /// Returns true if the initialization of the reduction item uses initializer
220 /// from declare reduction construct.
221 bool usesReductionInitializer(unsigned N
) const;
222 /// Return the type of the private item.
223 QualType
getPrivateType(unsigned N
) const {
224 return cast
<VarDecl
>(cast
<DeclRefExpr
>(ClausesData
[N
].Private
)->getDecl())
229 class CGOpenMPRuntime
{
231 /// Allows to disable automatic handling of functions used in target regions
232 /// as those marked as `omp declare target`.
233 class DisableAutoDeclareTargetRAII
{
235 bool SavedShouldMarkAsGlobal
;
238 DisableAutoDeclareTargetRAII(CodeGenModule
&CGM
);
239 ~DisableAutoDeclareTargetRAII();
242 /// Manages list of nontemporal decls for the specified directive.
243 class NontemporalDeclsRAII
{
245 const bool NeedToPush
;
248 NontemporalDeclsRAII(CodeGenModule
&CGM
, const OMPLoopDirective
&S
);
249 ~NontemporalDeclsRAII();
252 /// Manages list of nontemporal decls for the specified directive.
253 class UntiedTaskLocalDeclsRAII
{
255 const bool NeedToPush
;
258 UntiedTaskLocalDeclsRAII(
259 CodeGenFunction
&CGF
,
260 const llvm::MapVector
<CanonicalDeclPtr
<const VarDecl
>,
261 std::pair
<Address
, Address
>> &LocalVars
);
262 ~UntiedTaskLocalDeclsRAII();
265 /// Maps the expression for the lastprivate variable to the global copy used
266 /// to store new value because original variables are not mapped in inner
267 /// parallel regions. Only private copies are captured but we need also to
268 /// store private copy in shared address.
269 /// Also, stores the expression for the private loop counter and it
270 /// threaprivate name.
271 struct LastprivateConditionalData
{
272 llvm::MapVector
<CanonicalDeclPtr
<const Decl
>, SmallString
<16>>
275 llvm::Function
*Fn
= nullptr;
276 bool Disabled
= false;
278 /// Manages list of lastprivate conditional decls for the specified directive.
279 class LastprivateConditionalRAII
{
280 enum class ActionToDo
{
282 PushAsLastprivateConditional
,
283 DisableLastprivateConditional
,
286 ActionToDo Action
= ActionToDo::DoNotPush
;
288 /// Check and try to disable analysis of inner regions for changes in
289 /// lastprivate conditional.
290 void tryToDisableInnerAnalysis(const OMPExecutableDirective
&S
,
291 llvm::DenseSet
<CanonicalDeclPtr
<const Decl
>>
292 &NeedToAddForLPCsAsDisabled
) const;
294 LastprivateConditionalRAII(CodeGenFunction
&CGF
,
295 const OMPExecutableDirective
&S
);
298 explicit LastprivateConditionalRAII(CodeGenFunction
&CGF
,
299 const OMPExecutableDirective
&S
,
301 static LastprivateConditionalRAII
disable(CodeGenFunction
&CGF
,
302 const OMPExecutableDirective
&S
);
303 ~LastprivateConditionalRAII();
306 llvm::OpenMPIRBuilder
&getOMPBuilder() { return OMPBuilder
; }
311 /// An OpenMP-IR-Builder instance.
312 llvm::OpenMPIRBuilder OMPBuilder
;
314 /// Helper to emit outlined function for 'target' directive.
315 /// \param D Directive to emit.
316 /// \param ParentName Name of the function that encloses the target region.
317 /// \param OutlinedFn Outlined function value to be defined by this call.
318 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
319 /// \param IsOffloadEntry True if the outlined function is an offload entry.
320 /// \param CodeGen Lambda codegen specific to an accelerator device.
321 /// An outlined function may not be an entry if, e.g. the if clause always
322 /// evaluates to false.
323 virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective
&D
,
324 StringRef ParentName
,
325 llvm::Function
*&OutlinedFn
,
326 llvm::Constant
*&OutlinedFnID
,
328 const RegionCodeGenTy
&CodeGen
);
330 /// Emits object of ident_t type with info for source location.
331 /// \param Flags Flags for OpenMP location.
332 /// \param EmitLoc emit source location with debug-info is off.
334 llvm::Value
*emitUpdateLocation(CodeGenFunction
&CGF
, SourceLocation Loc
,
335 unsigned Flags
= 0, bool EmitLoc
= false);
337 /// Emit the number of teams for a target directive. Inspect the num_teams
338 /// clause associated with a teams construct combined or closely nested
339 /// with the target directive.
341 /// Emit a team of size one for directives such as 'target parallel' that
342 /// have no associated teams construct.
344 /// Otherwise, return nullptr.
345 const Expr
*getNumTeamsExprForTargetDirective(CodeGenFunction
&CGF
,
346 const OMPExecutableDirective
&D
,
347 int32_t &DefaultVal
);
348 llvm::Value
*emitNumTeamsForTargetDirective(CodeGenFunction
&CGF
,
349 const OMPExecutableDirective
&D
);
350 /// Emit the number of threads for a target directive. Inspect the
351 /// thread_limit clause associated with a teams construct combined or closely
352 /// nested with the target directive.
354 /// Emit the num_threads clause for directives such as 'target parallel' that
355 /// have no associated teams construct.
357 /// Otherwise, return nullptr.
359 getNumThreadsExprForTargetDirective(CodeGenFunction
&CGF
,
360 const OMPExecutableDirective
&D
,
361 int32_t &DefaultVal
);
363 emitNumThreadsForTargetDirective(CodeGenFunction
&CGF
,
364 const OMPExecutableDirective
&D
);
366 /// Returns pointer to ident_t type.
367 llvm::Type
*getIdentTyPointerTy();
369 /// Gets thread id value for the current thread.
371 llvm::Value
*getThreadID(CodeGenFunction
&CGF
, SourceLocation Loc
);
373 /// Get the function name of an outlined region.
374 std::string
getOutlinedHelperName(StringRef Name
) const;
375 std::string
getOutlinedHelperName(CodeGenFunction
&CGF
) const;
377 /// Get the function name of a reduction function.
378 std::string
getReductionFuncName(StringRef Name
) const;
380 /// Emits \p Callee function call with arguments \p Args with location \p Loc.
381 void emitCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
382 llvm::FunctionCallee Callee
,
383 ArrayRef
<llvm::Value
*> Args
= std::nullopt
) const;
385 /// Emits address of the word in a memory where current thread id is
387 virtual Address
emitThreadIDAddress(CodeGenFunction
&CGF
, SourceLocation Loc
);
389 void setLocThreadIdInsertPt(CodeGenFunction
&CGF
,
390 bool AtCurrentPoint
= false);
391 void clearLocThreadIdInsertPt(CodeGenFunction
&CGF
);
393 /// Check if the default location must be constant.
394 /// Default is false to support OMPT/OMPD.
395 virtual bool isDefaultLocationConstant() const { return false; }
397 /// Returns additional flags that can be stored in reserved_2 field of the
398 /// default location.
399 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
401 /// Returns default flags for the barriers depending on the directive, for
402 /// which this barier is going to be emitted.
403 static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind
);
405 /// Get the LLVM type for the critical name.
406 llvm::ArrayType
*getKmpCriticalNameTy() const {return KmpCriticalNameTy
;}
408 /// Returns corresponding lock object for the specified critical region
409 /// name. If the lock object does not exist it is created, otherwise the
410 /// reference to the existing copy is returned.
411 /// \param CriticalName Name of the critical region.
413 llvm::Value
*getCriticalRegionLock(StringRef CriticalName
);
416 /// Map for SourceLocation and OpenMP runtime library debug locations.
417 typedef llvm::DenseMap
<SourceLocation
, llvm::Value
*> OpenMPDebugLocMapTy
;
418 OpenMPDebugLocMapTy OpenMPDebugLocMap
;
419 /// The type for a microtask which gets passed to __kmpc_fork_call().
420 /// Original representation is:
421 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
422 llvm::FunctionType
*Kmpc_MicroTy
= nullptr;
423 /// Stores debug location and ThreadID for the function.
424 struct DebugLocThreadIdTy
{
425 llvm::Value
*DebugLoc
;
426 llvm::Value
*ThreadID
;
427 /// Insert point for the service instructions.
428 llvm::AssertingVH
<llvm::Instruction
> ServiceInsertPt
= nullptr;
430 /// Map of local debug location, ThreadId and functions.
431 typedef llvm::DenseMap
<llvm::Function
*, DebugLocThreadIdTy
>
432 OpenMPLocThreadIDMapTy
;
433 OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap
;
434 /// Map of UDRs and corresponding combiner/initializer.
435 typedef llvm::DenseMap
<const OMPDeclareReductionDecl
*,
436 std::pair
<llvm::Function
*, llvm::Function
*>>
439 /// Map of functions and locally defined UDRs.
440 typedef llvm::DenseMap
<llvm::Function
*,
441 SmallVector
<const OMPDeclareReductionDecl
*, 4>>
443 FunctionUDRMapTy FunctionUDRMap
;
444 /// Map from the user-defined mapper declaration to its corresponding
446 llvm::DenseMap
<const OMPDeclareMapperDecl
*, llvm::Function
*> UDMMap
;
447 /// Map of functions and their local user-defined mappers.
448 using FunctionUDMMapTy
=
449 llvm::DenseMap
<llvm::Function
*,
450 SmallVector
<const OMPDeclareMapperDecl
*, 4>>;
451 FunctionUDMMapTy FunctionUDMMap
;
452 /// Maps local variables marked as lastprivate conditional to their internal
454 llvm::DenseMap
<llvm::Function
*,
455 llvm::DenseMap
<CanonicalDeclPtr
<const Decl
>,
456 std::tuple
<QualType
, const FieldDecl
*,
457 const FieldDecl
*, LValue
>>>
458 LastprivateConditionalToTypes
;
459 /// Maps function to the position of the untied task locals stack.
460 llvm::DenseMap
<llvm::Function
*, unsigned> FunctionToUntiedTaskStackMap
;
461 /// Type kmp_critical_name, originally defined as typedef kmp_int32
462 /// kmp_critical_name[8];
463 llvm::ArrayType
*KmpCriticalNameTy
;
464 /// An ordered map of auto-generated variables to their unique names.
465 /// It stores variables with the following names: 1) ".gomp_critical_user_" +
466 /// <critical_section_name> + ".var" for "omp critical" directives; 2)
467 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
469 llvm::StringMap
<llvm::AssertingVH
<llvm::GlobalVariable
>,
470 llvm::BumpPtrAllocator
> InternalVars
;
471 /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
472 llvm::Type
*KmpRoutineEntryPtrTy
= nullptr;
473 QualType KmpRoutineEntryPtrQTy
;
474 /// Type typedef struct kmp_task {
475 /// void * shareds; /**< pointer to block of pointers to
477 /// kmp_routine_entry_t routine; /**< pointer to routine to call for
478 /// executing task */
479 /// kmp_int32 part_id; /**< part id for the task */
480 /// kmp_routine_entry_t destructors; /* pointer to function to invoke
481 /// deconstructors of firstprivate C++ objects */
483 QualType KmpTaskTQTy
;
484 /// Saved kmp_task_t for task directive.
485 QualType SavedKmpTaskTQTy
;
486 /// Saved kmp_task_t for taskloop-based directive.
487 QualType SavedKmpTaskloopTQTy
;
488 /// Type typedef struct kmp_depend_info {
489 /// kmp_intptr_t base_addr;
495 /// } kmp_depend_info_t;
496 QualType KmpDependInfoTy
;
497 /// Type typedef struct kmp_task_affinity_info {
498 /// kmp_intptr_t base_addr;
503 /// kmp_int32 reserved : 30;
505 /// } kmp_task_affinity_info_t;
506 QualType KmpTaskAffinityInfoTy
;
507 /// struct kmp_dim { // loop bounds info casted to kmp_int64
508 /// kmp_int64 lo; // lower
509 /// kmp_int64 up; // upper
510 /// kmp_int64 st; // stride
514 bool ShouldMarkAsGlobal
= true;
515 /// List of the emitted declarations.
516 llvm::DenseSet
<CanonicalDeclPtr
<const Decl
>> AlreadyEmittedTargetDecls
;
517 /// List of the global variables with their addresses that should not be
518 /// emitted for the target.
519 llvm::StringMap
<llvm::WeakTrackingVH
> EmittedNonTargetVariables
;
521 /// List of variables that can become declare target implicitly and, thus,
523 llvm::SmallDenseSet
<const VarDecl
*> DeferredGlobalVariables
;
525 using NontemporalDeclsSet
= llvm::SmallDenseSet
<CanonicalDeclPtr
<const Decl
>>;
526 /// Stack for list of declarations in current context marked as nontemporal.
527 /// The set is the union of all current stack elements.
528 llvm::SmallVector
<NontemporalDeclsSet
, 4> NontemporalDeclsStack
;
530 using UntiedLocalVarsAddressesMap
=
531 llvm::MapVector
<CanonicalDeclPtr
<const VarDecl
>,
532 std::pair
<Address
, Address
>>;
533 llvm::SmallVector
<UntiedLocalVarsAddressesMap
, 4> UntiedLocalVarsStack
;
535 /// Stack for list of addresses of declarations in current context marked as
536 /// lastprivate conditional. The set is the union of all current stack
538 llvm::SmallVector
<LastprivateConditionalData
, 4> LastprivateConditionalStack
;
540 /// Flag for keeping track of weather a requires unified_shared_memory
541 /// directive is present.
542 bool HasRequiresUnifiedSharedMemory
= false;
544 /// Atomic ordering from the omp requires directive.
545 llvm::AtomicOrdering RequiresAtomicOrdering
= llvm::AtomicOrdering::Monotonic
;
547 /// Flag for keeping track of weather a target region has been emitted.
548 bool HasEmittedTargetRegion
= false;
550 /// Flag for keeping track of weather a device routine has been emitted.
551 /// Device routines are specific to the
552 bool HasEmittedDeclareTargetRegion
= false;
554 /// Start scanning from statement \a S and emit all target regions
555 /// found along the way.
556 /// \param S Starting statement.
557 /// \param ParentName Name of the function declaration that is being scanned.
558 void scanForTargetRegionsFunctions(const Stmt
*S
, StringRef ParentName
);
560 /// Build type kmp_routine_entry_t (if not built yet).
561 void emitKmpRoutineEntryT(QualType KmpInt32Ty
);
563 /// Returns pointer to kmpc_micro type.
564 llvm::Type
*getKmpc_MicroPointerTy();
566 /// Returns __kmpc_for_static_init_* runtime function for the specified
567 /// size \a IVSize and sign \a IVSigned. Will create a distribute call
568 /// __kmpc_distribute_static_init* if \a IsGPUDistribute is set.
569 llvm::FunctionCallee
createForStaticInitFunction(unsigned IVSize
,
571 bool IsGPUDistribute
);
573 /// Returns __kmpc_dispatch_init_* runtime function for the specified
574 /// size \a IVSize and sign \a IVSigned.
575 llvm::FunctionCallee
createDispatchInitFunction(unsigned IVSize
,
578 /// Returns __kmpc_dispatch_next_* runtime function for the specified
579 /// size \a IVSize and sign \a IVSigned.
580 llvm::FunctionCallee
createDispatchNextFunction(unsigned IVSize
,
583 /// Returns __kmpc_dispatch_fini_* runtime function for the specified
584 /// size \a IVSize and sign \a IVSigned.
585 llvm::FunctionCallee
createDispatchFiniFunction(unsigned IVSize
,
588 /// If the specified mangled name is not in the module, create and
589 /// return threadprivate cache object. This object is a pointer's worth of
590 /// storage that's reserved for use by the OpenMP runtime.
591 /// \param VD Threadprivate variable.
592 /// \return Cache variable for the specified threadprivate.
593 llvm::Constant
*getOrCreateThreadPrivateCache(const VarDecl
*VD
);
595 /// Set of threadprivate variables with the generated initializer.
596 llvm::StringSet
<> ThreadPrivateWithDefinition
;
598 /// Set of declare target variables with the generated initializer.
599 llvm::StringSet
<> DeclareTargetWithDefinition
;
601 /// Emits initialization code for the threadprivate variables.
602 /// \param VDAddr Address of the global variable \a VD.
603 /// \param Ctor Pointer to a global init function for \a VD.
604 /// \param CopyCtor Pointer to a global copy function for \a VD.
605 /// \param Dtor Pointer to a global destructor function for \a VD.
606 /// \param Loc Location of threadprivate declaration.
607 void emitThreadPrivateVarInit(CodeGenFunction
&CGF
, Address VDAddr
,
608 llvm::Value
*Ctor
, llvm::Value
*CopyCtor
,
609 llvm::Value
*Dtor
, SourceLocation Loc
);
611 /// Emit the array initialization or deletion portion for user-defined mapper
613 void emitUDMapperArrayInitOrDel(CodeGenFunction
&MapperCGF
,
614 llvm::Value
*Handle
, llvm::Value
*BasePtr
,
615 llvm::Value
*Ptr
, llvm::Value
*Size
,
616 llvm::Value
*MapType
, llvm::Value
*MapName
,
617 CharUnits ElementSize
,
618 llvm::BasicBlock
*ExitBB
, bool IsInit
);
620 struct TaskResultTy
{
621 llvm::Value
*NewTask
= nullptr;
622 llvm::Function
*TaskEntry
= nullptr;
623 llvm::Value
*NewTaskNewTaskTTy
= nullptr;
625 const RecordDecl
*KmpTaskTQTyRD
= nullptr;
626 llvm::Value
*TaskDupFn
= nullptr;
628 /// Emit task region for the task directive. The task region is emitted in
630 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
631 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
632 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
634 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
635 /// TaskFunction(gtid, tt->part_id, tt->shareds);
638 /// 2. Copy a list of shared variables to field shareds of the resulting
639 /// structure kmp_task_t returned by the previous call (if any).
640 /// 3. Copy a pointer to destructions function to field destructions of the
641 /// resulting structure kmp_task_t.
642 /// \param D Current task directive.
643 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
644 /// /*part_id*/, captured_struct */*__context*/);
645 /// \param SharedsTy A type which contains references the shared variables.
646 /// \param Shareds Context with the list of shared variables from the \p
648 /// \param Data Additional data for task generation like tiednsee, final
649 /// state, list of privates etc.
650 TaskResultTy
emitTaskInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
651 const OMPExecutableDirective
&D
,
652 llvm::Function
*TaskFunction
, QualType SharedsTy
,
653 Address Shareds
, const OMPTaskDataTy
&Data
);
655 /// Return the trip count of loops associated with constructs / 'target teams
656 /// distribute' and 'teams distribute parallel for'. \param SizeEmitter Emits
657 /// the int64 value for the number of iterations of the associated loop.
658 llvm::Value
*emitTargetNumIterationsCall(
659 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
660 llvm::function_ref
<llvm::Value
*(CodeGenFunction
&CGF
,
661 const OMPLoopDirective
&D
)>
664 /// Emit update for lastprivate conditional data.
665 void emitLastprivateConditionalUpdate(CodeGenFunction
&CGF
, LValue IVLVal
,
666 StringRef UniqueDeclName
, LValue LVal
,
669 /// Returns the number of the elements and the address of the depobj
670 /// dependency array.
671 /// \return Number of elements in depobj array and the pointer to the array of
673 std::pair
<llvm::Value
*, LValue
> getDepobjElements(CodeGenFunction
&CGF
,
677 SmallVector
<llvm::Value
*, 4>
678 emitDepobjElementsSizes(CodeGenFunction
&CGF
, QualType
&KmpDependInfoTy
,
679 const OMPTaskDataTy::DependData
&Data
);
681 void emitDepobjElements(CodeGenFunction
&CGF
, QualType
&KmpDependInfoTy
,
682 LValue PosLVal
, const OMPTaskDataTy::DependData
&Data
,
683 Address DependenciesArray
);
686 explicit CGOpenMPRuntime(CodeGenModule
&CGM
);
687 virtual ~CGOpenMPRuntime() {}
688 virtual void clear();
690 /// Returns true if the current target is a GPU.
691 virtual bool isTargetCodegen() const { return false; }
693 /// Emits code for OpenMP 'if' clause using specified \a CodeGen
694 /// function. Here is the logic:
700 void emitIfClause(CodeGenFunction
&CGF
, const Expr
*Cond
,
701 const RegionCodeGenTy
&ThenGen
,
702 const RegionCodeGenTy
&ElseGen
);
704 /// Checks if the \p Body is the \a CompoundStmt and returns its child
705 /// statement iff there is only one that is not evaluatable at the compile
707 static const Stmt
*getSingleCompoundChild(ASTContext
&Ctx
, const Stmt
*Body
);
709 /// Get the platform-specific name separator.
710 std::string
getName(ArrayRef
<StringRef
> Parts
) const;
712 /// Emit code for the specified user defined reduction construct.
713 virtual void emitUserDefinedReduction(CodeGenFunction
*CGF
,
714 const OMPDeclareReductionDecl
*D
);
715 /// Get combiner/initializer for the specified user-defined reduction, if any.
716 virtual std::pair
<llvm::Function
*, llvm::Function
*>
717 getUserDefinedReduction(const OMPDeclareReductionDecl
*D
);
719 /// Emit the function for the user defined mapper construct.
720 void emitUserDefinedMapper(const OMPDeclareMapperDecl
*D
,
721 CodeGenFunction
*CGF
= nullptr);
722 /// Get the function for the specified user-defined mapper. If it does not
723 /// exist, create one.
725 getOrCreateUserDefinedMapperFunc(const OMPDeclareMapperDecl
*D
);
727 /// Emits outlined function for the specified OpenMP parallel directive
728 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
729 /// kmp_int32 BoundID, struct context_vars*).
730 /// \param CGF Reference to current CodeGenFunction.
731 /// \param D OpenMP directive.
732 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
733 /// \param InnermostKind Kind of innermost directive (for simple directives it
734 /// is a directive itself, for combined - its innermost directive).
735 /// \param CodeGen Code generation sequence for the \a D directive.
736 virtual llvm::Function
*emitParallelOutlinedFunction(
737 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
738 const VarDecl
*ThreadIDVar
, OpenMPDirectiveKind InnermostKind
,
739 const RegionCodeGenTy
&CodeGen
);
741 /// Emits outlined function for the specified OpenMP teams directive
742 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
743 /// kmp_int32 BoundID, struct context_vars*).
744 /// \param CGF Reference to current CodeGenFunction.
745 /// \param D OpenMP directive.
746 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
747 /// \param InnermostKind Kind of innermost directive (for simple directives it
748 /// is a directive itself, for combined - its innermost directive).
749 /// \param CodeGen Code generation sequence for the \a D directive.
750 virtual llvm::Function
*emitTeamsOutlinedFunction(
751 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
752 const VarDecl
*ThreadIDVar
, OpenMPDirectiveKind InnermostKind
,
753 const RegionCodeGenTy
&CodeGen
);
755 /// Emits outlined function for the OpenMP task directive \a D. This
756 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
758 /// \param D OpenMP directive.
759 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
760 /// \param PartIDVar Variable for partition id in the current OpenMP untied
762 /// \param TaskTVar Variable for task_t argument.
763 /// \param InnermostKind Kind of innermost directive (for simple directives it
764 /// is a directive itself, for combined - its innermost directive).
765 /// \param CodeGen Code generation sequence for the \a D directive.
766 /// \param Tied true if task is generated for tied task, false otherwise.
767 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
770 virtual llvm::Function
*emitTaskOutlinedFunction(
771 const OMPExecutableDirective
&D
, const VarDecl
*ThreadIDVar
,
772 const VarDecl
*PartIDVar
, const VarDecl
*TaskTVar
,
773 OpenMPDirectiveKind InnermostKind
, const RegionCodeGenTy
&CodeGen
,
774 bool Tied
, unsigned &NumberOfParts
);
776 /// Cleans up references to the objects in finished function.
778 virtual void functionFinished(CodeGenFunction
&CGF
);
780 /// Emits code for parallel or serial call of the \a OutlinedFn with
781 /// variables captured in a record which address is stored in \a
783 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
784 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
785 /// \param CapturedVars A pointer to the record with the references to
786 /// variables used in \a OutlinedFn function.
787 /// \param IfCond Condition in the associated 'if' clause, if it was
788 /// specified, nullptr otherwise.
789 /// \param NumThreads The value corresponding to the num_threads clause, if
792 virtual void emitParallelCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
793 llvm::Function
*OutlinedFn
,
794 ArrayRef
<llvm::Value
*> CapturedVars
,
795 const Expr
*IfCond
, llvm::Value
*NumThreads
);
797 /// Emits a critical region.
798 /// \param CriticalName Name of the critical region.
799 /// \param CriticalOpGen Generator for the statement associated with the given
801 /// \param Hint Value of the 'hint' clause (optional).
802 virtual void emitCriticalRegion(CodeGenFunction
&CGF
, StringRef CriticalName
,
803 const RegionCodeGenTy
&CriticalOpGen
,
805 const Expr
*Hint
= nullptr);
807 /// Emits a master region.
808 /// \param MasterOpGen Generator for the statement associated with the given
810 virtual void emitMasterRegion(CodeGenFunction
&CGF
,
811 const RegionCodeGenTy
&MasterOpGen
,
814 /// Emits a masked region.
815 /// \param MaskedOpGen Generator for the statement associated with the given
817 virtual void emitMaskedRegion(CodeGenFunction
&CGF
,
818 const RegionCodeGenTy
&MaskedOpGen
,
820 const Expr
*Filter
= nullptr);
822 /// Emits code for a taskyield directive.
823 virtual void emitTaskyieldCall(CodeGenFunction
&CGF
, SourceLocation Loc
);
825 /// Emit __kmpc_error call for error directive
826 /// extern void __kmpc_error(ident_t *loc, int severity, const char *message);
827 virtual void emitErrorCall(CodeGenFunction
&CGF
, SourceLocation Loc
, Expr
*ME
,
830 /// Emit a taskgroup region.
831 /// \param TaskgroupOpGen Generator for the statement associated with the
832 /// given taskgroup region.
833 virtual void emitTaskgroupRegion(CodeGenFunction
&CGF
,
834 const RegionCodeGenTy
&TaskgroupOpGen
,
837 /// Emits a single region.
838 /// \param SingleOpGen Generator for the statement associated with the given
840 virtual void emitSingleRegion(CodeGenFunction
&CGF
,
841 const RegionCodeGenTy
&SingleOpGen
,
843 ArrayRef
<const Expr
*> CopyprivateVars
,
844 ArrayRef
<const Expr
*> DestExprs
,
845 ArrayRef
<const Expr
*> SrcExprs
,
846 ArrayRef
<const Expr
*> AssignmentOps
);
848 /// Emit an ordered region.
849 /// \param OrderedOpGen Generator for the statement associated with the given
851 virtual void emitOrderedRegion(CodeGenFunction
&CGF
,
852 const RegionCodeGenTy
&OrderedOpGen
,
853 SourceLocation Loc
, bool IsThreads
);
855 /// Emit an implicit/explicit barrier for OpenMP threads.
856 /// \param Kind Directive for which this implicit barrier call must be
857 /// generated. Must be OMPD_barrier for explicit barrier generation.
858 /// \param EmitChecks true if need to emit checks for cancellation barriers.
859 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
860 /// runtime class decides which one to emit (simple or with cancellation
863 virtual void emitBarrierCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
864 OpenMPDirectiveKind Kind
,
865 bool EmitChecks
= true,
866 bool ForceSimpleCall
= false);
868 /// Check if the specified \a ScheduleKind is static non-chunked.
869 /// This kind of worksharing directive is emitted without outer loop.
870 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
871 /// \param Chunked True if chunk is specified in the clause.
873 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind
,
876 /// Check if the specified \a ScheduleKind is static non-chunked.
877 /// This kind of distribute directive is emitted without outer loop.
878 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
879 /// \param Chunked True if chunk is specified in the clause.
881 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind
,
884 /// Check if the specified \a ScheduleKind is static chunked.
885 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
886 /// \param Chunked True if chunk is specified in the clause.
888 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind
,
891 /// Check if the specified \a ScheduleKind is static non-chunked.
892 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
893 /// \param Chunked True if chunk is specified in the clause.
895 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind
,
898 /// Check if the specified \a ScheduleKind is dynamic.
899 /// This kind of worksharing directive is emitted without outer loop.
900 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
902 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind
) const;
904 /// struct with the values to be passed to the dispatch runtime function
905 struct DispatchRTInput
{
907 llvm::Value
*LB
= nullptr;
909 llvm::Value
*UB
= nullptr;
910 /// Chunk size specified using 'schedule' clause (nullptr if chunk
911 /// was not specified)
912 llvm::Value
*Chunk
= nullptr;
913 DispatchRTInput() = default;
914 DispatchRTInput(llvm::Value
*LB
, llvm::Value
*UB
, llvm::Value
*Chunk
)
915 : LB(LB
), UB(UB
), Chunk(Chunk
) {}
918 /// Call the appropriate runtime routine to initialize it before start
921 /// This is used for non static scheduled types and when the ordered
922 /// clause is present on the loop construct.
923 /// Depending on the loop schedule, it is necessary to call some runtime
924 /// routine before start of the OpenMP loop to get the loop upper / lower
925 /// bounds \a LB and \a UB and stride \a ST.
927 /// \param CGF Reference to current CodeGenFunction.
928 /// \param Loc Clang source location.
929 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
930 /// \param IVSize Size of the iteration variable in bits.
931 /// \param IVSigned Sign of the iteration variable.
932 /// \param Ordered true if loop is ordered, false otherwise.
933 /// \param DispatchValues struct containing llvm values for lower bound, upper
934 /// bound, and chunk expression.
935 /// For the default (nullptr) value, the chunk 1 will be used.
937 virtual void emitForDispatchInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
938 const OpenMPScheduleTy
&ScheduleKind
,
939 unsigned IVSize
, bool IVSigned
, bool Ordered
,
940 const DispatchRTInput
&DispatchValues
);
942 /// Struct with the values to be passed to the static runtime function
943 struct StaticRTInput
{
944 /// Size of the iteration variable in bits.
946 /// Sign of the iteration variable.
947 bool IVSigned
= false;
948 /// true if loop is ordered, false otherwise.
949 bool Ordered
= false;
950 /// Address of the output variable in which the flag of the last iteration
952 Address IL
= Address::invalid();
953 /// Address of the output variable in which the lower iteration number is
955 Address LB
= Address::invalid();
956 /// Address of the output variable in which the upper iteration number is
958 Address UB
= Address::invalid();
959 /// Address of the output variable in which the stride value is returned
960 /// necessary to generated the static_chunked scheduled loop.
961 Address ST
= Address::invalid();
962 /// Value of the chunk for the static_chunked scheduled loop. For the
963 /// default (nullptr) value, the chunk 1 will be used.
964 llvm::Value
*Chunk
= nullptr;
965 StaticRTInput(unsigned IVSize
, bool IVSigned
, bool Ordered
, Address IL
,
966 Address LB
, Address UB
, Address ST
,
967 llvm::Value
*Chunk
= nullptr)
968 : IVSize(IVSize
), IVSigned(IVSigned
), Ordered(Ordered
), IL(IL
), LB(LB
),
969 UB(UB
), ST(ST
), Chunk(Chunk
) {}
971 /// Call the appropriate runtime routine to initialize it before start
974 /// This is used only in case of static schedule, when the user did not
975 /// specify a ordered clause on the loop construct.
976 /// Depending on the loop schedule, it is necessary to call some runtime
977 /// routine before start of the OpenMP loop to get the loop upper / lower
978 /// bounds LB and UB and stride ST.
980 /// \param CGF Reference to current CodeGenFunction.
981 /// \param Loc Clang source location.
982 /// \param DKind Kind of the directive.
983 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
984 /// \param Values Input arguments for the construct.
986 virtual void emitForStaticInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
987 OpenMPDirectiveKind DKind
,
988 const OpenMPScheduleTy
&ScheduleKind
,
989 const StaticRTInput
&Values
);
992 /// \param CGF Reference to current CodeGenFunction.
993 /// \param Loc Clang source location.
994 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
995 /// \param Values Input arguments for the construct.
997 virtual void emitDistributeStaticInit(CodeGenFunction
&CGF
,
999 OpenMPDistScheduleClauseKind SchedKind
,
1000 const StaticRTInput
&Values
);
1002 /// Call the appropriate runtime routine to notify that we finished
1003 /// iteration of the ordered loop with the dynamic scheduling.
1005 /// \param CGF Reference to current CodeGenFunction.
1006 /// \param Loc Clang source location.
1007 /// \param IVSize Size of the iteration variable in bits.
1008 /// \param IVSigned Sign of the iteration variable.
1010 virtual void emitForOrderedIterationEnd(CodeGenFunction
&CGF
,
1011 SourceLocation Loc
, unsigned IVSize
,
1014 /// Call the appropriate runtime routine to notify that we finished
1015 /// all the work with current loop.
1017 /// \param CGF Reference to current CodeGenFunction.
1018 /// \param Loc Clang source location.
1019 /// \param DKind Kind of the directive for which the static finish is emitted.
1021 virtual void emitForStaticFinish(CodeGenFunction
&CGF
, SourceLocation Loc
,
1022 OpenMPDirectiveKind DKind
);
1024 /// Call __kmpc_dispatch_next(
1025 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1026 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1027 /// kmp_int[32|64] *p_stride);
1028 /// \param IVSize Size of the iteration variable in bits.
1029 /// \param IVSigned Sign of the iteration variable.
1030 /// \param IL Address of the output variable in which the flag of the
1031 /// last iteration is returned.
1032 /// \param LB Address of the output variable in which the lower iteration
1033 /// number is returned.
1034 /// \param UB Address of the output variable in which the upper iteration
1035 /// number is returned.
1036 /// \param ST Address of the output variable in which the stride value is
1038 virtual llvm::Value
*emitForNext(CodeGenFunction
&CGF
, SourceLocation Loc
,
1039 unsigned IVSize
, bool IVSigned
,
1040 Address IL
, Address LB
,
1041 Address UB
, Address ST
);
1043 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1044 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1046 /// \param NumThreads An integer value of threads.
1047 virtual void emitNumThreadsClause(CodeGenFunction
&CGF
,
1048 llvm::Value
*NumThreads
,
1049 SourceLocation Loc
);
1051 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1052 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1053 virtual void emitProcBindClause(CodeGenFunction
&CGF
,
1054 llvm::omp::ProcBindKind ProcBind
,
1055 SourceLocation Loc
);
1057 /// Returns address of the threadprivate variable for the current
1059 /// \param VD Threadprivate variable.
1060 /// \param VDAddr Address of the global variable \a VD.
1061 /// \param Loc Location of the reference to threadprivate var.
1062 /// \return Address of the threadprivate variable for the current thread.
1063 virtual Address
getAddrOfThreadPrivate(CodeGenFunction
&CGF
,
1066 SourceLocation Loc
);
1068 /// Returns the address of the variable marked as declare target with link
1069 /// clause OR as declare target with to clause and unified memory.
1070 virtual Address
getAddrOfDeclareTargetVar(const VarDecl
*VD
);
1072 /// Emit a code for initialization of threadprivate variable. It emits
1073 /// a call to runtime library which adds initial value to the newly created
1074 /// threadprivate variable (if it is not constant) and registers destructor
1075 /// for the variable (if any).
1076 /// \param VD Threadprivate variable.
1077 /// \param VDAddr Address of the global variable \a VD.
1078 /// \param Loc Location of threadprivate declaration.
1079 /// \param PerformInit true if initialization expression is not constant.
1080 virtual llvm::Function
*
1081 emitThreadPrivateVarDefinition(const VarDecl
*VD
, Address VDAddr
,
1082 SourceLocation Loc
, bool PerformInit
,
1083 CodeGenFunction
*CGF
= nullptr);
1085 /// Emit a code for initialization of declare target variable.
1086 /// \param VD Declare target variable.
1087 /// \param Addr Address of the global variable \a VD.
1088 /// \param PerformInit true if initialization expression is not constant.
1089 virtual bool emitDeclareTargetVarDefinition(const VarDecl
*VD
,
1090 llvm::GlobalVariable
*Addr
,
1093 /// Creates artificial threadprivate variable with name \p Name and type \p
1095 /// \param VarType Type of the artificial threadprivate variable.
1096 /// \param Name Name of the artificial threadprivate variable.
1097 virtual Address
getAddrOfArtificialThreadPrivate(CodeGenFunction
&CGF
,
1101 /// Emit flush of the variables specified in 'omp flush' directive.
1102 /// \param Vars List of variables to flush.
1103 virtual void emitFlush(CodeGenFunction
&CGF
, ArrayRef
<const Expr
*> Vars
,
1104 SourceLocation Loc
, llvm::AtomicOrdering AO
);
1106 /// Emit task region for the task directive. The task region is
1107 /// emitted in several steps:
1108 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1109 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1110 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1112 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1113 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1116 /// 2. Copy a list of shared variables to field shareds of the resulting
1117 /// structure kmp_task_t returned by the previous call (if any).
1118 /// 3. Copy a pointer to destructions function to field destructions of the
1119 /// resulting structure kmp_task_t.
1120 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1121 /// kmp_task_t *new_task), where new_task is a resulting structure from
1123 /// \param D Current task directive.
1124 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1125 /// /*part_id*/, captured_struct */*__context*/);
1126 /// \param SharedsTy A type which contains references the shared variables.
1127 /// \param Shareds Context with the list of shared variables from the \p
1129 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1131 /// \param Data Additional data for task generation like tiednsee, final
1132 /// state, list of privates etc.
1133 virtual void emitTaskCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1134 const OMPExecutableDirective
&D
,
1135 llvm::Function
*TaskFunction
, QualType SharedsTy
,
1136 Address Shareds
, const Expr
*IfCond
,
1137 const OMPTaskDataTy
&Data
);
1139 /// Emit task region for the taskloop directive. The taskloop region is
1140 /// emitted in several steps:
1141 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1142 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1143 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1145 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1146 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1149 /// 2. Copy a list of shared variables to field shareds of the resulting
1150 /// structure kmp_task_t returned by the previous call (if any).
1151 /// 3. Copy a pointer to destructions function to field destructions of the
1152 /// resulting structure kmp_task_t.
1153 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1154 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1155 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1156 /// is a resulting structure from
1158 /// \param D Current task directive.
1159 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1160 /// /*part_id*/, captured_struct */*__context*/);
1161 /// \param SharedsTy A type which contains references the shared variables.
1162 /// \param Shareds Context with the list of shared variables from the \p
1164 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1166 /// \param Data Additional data for task generation like tiednsee, final
1167 /// state, list of privates etc.
1168 virtual void emitTaskLoopCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1169 const OMPLoopDirective
&D
,
1170 llvm::Function
*TaskFunction
,
1171 QualType SharedsTy
, Address Shareds
,
1172 const Expr
*IfCond
, const OMPTaskDataTy
&Data
);
1174 /// Emit code for the directive that does not require outlining.
1176 /// \param InnermostKind Kind of innermost directive (for simple directives it
1177 /// is a directive itself, for combined - its innermost directive).
1178 /// \param CodeGen Code generation sequence for the \a D directive.
1179 /// \param HasCancel true if region has inner cancel directive, false
1181 virtual void emitInlinedDirective(CodeGenFunction
&CGF
,
1182 OpenMPDirectiveKind InnermostKind
,
1183 const RegionCodeGenTy
&CodeGen
,
1184 bool HasCancel
= false);
1186 /// Emits reduction function.
1187 /// \param ReducerName Name of the function calling the reduction.
1188 /// \param ArgsElemType Array type containing pointers to reduction variables.
1189 /// \param Privates List of private copies for original reduction arguments.
1190 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1191 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1192 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1193 /// or 'operator binop(LHS, RHS)'.
1194 llvm::Function
*emitReductionFunction(
1195 StringRef ReducerName
, SourceLocation Loc
, llvm::Type
*ArgsElemType
,
1196 ArrayRef
<const Expr
*> Privates
, ArrayRef
<const Expr
*> LHSExprs
,
1197 ArrayRef
<const Expr
*> RHSExprs
, ArrayRef
<const Expr
*> ReductionOps
);
1199 /// Emits single reduction combiner
1200 void emitSingleReductionCombiner(CodeGenFunction
&CGF
,
1201 const Expr
*ReductionOp
,
1202 const Expr
*PrivateRef
,
1203 const DeclRefExpr
*LHS
,
1204 const DeclRefExpr
*RHS
);
1206 struct ReductionOptionsTy
{
1208 bool SimpleReduction
;
1209 OpenMPDirectiveKind ReductionKind
;
1211 /// Emit a code for reduction clause. Next code should be emitted for
1215 /// static kmp_critical_name lock = { 0 };
1217 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1219 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1224 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1225 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1226 /// RedList, reduce_func, &<lock>)) {
1229 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1231 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1235 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1242 /// \param Privates List of private copies for original reduction arguments.
1243 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1244 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1245 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1246 /// or 'operator binop(LHS, RHS)'.
1247 /// \param Options List of options for reduction codegen:
1248 /// WithNowait true if parent directive has also nowait clause, false
1250 /// SimpleReduction Emit reduction operation only. Used for omp simd
1251 /// directive on the host.
1252 /// ReductionKind The kind of reduction to perform.
1253 virtual void emitReduction(CodeGenFunction
&CGF
, SourceLocation Loc
,
1254 ArrayRef
<const Expr
*> Privates
,
1255 ArrayRef
<const Expr
*> LHSExprs
,
1256 ArrayRef
<const Expr
*> RHSExprs
,
1257 ArrayRef
<const Expr
*> ReductionOps
,
1258 ReductionOptionsTy Options
);
1260 /// Emit a code for initialization of task reduction clause. Next code
1261 /// should be emitted for reduction:
1264 /// _taskred_item_t red_data[n];
1266 /// red_data[i].shar = &shareds[i];
1267 /// red_data[i].orig = &origs[i];
1268 /// red_data[i].size = sizeof(origs[i]);
1269 /// red_data[i].f_init = (void*)RedInit<i>;
1270 /// red_data[i].f_fini = (void*)RedDest<i>;
1271 /// red_data[i].f_comb = (void*)RedOp<i>;
1272 /// red_data[i].flags = <Flag_i>;
1274 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
1276 /// For reduction clause with task modifier it emits the next call:
1279 /// _taskred_item_t red_data[n];
1281 /// red_data[i].shar = &shareds[i];
1282 /// red_data[i].orig = &origs[i];
1283 /// red_data[i].size = sizeof(origs[i]);
1284 /// red_data[i].f_init = (void*)RedInit<i>;
1285 /// red_data[i].f_fini = (void*)RedDest<i>;
1286 /// red_data[i].f_comb = (void*)RedOp<i>;
1287 /// red_data[i].flags = <Flag_i>;
1289 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
1292 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1293 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1294 /// \param Data Additional data for task generation like tiedness, final
1295 /// state, list of privates, reductions etc.
1296 virtual llvm::Value
*emitTaskReductionInit(CodeGenFunction
&CGF
,
1298 ArrayRef
<const Expr
*> LHSExprs
,
1299 ArrayRef
<const Expr
*> RHSExprs
,
1300 const OMPTaskDataTy
&Data
);
1302 /// Emits the following code for reduction clause with task modifier:
1304 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
1306 virtual void emitTaskReductionFini(CodeGenFunction
&CGF
, SourceLocation Loc
,
1307 bool IsWorksharingReduction
);
1309 /// Required to resolve existing problems in the runtime. Emits threadprivate
1310 /// variables to store the size of the VLAs/array sections for
1311 /// initializer/combiner/finalizer functions.
1312 /// \param RCG Allows to reuse an existing data for the reductions.
1313 /// \param N Reduction item for which fixups must be emitted.
1314 virtual void emitTaskReductionFixups(CodeGenFunction
&CGF
, SourceLocation Loc
,
1315 ReductionCodeGen
&RCG
, unsigned N
);
1317 /// Get the address of `void *` type of the privatue copy of the reduction
1318 /// item specified by the \p SharedLVal.
1319 /// \param ReductionsPtr Pointer to the reduction data returned by the
1320 /// emitTaskReductionInit function.
1321 /// \param SharedLVal Address of the original reduction item.
1322 virtual Address
getTaskReductionItem(CodeGenFunction
&CGF
, SourceLocation Loc
,
1323 llvm::Value
*ReductionsPtr
,
1326 /// Emit code for 'taskwait' directive.
1327 virtual void emitTaskwaitCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1328 const OMPTaskDataTy
&Data
);
1330 /// Emit code for 'cancellation point' construct.
1331 /// \param CancelRegion Region kind for which the cancellation point must be
1334 virtual void emitCancellationPointCall(CodeGenFunction
&CGF
,
1336 OpenMPDirectiveKind CancelRegion
);
1338 /// Emit code for 'cancel' construct.
1339 /// \param IfCond Condition in the associated 'if' clause, if it was
1340 /// specified, nullptr otherwise.
1341 /// \param CancelRegion Region kind for which the cancel must be emitted.
1343 virtual void emitCancelCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1345 OpenMPDirectiveKind CancelRegion
);
1347 /// Emit outilined function for 'target' directive.
1348 /// \param D Directive to emit.
1349 /// \param ParentName Name of the function that encloses the target region.
1350 /// \param OutlinedFn Outlined function value to be defined by this call.
1351 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1352 /// \param IsOffloadEntry True if the outlined function is an offload entry.
1353 /// \param CodeGen Code generation sequence for the \a D directive.
1354 /// An outlined function may not be an entry if, e.g. the if clause always
1355 /// evaluates to false.
1356 virtual void emitTargetOutlinedFunction(const OMPExecutableDirective
&D
,
1357 StringRef ParentName
,
1358 llvm::Function
*&OutlinedFn
,
1359 llvm::Constant
*&OutlinedFnID
,
1360 bool IsOffloadEntry
,
1361 const RegionCodeGenTy
&CodeGen
);
1363 /// Emit the target offloading code associated with \a D. The emitted
1364 /// code attempts offloading the execution to the device, an the event of
1365 /// a failure it executes the host version outlined in \a OutlinedFn.
1366 /// \param D Directive to emit.
1367 /// \param OutlinedFn Host version of the code to be offloaded.
1368 /// \param OutlinedFnID ID of host version of the code to be offloaded.
1369 /// \param IfCond Expression evaluated in if clause associated with the target
1370 /// directive, or null if no if clause is used.
1371 /// \param Device Expression evaluated in device clause associated with the
1372 /// target directive, or null if no device clause is used and device modifier.
1373 /// \param SizeEmitter Callback to emit number of iterations for loop-based
1375 virtual void emitTargetCall(
1376 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
1377 llvm::Function
*OutlinedFn
, llvm::Value
*OutlinedFnID
, const Expr
*IfCond
,
1378 llvm::PointerIntPair
<const Expr
*, 2, OpenMPDeviceClauseModifier
> Device
,
1379 llvm::function_ref
<llvm::Value
*(CodeGenFunction
&CGF
,
1380 const OMPLoopDirective
&D
)>
1383 /// Emit the target regions enclosed in \a GD function definition or
1384 /// the function itself in case it is a valid device function. Returns true if
1385 /// \a GD was dealt with successfully.
1386 /// \param GD Function to scan.
1387 virtual bool emitTargetFunctions(GlobalDecl GD
);
1389 /// Emit the global variable if it is a valid device global variable.
1390 /// Returns true if \a GD was dealt with successfully.
1391 /// \param GD Variable declaration to emit.
1392 virtual bool emitTargetGlobalVariable(GlobalDecl GD
);
1394 /// Checks if the provided global decl \a GD is a declare target variable and
1395 /// registers it when emitting code for the host.
1396 virtual void registerTargetGlobalVariable(const VarDecl
*VD
,
1397 llvm::Constant
*Addr
);
1399 /// Emit the global \a GD if it is meaningful for the target. Returns
1400 /// if it was emitted successfully.
1401 /// \param GD Global to scan.
1402 virtual bool emitTargetGlobal(GlobalDecl GD
);
1404 /// Creates and returns a registration function for when at least one
1405 /// requires directives was used in the current module.
1406 llvm::Function
*emitRequiresDirectiveRegFun();
1408 /// Creates all the offload entries in the current compilation unit
1409 /// along with the associated metadata.
1410 void createOffloadEntriesAndInfoMetadata();
1412 /// Emits code for teams call of the \a OutlinedFn with
1413 /// variables captured in a record which address is stored in \a
1415 /// \param OutlinedFn Outlined function to be run by team masters. Type of
1416 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1417 /// \param CapturedVars A pointer to the record with the references to
1418 /// variables used in \a OutlinedFn function.
1420 virtual void emitTeamsCall(CodeGenFunction
&CGF
,
1421 const OMPExecutableDirective
&D
,
1422 SourceLocation Loc
, llvm::Function
*OutlinedFn
,
1423 ArrayRef
<llvm::Value
*> CapturedVars
);
1425 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1426 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1427 /// for num_teams clause.
1428 /// \param NumTeams An integer expression of teams.
1429 /// \param ThreadLimit An integer expression of threads.
1430 virtual void emitNumTeamsClause(CodeGenFunction
&CGF
, const Expr
*NumTeams
,
1431 const Expr
*ThreadLimit
, SourceLocation Loc
);
1433 /// Struct that keeps all the relevant information that should be kept
1434 /// throughout a 'target data' region.
1435 class TargetDataInfo
: public llvm::OpenMPIRBuilder::TargetDataInfo
{
1437 explicit TargetDataInfo() : llvm::OpenMPIRBuilder::TargetDataInfo() {}
1438 explicit TargetDataInfo(bool RequiresDevicePointerInfo
,
1439 bool SeparateBeginEndCalls
)
1440 : llvm::OpenMPIRBuilder::TargetDataInfo(RequiresDevicePointerInfo
,
1441 SeparateBeginEndCalls
) {}
1442 /// Map between the a declaration of a capture and the corresponding base
1443 /// pointer address where the runtime returns the device pointers.
1444 llvm::DenseMap
<const ValueDecl
*, Address
> CaptureDeviceAddrMap
;
1447 /// Emit the target data mapping code associated with \a D.
1448 /// \param D Directive to emit.
1449 /// \param IfCond Expression evaluated in if clause associated with the
1450 /// target directive, or null if no device clause is used.
1451 /// \param Device Expression evaluated in device clause associated with the
1452 /// target directive, or null if no device clause is used.
1453 /// \param Info A record used to store information that needs to be preserved
1454 /// until the region is closed.
1455 virtual void emitTargetDataCalls(CodeGenFunction
&CGF
,
1456 const OMPExecutableDirective
&D
,
1457 const Expr
*IfCond
, const Expr
*Device
,
1458 const RegionCodeGenTy
&CodeGen
,
1459 CGOpenMPRuntime::TargetDataInfo
&Info
);
1461 /// Emit the data mapping/movement code associated with the directive
1462 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1463 /// \param D Directive to emit.
1464 /// \param IfCond Expression evaluated in if clause associated with the target
1465 /// directive, or null if no if clause is used.
1466 /// \param Device Expression evaluated in device clause associated with the
1467 /// target directive, or null if no device clause is used.
1468 virtual void emitTargetDataStandAloneCall(CodeGenFunction
&CGF
,
1469 const OMPExecutableDirective
&D
,
1471 const Expr
*Device
);
1473 /// Marks function \a Fn with properly mangled versions of vector functions.
1474 /// \param FD Function marked as 'declare simd'.
1475 /// \param Fn LLVM function that must be marked with 'declare simd'
1477 virtual void emitDeclareSimdFunction(const FunctionDecl
*FD
,
1478 llvm::Function
*Fn
);
1480 /// Emit initialization for doacross loop nesting support.
1481 /// \param D Loop-based construct used in doacross nesting construct.
1482 virtual void emitDoacrossInit(CodeGenFunction
&CGF
, const OMPLoopDirective
&D
,
1483 ArrayRef
<Expr
*> NumIterations
);
1485 /// Emit code for doacross ordered directive with 'depend' clause.
1486 /// \param C 'depend' clause with 'sink|source' dependency kind.
1487 virtual void emitDoacrossOrdered(CodeGenFunction
&CGF
,
1488 const OMPDependClause
*C
);
1490 /// Translates the native parameter of outlined function if this is required
1492 /// \param FD Field decl from captured record for the parameter.
1493 /// \param NativeParam Parameter itself.
1494 virtual const VarDecl
*translateParameter(const FieldDecl
*FD
,
1495 const VarDecl
*NativeParam
) const {
1499 /// Gets the address of the native argument basing on the address of the
1500 /// target-specific parameter.
1501 /// \param NativeParam Parameter itself.
1502 /// \param TargetParam Corresponding target-specific parameter.
1503 virtual Address
getParameterAddress(CodeGenFunction
&CGF
,
1504 const VarDecl
*NativeParam
,
1505 const VarDecl
*TargetParam
) const;
1507 /// Choose default schedule type and chunk value for the
1508 /// dist_schedule clause.
1509 virtual void getDefaultDistScheduleAndChunk(CodeGenFunction
&CGF
,
1510 const OMPLoopDirective
&S
, OpenMPDistScheduleClauseKind
&ScheduleKind
,
1511 llvm::Value
*&Chunk
) const {}
1513 /// Choose default schedule type and chunk value for the
1514 /// schedule clause.
1515 virtual void getDefaultScheduleAndChunk(CodeGenFunction
&CGF
,
1516 const OMPLoopDirective
&S
, OpenMPScheduleClauseKind
&ScheduleKind
,
1517 const Expr
*&ChunkExpr
) const;
1519 /// Emits call of the outlined function with the provided arguments,
1520 /// translating these arguments to correct target-specific arguments.
1522 emitOutlinedFunctionCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1523 llvm::FunctionCallee OutlinedFn
,
1524 ArrayRef
<llvm::Value
*> Args
= std::nullopt
) const;
1526 /// Emits OpenMP-specific function prolog.
1527 /// Required for device constructs.
1528 virtual void emitFunctionProlog(CodeGenFunction
&CGF
, const Decl
*D
);
1530 /// Gets the OpenMP-specific address of the local variable.
1531 virtual Address
getAddressOfLocalVariable(CodeGenFunction
&CGF
,
1534 /// Marks the declaration as already emitted for the device code and returns
1535 /// true, if it was marked already, and false, otherwise.
1536 bool markAsGlobalTarget(GlobalDecl GD
);
1538 /// Emit deferred declare target variables marked for deferred emission.
1539 void emitDeferredTargetDecls() const;
1541 /// Adjust some parameters for the target-based directives, like addresses of
1542 /// the variables captured by reference in lambdas.
1544 adjustTargetSpecificDataForLambdas(CodeGenFunction
&CGF
,
1545 const OMPExecutableDirective
&D
) const;
1547 /// Perform check on requires decl to ensure that target architecture
1548 /// supports unified addressing
1549 virtual void processRequiresDirective(const OMPRequiresDecl
*D
);
1551 /// Gets default memory ordering as specified in requires directive.
1552 llvm::AtomicOrdering
getDefaultMemoryOrdering() const;
1554 /// Checks if the variable has associated OMPAllocateDeclAttr attribute with
1555 /// the predefined allocator and translates it into the corresponding address
1557 virtual bool hasAllocateAttributeForGlobalVar(const VarDecl
*VD
, LangAS
&AS
);
1559 /// Return whether the unified_shared_memory has been specified.
1560 bool hasRequiresUnifiedSharedMemory() const;
1562 /// Checks if the \p VD variable is marked as nontemporal declaration in
1563 /// current context.
1564 bool isNontemporalDecl(const ValueDecl
*VD
) const;
1566 /// Create specialized alloca to handle lastprivate conditionals.
1567 Address
emitLastprivateConditionalInit(CodeGenFunction
&CGF
,
1570 /// Checks if the provided \p LVal is lastprivate conditional and emits the
1571 /// code to update the value of the original variable.
1573 /// lastprivate(conditional: a)
1577 /// #pragma omp critical(a)
1578 /// if (last_iv_a <= iv) {
1580 /// global_a = lp_a;
1583 virtual void checkAndEmitLastprivateConditional(CodeGenFunction
&CGF
,
1586 /// Checks if the lastprivate conditional was updated in inner region and
1587 /// writes the value.
1589 /// lastprivate(conditional: a)
1591 /// <type> a;bool Fired = false;
1592 /// #pragma omp ... shared(a)
1598 /// #pragma omp critical(a)
1599 /// if (last_iv_a <= iv) {
1601 /// global_a = lp_a;
1606 virtual void checkAndEmitSharedLastprivateConditional(
1607 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
1608 const llvm::DenseSet
<CanonicalDeclPtr
<const VarDecl
>> &IgnoredDecls
);
1610 /// Gets the address of the global copy used for lastprivate conditional
1612 /// \param PrivLVal LValue for the private copy.
1613 /// \param VD Original lastprivate declaration.
1614 virtual void emitLastprivateConditionalFinalUpdate(CodeGenFunction
&CGF
,
1617 SourceLocation Loc
);
1619 /// Emits list of dependecies based on the provided data (array of
1620 /// dependence/expression pairs).
1621 /// \returns Pointer to the first element of the array casted to VoidPtr type.
1622 std::pair
<llvm::Value
*, Address
>
1623 emitDependClause(CodeGenFunction
&CGF
,
1624 ArrayRef
<OMPTaskDataTy::DependData
> Dependencies
,
1625 SourceLocation Loc
);
1627 /// Emits list of dependecies based on the provided data (array of
1628 /// dependence/expression pairs) for depobj construct. In this case, the
1629 /// variable is allocated in dynamically. \returns Pointer to the first
1630 /// element of the array casted to VoidPtr type.
1631 Address
emitDepobjDependClause(CodeGenFunction
&CGF
,
1632 const OMPTaskDataTy::DependData
&Dependencies
,
1633 SourceLocation Loc
);
1635 /// Emits the code to destroy the dependency object provided in depobj
1637 void emitDestroyClause(CodeGenFunction
&CGF
, LValue DepobjLVal
,
1638 SourceLocation Loc
);
1640 /// Updates the dependency kind in the specified depobj object.
1641 /// \param DepobjLVal LValue for the main depobj object.
1642 /// \param NewDepKind New dependency kind.
1643 void emitUpdateClause(CodeGenFunction
&CGF
, LValue DepobjLVal
,
1644 OpenMPDependClauseKind NewDepKind
, SourceLocation Loc
);
1646 /// Initializes user defined allocators specified in the uses_allocators
1648 void emitUsesAllocatorsInit(CodeGenFunction
&CGF
, const Expr
*Allocator
,
1649 const Expr
*AllocatorTraits
);
1651 /// Destroys user defined allocators specified in the uses_allocators clause.
1652 void emitUsesAllocatorsFini(CodeGenFunction
&CGF
, const Expr
*Allocator
);
1654 /// Returns true if the variable is a local variable in untied task.
1655 bool isLocalVarInUntiedTask(CodeGenFunction
&CGF
, const VarDecl
*VD
) const;
1658 /// Class supports emissionof SIMD-only code.
1659 class CGOpenMPSIMDRuntime final
: public CGOpenMPRuntime
{
1661 explicit CGOpenMPSIMDRuntime(CodeGenModule
&CGM
) : CGOpenMPRuntime(CGM
) {}
1662 ~CGOpenMPSIMDRuntime() override
{}
1664 /// Emits outlined function for the specified OpenMP parallel directive
1665 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1666 /// kmp_int32 BoundID, struct context_vars*).
1667 /// \param CGF Reference to current CodeGenFunction.
1668 /// \param D OpenMP directive.
1669 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1670 /// \param InnermostKind Kind of innermost directive (for simple directives it
1671 /// is a directive itself, for combined - its innermost directive).
1672 /// \param CodeGen Code generation sequence for the \a D directive.
1673 llvm::Function
*emitParallelOutlinedFunction(
1674 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
1675 const VarDecl
*ThreadIDVar
, OpenMPDirectiveKind InnermostKind
,
1676 const RegionCodeGenTy
&CodeGen
) override
;
1678 /// Emits outlined function for the specified OpenMP teams directive
1679 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1680 /// kmp_int32 BoundID, struct context_vars*).
1681 /// \param CGF Reference to current CodeGenFunction.
1682 /// \param D OpenMP directive.
1683 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1684 /// \param InnermostKind Kind of innermost directive (for simple directives it
1685 /// is a directive itself, for combined - its innermost directive).
1686 /// \param CodeGen Code generation sequence for the \a D directive.
1687 llvm::Function
*emitTeamsOutlinedFunction(
1688 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
1689 const VarDecl
*ThreadIDVar
, OpenMPDirectiveKind InnermostKind
,
1690 const RegionCodeGenTy
&CodeGen
) override
;
1692 /// Emits outlined function for the OpenMP task directive \a D. This
1693 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1695 /// \param D OpenMP directive.
1696 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1697 /// \param PartIDVar Variable for partition id in the current OpenMP untied
1699 /// \param TaskTVar Variable for task_t argument.
1700 /// \param InnermostKind Kind of innermost directive (for simple directives it
1701 /// is a directive itself, for combined - its innermost directive).
1702 /// \param CodeGen Code generation sequence for the \a D directive.
1703 /// \param Tied true if task is generated for tied task, false otherwise.
1704 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1707 llvm::Function
*emitTaskOutlinedFunction(
1708 const OMPExecutableDirective
&D
, const VarDecl
*ThreadIDVar
,
1709 const VarDecl
*PartIDVar
, const VarDecl
*TaskTVar
,
1710 OpenMPDirectiveKind InnermostKind
, const RegionCodeGenTy
&CodeGen
,
1711 bool Tied
, unsigned &NumberOfParts
) override
;
1713 /// Emits code for parallel or serial call of the \a OutlinedFn with
1714 /// variables captured in a record which address is stored in \a
1716 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1717 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1718 /// \param CapturedVars A pointer to the record with the references to
1719 /// variables used in \a OutlinedFn function.
1720 /// \param IfCond Condition in the associated 'if' clause, if it was
1721 /// specified, nullptr otherwise.
1722 /// \param NumThreads The value corresponding to the num_threads clause, if
1723 /// any, or nullptr.
1725 void emitParallelCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1726 llvm::Function
*OutlinedFn
,
1727 ArrayRef
<llvm::Value
*> CapturedVars
,
1728 const Expr
*IfCond
, llvm::Value
*NumThreads
) override
;
1730 /// Emits a critical region.
1731 /// \param CriticalName Name of the critical region.
1732 /// \param CriticalOpGen Generator for the statement associated with the given
1733 /// critical region.
1734 /// \param Hint Value of the 'hint' clause (optional).
1735 void emitCriticalRegion(CodeGenFunction
&CGF
, StringRef CriticalName
,
1736 const RegionCodeGenTy
&CriticalOpGen
,
1738 const Expr
*Hint
= nullptr) override
;
1740 /// Emits a master region.
1741 /// \param MasterOpGen Generator for the statement associated with the given
1743 void emitMasterRegion(CodeGenFunction
&CGF
,
1744 const RegionCodeGenTy
&MasterOpGen
,
1745 SourceLocation Loc
) override
;
1747 /// Emits a masked region.
1748 /// \param MaskedOpGen Generator for the statement associated with the given
1750 void emitMaskedRegion(CodeGenFunction
&CGF
,
1751 const RegionCodeGenTy
&MaskedOpGen
, SourceLocation Loc
,
1752 const Expr
*Filter
= nullptr) override
;
1754 /// Emits a masked region.
1755 /// \param MaskedOpGen Generator for the statement associated with the given
1758 /// Emits code for a taskyield directive.
1759 void emitTaskyieldCall(CodeGenFunction
&CGF
, SourceLocation Loc
) override
;
1761 /// Emit a taskgroup region.
1762 /// \param TaskgroupOpGen Generator for the statement associated with the
1763 /// given taskgroup region.
1764 void emitTaskgroupRegion(CodeGenFunction
&CGF
,
1765 const RegionCodeGenTy
&TaskgroupOpGen
,
1766 SourceLocation Loc
) override
;
1768 /// Emits a single region.
1769 /// \param SingleOpGen Generator for the statement associated with the given
1771 void emitSingleRegion(CodeGenFunction
&CGF
,
1772 const RegionCodeGenTy
&SingleOpGen
, SourceLocation Loc
,
1773 ArrayRef
<const Expr
*> CopyprivateVars
,
1774 ArrayRef
<const Expr
*> DestExprs
,
1775 ArrayRef
<const Expr
*> SrcExprs
,
1776 ArrayRef
<const Expr
*> AssignmentOps
) override
;
1778 /// Emit an ordered region.
1779 /// \param OrderedOpGen Generator for the statement associated with the given
1781 void emitOrderedRegion(CodeGenFunction
&CGF
,
1782 const RegionCodeGenTy
&OrderedOpGen
,
1783 SourceLocation Loc
, bool IsThreads
) override
;
1785 /// Emit an implicit/explicit barrier for OpenMP threads.
1786 /// \param Kind Directive for which this implicit barrier call must be
1787 /// generated. Must be OMPD_barrier for explicit barrier generation.
1788 /// \param EmitChecks true if need to emit checks for cancellation barriers.
1789 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1790 /// runtime class decides which one to emit (simple or with cancellation
1793 void emitBarrierCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1794 OpenMPDirectiveKind Kind
, bool EmitChecks
= true,
1795 bool ForceSimpleCall
= false) override
;
1797 /// This is used for non static scheduled types and when the ordered
1798 /// clause is present on the loop construct.
1799 /// Depending on the loop schedule, it is necessary to call some runtime
1800 /// routine before start of the OpenMP loop to get the loop upper / lower
1801 /// bounds \a LB and \a UB and stride \a ST.
1803 /// \param CGF Reference to current CodeGenFunction.
1804 /// \param Loc Clang source location.
1805 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1806 /// \param IVSize Size of the iteration variable in bits.
1807 /// \param IVSigned Sign of the iteration variable.
1808 /// \param Ordered true if loop is ordered, false otherwise.
1809 /// \param DispatchValues struct containing llvm values for lower bound, upper
1810 /// bound, and chunk expression.
1811 /// For the default (nullptr) value, the chunk 1 will be used.
1813 void emitForDispatchInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
1814 const OpenMPScheduleTy
&ScheduleKind
,
1815 unsigned IVSize
, bool IVSigned
, bool Ordered
,
1816 const DispatchRTInput
&DispatchValues
) override
;
1818 /// Call the appropriate runtime routine to initialize it before start
1821 /// This is used only in case of static schedule, when the user did not
1822 /// specify a ordered clause on the loop construct.
1823 /// Depending on the loop schedule, it is necessary to call some runtime
1824 /// routine before start of the OpenMP loop to get the loop upper / lower
1825 /// bounds LB and UB and stride ST.
1827 /// \param CGF Reference to current CodeGenFunction.
1828 /// \param Loc Clang source location.
1829 /// \param DKind Kind of the directive.
1830 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1831 /// \param Values Input arguments for the construct.
1833 void emitForStaticInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
1834 OpenMPDirectiveKind DKind
,
1835 const OpenMPScheduleTy
&ScheduleKind
,
1836 const StaticRTInput
&Values
) override
;
1839 /// \param CGF Reference to current CodeGenFunction.
1840 /// \param Loc Clang source location.
1841 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1842 /// \param Values Input arguments for the construct.
1844 void emitDistributeStaticInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
1845 OpenMPDistScheduleClauseKind SchedKind
,
1846 const StaticRTInput
&Values
) override
;
1848 /// Call the appropriate runtime routine to notify that we finished
1849 /// iteration of the ordered loop with the dynamic scheduling.
1851 /// \param CGF Reference to current CodeGenFunction.
1852 /// \param Loc Clang source location.
1853 /// \param IVSize Size of the iteration variable in bits.
1854 /// \param IVSigned Sign of the iteration variable.
1856 void emitForOrderedIterationEnd(CodeGenFunction
&CGF
, SourceLocation Loc
,
1857 unsigned IVSize
, bool IVSigned
) override
;
1859 /// Call the appropriate runtime routine to notify that we finished
1860 /// all the work with current loop.
1862 /// \param CGF Reference to current CodeGenFunction.
1863 /// \param Loc Clang source location.
1864 /// \param DKind Kind of the directive for which the static finish is emitted.
1866 void emitForStaticFinish(CodeGenFunction
&CGF
, SourceLocation Loc
,
1867 OpenMPDirectiveKind DKind
) override
;
1869 /// Call __kmpc_dispatch_next(
1870 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1871 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1872 /// kmp_int[32|64] *p_stride);
1873 /// \param IVSize Size of the iteration variable in bits.
1874 /// \param IVSigned Sign of the iteration variable.
1875 /// \param IL Address of the output variable in which the flag of the
1876 /// last iteration is returned.
1877 /// \param LB Address of the output variable in which the lower iteration
1878 /// number is returned.
1879 /// \param UB Address of the output variable in which the upper iteration
1880 /// number is returned.
1881 /// \param ST Address of the output variable in which the stride value is
1883 llvm::Value
*emitForNext(CodeGenFunction
&CGF
, SourceLocation Loc
,
1884 unsigned IVSize
, bool IVSigned
, Address IL
,
1885 Address LB
, Address UB
, Address ST
) override
;
1887 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1888 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1890 /// \param NumThreads An integer value of threads.
1891 void emitNumThreadsClause(CodeGenFunction
&CGF
, llvm::Value
*NumThreads
,
1892 SourceLocation Loc
) override
;
1894 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1895 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1896 void emitProcBindClause(CodeGenFunction
&CGF
,
1897 llvm::omp::ProcBindKind ProcBind
,
1898 SourceLocation Loc
) override
;
1900 /// Returns address of the threadprivate variable for the current
1902 /// \param VD Threadprivate variable.
1903 /// \param VDAddr Address of the global variable \a VD.
1904 /// \param Loc Location of the reference to threadprivate var.
1905 /// \return Address of the threadprivate variable for the current thread.
1906 Address
getAddrOfThreadPrivate(CodeGenFunction
&CGF
, const VarDecl
*VD
,
1907 Address VDAddr
, SourceLocation Loc
) override
;
1909 /// Emit a code for initialization of threadprivate variable. It emits
1910 /// a call to runtime library which adds initial value to the newly created
1911 /// threadprivate variable (if it is not constant) and registers destructor
1912 /// for the variable (if any).
1913 /// \param VD Threadprivate variable.
1914 /// \param VDAddr Address of the global variable \a VD.
1915 /// \param Loc Location of threadprivate declaration.
1916 /// \param PerformInit true if initialization expression is not constant.
1918 emitThreadPrivateVarDefinition(const VarDecl
*VD
, Address VDAddr
,
1919 SourceLocation Loc
, bool PerformInit
,
1920 CodeGenFunction
*CGF
= nullptr) override
;
1922 /// Creates artificial threadprivate variable with name \p Name and type \p
1924 /// \param VarType Type of the artificial threadprivate variable.
1925 /// \param Name Name of the artificial threadprivate variable.
1926 Address
getAddrOfArtificialThreadPrivate(CodeGenFunction
&CGF
,
1928 StringRef Name
) override
;
1930 /// Emit flush of the variables specified in 'omp flush' directive.
1931 /// \param Vars List of variables to flush.
1932 void emitFlush(CodeGenFunction
&CGF
, ArrayRef
<const Expr
*> Vars
,
1933 SourceLocation Loc
, llvm::AtomicOrdering AO
) override
;
1935 /// Emit task region for the task directive. The task region is
1936 /// emitted in several steps:
1937 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1938 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1939 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1941 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1942 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1945 /// 2. Copy a list of shared variables to field shareds of the resulting
1946 /// structure kmp_task_t returned by the previous call (if any).
1947 /// 3. Copy a pointer to destructions function to field destructions of the
1948 /// resulting structure kmp_task_t.
1949 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1950 /// kmp_task_t *new_task), where new_task is a resulting structure from
1952 /// \param D Current task directive.
1953 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1954 /// /*part_id*/, captured_struct */*__context*/);
1955 /// \param SharedsTy A type which contains references the shared variables.
1956 /// \param Shareds Context with the list of shared variables from the \p
1958 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1960 /// \param Data Additional data for task generation like tiednsee, final
1961 /// state, list of privates etc.
1962 void emitTaskCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1963 const OMPExecutableDirective
&D
,
1964 llvm::Function
*TaskFunction
, QualType SharedsTy
,
1965 Address Shareds
, const Expr
*IfCond
,
1966 const OMPTaskDataTy
&Data
) override
;
1968 /// Emit task region for the taskloop directive. The taskloop region is
1969 /// emitted in several steps:
1970 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1971 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1972 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1974 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1975 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1978 /// 2. Copy a list of shared variables to field shareds of the resulting
1979 /// structure kmp_task_t returned by the previous call (if any).
1980 /// 3. Copy a pointer to destructions function to field destructions of the
1981 /// resulting structure kmp_task_t.
1982 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1983 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1984 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1985 /// is a resulting structure from
1987 /// \param D Current task directive.
1988 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1989 /// /*part_id*/, captured_struct */*__context*/);
1990 /// \param SharedsTy A type which contains references the shared variables.
1991 /// \param Shareds Context with the list of shared variables from the \p
1993 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1995 /// \param Data Additional data for task generation like tiednsee, final
1996 /// state, list of privates etc.
1997 void emitTaskLoopCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
1998 const OMPLoopDirective
&D
, llvm::Function
*TaskFunction
,
1999 QualType SharedsTy
, Address Shareds
, const Expr
*IfCond
,
2000 const OMPTaskDataTy
&Data
) override
;
2002 /// Emit a code for reduction clause. Next code should be emitted for
2006 /// static kmp_critical_name lock = { 0 };
2008 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
2010 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
2015 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
2016 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
2017 /// RedList, reduce_func, &<lock>)) {
2020 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
2022 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
2026 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
2033 /// \param Privates List of private copies for original reduction arguments.
2034 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
2035 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
2036 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
2037 /// or 'operator binop(LHS, RHS)'.
2038 /// \param Options List of options for reduction codegen:
2039 /// WithNowait true if parent directive has also nowait clause, false
2041 /// SimpleReduction Emit reduction operation only. Used for omp simd
2042 /// directive on the host.
2043 /// ReductionKind The kind of reduction to perform.
2044 void emitReduction(CodeGenFunction
&CGF
, SourceLocation Loc
,
2045 ArrayRef
<const Expr
*> Privates
,
2046 ArrayRef
<const Expr
*> LHSExprs
,
2047 ArrayRef
<const Expr
*> RHSExprs
,
2048 ArrayRef
<const Expr
*> ReductionOps
,
2049 ReductionOptionsTy Options
) override
;
2051 /// Emit a code for initialization of task reduction clause. Next code
2052 /// should be emitted for reduction:
2055 /// _taskred_item_t red_data[n];
2057 /// red_data[i].shar = &shareds[i];
2058 /// red_data[i].orig = &origs[i];
2059 /// red_data[i].size = sizeof(origs[i]);
2060 /// red_data[i].f_init = (void*)RedInit<i>;
2061 /// red_data[i].f_fini = (void*)RedDest<i>;
2062 /// red_data[i].f_comb = (void*)RedOp<i>;
2063 /// red_data[i].flags = <Flag_i>;
2065 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
2067 /// For reduction clause with task modifier it emits the next call:
2070 /// _taskred_item_t red_data[n];
2072 /// red_data[i].shar = &shareds[i];
2073 /// red_data[i].orig = &origs[i];
2074 /// red_data[i].size = sizeof(origs[i]);
2075 /// red_data[i].f_init = (void*)RedInit<i>;
2076 /// red_data[i].f_fini = (void*)RedDest<i>;
2077 /// red_data[i].f_comb = (void*)RedOp<i>;
2078 /// red_data[i].flags = <Flag_i>;
2080 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
2083 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
2084 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
2085 /// \param Data Additional data for task generation like tiedness, final
2086 /// state, list of privates, reductions etc.
2087 llvm::Value
*emitTaskReductionInit(CodeGenFunction
&CGF
, SourceLocation Loc
,
2088 ArrayRef
<const Expr
*> LHSExprs
,
2089 ArrayRef
<const Expr
*> RHSExprs
,
2090 const OMPTaskDataTy
&Data
) override
;
2092 /// Emits the following code for reduction clause with task modifier:
2094 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
2096 void emitTaskReductionFini(CodeGenFunction
&CGF
, SourceLocation Loc
,
2097 bool IsWorksharingReduction
) override
;
2099 /// Required to resolve existing problems in the runtime. Emits threadprivate
2100 /// variables to store the size of the VLAs/array sections for
2101 /// initializer/combiner/finalizer functions + emits threadprivate variable to
2102 /// store the pointer to the original reduction item for the custom
2103 /// initializer defined by declare reduction construct.
2104 /// \param RCG Allows to reuse an existing data for the reductions.
2105 /// \param N Reduction item for which fixups must be emitted.
2106 void emitTaskReductionFixups(CodeGenFunction
&CGF
, SourceLocation Loc
,
2107 ReductionCodeGen
&RCG
, unsigned N
) override
;
2109 /// Get the address of `void *` type of the privatue copy of the reduction
2110 /// item specified by the \p SharedLVal.
2111 /// \param ReductionsPtr Pointer to the reduction data returned by the
2112 /// emitTaskReductionInit function.
2113 /// \param SharedLVal Address of the original reduction item.
2114 Address
getTaskReductionItem(CodeGenFunction
&CGF
, SourceLocation Loc
,
2115 llvm::Value
*ReductionsPtr
,
2116 LValue SharedLVal
) override
;
2118 /// Emit code for 'taskwait' directive.
2119 void emitTaskwaitCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
2120 const OMPTaskDataTy
&Data
) override
;
2122 /// Emit code for 'cancellation point' construct.
2123 /// \param CancelRegion Region kind for which the cancellation point must be
2126 void emitCancellationPointCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
2127 OpenMPDirectiveKind CancelRegion
) override
;
2129 /// Emit code for 'cancel' construct.
2130 /// \param IfCond Condition in the associated 'if' clause, if it was
2131 /// specified, nullptr otherwise.
2132 /// \param CancelRegion Region kind for which the cancel must be emitted.
2134 void emitCancelCall(CodeGenFunction
&CGF
, SourceLocation Loc
,
2136 OpenMPDirectiveKind CancelRegion
) override
;
2138 /// Emit outilined function for 'target' directive.
2139 /// \param D Directive to emit.
2140 /// \param ParentName Name of the function that encloses the target region.
2141 /// \param OutlinedFn Outlined function value to be defined by this call.
2142 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2143 /// \param IsOffloadEntry True if the outlined function is an offload entry.
2144 /// \param CodeGen Code generation sequence for the \a D directive.
2145 /// An outlined function may not be an entry if, e.g. the if clause always
2146 /// evaluates to false.
2147 void emitTargetOutlinedFunction(const OMPExecutableDirective
&D
,
2148 StringRef ParentName
,
2149 llvm::Function
*&OutlinedFn
,
2150 llvm::Constant
*&OutlinedFnID
,
2151 bool IsOffloadEntry
,
2152 const RegionCodeGenTy
&CodeGen
) override
;
2154 /// Emit the target offloading code associated with \a D. The emitted
2155 /// code attempts offloading the execution to the device, an the event of
2156 /// a failure it executes the host version outlined in \a OutlinedFn.
2157 /// \param D Directive to emit.
2158 /// \param OutlinedFn Host version of the code to be offloaded.
2159 /// \param OutlinedFnID ID of host version of the code to be offloaded.
2160 /// \param IfCond Expression evaluated in if clause associated with the target
2161 /// directive, or null if no if clause is used.
2162 /// \param Device Expression evaluated in device clause associated with the
2163 /// target directive, or null if no device clause is used and device modifier.
2164 void emitTargetCall(
2165 CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
2166 llvm::Function
*OutlinedFn
, llvm::Value
*OutlinedFnID
, const Expr
*IfCond
,
2167 llvm::PointerIntPair
<const Expr
*, 2, OpenMPDeviceClauseModifier
> Device
,
2168 llvm::function_ref
<llvm::Value
*(CodeGenFunction
&CGF
,
2169 const OMPLoopDirective
&D
)>
2170 SizeEmitter
) override
;
2172 /// Emit the target regions enclosed in \a GD function definition or
2173 /// the function itself in case it is a valid device function. Returns true if
2174 /// \a GD was dealt with successfully.
2175 /// \param GD Function to scan.
2176 bool emitTargetFunctions(GlobalDecl GD
) override
;
2178 /// Emit the global variable if it is a valid device global variable.
2179 /// Returns true if \a GD was dealt with successfully.
2180 /// \param GD Variable declaration to emit.
2181 bool emitTargetGlobalVariable(GlobalDecl GD
) override
;
2183 /// Emit the global \a GD if it is meaningful for the target. Returns
2184 /// if it was emitted successfully.
2185 /// \param GD Global to scan.
2186 bool emitTargetGlobal(GlobalDecl GD
) override
;
2188 /// Emits code for teams call of the \a OutlinedFn with
2189 /// variables captured in a record which address is stored in \a
2191 /// \param OutlinedFn Outlined function to be run by team masters. Type of
2192 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2193 /// \param CapturedVars A pointer to the record with the references to
2194 /// variables used in \a OutlinedFn function.
2196 void emitTeamsCall(CodeGenFunction
&CGF
, const OMPExecutableDirective
&D
,
2197 SourceLocation Loc
, llvm::Function
*OutlinedFn
,
2198 ArrayRef
<llvm::Value
*> CapturedVars
) override
;
2200 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2201 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2202 /// for num_teams clause.
2203 /// \param NumTeams An integer expression of teams.
2204 /// \param ThreadLimit An integer expression of threads.
2205 void emitNumTeamsClause(CodeGenFunction
&CGF
, const Expr
*NumTeams
,
2206 const Expr
*ThreadLimit
, SourceLocation Loc
) override
;
2208 /// Emit the target data mapping code associated with \a D.
2209 /// \param D Directive to emit.
2210 /// \param IfCond Expression evaluated in if clause associated with the
2211 /// target directive, or null if no device clause is used.
2212 /// \param Device Expression evaluated in device clause associated with the
2213 /// target directive, or null if no device clause is used.
2214 /// \param Info A record used to store information that needs to be preserved
2215 /// until the region is closed.
2216 void emitTargetDataCalls(CodeGenFunction
&CGF
,
2217 const OMPExecutableDirective
&D
, const Expr
*IfCond
,
2218 const Expr
*Device
, const RegionCodeGenTy
&CodeGen
,
2219 CGOpenMPRuntime::TargetDataInfo
&Info
) override
;
2221 /// Emit the data mapping/movement code associated with the directive
2222 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2223 /// \param D Directive to emit.
2224 /// \param IfCond Expression evaluated in if clause associated with the target
2225 /// directive, or null if no if clause is used.
2226 /// \param Device Expression evaluated in device clause associated with the
2227 /// target directive, or null if no device clause is used.
2228 void emitTargetDataStandAloneCall(CodeGenFunction
&CGF
,
2229 const OMPExecutableDirective
&D
,
2231 const Expr
*Device
) override
;
2233 /// Emit initialization for doacross loop nesting support.
2234 /// \param D Loop-based construct used in doacross nesting construct.
2235 void emitDoacrossInit(CodeGenFunction
&CGF
, const OMPLoopDirective
&D
,
2236 ArrayRef
<Expr
*> NumIterations
) override
;
2238 /// Emit code for doacross ordered directive with 'depend' clause.
2239 /// \param C 'depend' clause with 'sink|source' dependency kind.
2240 void emitDoacrossOrdered(CodeGenFunction
&CGF
,
2241 const OMPDependClause
*C
) override
;
2243 /// Translates the native parameter of outlined function if this is required
2245 /// \param FD Field decl from captured record for the parameter.
2246 /// \param NativeParam Parameter itself.
2247 const VarDecl
*translateParameter(const FieldDecl
*FD
,
2248 const VarDecl
*NativeParam
) const override
;
2250 /// Gets the address of the native argument basing on the address of the
2251 /// target-specific parameter.
2252 /// \param NativeParam Parameter itself.
2253 /// \param TargetParam Corresponding target-specific parameter.
2254 Address
getParameterAddress(CodeGenFunction
&CGF
, const VarDecl
*NativeParam
,
2255 const VarDecl
*TargetParam
) const override
;
2257 /// Gets the OpenMP-specific address of the local variable.
2258 Address
getAddressOfLocalVariable(CodeGenFunction
&CGF
,
2259 const VarDecl
*VD
) override
{
2260 return Address::invalid();
2264 } // namespace CodeGen
2265 } // namespace clang