clang 19.0.0git
CGOpenMPRuntime.h
Go to the documentation of this file.
1//===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This provides a class for OpenMP runtime code generation.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
14#define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
15
16#include "CGValue.h"
19#include "clang/AST/Type.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"
32
33namespace llvm {
34class ArrayType;
35class Constant;
36class FunctionType;
37class GlobalVariable;
38class Type;
39class Value;
40class OpenMPIRBuilder;
41} // namespace llvm
42
43namespace clang {
44class Expr;
45class OMPDependClause;
46class OMPExecutableDirective;
47class OMPLoopDirective;
48class VarDecl;
49class OMPDeclareReductionDecl;
50
51namespace CodeGen {
52class Address;
53class CodeGenFunction;
54class CodeGenModule;
55
56/// A basic class for pre|post-action for advanced codegen sequence for OpenMP
57/// region.
59public:
60 explicit PrePostActionTy() {}
61 virtual void Enter(CodeGenFunction &CGF) {}
62 virtual void Exit(CodeGenFunction &CGF) {}
63 virtual ~PrePostActionTy() {}
64};
65
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.
68class RegionCodeGenTy final {
69 intptr_t CodeGen;
70 typedef void (*CodeGenTy)(intptr_t, CodeGenFunction &, PrePostActionTy &);
71 CodeGenTy Callback;
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);
78 }
79
80public:
81 template <typename Callable>
83 Callable &&CodeGen,
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;
91};
92
93struct OMPTaskDataTy final {
106 struct DependData {
108 const Expr *IteratorExpr = nullptr;
110 explicit DependData() = default;
113 };
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;
120 bool Tied = true;
121 bool Nogroup = false;
124 bool HasNowaitClause = false;
125};
126
127/// Class intended to support codegen of all kind of the reduction clauses.
129private:
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) {
143 }
144 };
145 /// List of reduction-based clauses.
147
148 /// List of addresses of shared variables/expressions.
149 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
150 /// List of addresses of original variables/expressions.
152 /// Sizes of the reduction items in chars.
154 /// Base declarations for the reduction items.
156
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);
169
170public:
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.
190 void
191 emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
192 Address SharedAddr,
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.
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 {
213 return Sizes[N];
214 }
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())
225 ->getType();
226 }
227};
228
230public:
231 /// Allows to disable automatic handling of functions used in target regions
232 /// as those marked as `omp declare target`.
234 CodeGenModule &CGM;
235 bool SavedShouldMarkAsGlobal = false;
236
237 public:
240 };
241
242 /// Manages list of nontemporal decls for the specified directive.
244 CodeGenModule &CGM;
245 const bool NeedToPush;
246
247 public:
250 };
251
252 /// Manages list of nontemporal decls for the specified directive.
254 CodeGenModule &CGM;
255 const bool NeedToPush;
256
257 public:
259 CodeGenFunction &CGF,
260 const llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
261 std::pair<Address, Address>> &LocalVars);
263 };
264
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.
272 llvm::MapVector<CanonicalDeclPtr<const Decl>, SmallString<16>>
275 llvm::Function *Fn = nullptr;
276 bool Disabled = false;
277 };
278 /// Manages list of lastprivate conditional decls for the specified directive.
280 enum class ActionToDo {
281 DoNotPush,
282 PushAsLastprivateConditional,
283 DisableLastprivateConditional,
284 };
285 CodeGenModule &CGM;
286 ActionToDo Action = ActionToDo::DoNotPush;
287
288 /// Check and try to disable analysis of inner regions for changes in
289 /// lastprivate conditional.
290 void tryToDisableInnerAnalysis(const OMPExecutableDirective &S,
292 &NeedToAddForLPCsAsDisabled) const;
293
295 const OMPExecutableDirective &S);
296
297 public:
299 const OMPExecutableDirective &S,
300 LValue IVLVal);
302 const OMPExecutableDirective &S);
304 };
305
306 llvm::OpenMPIRBuilder &getOMPBuilder() { return OMPBuilder; }
307
308protected:
310
311 /// An OpenMP-IR-Builder instance.
312 llvm::OpenMPIRBuilder OMPBuilder;
313
314 /// Helper to determine the min/max number of threads/teams for \p D.
316 CodeGenFunction &CGF,
317 int32_t &MinThreadsVal,
318 int32_t &MaxThreadsVal,
319 int32_t &MinTeamsVal,
320 int32_t &MaxTeamsVal);
321
322 /// Helper to emit outlined function for 'target' directive.
323 /// \param D Directive to emit.
324 /// \param ParentName Name of the function that encloses the target region.
325 /// \param OutlinedFn Outlined function value to be defined by this call.
326 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
327 /// \param IsOffloadEntry True if the outlined function is an offload entry.
328 /// \param CodeGen Lambda codegen specific to an accelerator device.
329 /// An outlined function may not be an entry if, e.g. the if clause always
330 /// evaluates to false.
332 StringRef ParentName,
333 llvm::Function *&OutlinedFn,
334 llvm::Constant *&OutlinedFnID,
335 bool IsOffloadEntry,
336 const RegionCodeGenTy &CodeGen);
337
338 /// Returns pointer to ident_t type.
339 llvm::Type *getIdentTyPointerTy();
340
341 /// Gets thread id value for the current thread.
342 ///
343 llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
344
345 /// Get the function name of an outlined region.
346 std::string getOutlinedHelperName(StringRef Name) const;
347 std::string getOutlinedHelperName(CodeGenFunction &CGF) const;
348
349 /// Get the function name of a reduction function.
350 std::string getReductionFuncName(StringRef Name) const;
351
352 /// Emits \p Callee function call with arguments \p Args with location \p Loc.
354 llvm::FunctionCallee Callee,
355 ArrayRef<llvm::Value *> Args = std::nullopt) const;
356
357 /// Emits address of the word in a memory where current thread id is
358 /// stored.
360
362 bool AtCurrentPoint = false);
364
365 /// Check if the default location must be constant.
366 /// Default is false to support OMPT/OMPD.
367 virtual bool isDefaultLocationConstant() const { return false; }
368
369 /// Returns additional flags that can be stored in reserved_2 field of the
370 /// default location.
371 virtual unsigned getDefaultLocationReserved2Flags() const { return 0; }
372
373 /// Returns default flags for the barriers depending on the directive, for
374 /// which this barier is going to be emitted.
376
377 /// Get the LLVM type for the critical name.
378 llvm::ArrayType *getKmpCriticalNameTy() const {return KmpCriticalNameTy;}
379
380 /// Returns corresponding lock object for the specified critical region
381 /// name. If the lock object does not exist it is created, otherwise the
382 /// reference to the existing copy is returned.
383 /// \param CriticalName Name of the critical region.
384 ///
385 llvm::Value *getCriticalRegionLock(StringRef CriticalName);
386
387protected:
388 /// Map for SourceLocation and OpenMP runtime library debug locations.
389 typedef llvm::DenseMap<SourceLocation, llvm::Value *> OpenMPDebugLocMapTy;
391 /// The type for a microtask which gets passed to __kmpc_fork_call().
392 /// Original representation is:
393 /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
394 llvm::FunctionType *Kmpc_MicroTy = nullptr;
395 /// Stores debug location and ThreadID for the function.
397 llvm::Value *DebugLoc;
398 llvm::Value *ThreadID;
399 /// Insert point for the service instructions.
400 llvm::AssertingVH<llvm::Instruction> ServiceInsertPt = nullptr;
401 };
402 /// Map of local debug location, ThreadId and functions.
403 typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
406 /// Map of UDRs and corresponding combiner/initializer.
407 typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
408 std::pair<llvm::Function *, llvm::Function *>>
411 /// Map of functions and locally defined UDRs.
412 typedef llvm::DenseMap<llvm::Function *,
416 /// Map from the user-defined mapper declaration to its corresponding
417 /// functions.
418 llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
419 /// Map of functions and their local user-defined mappers.
421 llvm::DenseMap<llvm::Function *,
424 /// Maps local variables marked as lastprivate conditional to their internal
425 /// types.
426 llvm::DenseMap<llvm::Function *,
427 llvm::DenseMap<CanonicalDeclPtr<const Decl>,
428 std::tuple<QualType, const FieldDecl *,
429 const FieldDecl *, LValue>>>
431 /// Maps function to the position of the untied task locals stack.
432 llvm::DenseMap<llvm::Function *, unsigned> FunctionToUntiedTaskStackMap;
433 /// Type kmp_critical_name, originally defined as typedef kmp_int32
434 /// kmp_critical_name[8];
435 llvm::ArrayType *KmpCriticalNameTy;
436 /// An ordered map of auto-generated variables to their unique names.
437 /// It stores variables with the following names: 1) ".gomp_critical_user_" +
438 /// <critical_section_name> + ".var" for "omp critical" directives; 2)
439 /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
440 /// variables.
441 llvm::StringMap<llvm::AssertingVH<llvm::GlobalVariable>,
442 llvm::BumpPtrAllocator> InternalVars;
443 /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
444 llvm::Type *KmpRoutineEntryPtrTy = nullptr;
446 /// Type typedef struct kmp_task {
447 /// void * shareds; /**< pointer to block of pointers to
448 /// shared vars */
449 /// kmp_routine_entry_t routine; /**< pointer to routine to call for
450 /// executing task */
451 /// kmp_int32 part_id; /**< part id for the task */
452 /// kmp_routine_entry_t destructors; /* pointer to function to invoke
453 /// deconstructors of firstprivate C++ objects */
454 /// } kmp_task_t;
456 /// Saved kmp_task_t for task directive.
458 /// Saved kmp_task_t for taskloop-based directive.
460 /// Type typedef struct kmp_depend_info {
461 /// kmp_intptr_t base_addr;
462 /// size_t len;
463 /// struct {
464 /// bool in:1;
465 /// bool out:1;
466 /// } flags;
467 /// } kmp_depend_info_t;
469 /// Type typedef struct kmp_task_affinity_info {
470 /// kmp_intptr_t base_addr;
471 /// size_t len;
472 /// struct {
473 /// bool flag1 : 1;
474 /// bool flag2 : 1;
475 /// kmp_int32 reserved : 30;
476 /// } flags;
477 /// } kmp_task_affinity_info_t;
479 /// struct kmp_dim { // loop bounds info casted to kmp_int64
480 /// kmp_int64 lo; // lower
481 /// kmp_int64 up; // upper
482 /// kmp_int64 st; // stride
483 /// };
485
487 /// List of the emitted declarations.
489 /// List of the global variables with their addresses that should not be
490 /// emitted for the target.
491 llvm::StringMap<llvm::WeakTrackingVH> EmittedNonTargetVariables;
492
493 /// List of variables that can become declare target implicitly and, thus,
494 /// must be emitted.
495 llvm::SmallDenseSet<const VarDecl *> DeferredGlobalVariables;
496
497 using NontemporalDeclsSet = llvm::SmallDenseSet<CanonicalDeclPtr<const Decl>>;
498 /// Stack for list of declarations in current context marked as nontemporal.
499 /// The set is the union of all current stack elements.
501
503 llvm::MapVector<CanonicalDeclPtr<const VarDecl>,
504 std::pair<Address, Address>>;
506
507 /// Stack for list of addresses of declarations in current context marked as
508 /// lastprivate conditional. The set is the union of all current stack
509 /// elements.
511
512 /// Flag for keeping track of weather a requires unified_shared_memory
513 /// directive is present.
515
516 /// Atomic ordering from the omp requires directive.
517 llvm::AtomicOrdering RequiresAtomicOrdering = llvm::AtomicOrdering::Monotonic;
518
519 /// Flag for keeping track of weather a target region has been emitted.
521
522 /// Flag for keeping track of weather a device routine has been emitted.
523 /// Device routines are specific to the
525
526 /// Start scanning from statement \a S and emit all target regions
527 /// found along the way.
528 /// \param S Starting statement.
529 /// \param ParentName Name of the function declaration that is being scanned.
530 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
531
532 /// Build type kmp_routine_entry_t (if not built yet).
533 void emitKmpRoutineEntryT(QualType KmpInt32Ty);
534
535 /// Returns pointer to kmpc_micro type.
536 llvm::Type *getKmpc_MicroPointerTy();
537
538 /// If the specified mangled name is not in the module, create and
539 /// return threadprivate cache object. This object is a pointer's worth of
540 /// storage that's reserved for use by the OpenMP runtime.
541 /// \param VD Threadprivate variable.
542 /// \return Cache variable for the specified threadprivate.
543 llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
544
545 /// Set of threadprivate variables with the generated initializer.
547
548 /// Set of declare target variables with the generated initializer.
550
551 /// Emits initialization code for the threadprivate variables.
552 /// \param VDAddr Address of the global variable \a VD.
553 /// \param Ctor Pointer to a global init function for \a VD.
554 /// \param CopyCtor Pointer to a global copy function for \a VD.
555 /// \param Dtor Pointer to a global destructor function for \a VD.
556 /// \param Loc Location of threadprivate declaration.
558 llvm::Value *Ctor, llvm::Value *CopyCtor,
559 llvm::Value *Dtor, SourceLocation Loc);
560
561 /// Emit the array initialization or deletion portion for user-defined mapper
562 /// code generation.
564 llvm::Value *Handle, llvm::Value *BasePtr,
565 llvm::Value *Ptr, llvm::Value *Size,
566 llvm::Value *MapType, llvm::Value *MapName,
567 CharUnits ElementSize,
568 llvm::BasicBlock *ExitBB, bool IsInit);
569
571 llvm::Value *NewTask = nullptr;
572 llvm::Function *TaskEntry = nullptr;
573 llvm::Value *NewTaskNewTaskTTy = nullptr;
575 const RecordDecl *KmpTaskTQTyRD = nullptr;
576 llvm::Value *TaskDupFn = nullptr;
577 };
578 /// Emit task region for the task directive. The task region is emitted in
579 /// several steps:
580 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
581 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
582 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
583 /// function:
584 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
585 /// TaskFunction(gtid, tt->part_id, tt->shareds);
586 /// return 0;
587 /// }
588 /// 2. Copy a list of shared variables to field shareds of the resulting
589 /// structure kmp_task_t returned by the previous call (if any).
590 /// 3. Copy a pointer to destructions function to field destructions of the
591 /// resulting structure kmp_task_t.
592 /// \param D Current task directive.
593 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
594 /// /*part_id*/, captured_struct */*__context*/);
595 /// \param SharedsTy A type which contains references the shared variables.
596 /// \param Shareds Context with the list of shared variables from the \p
597 /// TaskFunction.
598 /// \param Data Additional data for task generation like tiednsee, final
599 /// state, list of privates etc.
601 const OMPExecutableDirective &D,
602 llvm::Function *TaskFunction, QualType SharedsTy,
603 Address Shareds, const OMPTaskDataTy &Data);
604
605 /// Emit update for lastprivate conditional data.
607 StringRef UniqueDeclName, LValue LVal,
608 SourceLocation Loc);
609
610 /// Returns the number of the elements and the address of the depobj
611 /// dependency array.
612 /// \return Number of elements in depobj array and the pointer to the array of
613 /// dependencies.
614 std::pair<llvm::Value *, LValue> getDepobjElements(CodeGenFunction &CGF,
615 LValue DepobjLVal,
616 SourceLocation Loc);
617
621
623 LValue PosLVal, const OMPTaskDataTy::DependData &Data,
624 Address DependenciesArray);
625
626public:
628 virtual ~CGOpenMPRuntime() {}
629 virtual void clear();
630
631 /// Emits object of ident_t type with info for source location.
632 /// \param Flags Flags for OpenMP location.
633 /// \param EmitLoc emit source location with debug-info is off.
634 ///
636 unsigned Flags = 0, bool EmitLoc = false);
637
638 /// Emit the number of teams for a target directive. Inspect the num_teams
639 /// clause associated with a teams construct combined or closely nested
640 /// with the target directive.
641 ///
642 /// Emit a team of size one for directives such as 'target parallel' that
643 /// have no associated teams construct.
644 ///
645 /// Otherwise, return nullptr.
647 const OMPExecutableDirective &D,
648 int32_t &MinTeamsVal,
649 int32_t &MaxTeamsVal);
651 const OMPExecutableDirective &D);
652
653 /// Check for a number of threads upper bound constant value (stored in \p
654 /// UpperBound), or expression (returned). If the value is conditional (via an
655 /// if-clause), store the condition in \p CondExpr. Similarly, a potential
656 /// thread limit expression is stored in \p ThreadLimitExpr. If \p
657 /// UpperBoundOnly is true, no expression evaluation is perfomed.
660 int32_t &UpperBound, bool UpperBoundOnly,
661 llvm::Value **CondExpr = nullptr, const Expr **ThreadLimitExpr = nullptr);
662
663 /// Emit an expression that denotes the number of threads a target region
664 /// shall use. Will generate "i32 0" to allow the runtime to choose.
665 llvm::Value *
667 const OMPExecutableDirective &D);
668
669 /// Return the trip count of loops associated with constructs / 'target teams
670 /// distribute' and 'teams distribute parallel for'. \param SizeEmitter Emits
671 /// the int64 value for the number of iterations of the associated loop.
672 llvm::Value *emitTargetNumIterationsCall(
674 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
675 const OMPLoopDirective &D)>
676 SizeEmitter);
677
678 /// Returns true if the current target is a GPU.
679 virtual bool isGPU() const { return false; }
680
681 /// Check if the variable length declaration is delayed:
683 const VarDecl *VD) const {
684 return false;
685 };
686
687 /// Get call to __kmpc_alloc_shared
688 virtual std::pair<llvm::Value *, llvm::Value *>
690 llvm_unreachable("not implemented");
691 }
692
693 /// Get call to __kmpc_free_shared
694 virtual void getKmpcFreeShared(
695 CodeGenFunction &CGF,
696 const std::pair<llvm::Value *, llvm::Value *> &AddrSizePair) {
697 llvm_unreachable("not implemented");
698 }
699
700 /// Emits code for OpenMP 'if' clause using specified \a CodeGen
701 /// function. Here is the logic:
702 /// if (Cond) {
703 /// ThenGen();
704 /// } else {
705 /// ElseGen();
706 /// }
707 void emitIfClause(CodeGenFunction &CGF, const Expr *Cond,
708 const RegionCodeGenTy &ThenGen,
709 const RegionCodeGenTy &ElseGen);
710
711 /// Checks if the \p Body is the \a CompoundStmt and returns its child
712 /// statement iff there is only one that is not evaluatable at the compile
713 /// time.
714 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
715
716 /// Get the platform-specific name separator.
717 std::string getName(ArrayRef<StringRef> Parts) const;
718
719 /// Emit code for the specified user defined reduction construct.
721 const OMPDeclareReductionDecl *D);
722 /// Get combiner/initializer for the specified user-defined reduction, if any.
723 virtual std::pair<llvm::Function *, llvm::Function *>
725
726 /// Emit the function for the user defined mapper construct.
728 CodeGenFunction *CGF = nullptr);
729 /// Get the function for the specified user-defined mapper. If it does not
730 /// exist, create one.
731 llvm::Function *
733
734 /// Emits outlined function for the specified OpenMP parallel directive
735 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
736 /// kmp_int32 BoundID, struct context_vars*).
737 /// \param CGF Reference to current CodeGenFunction.
738 /// \param D OpenMP directive.
739 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
740 /// \param InnermostKind Kind of innermost directive (for simple directives it
741 /// is a directive itself, for combined - its innermost directive).
742 /// \param CodeGen Code generation sequence for the \a D directive.
743 virtual llvm::Function *emitParallelOutlinedFunction(
745 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
746 const RegionCodeGenTy &CodeGen);
747
748 /// Emits outlined function for the specified OpenMP teams directive
749 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
750 /// kmp_int32 BoundID, struct context_vars*).
751 /// \param CGF Reference to current CodeGenFunction.
752 /// \param D OpenMP directive.
753 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
754 /// \param InnermostKind Kind of innermost directive (for simple directives it
755 /// is a directive itself, for combined - its innermost directive).
756 /// \param CodeGen Code generation sequence for the \a D directive.
757 virtual llvm::Function *emitTeamsOutlinedFunction(
759 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
760 const RegionCodeGenTy &CodeGen);
761
762 /// Emits outlined function for the OpenMP task directive \a D. This
763 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
764 /// TaskT).
765 /// \param D OpenMP directive.
766 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
767 /// \param PartIDVar Variable for partition id in the current OpenMP untied
768 /// task region.
769 /// \param TaskTVar Variable for task_t argument.
770 /// \param InnermostKind Kind of innermost directive (for simple directives it
771 /// is a directive itself, for combined - its innermost directive).
772 /// \param CodeGen Code generation sequence for the \a D directive.
773 /// \param Tied true if task is generated for tied task, false otherwise.
774 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
775 /// tasks.
776 ///
777 virtual llvm::Function *emitTaskOutlinedFunction(
778 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
779 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
780 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
781 bool Tied, unsigned &NumberOfParts);
782
783 /// Cleans up references to the objects in finished function.
784 ///
785 virtual void functionFinished(CodeGenFunction &CGF);
786
787 /// Emits code for parallel or serial call of the \a OutlinedFn with
788 /// variables captured in a record which address is stored in \a
789 /// CapturedStruct.
790 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
791 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
792 /// \param CapturedVars A pointer to the record with the references to
793 /// variables used in \a OutlinedFn function.
794 /// \param IfCond Condition in the associated 'if' clause, if it was
795 /// specified, nullptr otherwise.
796 /// \param NumThreads The value corresponding to the num_threads clause, if
797 /// any, or nullptr.
798 ///
799 virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
800 llvm::Function *OutlinedFn,
801 ArrayRef<llvm::Value *> CapturedVars,
802 const Expr *IfCond, llvm::Value *NumThreads);
803
804 /// Emits a critical region.
805 /// \param CriticalName Name of the critical region.
806 /// \param CriticalOpGen Generator for the statement associated with the given
807 /// critical region.
808 /// \param Hint Value of the 'hint' clause (optional).
809 virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
810 const RegionCodeGenTy &CriticalOpGen,
811 SourceLocation Loc,
812 const Expr *Hint = nullptr);
813
814 /// Emits a master region.
815 /// \param MasterOpGen Generator for the statement associated with the given
816 /// master region.
817 virtual void emitMasterRegion(CodeGenFunction &CGF,
818 const RegionCodeGenTy &MasterOpGen,
819 SourceLocation Loc);
820
821 /// Emits a masked region.
822 /// \param MaskedOpGen Generator for the statement associated with the given
823 /// masked region.
824 virtual void emitMaskedRegion(CodeGenFunction &CGF,
825 const RegionCodeGenTy &MaskedOpGen,
826 SourceLocation Loc,
827 const Expr *Filter = nullptr);
828
829 /// Emits code for a taskyield directive.
830 virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
831
832 /// Emit __kmpc_error call for error directive
833 /// extern void __kmpc_error(ident_t *loc, int severity, const char *message);
834 virtual void emitErrorCall(CodeGenFunction &CGF, SourceLocation Loc, Expr *ME,
835 bool IsFatal);
836
837 /// Emit a taskgroup region.
838 /// \param TaskgroupOpGen Generator for the statement associated with the
839 /// given taskgroup region.
840 virtual void emitTaskgroupRegion(CodeGenFunction &CGF,
841 const RegionCodeGenTy &TaskgroupOpGen,
842 SourceLocation Loc);
843
844 /// Emits a single region.
845 /// \param SingleOpGen Generator for the statement associated with the given
846 /// single region.
847 virtual void emitSingleRegion(CodeGenFunction &CGF,
848 const RegionCodeGenTy &SingleOpGen,
849 SourceLocation Loc,
850 ArrayRef<const Expr *> CopyprivateVars,
851 ArrayRef<const Expr *> DestExprs,
852 ArrayRef<const Expr *> SrcExprs,
853 ArrayRef<const Expr *> AssignmentOps);
854
855 /// Emit an ordered region.
856 /// \param OrderedOpGen Generator for the statement associated with the given
857 /// ordered region.
858 virtual void emitOrderedRegion(CodeGenFunction &CGF,
859 const RegionCodeGenTy &OrderedOpGen,
860 SourceLocation Loc, bool IsThreads);
861
862 /// Emit an implicit/explicit barrier for OpenMP threads.
863 /// \param Kind Directive for which this implicit barrier call must be
864 /// generated. Must be OMPD_barrier for explicit barrier generation.
865 /// \param EmitChecks true if need to emit checks for cancellation barriers.
866 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
867 /// runtime class decides which one to emit (simple or with cancellation
868 /// checks).
869 ///
870 virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
872 bool EmitChecks = true,
873 bool ForceSimpleCall = false);
874
875 /// Check if the specified \a ScheduleKind is static non-chunked.
876 /// This kind of worksharing directive is emitted without outer loop.
877 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
878 /// \param Chunked True if chunk is specified in the clause.
879 ///
880 virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
881 bool Chunked) const;
882
883 /// Check if the specified \a ScheduleKind is static non-chunked.
884 /// This kind of distribute directive is emitted without outer loop.
885 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
886 /// \param Chunked True if chunk is specified in the clause.
887 ///
888 virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind,
889 bool Chunked) const;
890
891 /// Check if the specified \a ScheduleKind is static chunked.
892 /// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
893 /// \param Chunked True if chunk is specified in the clause.
894 ///
895 virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind,
896 bool Chunked) const;
897
898 /// Check if the specified \a ScheduleKind is static non-chunked.
899 /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause.
900 /// \param Chunked True if chunk is specified in the clause.
901 ///
902 virtual bool isStaticChunked(OpenMPDistScheduleClauseKind ScheduleKind,
903 bool Chunked) const;
904
905 /// Check if the specified \a ScheduleKind is dynamic.
906 /// This kind of worksharing directive is emitted without outer loop.
907 /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
908 ///
909 virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
910
911 /// struct with the values to be passed to the dispatch runtime function
913 /// Loop lower bound
914 llvm::Value *LB = nullptr;
915 /// Loop upper bound
916 llvm::Value *UB = nullptr;
917 /// Chunk size specified using 'schedule' clause (nullptr if chunk
918 /// was not specified)
919 llvm::Value *Chunk = nullptr;
920 DispatchRTInput() = default;
921 DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
922 : LB(LB), UB(UB), Chunk(Chunk) {}
923 };
924
925 /// Call the appropriate runtime routine to initialize it before start
926 /// of loop.
927
928 /// This is used for non static scheduled types and when the ordered
929 /// clause is present on the loop construct.
930 /// Depending on the loop schedule, it is necessary to call some runtime
931 /// routine before start of the OpenMP loop to get the loop upper / lower
932 /// bounds \a LB and \a UB and stride \a ST.
933 ///
934 /// \param CGF Reference to current CodeGenFunction.
935 /// \param Loc Clang source location.
936 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
937 /// \param IVSize Size of the iteration variable in bits.
938 /// \param IVSigned Sign of the iteration variable.
939 /// \param Ordered true if loop is ordered, false otherwise.
940 /// \param DispatchValues struct containing llvm values for lower bound, upper
941 /// bound, and chunk expression.
942 /// For the default (nullptr) value, the chunk 1 will be used.
943 ///
945 const OpenMPScheduleTy &ScheduleKind,
946 unsigned IVSize, bool IVSigned, bool Ordered,
947 const DispatchRTInput &DispatchValues);
948
949 /// Struct with the values to be passed to the static runtime function
951 /// Size of the iteration variable in bits.
952 unsigned IVSize = 0;
953 /// Sign of the iteration variable.
954 bool IVSigned = false;
955 /// true if loop is ordered, false otherwise.
956 bool Ordered = false;
957 /// Address of the output variable in which the flag of the last iteration
958 /// is returned.
960 /// Address of the output variable in which the lower iteration number is
961 /// returned.
963 /// Address of the output variable in which the upper iteration number is
964 /// returned.
966 /// Address of the output variable in which the stride value is returned
967 /// necessary to generated the static_chunked scheduled loop.
969 /// Value of the chunk for the static_chunked scheduled loop. For the
970 /// default (nullptr) value, the chunk 1 will be used.
971 llvm::Value *Chunk = nullptr;
974 llvm::Value *Chunk = nullptr)
976 UB(UB), ST(ST), Chunk(Chunk) {}
977 };
978 /// Call the appropriate runtime routine to initialize it before start
979 /// of loop.
980 ///
981 /// This is used only in case of static schedule, when the user did not
982 /// specify a ordered clause on the loop construct.
983 /// Depending on the loop schedule, it is necessary to call some runtime
984 /// routine before start of the OpenMP loop to get the loop upper / lower
985 /// bounds LB and UB and stride ST.
986 ///
987 /// \param CGF Reference to current CodeGenFunction.
988 /// \param Loc Clang source location.
989 /// \param DKind Kind of the directive.
990 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
991 /// \param Values Input arguments for the construct.
992 ///
993 virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc,
995 const OpenMPScheduleTy &ScheduleKind,
996 const StaticRTInput &Values);
997
998 ///
999 /// \param CGF Reference to current CodeGenFunction.
1000 /// \param Loc Clang source location.
1001 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1002 /// \param Values Input arguments for the construct.
1003 ///
1004 virtual void emitDistributeStaticInit(CodeGenFunction &CGF,
1005 SourceLocation Loc,
1007 const StaticRTInput &Values);
1008
1009 /// Call the appropriate runtime routine to notify that we finished
1010 /// iteration of the ordered loop with the dynamic scheduling.
1011 ///
1012 /// \param CGF Reference to current CodeGenFunction.
1013 /// \param Loc Clang source location.
1014 /// \param IVSize Size of the iteration variable in bits.
1015 /// \param IVSigned Sign of the iteration variable.
1016 ///
1018 SourceLocation Loc, unsigned IVSize,
1019 bool IVSigned);
1020
1021 /// Call the appropriate runtime routine to notify that we finished
1022 /// all the work with current loop.
1023 ///
1024 /// \param CGF Reference to current CodeGenFunction.
1025 /// \param Loc Clang source location.
1026 /// \param DKind Kind of the directive for which the static finish is emitted.
1027 ///
1028 virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc,
1029 OpenMPDirectiveKind DKind);
1030
1031 /// Call __kmpc_dispatch_next(
1032 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1033 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1034 /// kmp_int[32|64] *p_stride);
1035 /// \param IVSize Size of the iteration variable in bits.
1036 /// \param IVSigned Sign of the iteration variable.
1037 /// \param IL Address of the output variable in which the flag of the
1038 /// last iteration is returned.
1039 /// \param LB Address of the output variable in which the lower iteration
1040 /// number is returned.
1041 /// \param UB Address of the output variable in which the upper iteration
1042 /// number is returned.
1043 /// \param ST Address of the output variable in which the stride value is
1044 /// returned.
1045 virtual llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1046 unsigned IVSize, bool IVSigned,
1047 Address IL, Address LB,
1048 Address UB, Address ST);
1049
1050 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1051 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1052 /// clause.
1053 /// \param NumThreads An integer value of threads.
1054 virtual void emitNumThreadsClause(CodeGenFunction &CGF,
1055 llvm::Value *NumThreads,
1056 SourceLocation Loc);
1057
1058 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1059 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1060 virtual void emitProcBindClause(CodeGenFunction &CGF,
1061 llvm::omp::ProcBindKind ProcBind,
1062 SourceLocation Loc);
1063
1064 /// Returns address of the threadprivate variable for the current
1065 /// thread.
1066 /// \param VD Threadprivate variable.
1067 /// \param VDAddr Address of the global variable \a VD.
1068 /// \param Loc Location of the reference to threadprivate var.
1069 /// \return Address of the threadprivate variable for the current thread.
1071 const VarDecl *VD,
1072 Address VDAddr,
1073 SourceLocation Loc);
1074
1075 /// Returns the address of the variable marked as declare target with link
1076 /// clause OR as declare target with to clause and unified memory.
1077 virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD);
1078
1079 /// Emit a code for initialization of threadprivate variable. It emits
1080 /// a call to runtime library which adds initial value to the newly created
1081 /// threadprivate variable (if it is not constant) and registers destructor
1082 /// for the variable (if any).
1083 /// \param VD Threadprivate variable.
1084 /// \param VDAddr Address of the global variable \a VD.
1085 /// \param Loc Location of threadprivate declaration.
1086 /// \param PerformInit true if initialization expression is not constant.
1087 virtual llvm::Function *
1089 SourceLocation Loc, bool PerformInit,
1090 CodeGenFunction *CGF = nullptr);
1091
1092 /// Emit code for handling declare target functions in the runtime.
1093 /// \param FD Declare target function.
1094 /// \param Addr Address of the global \a FD.
1095 /// \param PerformInit true if initialization expression is not constant.
1096 virtual void emitDeclareTargetFunction(const FunctionDecl *FD,
1097 llvm::GlobalValue *GV);
1098
1099 /// Creates artificial threadprivate variable with name \p Name and type \p
1100 /// VarType.
1101 /// \param VarType Type of the artificial threadprivate variable.
1102 /// \param Name Name of the artificial threadprivate variable.
1104 QualType VarType,
1105 StringRef Name);
1106
1107 /// Emit flush of the variables specified in 'omp flush' directive.
1108 /// \param Vars List of variables to flush.
1109 virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
1110 SourceLocation Loc, llvm::AtomicOrdering AO);
1111
1112 /// Emit task region for the task directive. The task region is
1113 /// emitted in several steps:
1114 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1115 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1116 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1117 /// function:
1118 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1119 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1120 /// return 0;
1121 /// }
1122 /// 2. Copy a list of shared variables to field shareds of the resulting
1123 /// structure kmp_task_t returned by the previous call (if any).
1124 /// 3. Copy a pointer to destructions function to field destructions of the
1125 /// resulting structure kmp_task_t.
1126 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1127 /// kmp_task_t *new_task), where new_task is a resulting structure from
1128 /// previous items.
1129 /// \param D Current task directive.
1130 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1131 /// /*part_id*/, captured_struct */*__context*/);
1132 /// \param SharedsTy A type which contains references the shared variables.
1133 /// \param Shareds Context with the list of shared variables from the \p
1134 /// TaskFunction.
1135 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1136 /// otherwise.
1137 /// \param Data Additional data for task generation like tiednsee, final
1138 /// state, list of privates etc.
1139 virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc,
1140 const OMPExecutableDirective &D,
1141 llvm::Function *TaskFunction, QualType SharedsTy,
1142 Address Shareds, const Expr *IfCond,
1143 const OMPTaskDataTy &Data);
1144
1145 /// Emit task region for the taskloop directive. The taskloop region is
1146 /// emitted in several steps:
1147 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1148 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1149 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1150 /// function:
1151 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1152 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1153 /// return 0;
1154 /// }
1155 /// 2. Copy a list of shared variables to field shareds of the resulting
1156 /// structure kmp_task_t returned by the previous call (if any).
1157 /// 3. Copy a pointer to destructions function to field destructions of the
1158 /// resulting structure kmp_task_t.
1159 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1160 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1161 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
1162 /// is a resulting structure from
1163 /// previous items.
1164 /// \param D Current task directive.
1165 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1166 /// /*part_id*/, captured_struct */*__context*/);
1167 /// \param SharedsTy A type which contains references the shared variables.
1168 /// \param Shareds Context with the list of shared variables from the \p
1169 /// TaskFunction.
1170 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1171 /// otherwise.
1172 /// \param Data Additional data for task generation like tiednsee, final
1173 /// state, list of privates etc.
1174 virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
1175 const OMPLoopDirective &D,
1176 llvm::Function *TaskFunction,
1177 QualType SharedsTy, Address Shareds,
1178 const Expr *IfCond, const OMPTaskDataTy &Data);
1179
1180 /// Emit code for the directive that does not require outlining.
1181 ///
1182 /// \param InnermostKind Kind of innermost directive (for simple directives it
1183 /// is a directive itself, for combined - its innermost directive).
1184 /// \param CodeGen Code generation sequence for the \a D directive.
1185 /// \param HasCancel true if region has inner cancel directive, false
1186 /// otherwise.
1187 virtual void emitInlinedDirective(CodeGenFunction &CGF,
1188 OpenMPDirectiveKind InnermostKind,
1189 const RegionCodeGenTy &CodeGen,
1190 bool HasCancel = false);
1191
1192 /// Emits reduction function.
1193 /// \param ReducerName Name of the function calling the reduction.
1194 /// \param ArgsElemType Array type containing pointers to reduction variables.
1195 /// \param Privates List of private copies for original reduction arguments.
1196 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1197 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1198 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1199 /// or 'operator binop(LHS, RHS)'.
1200 llvm::Function *emitReductionFunction(
1201 StringRef ReducerName, SourceLocation Loc, llvm::Type *ArgsElemType,
1203 ArrayRef<const Expr *> RHSExprs, ArrayRef<const Expr *> ReductionOps);
1204
1205 /// Emits single reduction combiner
1207 const Expr *ReductionOp,
1208 const Expr *PrivateRef,
1209 const DeclRefExpr *LHS,
1210 const DeclRefExpr *RHS);
1211
1216 };
1217 /// Emit a code for reduction clause. Next code should be emitted for
1218 /// reduction:
1219 /// \code
1220 ///
1221 /// static kmp_critical_name lock = { 0 };
1222 ///
1223 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1224 /// ...
1225 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
1226 /// ...
1227 /// }
1228 ///
1229 /// ...
1230 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
1231 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
1232 /// RedList, reduce_func, &<lock>)) {
1233 /// case 1:
1234 /// ...
1235 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
1236 /// ...
1237 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
1238 /// break;
1239 /// case 2:
1240 /// ...
1241 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
1242 /// ...
1243 /// break;
1244 /// default:;
1245 /// }
1246 /// \endcode
1247 ///
1248 /// \param Privates List of private copies for original reduction arguments.
1249 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
1250 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
1251 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
1252 /// or 'operator binop(LHS, RHS)'.
1253 /// \param Options List of options for reduction codegen:
1254 /// WithNowait true if parent directive has also nowait clause, false
1255 /// otherwise.
1256 /// SimpleReduction Emit reduction operation only. Used for omp simd
1257 /// directive on the host.
1258 /// ReductionKind The kind of reduction to perform.
1259 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
1260 ArrayRef<const Expr *> Privates,
1261 ArrayRef<const Expr *> LHSExprs,
1262 ArrayRef<const Expr *> RHSExprs,
1263 ArrayRef<const Expr *> ReductionOps,
1264 ReductionOptionsTy Options);
1265
1266 /// Emit a code for initialization of task reduction clause. Next code
1267 /// should be emitted for reduction:
1268 /// \code
1269 ///
1270 /// _taskred_item_t red_data[n];
1271 /// ...
1272 /// red_data[i].shar = &shareds[i];
1273 /// red_data[i].orig = &origs[i];
1274 /// red_data[i].size = sizeof(origs[i]);
1275 /// red_data[i].f_init = (void*)RedInit<i>;
1276 /// red_data[i].f_fini = (void*)RedDest<i>;
1277 /// red_data[i].f_comb = (void*)RedOp<i>;
1278 /// red_data[i].flags = <Flag_i>;
1279 /// ...
1280 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
1281 /// \endcode
1282 /// For reduction clause with task modifier it emits the next call:
1283 /// \code
1284 ///
1285 /// _taskred_item_t red_data[n];
1286 /// ...
1287 /// red_data[i].shar = &shareds[i];
1288 /// red_data[i].orig = &origs[i];
1289 /// red_data[i].size = sizeof(origs[i]);
1290 /// red_data[i].f_init = (void*)RedInit<i>;
1291 /// red_data[i].f_fini = (void*)RedDest<i>;
1292 /// red_data[i].f_comb = (void*)RedOp<i>;
1293 /// red_data[i].flags = <Flag_i>;
1294 /// ...
1295 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
1296 /// red_data);
1297 /// \endcode
1298 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
1299 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
1300 /// \param Data Additional data for task generation like tiedness, final
1301 /// state, list of privates, reductions etc.
1302 virtual llvm::Value *emitTaskReductionInit(CodeGenFunction &CGF,
1303 SourceLocation Loc,
1304 ArrayRef<const Expr *> LHSExprs,
1305 ArrayRef<const Expr *> RHSExprs,
1306 const OMPTaskDataTy &Data);
1307
1308 /// Emits the following code for reduction clause with task modifier:
1309 /// \code
1310 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
1311 /// \endcode
1313 bool IsWorksharingReduction);
1314
1315 /// Required to resolve existing problems in the runtime. Emits threadprivate
1316 /// variables to store the size of the VLAs/array sections for
1317 /// initializer/combiner/finalizer functions.
1318 /// \param RCG Allows to reuse an existing data for the reductions.
1319 /// \param N Reduction item for which fixups must be emitted.
1321 ReductionCodeGen &RCG, unsigned N);
1322
1323 /// Get the address of `void *` type of the privatue copy of the reduction
1324 /// item specified by the \p SharedLVal.
1325 /// \param ReductionsPtr Pointer to the reduction data returned by the
1326 /// emitTaskReductionInit function.
1327 /// \param SharedLVal Address of the original reduction item.
1329 llvm::Value *ReductionsPtr,
1330 LValue SharedLVal);
1331
1332 /// Emit code for 'taskwait' directive.
1333 virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc,
1334 const OMPTaskDataTy &Data);
1335
1336 /// Emit code for 'cancellation point' construct.
1337 /// \param CancelRegion Region kind for which the cancellation point must be
1338 /// emitted.
1339 ///
1341 SourceLocation Loc,
1342 OpenMPDirectiveKind CancelRegion);
1343
1344 /// Emit code for 'cancel' construct.
1345 /// \param IfCond Condition in the associated 'if' clause, if it was
1346 /// specified, nullptr otherwise.
1347 /// \param CancelRegion Region kind for which the cancel must be emitted.
1348 ///
1349 virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc,
1350 const Expr *IfCond,
1351 OpenMPDirectiveKind CancelRegion);
1352
1353 /// Emit outilined function for 'target' directive.
1354 /// \param D Directive to emit.
1355 /// \param ParentName Name of the function that encloses the target region.
1356 /// \param OutlinedFn Outlined function value to be defined by this call.
1357 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
1358 /// \param IsOffloadEntry True if the outlined function is an offload entry.
1359 /// \param CodeGen Code generation sequence for the \a D directive.
1360 /// An outlined function may not be an entry if, e.g. the if clause always
1361 /// evaluates to false.
1363 StringRef ParentName,
1364 llvm::Function *&OutlinedFn,
1365 llvm::Constant *&OutlinedFnID,
1366 bool IsOffloadEntry,
1367 const RegionCodeGenTy &CodeGen);
1368
1369 /// Emit the target offloading code associated with \a D. The emitted
1370 /// code attempts offloading the execution to the device, an the event of
1371 /// a failure it executes the host version outlined in \a OutlinedFn.
1372 /// \param D Directive to emit.
1373 /// \param OutlinedFn Host version of the code to be offloaded.
1374 /// \param OutlinedFnID ID of host version of the code to be offloaded.
1375 /// \param IfCond Expression evaluated in if clause associated with the target
1376 /// directive, or null if no if clause is used.
1377 /// \param Device Expression evaluated in device clause associated with the
1378 /// target directive, or null if no device clause is used and device modifier.
1379 /// \param SizeEmitter Callback to emit number of iterations for loop-based
1380 /// directives.
1381 virtual void emitTargetCall(
1383 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
1384 llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
1385 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
1386 const OMPLoopDirective &D)>
1387 SizeEmitter);
1388
1389 /// Emit the target regions enclosed in \a GD function definition or
1390 /// the function itself in case it is a valid device function. Returns true if
1391 /// \a GD was dealt with successfully.
1392 /// \param GD Function to scan.
1393 virtual bool emitTargetFunctions(GlobalDecl GD);
1394
1395 /// Emit the global variable if it is a valid device global variable.
1396 /// Returns true if \a GD was dealt with successfully.
1397 /// \param GD Variable declaration to emit.
1398 virtual bool emitTargetGlobalVariable(GlobalDecl GD);
1399
1400 /// Checks if the provided global decl \a GD is a declare target variable and
1401 /// registers it when emitting code for the host.
1402 virtual void registerTargetGlobalVariable(const VarDecl *VD,
1403 llvm::Constant *Addr);
1404
1405 /// Emit the global \a GD if it is meaningful for the target. Returns
1406 /// if it was emitted successfully.
1407 /// \param GD Global to scan.
1408 virtual bool emitTargetGlobal(GlobalDecl GD);
1409
1410 /// Creates all the offload entries in the current compilation unit
1411 /// along with the associated metadata.
1413
1414 /// Emits code for teams call of the \a OutlinedFn with
1415 /// variables captured in a record which address is stored in \a
1416 /// CapturedStruct.
1417 /// \param OutlinedFn Outlined function to be run by team masters. Type of
1418 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1419 /// \param CapturedVars A pointer to the record with the references to
1420 /// variables used in \a OutlinedFn function.
1421 ///
1422 virtual void emitTeamsCall(CodeGenFunction &CGF,
1423 const OMPExecutableDirective &D,
1424 SourceLocation Loc, llvm::Function *OutlinedFn,
1425 ArrayRef<llvm::Value *> CapturedVars);
1426
1427 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
1428 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
1429 /// for num_teams clause.
1430 /// \param NumTeams An integer expression of teams.
1431 /// \param ThreadLimit An integer expression of threads.
1432 virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
1433 const Expr *ThreadLimit, SourceLocation Loc);
1434
1435 /// Emits call to void __kmpc_set_thread_limit(ident_t *loc, kmp_int32
1436 /// global_tid, kmp_int32 thread_limit) to generate code for
1437 /// thread_limit clause on target directive
1438 /// \param ThreadLimit An integer expression of threads.
1439 virtual void emitThreadLimitClause(CodeGenFunction &CGF,
1440 const Expr *ThreadLimit,
1441 SourceLocation Loc);
1442
1443 /// Struct that keeps all the relevant information that should be kept
1444 /// throughout a 'target data' region.
1446 public:
1447 explicit TargetDataInfo() : llvm::OpenMPIRBuilder::TargetDataInfo() {}
1448 explicit TargetDataInfo(bool RequiresDevicePointerInfo,
1449 bool SeparateBeginEndCalls)
1450 : llvm::OpenMPIRBuilder::TargetDataInfo(RequiresDevicePointerInfo,
1451 SeparateBeginEndCalls) {}
1452 /// Map between the a declaration of a capture and the corresponding new
1453 /// llvm address where the runtime returns the device pointers.
1454 llvm::DenseMap<const ValueDecl *, llvm::Value *> CaptureDeviceAddrMap;
1455 };
1456
1457 /// Emit the target data mapping code associated with \a D.
1458 /// \param D Directive to emit.
1459 /// \param IfCond Expression evaluated in if clause associated with the
1460 /// target directive, or null if no device clause is used.
1461 /// \param Device Expression evaluated in device clause associated with the
1462 /// target directive, or null if no device clause is used.
1463 /// \param Info A record used to store information that needs to be preserved
1464 /// until the region is closed.
1465 virtual void emitTargetDataCalls(CodeGenFunction &CGF,
1466 const OMPExecutableDirective &D,
1467 const Expr *IfCond, const Expr *Device,
1468 const RegionCodeGenTy &CodeGen,
1470
1471 /// Emit the data mapping/movement code associated with the directive
1472 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
1473 /// \param D Directive to emit.
1474 /// \param IfCond Expression evaluated in if clause associated with the target
1475 /// directive, or null if no if clause is used.
1476 /// \param Device Expression evaluated in device clause associated with the
1477 /// target directive, or null if no device clause is used.
1479 const OMPExecutableDirective &D,
1480 const Expr *IfCond,
1481 const Expr *Device);
1482
1483 /// Marks function \a Fn with properly mangled versions of vector functions.
1484 /// \param FD Function marked as 'declare simd'.
1485 /// \param Fn LLVM function that must be marked with 'declare simd'
1486 /// attributes.
1487 virtual void emitDeclareSimdFunction(const FunctionDecl *FD,
1488 llvm::Function *Fn);
1489
1490 /// Emit initialization for doacross loop nesting support.
1491 /// \param D Loop-based construct used in doacross nesting construct.
1492 virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D,
1493 ArrayRef<Expr *> NumIterations);
1494
1495 /// Emit code for doacross ordered directive with 'depend' clause.
1496 /// \param C 'depend' clause with 'sink|source' dependency kind.
1497 virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1498 const OMPDependClause *C);
1499
1500 /// Emit code for doacross ordered directive with 'doacross' clause.
1501 /// \param C 'doacross' clause with 'sink|source' dependence type.
1502 virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
1503 const OMPDoacrossClause *C);
1504
1505 /// Translates the native parameter of outlined function if this is required
1506 /// for target.
1507 /// \param FD Field decl from captured record for the parameter.
1508 /// \param NativeParam Parameter itself.
1509 virtual const VarDecl *translateParameter(const FieldDecl *FD,
1510 const VarDecl *NativeParam) const {
1511 return NativeParam;
1512 }
1513
1514 /// Gets the address of the native argument basing on the address of the
1515 /// target-specific parameter.
1516 /// \param NativeParam Parameter itself.
1517 /// \param TargetParam Corresponding target-specific parameter.
1519 const VarDecl *NativeParam,
1520 const VarDecl *TargetParam) const;
1521
1522 /// Choose default schedule type and chunk value for the
1523 /// dist_schedule clause.
1525 const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind,
1526 llvm::Value *&Chunk) const {}
1527
1528 /// Choose default schedule type and chunk value for the
1529 /// schedule clause.
1531 const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind,
1532 const Expr *&ChunkExpr) const;
1533
1534 /// Emits call of the outlined function with the provided arguments,
1535 /// translating these arguments to correct target-specific arguments.
1536 virtual void
1538 llvm::FunctionCallee OutlinedFn,
1539 ArrayRef<llvm::Value *> Args = std::nullopt) const;
1540
1541 /// Emits OpenMP-specific function prolog.
1542 /// Required for device constructs.
1543 virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D);
1544
1545 /// Gets the OpenMP-specific address of the local variable.
1547 const VarDecl *VD);
1548
1549 /// Marks the declaration as already emitted for the device code and returns
1550 /// true, if it was marked already, and false, otherwise.
1552
1553 /// Emit deferred declare target variables marked for deferred emission.
1554 void emitDeferredTargetDecls() const;
1555
1556 /// Adjust some parameters for the target-based directives, like addresses of
1557 /// the variables captured by reference in lambdas.
1558 virtual void
1560 const OMPExecutableDirective &D) const;
1561
1562 /// Perform check on requires decl to ensure that target architecture
1563 /// supports unified addressing
1564 virtual void processRequiresDirective(const OMPRequiresDecl *D);
1565
1566 /// Gets default memory ordering as specified in requires directive.
1567 llvm::AtomicOrdering getDefaultMemoryOrdering() const;
1568
1569 /// Checks if the variable has associated OMPAllocateDeclAttr attribute with
1570 /// the predefined allocator and translates it into the corresponding address
1571 /// space.
1572 virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS);
1573
1574 /// Return whether the unified_shared_memory has been specified.
1575 bool hasRequiresUnifiedSharedMemory() const;
1576
1577 /// Checks if the \p VD variable is marked as nontemporal declaration in
1578 /// current context.
1579 bool isNontemporalDecl(const ValueDecl *VD) const;
1580
1581 /// Create specialized alloca to handle lastprivate conditionals.
1583 const VarDecl *VD);
1584
1585 /// Checks if the provided \p LVal is lastprivate conditional and emits the
1586 /// code to update the value of the original variable.
1587 /// \code
1588 /// lastprivate(conditional: a)
1589 /// ...
1590 /// <type> a;
1591 /// lp_a = ...;
1592 /// #pragma omp critical(a)
1593 /// if (last_iv_a <= iv) {
1594 /// last_iv_a = iv;
1595 /// global_a = lp_a;
1596 /// }
1597 /// \endcode
1599 const Expr *LHS);
1600
1601 /// Checks if the lastprivate conditional was updated in inner region and
1602 /// writes the value.
1603 /// \code
1604 /// lastprivate(conditional: a)
1605 /// ...
1606 /// <type> a;bool Fired = false;
1607 /// #pragma omp ... shared(a)
1608 /// {
1609 /// lp_a = ...;
1610 /// Fired = true;
1611 /// }
1612 /// if (Fired) {
1613 /// #pragma omp critical(a)
1614 /// if (last_iv_a <= iv) {
1615 /// last_iv_a = iv;
1616 /// global_a = lp_a;
1617 /// }
1618 /// Fired = false;
1619 /// }
1620 /// \endcode
1623 const llvm::DenseSet<CanonicalDeclPtr<const VarDecl>> &IgnoredDecls);
1624
1625 /// Gets the address of the global copy used for lastprivate conditional
1626 /// update, if any.
1627 /// \param PrivLVal LValue for the private copy.
1628 /// \param VD Original lastprivate declaration.
1630 LValue PrivLVal,
1631 const VarDecl *VD,
1632 SourceLocation Loc);
1633
1634 /// Emits list of dependecies based on the provided data (array of
1635 /// dependence/expression pairs).
1636 /// \returns Pointer to the first element of the array casted to VoidPtr type.
1637 std::pair<llvm::Value *, Address>
1640 SourceLocation Loc);
1641
1642 /// Emits list of dependecies based on the provided data (array of
1643 /// dependence/expression pairs) for depobj construct. In this case, the
1644 /// variable is allocated in dynamically. \returns Pointer to the first
1645 /// element of the array casted to VoidPtr type.
1647 const OMPTaskDataTy::DependData &Dependencies,
1648 SourceLocation Loc);
1649
1650 /// Emits the code to destroy the dependency object provided in depobj
1651 /// directive.
1652 void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal,
1653 SourceLocation Loc);
1654
1655 /// Updates the dependency kind in the specified depobj object.
1656 /// \param DepobjLVal LValue for the main depobj object.
1657 /// \param NewDepKind New dependency kind.
1658 void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal,
1659 OpenMPDependClauseKind NewDepKind, SourceLocation Loc);
1660
1661 /// Initializes user defined allocators specified in the uses_allocators
1662 /// clauses.
1663 void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator,
1664 const Expr *AllocatorTraits);
1665
1666 /// Destroys user defined allocators specified in the uses_allocators clause.
1667 void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator);
1668
1669 /// Returns true if the variable is a local variable in untied task.
1670 bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const;
1671};
1672
1673/// Class supports emissionof SIMD-only code.
1675public:
1678
1679 /// Emits outlined function for the specified OpenMP parallel directive
1680 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1681 /// kmp_int32 BoundID, struct context_vars*).
1682 /// \param CGF Reference to current CodeGenFunction.
1683 /// \param D OpenMP directive.
1684 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1685 /// \param InnermostKind Kind of innermost directive (for simple directives it
1686 /// is a directive itself, for combined - its innermost directive).
1687 /// \param CodeGen Code generation sequence for the \a D directive.
1688 llvm::Function *emitParallelOutlinedFunction(
1690 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1691 const RegionCodeGenTy &CodeGen) override;
1692
1693 /// Emits outlined function for the specified OpenMP teams directive
1694 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
1695 /// kmp_int32 BoundID, struct context_vars*).
1696 /// \param CGF Reference to current CodeGenFunction.
1697 /// \param D OpenMP directive.
1698 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1699 /// \param InnermostKind Kind of innermost directive (for simple directives it
1700 /// is a directive itself, for combined - its innermost directive).
1701 /// \param CodeGen Code generation sequence for the \a D directive.
1702 llvm::Function *emitTeamsOutlinedFunction(
1704 const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind,
1705 const RegionCodeGenTy &CodeGen) override;
1706
1707 /// Emits outlined function for the OpenMP task directive \a D. This
1708 /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t*
1709 /// TaskT).
1710 /// \param D OpenMP directive.
1711 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
1712 /// \param PartIDVar Variable for partition id in the current OpenMP untied
1713 /// task region.
1714 /// \param TaskTVar Variable for task_t argument.
1715 /// \param InnermostKind Kind of innermost directive (for simple directives it
1716 /// is a directive itself, for combined - its innermost directive).
1717 /// \param CodeGen Code generation sequence for the \a D directive.
1718 /// \param Tied true if task is generated for tied task, false otherwise.
1719 /// \param NumberOfParts Number of parts in untied task. Ignored for tied
1720 /// tasks.
1721 ///
1722 llvm::Function *emitTaskOutlinedFunction(
1723 const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,
1724 const VarDecl *PartIDVar, const VarDecl *TaskTVar,
1725 OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen,
1726 bool Tied, unsigned &NumberOfParts) override;
1727
1728 /// Emits code for parallel or serial call of the \a OutlinedFn with
1729 /// variables captured in a record which address is stored in \a
1730 /// CapturedStruct.
1731 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
1732 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
1733 /// \param CapturedVars A pointer to the record with the references to
1734 /// variables used in \a OutlinedFn function.
1735 /// \param IfCond Condition in the associated 'if' clause, if it was
1736 /// specified, nullptr otherwise.
1737 /// \param NumThreads The value corresponding to the num_threads clause, if
1738 /// any, or nullptr.
1739 ///
1741 llvm::Function *OutlinedFn,
1742 ArrayRef<llvm::Value *> CapturedVars,
1743 const Expr *IfCond, llvm::Value *NumThreads) override;
1744
1745 /// Emits a critical region.
1746 /// \param CriticalName Name of the critical region.
1747 /// \param CriticalOpGen Generator for the statement associated with the given
1748 /// critical region.
1749 /// \param Hint Value of the 'hint' clause (optional).
1750 void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName,
1751 const RegionCodeGenTy &CriticalOpGen,
1752 SourceLocation Loc,
1753 const Expr *Hint = nullptr) override;
1754
1755 /// Emits a master region.
1756 /// \param MasterOpGen Generator for the statement associated with the given
1757 /// master region.
1759 const RegionCodeGenTy &MasterOpGen,
1760 SourceLocation Loc) override;
1761
1762 /// Emits a masked region.
1763 /// \param MaskedOpGen Generator for the statement associated with the given
1764 /// masked region.
1766 const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc,
1767 const Expr *Filter = nullptr) override;
1768
1769 /// Emits a masked region.
1770 /// \param MaskedOpGen Generator for the statement associated with the given
1771 /// masked region.
1772
1773 /// Emits code for a taskyield directive.
1774 void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override;
1775
1776 /// Emit a taskgroup region.
1777 /// \param TaskgroupOpGen Generator for the statement associated with the
1778 /// given taskgroup region.
1780 const RegionCodeGenTy &TaskgroupOpGen,
1781 SourceLocation Loc) override;
1782
1783 /// Emits a single region.
1784 /// \param SingleOpGen Generator for the statement associated with the given
1785 /// single region.
1787 const RegionCodeGenTy &SingleOpGen, SourceLocation Loc,
1788 ArrayRef<const Expr *> CopyprivateVars,
1789 ArrayRef<const Expr *> DestExprs,
1790 ArrayRef<const Expr *> SrcExprs,
1791 ArrayRef<const Expr *> AssignmentOps) override;
1792
1793 /// Emit an ordered region.
1794 /// \param OrderedOpGen Generator for the statement associated with the given
1795 /// ordered region.
1797 const RegionCodeGenTy &OrderedOpGen,
1798 SourceLocation Loc, bool IsThreads) override;
1799
1800 /// Emit an implicit/explicit barrier for OpenMP threads.
1801 /// \param Kind Directive for which this implicit barrier call must be
1802 /// generated. Must be OMPD_barrier for explicit barrier generation.
1803 /// \param EmitChecks true if need to emit checks for cancellation barriers.
1804 /// \param ForceSimpleCall true simple barrier call must be emitted, false if
1805 /// runtime class decides which one to emit (simple or with cancellation
1806 /// checks).
1807 ///
1809 OpenMPDirectiveKind Kind, bool EmitChecks = true,
1810 bool ForceSimpleCall = false) override;
1811
1812 /// This is used for non static scheduled types and when the ordered
1813 /// clause is present on the loop construct.
1814 /// Depending on the loop schedule, it is necessary to call some runtime
1815 /// routine before start of the OpenMP loop to get the loop upper / lower
1816 /// bounds \a LB and \a UB and stride \a ST.
1817 ///
1818 /// \param CGF Reference to current CodeGenFunction.
1819 /// \param Loc Clang source location.
1820 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1821 /// \param IVSize Size of the iteration variable in bits.
1822 /// \param IVSigned Sign of the iteration variable.
1823 /// \param Ordered true if loop is ordered, false otherwise.
1824 /// \param DispatchValues struct containing llvm values for lower bound, upper
1825 /// bound, and chunk expression.
1826 /// For the default (nullptr) value, the chunk 1 will be used.
1827 ///
1829 const OpenMPScheduleTy &ScheduleKind,
1830 unsigned IVSize, bool IVSigned, bool Ordered,
1831 const DispatchRTInput &DispatchValues) override;
1832
1833 /// Call the appropriate runtime routine to initialize it before start
1834 /// of loop.
1835 ///
1836 /// This is used only in case of static schedule, when the user did not
1837 /// specify a ordered clause on the loop construct.
1838 /// Depending on the loop schedule, it is necessary to call some runtime
1839 /// routine before start of the OpenMP loop to get the loop upper / lower
1840 /// bounds LB and UB and stride ST.
1841 ///
1842 /// \param CGF Reference to current CodeGenFunction.
1843 /// \param Loc Clang source location.
1844 /// \param DKind Kind of the directive.
1845 /// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
1846 /// \param Values Input arguments for the construct.
1847 ///
1849 OpenMPDirectiveKind DKind,
1850 const OpenMPScheduleTy &ScheduleKind,
1851 const StaticRTInput &Values) override;
1852
1853 ///
1854 /// \param CGF Reference to current CodeGenFunction.
1855 /// \param Loc Clang source location.
1856 /// \param SchedKind Schedule kind, specified by the 'dist_schedule' clause.
1857 /// \param Values Input arguments for the construct.
1858 ///
1861 const StaticRTInput &Values) override;
1862
1863 /// Call the appropriate runtime routine to notify that we finished
1864 /// iteration of the ordered loop with the dynamic scheduling.
1865 ///
1866 /// \param CGF Reference to current CodeGenFunction.
1867 /// \param Loc Clang source location.
1868 /// \param IVSize Size of the iteration variable in bits.
1869 /// \param IVSigned Sign of the iteration variable.
1870 ///
1872 unsigned IVSize, bool IVSigned) override;
1873
1874 /// Call the appropriate runtime routine to notify that we finished
1875 /// all the work with current loop.
1876 ///
1877 /// \param CGF Reference to current CodeGenFunction.
1878 /// \param Loc Clang source location.
1879 /// \param DKind Kind of the directive for which the static finish is emitted.
1880 ///
1882 OpenMPDirectiveKind DKind) override;
1883
1884 /// Call __kmpc_dispatch_next(
1885 /// ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter,
1886 /// kmp_int[32|64] *p_lower, kmp_int[32|64] *p_upper,
1887 /// kmp_int[32|64] *p_stride);
1888 /// \param IVSize Size of the iteration variable in bits.
1889 /// \param IVSigned Sign of the iteration variable.
1890 /// \param IL Address of the output variable in which the flag of the
1891 /// last iteration is returned.
1892 /// \param LB Address of the output variable in which the lower iteration
1893 /// number is returned.
1894 /// \param UB Address of the output variable in which the upper iteration
1895 /// number is returned.
1896 /// \param ST Address of the output variable in which the stride value is
1897 /// returned.
1898 llvm::Value *emitForNext(CodeGenFunction &CGF, SourceLocation Loc,
1899 unsigned IVSize, bool IVSigned, Address IL,
1900 Address LB, Address UB, Address ST) override;
1901
1902 /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
1903 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
1904 /// clause.
1905 /// \param NumThreads An integer value of threads.
1906 void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads,
1907 SourceLocation Loc) override;
1908
1909 /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
1910 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
1912 llvm::omp::ProcBindKind ProcBind,
1913 SourceLocation Loc) override;
1914
1915 /// Returns address of the threadprivate variable for the current
1916 /// thread.
1917 /// \param VD Threadprivate variable.
1918 /// \param VDAddr Address of the global variable \a VD.
1919 /// \param Loc Location of the reference to threadprivate var.
1920 /// \return Address of the threadprivate variable for the current thread.
1922 Address VDAddr, SourceLocation Loc) override;
1923
1924 /// Emit a code for initialization of threadprivate variable. It emits
1925 /// a call to runtime library which adds initial value to the newly created
1926 /// threadprivate variable (if it is not constant) and registers destructor
1927 /// for the variable (if any).
1928 /// \param VD Threadprivate variable.
1929 /// \param VDAddr Address of the global variable \a VD.
1930 /// \param Loc Location of threadprivate declaration.
1931 /// \param PerformInit true if initialization expression is not constant.
1932 llvm::Function *
1934 SourceLocation Loc, bool PerformInit,
1935 CodeGenFunction *CGF = nullptr) override;
1936
1937 /// Creates artificial threadprivate variable with name \p Name and type \p
1938 /// VarType.
1939 /// \param VarType Type of the artificial threadprivate variable.
1940 /// \param Name Name of the artificial threadprivate variable.
1942 QualType VarType,
1943 StringRef Name) override;
1944
1945 /// Emit flush of the variables specified in 'omp flush' directive.
1946 /// \param Vars List of variables to flush.
1948 SourceLocation Loc, llvm::AtomicOrdering AO) override;
1949
1950 /// Emit task region for the task directive. The task region is
1951 /// emitted in several steps:
1952 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1953 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1954 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1955 /// function:
1956 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1957 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1958 /// return 0;
1959 /// }
1960 /// 2. Copy a list of shared variables to field shareds of the resulting
1961 /// structure kmp_task_t returned by the previous call (if any).
1962 /// 3. Copy a pointer to destructions function to field destructions of the
1963 /// resulting structure kmp_task_t.
1964 /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
1965 /// kmp_task_t *new_task), where new_task is a resulting structure from
1966 /// previous items.
1967 /// \param D Current task directive.
1968 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
1969 /// /*part_id*/, captured_struct */*__context*/);
1970 /// \param SharedsTy A type which contains references the shared variables.
1971 /// \param Shareds Context with the list of shared variables from the \p
1972 /// TaskFunction.
1973 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
1974 /// otherwise.
1975 /// \param Data Additional data for task generation like tiednsee, final
1976 /// state, list of privates etc.
1978 const OMPExecutableDirective &D,
1979 llvm::Function *TaskFunction, QualType SharedsTy,
1980 Address Shareds, const Expr *IfCond,
1981 const OMPTaskDataTy &Data) override;
1982
1983 /// Emit task region for the taskloop directive. The taskloop region is
1984 /// emitted in several steps:
1985 /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
1986 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
1987 /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
1988 /// function:
1989 /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
1990 /// TaskFunction(gtid, tt->part_id, tt->shareds);
1991 /// return 0;
1992 /// }
1993 /// 2. Copy a list of shared variables to field shareds of the resulting
1994 /// structure kmp_task_t returned by the previous call (if any).
1995 /// 3. Copy a pointer to destructions function to field destructions of the
1996 /// resulting structure kmp_task_t.
1997 /// 4. Emit a call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t
1998 /// *task, int if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int
1999 /// nogroup, int sched, kmp_uint64 grainsize, void *task_dup ), where new_task
2000 /// is a resulting structure from
2001 /// previous items.
2002 /// \param D Current task directive.
2003 /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
2004 /// /*part_id*/, captured_struct */*__context*/);
2005 /// \param SharedsTy A type which contains references the shared variables.
2006 /// \param Shareds Context with the list of shared variables from the \p
2007 /// TaskFunction.
2008 /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr
2009 /// otherwise.
2010 /// \param Data Additional data for task generation like tiednsee, final
2011 /// state, list of privates etc.
2013 const OMPLoopDirective &D, llvm::Function *TaskFunction,
2014 QualType SharedsTy, Address Shareds, const Expr *IfCond,
2015 const OMPTaskDataTy &Data) override;
2016
2017 /// Emit a code for reduction clause. Next code should be emitted for
2018 /// reduction:
2019 /// \code
2020 ///
2021 /// static kmp_critical_name lock = { 0 };
2022 ///
2023 /// void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
2024 /// ...
2025 /// *(Type<i>*)lhs[i] = RedOp<i>(*(Type<i>*)lhs[i], *(Type<i>*)rhs[i]);
2026 /// ...
2027 /// }
2028 ///
2029 /// ...
2030 /// void *RedList[<n>] = {&<RHSExprs>[0], ..., &<RHSExprs>[<n>-1]};
2031 /// switch (__kmpc_reduce{_nowait}(<loc>, <gtid>, <n>, sizeof(RedList),
2032 /// RedList, reduce_func, &<lock>)) {
2033 /// case 1:
2034 /// ...
2035 /// <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]);
2036 /// ...
2037 /// __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
2038 /// break;
2039 /// case 2:
2040 /// ...
2041 /// Atomic(<LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]));
2042 /// ...
2043 /// break;
2044 /// default:;
2045 /// }
2046 /// \endcode
2047 ///
2048 /// \param Privates List of private copies for original reduction arguments.
2049 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
2050 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
2051 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
2052 /// or 'operator binop(LHS, RHS)'.
2053 /// \param Options List of options for reduction codegen:
2054 /// WithNowait true if parent directive has also nowait clause, false
2055 /// otherwise.
2056 /// SimpleReduction Emit reduction operation only. Used for omp simd
2057 /// directive on the host.
2058 /// ReductionKind The kind of reduction to perform.
2060 ArrayRef<const Expr *> Privates,
2061 ArrayRef<const Expr *> LHSExprs,
2062 ArrayRef<const Expr *> RHSExprs,
2063 ArrayRef<const Expr *> ReductionOps,
2064 ReductionOptionsTy Options) override;
2065
2066 /// Emit a code for initialization of task reduction clause. Next code
2067 /// should be emitted for reduction:
2068 /// \code
2069 ///
2070 /// _taskred_item_t red_data[n];
2071 /// ...
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>;
2079 /// ...
2080 /// void* tg1 = __kmpc_taskred_init(gtid, n, red_data);
2081 /// \endcode
2082 /// For reduction clause with task modifier it emits the next call:
2083 /// \code
2084 ///
2085 /// _taskred_item_t red_data[n];
2086 /// ...
2087 /// red_data[i].shar = &shareds[i];
2088 /// red_data[i].orig = &origs[i];
2089 /// red_data[i].size = sizeof(origs[i]);
2090 /// red_data[i].f_init = (void*)RedInit<i>;
2091 /// red_data[i].f_fini = (void*)RedDest<i>;
2092 /// red_data[i].f_comb = (void*)RedOp<i>;
2093 /// red_data[i].flags = <Flag_i>;
2094 /// ...
2095 /// void* tg1 = __kmpc_taskred_modifier_init(loc, gtid, is_worksharing, n,
2096 /// red_data);
2097 /// \endcode
2098 /// \param LHSExprs List of LHS in \a Data.ReductionOps reduction operations.
2099 /// \param RHSExprs List of RHS in \a Data.ReductionOps reduction operations.
2100 /// \param Data Additional data for task generation like tiedness, final
2101 /// state, list of privates, reductions etc.
2103 ArrayRef<const Expr *> LHSExprs,
2104 ArrayRef<const Expr *> RHSExprs,
2105 const OMPTaskDataTy &Data) override;
2106
2107 /// Emits the following code for reduction clause with task modifier:
2108 /// \code
2109 /// __kmpc_task_reduction_modifier_fini(loc, gtid, is_worksharing);
2110 /// \endcode
2112 bool IsWorksharingReduction) override;
2113
2114 /// Required to resolve existing problems in the runtime. Emits threadprivate
2115 /// variables to store the size of the VLAs/array sections for
2116 /// initializer/combiner/finalizer functions + emits threadprivate variable to
2117 /// store the pointer to the original reduction item for the custom
2118 /// initializer defined by declare reduction construct.
2119 /// \param RCG Allows to reuse an existing data for the reductions.
2120 /// \param N Reduction item for which fixups must be emitted.
2122 ReductionCodeGen &RCG, unsigned N) override;
2123
2124 /// Get the address of `void *` type of the privatue copy of the reduction
2125 /// item specified by the \p SharedLVal.
2126 /// \param ReductionsPtr Pointer to the reduction data returned by the
2127 /// emitTaskReductionInit function.
2128 /// \param SharedLVal Address of the original reduction item.
2130 llvm::Value *ReductionsPtr,
2131 LValue SharedLVal) override;
2132
2133 /// Emit code for 'taskwait' directive.
2135 const OMPTaskDataTy &Data) override;
2136
2137 /// Emit code for 'cancellation point' construct.
2138 /// \param CancelRegion Region kind for which the cancellation point must be
2139 /// emitted.
2140 ///
2142 OpenMPDirectiveKind CancelRegion) override;
2143
2144 /// Emit code for 'cancel' construct.
2145 /// \param IfCond Condition in the associated 'if' clause, if it was
2146 /// specified, nullptr otherwise.
2147 /// \param CancelRegion Region kind for which the cancel must be emitted.
2148 ///
2150 const Expr *IfCond,
2151 OpenMPDirectiveKind CancelRegion) override;
2152
2153 /// Emit outilined function for 'target' directive.
2154 /// \param D Directive to emit.
2155 /// \param ParentName Name of the function that encloses the target region.
2156 /// \param OutlinedFn Outlined function value to be defined by this call.
2157 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
2158 /// \param IsOffloadEntry True if the outlined function is an offload entry.
2159 /// \param CodeGen Code generation sequence for the \a D directive.
2160 /// An outlined function may not be an entry if, e.g. the if clause always
2161 /// evaluates to false.
2163 StringRef ParentName,
2164 llvm::Function *&OutlinedFn,
2165 llvm::Constant *&OutlinedFnID,
2166 bool IsOffloadEntry,
2167 const RegionCodeGenTy &CodeGen) override;
2168
2169 /// Emit the target offloading code associated with \a D. The emitted
2170 /// code attempts offloading the execution to the device, an the event of
2171 /// a failure it executes the host version outlined in \a OutlinedFn.
2172 /// \param D Directive to emit.
2173 /// \param OutlinedFn Host version of the code to be offloaded.
2174 /// \param OutlinedFnID ID of host version of the code to be offloaded.
2175 /// \param IfCond Expression evaluated in if clause associated with the target
2176 /// directive, or null if no if clause is used.
2177 /// \param Device Expression evaluated in device clause associated with the
2178 /// target directive, or null if no device clause is used and device modifier.
2179 void emitTargetCall(
2181 llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
2182 llvm::PointerIntPair<const Expr *, 2, OpenMPDeviceClauseModifier> Device,
2183 llvm::function_ref<llvm::Value *(CodeGenFunction &CGF,
2184 const OMPLoopDirective &D)>
2185 SizeEmitter) override;
2186
2187 /// Emit the target regions enclosed in \a GD function definition or
2188 /// the function itself in case it is a valid device function. Returns true if
2189 /// \a GD was dealt with successfully.
2190 /// \param GD Function to scan.
2191 bool emitTargetFunctions(GlobalDecl GD) override;
2192
2193 /// Emit the global variable if it is a valid device global variable.
2194 /// Returns true if \a GD was dealt with successfully.
2195 /// \param GD Variable declaration to emit.
2196 bool emitTargetGlobalVariable(GlobalDecl GD) override;
2197
2198 /// Emit the global \a GD if it is meaningful for the target. Returns
2199 /// if it was emitted successfully.
2200 /// \param GD Global to scan.
2201 bool emitTargetGlobal(GlobalDecl GD) override;
2202
2203 /// Emits code for teams call of the \a OutlinedFn with
2204 /// variables captured in a record which address is stored in \a
2205 /// CapturedStruct.
2206 /// \param OutlinedFn Outlined function to be run by team masters. Type of
2207 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
2208 /// \param CapturedVars A pointer to the record with the references to
2209 /// variables used in \a OutlinedFn function.
2210 ///
2212 SourceLocation Loc, llvm::Function *OutlinedFn,
2213 ArrayRef<llvm::Value *> CapturedVars) override;
2214
2215 /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32
2216 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code
2217 /// for num_teams clause.
2218 /// \param NumTeams An integer expression of teams.
2219 /// \param ThreadLimit An integer expression of threads.
2220 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
2221 const Expr *ThreadLimit, SourceLocation Loc) override;
2222
2223 /// Emit the target data mapping code associated with \a D.
2224 /// \param D Directive to emit.
2225 /// \param IfCond Expression evaluated in if clause associated with the
2226 /// target directive, or null if no device clause is used.
2227 /// \param Device Expression evaluated in device clause associated with the
2228 /// target directive, or null if no device clause is used.
2229 /// \param Info A record used to store information that needs to be preserved
2230 /// until the region is closed.
2232 const OMPExecutableDirective &D, const Expr *IfCond,
2233 const Expr *Device, const RegionCodeGenTy &CodeGen,
2234 CGOpenMPRuntime::TargetDataInfo &Info) override;
2235
2236 /// Emit the data mapping/movement code associated with the directive
2237 /// \a D that should be of the form 'target [{enter|exit} data | update]'.
2238 /// \param D Directive to emit.
2239 /// \param IfCond Expression evaluated in if clause associated with the target
2240 /// directive, or null if no if clause is used.
2241 /// \param Device Expression evaluated in device clause associated with the
2242 /// target directive, or null if no device clause is used.
2244 const OMPExecutableDirective &D,
2245 const Expr *IfCond,
2246 const Expr *Device) override;
2247
2248 /// Emit initialization for doacross loop nesting support.
2249 /// \param D Loop-based construct used in doacross nesting construct.
2251 ArrayRef<Expr *> NumIterations) override;
2252
2253 /// Emit code for doacross ordered directive with 'depend' clause.
2254 /// \param C 'depend' clause with 'sink|source' dependency kind.
2256 const OMPDependClause *C) override;
2257
2258 /// Emit code for doacross ordered directive with 'doacross' clause.
2259 /// \param C 'doacross' clause with 'sink|source' dependence type.
2261 const OMPDoacrossClause *C) override;
2262
2263 /// Translates the native parameter of outlined function if this is required
2264 /// for target.
2265 /// \param FD Field decl from captured record for the parameter.
2266 /// \param NativeParam Parameter itself.
2267 const VarDecl *translateParameter(const FieldDecl *FD,
2268 const VarDecl *NativeParam) const override;
2269
2270 /// Gets the address of the native argument basing on the address of the
2271 /// target-specific parameter.
2272 /// \param NativeParam Parameter itself.
2273 /// \param TargetParam Corresponding target-specific parameter.
2274 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2275 const VarDecl *TargetParam) const override;
2276
2277 /// Gets the OpenMP-specific address of the local variable.
2279 const VarDecl *VD) override {
2280 return Address::invalid();
2281 }
2282};
2283
2284} // namespace CodeGen
2285// Utility for openmp doacross clause kind
2286namespace {
2287template <typename T> class OMPDoacrossKind {
2288public:
2289 bool isSink(const T *) { return false; }
2290 bool isSource(const T *) { return false; }
2291};
2292template <> class OMPDoacrossKind<OMPDependClause> {
2293public:
2294 bool isSink(const OMPDependClause *C) {
2295 return C->getDependencyKind() == OMPC_DEPEND_sink;
2296 }
2297 bool isSource(const OMPDependClause *C) {
2298 return C->getDependencyKind() == OMPC_DEPEND_source;
2299 }
2300};
2301template <> class OMPDoacrossKind<OMPDoacrossClause> {
2302public:
2303 bool isSource(const OMPDoacrossClause *C) {
2304 return C->getDependenceType() == OMPC_DOACROSS_source ||
2305 C->getDependenceType() == OMPC_DOACROSS_source_omp_cur_iteration;
2306 }
2307 bool isSink(const OMPDoacrossClause *C) {
2308 return C->getDependenceType() == OMPC_DOACROSS_sink ||
2309 C->getDependenceType() == OMPC_DOACROSS_sink_omp_cur_iteration;
2310 }
2311};
2312} // namespace
2313} // namespace clang
2314
2315#endif
MatchType Type
This file defines OpenMP nodes for declarative directives.
Defines some OpenMP-specific enums and functions.
Defines the clang::SourceLocation class and associated facilities.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
A wrapper class around a pointer that always points to its canonical declaration.
Definition: Redeclarable.h:349
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
An aligned address.
Definition: Address.h:29
static Address invalid()
Definition: Address.h:46
Allows to disable automatic handling of functions used in target regions as those marked as omp decla...
Manages list of lastprivate conditional decls for the specified directive.
static LastprivateConditionalRAII disable(CodeGenFunction &CGF, const OMPExecutableDirective &S)
Manages list of nontemporal decls for the specified directive.
Struct that keeps all the relevant information that should be kept throughout a 'target data' region.
llvm::DenseMap< const ValueDecl *, llvm::Value * > CaptureDeviceAddrMap
Map between the a declaration of a capture and the corresponding new llvm address where the runtime r...
TargetDataInfo(bool RequiresDevicePointerInfo, bool SeparateBeginEndCalls)
Manages list of nontemporal decls for the specified directive.
virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc)
Emits address of the word in a memory where current thread id is stored.
llvm::FunctionType * Kmpc_MicroTy
The type for a microtask which gets passed to __kmpc_fork_call().
llvm::StringSet ThreadPrivateWithDefinition
Set of threadprivate variables with the generated initializer.
virtual void getKmpcFreeShared(CodeGenFunction &CGF, const std::pair< llvm::Value *, llvm::Value * > &AddrSizePair)
Get call to __kmpc_free_shared.
virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the task directive.
void createOffloadEntriesAndInfoMetadata()
Creates all the offload entries in the current compilation unit along with the associated metadata.
const Expr * getNumTeamsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &MinTeamsVal, int32_t &MaxTeamsVal)
Emit the number of teams for a target directive.
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST)
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
bool markAsGlobalTarget(GlobalDecl GD)
Marks the declaration as already emitted for the device code and returns true, if it was marked alrea...
virtual void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device)
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
virtual void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc)
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
QualType SavedKmpTaskloopTQTy
Saved kmp_task_t for taskloop-based directive.
virtual void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps)
Emits a single region.
virtual bool emitTargetGlobal(GlobalDecl GD)
Emit the global GD if it is meaningful for the target.
void setLocThreadIdInsertPt(CodeGenFunction &CGF, bool AtCurrentPoint=false)
std::string getOutlinedHelperName(StringRef Name) const
Get the function name of an outlined region.
bool HasEmittedDeclareTargetRegion
Flag for keeping track of weather a device routine has been emitted.
llvm::Constant * getOrCreateThreadPrivateCache(const VarDecl *VD)
If the specified mangled name is not in the module, create and return threadprivate cache object.
virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal)
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
virtual void getDefaultScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPScheduleClauseKind &ScheduleKind, const Expr *&ChunkExpr) const
Choose default schedule type and chunk value for the schedule clause.
virtual std::pair< llvm::Function *, llvm::Function * > getUserDefinedReduction(const OMPDeclareReductionDecl *D)
Get combiner/initializer for the specified user-defined reduction, if any.
virtual bool isGPU() const
Returns true if the current target is a GPU.
static const Stmt * getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body)
Checks if the Body is the CompoundStmt and returns its child statement iff there is only one that is ...
virtual void emitDeclareTargetFunction(const FunctionDecl *FD, llvm::GlobalValue *GV)
Emit code for handling declare target functions in the runtime.
llvm::Type * getKmpc_MicroPointerTy()
Returns pointer to kmpc_micro type.
bool HasRequiresUnifiedSharedMemory
Flag for keeping track of weather a requires unified_shared_memory directive is present.
llvm::Value * emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags=0, bool EmitLoc=false)
Emits object of ident_t type with info for source location.
bool isLocalVarInUntiedTask(CodeGenFunction &CGF, const VarDecl *VD) const
Returns true if the variable is a local variable in untied task.
virtual void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars)
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
virtual void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancellation point' construct.
void emitUDMapperArrayInitOrDel(CodeGenFunction &MapperCGF, llvm::Value *Handle, llvm::Value *BasePtr, llvm::Value *Ptr, llvm::Value *Size, llvm::Value *MapType, llvm::Value *MapName, CharUnits ElementSize, llvm::BasicBlock *ExitBB, bool IsInit)
Emit the array initialization or deletion portion for user-defined mapper code generation.
virtual const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const
Translates the native parameter of outlined function if this is required for target.
virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
llvm::DenseMap< llvm::Function *, SmallVector< const OMPDeclareReductionDecl *, 4 > > FunctionUDRMapTy
Map of functions and locally defined UDRs.
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
virtual bool isDefaultLocationConstant() const
Check if the default location must be constant.
llvm::MapVector< CanonicalDeclPtr< const VarDecl >, std::pair< Address, Address > > UntiedLocalVarsAddressesMap
llvm::Function * getOrCreateUserDefinedMapperFunc(const OMPDeclareMapperDecl *D)
Get the function for the specified user-defined mapper.
OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap
virtual void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
void emitCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args=std::nullopt) const
Emits Callee function call with arguments Args with location Loc.
virtual llvm::Function * emitTeamsOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP teams directive D.
llvm::DenseMap< llvm::Function *, DebugLocThreadIdTy > OpenMPLocThreadIDMapTy
Map of local debug location, ThreadId and functions.
QualType KmpTaskTQTy
Type typedef struct kmp_task { void * shareds; /‍**< pointer to block of pointers to shared vars ‍/ k...
llvm::OpenMPIRBuilder OMPBuilder
An OpenMP-IR-Builder instance.
virtual void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations)
Emit initialization for doacross loop nesting support.
virtual void adjustTargetSpecificDataForLambdas(CodeGenFunction &CGF, const OMPExecutableDirective &D) const
Adjust some parameters for the target-based directives, like addresses of the variables captured by r...
virtual void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, CGOpenMPRuntime::TargetDataInfo &Info)
Emit the target data mapping code associated with D.
virtual unsigned getDefaultLocationReserved2Flags() const
Returns additional flags that can be stored in reserved_2 field of the default location.
void computeMinAndMaxThreadsAndTeams(const OMPExecutableDirective &D, CodeGenFunction &CGF, int32_t &MinThreadsVal, int32_t &MaxThreadsVal, int32_t &MinTeamsVal, int32_t &MaxTeamsVal)
Helper to determine the min/max number of threads/teams for D.
virtual Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const
Gets the address of the native argument basing on the address of the target-specific parameter.
void emitUsesAllocatorsFini(CodeGenFunction &CGF, const Expr *Allocator)
Destroys user defined allocators specified in the uses_allocators clause.
QualType KmpTaskAffinityInfoTy
Type typedef struct kmp_task_affinity_info { kmp_intptr_t base_addr; size_t len; struct { bool flag1 ...
llvm::SmallVector< NontemporalDeclsSet, 4 > NontemporalDeclsStack
Stack for list of declarations in current context marked as nontemporal.
llvm::Value * emitNumTeamsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
virtual void emitTargetOutlinedFunctionHelper(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Helper to emit outlined function for 'target' directive.
void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName)
Start scanning from statement S and emit all target regions found along the way.
SmallVector< llvm::Value *, 4 > emitDepobjElementsSizes(CodeGenFunction &CGF, QualType &KmpDependInfoTy, const OMPTaskDataTy::DependData &Data)
virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc)
Emit a taskgroup region.
llvm::DenseMap< llvm::Function *, SmallVector< const OMPDeclareMapperDecl *, 4 > > FunctionUDMMapTy
Map of functions and their local user-defined mappers.
llvm::DenseMap< llvm::Function *, llvm::DenseMap< CanonicalDeclPtr< const Decl >, std::tuple< QualType, const FieldDecl *, const FieldDecl *, LValue > > > LastprivateConditionalToTypes
Maps local variables marked as lastprivate conditional to their internal types.
virtual bool emitTargetGlobalVariable(GlobalDecl GD)
Emit the global variable if it is a valid device global variable.
virtual void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc)
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams,...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name)
Creates artificial threadprivate variable with name Name and type VarType.
void emitUserDefinedMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit the function for the user defined mapper construct.
llvm::DenseMap< SourceLocation, llvm::Value * > OpenMPDebugLocMapTy
Map for SourceLocation and OpenMP runtime library debug locations.
bool HasEmittedTargetRegion
Flag for keeping track of weather a target region has been emitted.
void emitDepobjElements(CodeGenFunction &CGF, QualType &KmpDependInfoTy, LValue PosLVal, const OMPTaskDataTy::DependData &Data, Address DependenciesArray)
std::string getReductionFuncName(StringRef Name) const
Get the function name of a reduction function.
virtual void processRequiresDirective(const OMPRequiresDecl *D)
Perform check on requires decl to ensure that target architecture supports unified addressing.
llvm::DenseSet< CanonicalDeclPtr< const Decl > > AlreadyEmittedTargetDecls
List of the emitted declarations.
virtual llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data)
Emit a code for initialization of task reduction clause.
llvm::Value * getThreadID(CodeGenFunction &CGF, SourceLocation Loc)
Gets thread id value for the current thread.
void emitUpdateClause(CodeGenFunction &CGF, LValue DepobjLVal, OpenMPDependClauseKind NewDepKind, SourceLocation Loc)
Updates the dependency kind in the specified depobj object.
virtual void emitLastprivateConditionalFinalUpdate(CodeGenFunction &CGF, LValue PrivLVal, const VarDecl *VD, SourceLocation Loc)
Gets the address of the global copy used for lastprivate conditional update, if any.
virtual void emitErrorCall(CodeGenFunction &CGF, SourceLocation Loc, Expr *ME, bool IsFatal)
Emit __kmpc_error call for error directive extern void __kmpc_error(ident_t *loc, int severity,...
void clearLocThreadIdInsertPt(CodeGenFunction &CGF)
virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc)
Emits code for a taskyield directive.
virtual std::pair< llvm::Value *, llvm::Value * > getKmpcAllocShared(CodeGenFunction &CGF, const VarDecl *VD)
Get call to __kmpc_alloc_shared.
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
virtual void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO)
Emit flush of the variables specified in 'omp flush' directive.
virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data)
Emit code for 'taskwait' directive.
virtual void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc)
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
void emitLastprivateConditionalUpdate(CodeGenFunction &CGF, LValue IVLVal, StringRef UniqueDeclName, LValue LVal, SourceLocation Loc)
Emit update for lastprivate conditional data.
virtual void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data)
Emit task region for the taskloop directive.
virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false)
Emit an implicit/explicit barrier for OpenMP threads.
static unsigned getDefaultFlagsForBarriers(OpenMPDirectiveKind Kind)
Returns default flags for the barriers depending on the directive, for which this barier is going to ...
virtual bool isDelayedVariableLengthDecl(CodeGenFunction &CGF, const VarDecl *VD) const
Check if the variable length declaration is delayed:
virtual bool emitTargetFunctions(GlobalDecl GD)
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const OMPTaskDataTy &Data)
Emit task region for the task directive.
llvm::Value * emitTargetNumIterationsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter)
Return the trip count of loops associated with constructs / 'target teams distribute' and 'teams dist...
llvm::StringMap< llvm::AssertingVH< llvm::GlobalVariable >, llvm::BumpPtrAllocator > InternalVars
An ordered map of auto-generated variables to their unique names.
virtual void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values)
llvm::SmallVector< UntiedLocalVarsAddressesMap, 4 > UntiedLocalVarsStack
virtual void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind)
Call the appropriate runtime routine to notify that we finished all the work with current loop.
virtual void emitThreadLimitClause(CodeGenFunction &CGF, const Expr *ThreadLimit, SourceLocation Loc)
Emits call to void __kmpc_set_thread_limit(ident_t *loc, kmp_int32 global_tid, kmp_int32 thread_limit...
void emitIfClause(CodeGenFunction &CGF, const Expr *Cond, const RegionCodeGenTy &ThenGen, const RegionCodeGenTy &ElseGen)
Emits code for OpenMP 'if' clause using specified CodeGen function.
Address emitDepobjDependClause(CodeGenFunction &CGF, const OMPTaskDataTy::DependData &Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs) for depob...
bool isNontemporalDecl(const ValueDecl *VD) const
Checks if the VD variable is marked as nontemporal declaration in current context.
virtual llvm::Function * emitParallelOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen)
Emits outlined function for the specified OpenMP parallel directive D.
const Expr * getNumThreadsExprForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &UpperBound, bool UpperBoundOnly, llvm::Value **CondExpr=nullptr, const Expr **ThreadLimitExpr=nullptr)
Check for a number of threads upper bound constant value (stored in UpperBound), or expression (retur...
llvm::SmallVector< LastprivateConditionalData, 4 > LastprivateConditionalStack
Stack for list of addresses of declarations in current context marked as lastprivate conditional.
virtual void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values)
Call the appropriate runtime routine to initialize it before start of loop.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
llvm::AtomicOrdering getDefaultMemoryOrdering() const
Gets default memory ordering as specified in requires directive.
llvm::SmallDenseSet< CanonicalDeclPtr< const Decl > > NontemporalDeclsSet
llvm::StringSet DeclareTargetWithDefinition
Set of declare target variables with the generated initializer.
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static non-chunked.
llvm::Value * getCriticalRegionLock(StringRef CriticalName)
Returns corresponding lock object for the specified critical region name.
virtual void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion)
Emit code for 'cancel' construct.
QualType SavedKmpTaskTQTy
Saved kmp_task_t for task directive.
virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc)
Emits a master region.
virtual llvm::Function * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts)
Emits outlined function for the OpenMP task directive D.
OpenMPDebugLocMapTy OpenMPDebugLocMap
llvm::DenseMap< llvm::Function *, unsigned > FunctionToUntiedTaskStackMap
Maps function to the position of the untied task locals stack.
void emitDestroyClause(CodeGenFunction &CGF, LValue DepobjLVal, SourceLocation Loc)
Emits the code to destroy the dependency object provided in depobj directive.
virtual void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N)
Required to resolve existing problems in the runtime.
llvm::ArrayType * KmpCriticalNameTy
Type kmp_critical_name, originally defined as typedef kmp_int32 kmp_critical_name[8];.
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C)
Emit code for doacross ordered directive with 'depend' clause.
llvm::DenseMap< const OMPDeclareMapperDecl *, llvm::Function * > UDMMap
Map from the user-defined mapper declaration to its corresponding functions.
virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF, const Expr *LHS)
Checks if the provided LVal is lastprivate conditional and emits the code to update the value of the ...
std::pair< llvm::Value *, LValue > getDepobjElements(CodeGenFunction &CGF, LValue DepobjLVal, SourceLocation Loc)
Returns the number of the elements and the address of the depobj dependency array.
llvm::SmallDenseSet< const VarDecl * > DeferredGlobalVariables
List of variables that can become declare target implicitly and, thus, must be emitted.
void emitUsesAllocatorsInit(CodeGenFunction &CGF, const Expr *Allocator, const Expr *AllocatorTraits)
Initializes user defined allocators specified in the uses_allocators clauses.
virtual void getDefaultDistScheduleAndChunk(CodeGenFunction &CGF, const OMPLoopDirective &S, OpenMPDistScheduleClauseKind &ScheduleKind, llvm::Value *&Chunk) const
Choose default schedule type and chunk value for the dist_schedule clause.
llvm::DenseMap< const OMPDeclareReductionDecl *, std::pair< llvm::Function *, llvm::Function * > > UDRMapTy
Map of UDRs and corresponding combiner/initializer.
llvm::Type * KmpRoutineEntryPtrTy
Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);.
llvm::Type * getIdentTyPointerTy()
Returns pointer to ident_t type.
void emitSingleReductionCombiner(CodeGenFunction &CGF, const Expr *ReductionOp, const Expr *PrivateRef, const DeclRefExpr *LHS, const DeclRefExpr *RHS)
Emits single reduction combiner.
llvm::OpenMPIRBuilder & getOMPBuilder()
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for 'target' directive.
virtual void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr)
Emits a critical region.
virtual void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned)
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
llvm::Value * emitNumThreadsForTargetDirective(CodeGenFunction &CGF, const OMPExecutableDirective &D)
Emit an expression that denotes the number of threads a target region shall use.
void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr, llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc)
Emits initialization code for the threadprivate variables.
virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)
Emit code for the specified user defined reduction construct.
virtual void checkAndEmitSharedLastprivateConditional(CodeGenFunction &CGF, const OMPExecutableDirective &D, const llvm::DenseSet< CanonicalDeclPtr< const VarDecl > > &IgnoredDecls)
Checks if the lastprivate conditional was updated in inner region and writes the value.
QualType KmpDimTy
struct kmp_dim { // loop bounds info casted to kmp_int64 kmp_int64 lo; // lower kmp_int64 up; // uppe...
virtual void emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool HasCancel=false)
Emit code for the directive that does not require outlining.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D)
Emits OpenMP-specific function prolog.
virtual void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads)
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
void emitKmpRoutineEntryT(QualType KmpInt32Ty)
Build type kmp_routine_entry_t (if not built yet).
virtual bool isStaticChunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const
Check if the specified ScheduleKind is static chunked.
virtual void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter)
Emit the target offloading code associated with D.
virtual bool hasAllocateAttributeForGlobalVar(const VarDecl *VD, LangAS &AS)
Checks if the variable has associated OMPAllocateDeclAttr attribute with the predefined allocator and...
llvm::AtomicOrdering RequiresAtomicOrdering
Atomic ordering from the omp requires directive.
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options)
Emit a code for reduction clause.
std::pair< llvm::Value *, Address > emitDependClause(CodeGenFunction &CGF, ArrayRef< OMPTaskDataTy::DependData > Dependencies, SourceLocation Loc)
Emits list of dependecies based on the provided data (array of dependence/expression pairs).
llvm::StringMap< llvm::WeakTrackingVH > EmittedNonTargetVariables
List of the global variables with their addresses that should not be emitted for the target.
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
Address emitLastprivateConditionalInit(CodeGenFunction &CGF, const VarDecl *VD)
Create specialized alloca to handle lastprivate conditionals.
llvm::ArrayType * getKmpCriticalNameTy() const
Get the LLVM type for the critical name.
virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads)
Emit an ordered region.
virtual void emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::FunctionCallee OutlinedFn, ArrayRef< llvm::Value * > Args=std::nullopt) const
Emits call of the outlined function with the provided arguments, translating these arguments to corre...
virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)
Gets the OpenMP-specific address of the local variable.
virtual void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction)
Emits the following code for reduction clause with task modifier:
virtual void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr)
Emits a masked region.
QualType KmpDependInfoTy
Type typedef struct kmp_depend_info { kmp_intptr_t base_addr; size_t len; struct { bool in:1; bool ou...
llvm::Function * emitReductionFunction(StringRef ReducerName, SourceLocation Loc, llvm::Type *ArgsElemType, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps)
Emits reduction function.
virtual void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues)
Call the appropriate runtime routine to initialize it before start of loop.
Class supports emissionof SIMD-only code.
Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *ReductionsPtr, LValue SharedLVal) override
Get the address of void * type of the privatue copy of the reduction item specified by the SharedLVal...
void emitCriticalRegion(CodeGenFunction &CGF, StringRef CriticalName, const RegionCodeGenTy &CriticalOpGen, SourceLocation Loc, const Expr *Hint=nullptr) override
Emits a critical region.
void emitDistributeStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values) override
void emitForStaticInit(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind, const OpenMPScheduleTy &ScheduleKind, const StaticRTInput &Values) override
Call the appropriate runtime routine to initialize it before start of loop.
bool emitTargetGlobalVariable(GlobalDecl GD) override
Emit the global variable if it is a valid device global variable.
llvm::Value * emitForNext(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST) override
Call __kmpc_dispatch_next( ident_t *loc, kmp_int32 tid, kmp_int32 *p_lastiter, kmp_int[32|64] *p_lowe...
llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr) override
Emit a code for initialization of threadprivate variable.
void emitTargetDataStandAloneCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device) override
Emit the data mapping/movement code associated with the directive D that should be of the form 'targe...
llvm::Function * emitTeamsOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP teams directive D.
void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options) override
Emit a code for reduction clause.
void emitFlush(CodeGenFunction &CGF, ArrayRef< const Expr * > Vars, SourceLocation Loc, llvm::AtomicOrdering AO) override
Emit flush of the variables specified in 'omp flush' directive.
void emitDoacrossOrdered(CodeGenFunction &CGF, const OMPDependClause *C) override
Emit code for doacross ordered directive with 'depend' clause.
void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override
Emits a masked region.
Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF, QualType VarType, StringRef Name) override
Creates artificial threadprivate variable with name Name and type VarType.
Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc) override
Returns address of the threadprivate variable for the current thread.
void emitSingleRegion(CodeGenFunction &CGF, const RegionCodeGenTy &SingleOpGen, SourceLocation Loc, ArrayRef< const Expr * > CopyprivateVars, ArrayRef< const Expr * > DestExprs, ArrayRef< const Expr * > SrcExprs, ArrayRef< const Expr * > AssignmentOps) override
Emits a single region.
void emitTaskReductionFixups(CodeGenFunction &CGF, SourceLocation Loc, ReductionCodeGen &RCG, unsigned N) override
Required to resolve existing problems in the runtime.
llvm::Function * emitParallelOutlinedFunction(CodeGenFunction &CGF, const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits outlined function for the specified OpenMP parallel directive D.
void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancellation point' construct.
void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind Kind, bool EmitChecks=true, bool ForceSimpleCall=false) override
Emit an implicit/explicit barrier for OpenMP threads.
Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD) override
Gets the OpenMP-specific address of the local variable.
Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const override
Gets the address of the native argument basing on the address of the target-specific parameter.
void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars) override
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...
void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned) override
Call the appropriate runtime routine to notify that we finished iteration of the ordered loop with th...
bool emitTargetGlobal(GlobalDecl GD) override
Emit the global GD if it is meaningful for the target.
void emitTaskReductionFini(CodeGenFunction &CGF, SourceLocation Loc, bool IsWorksharingReduction) override
Emits the following code for reduction clause with task modifier:
void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads) override
Emit an ordered region.
void emitForStaticFinish(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind DKind) override
Call the appropriate runtime routine to notify that we finished all the work with current loop.
llvm::Value * emitTaskReductionInit(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, const OMPTaskDataTy &Data) override
Emit a code for initialization of task reduction clause.
void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond, llvm::Value *NumThreads) override
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
void emitProcBindClause(CodeGenFunction &CGF, llvm::omp::ProcBindKind ProcBind, SourceLocation Loc) override
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) override
Emit outilined function for 'target' directive.
void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc) override
Emits a master region.
void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override
Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_teams,...
const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const override
Translates the native parameter of outlined function if this is required for target.
void emitMaskedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MaskedOpGen, SourceLocation Loc, const Expr *Filter=nullptr) override
Emits a masked region.
void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the task directive.
void emitTargetCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, llvm::PointerIntPair< const Expr *, 2, OpenMPDeviceClauseModifier > Device, llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, const OMPLoopDirective &D)> SizeEmitter) override
Emit the target offloading code associated with D.
bool emitTargetFunctions(GlobalDecl GD) override
Emit the target regions enclosed in GD function definition or the function itself in case it is a val...
void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc) override
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
void emitDoacrossInit(CodeGenFunction &CGF, const OMPLoopDirective &D, ArrayRef< Expr * > NumIterations) override
Emit initialization for doacross loop nesting support.
void emitCancelCall(CodeGenFunction &CGF, SourceLocation Loc, const Expr *IfCond, OpenMPDirectiveKind CancelRegion) override
Emit code for 'cancel' construct.
void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data) override
Emit code for 'taskwait' directive.
void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc) override
Emit a taskgroup region.
void emitTargetDataCalls(CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond, const Expr *Device, const RegionCodeGenTy &CodeGen, CGOpenMPRuntime::TargetDataInfo &Info) override
Emit the target data mapping code associated with D.
void emitForDispatchInit(CodeGenFunction &CGF, SourceLocation Loc, const OpenMPScheduleTy &ScheduleKind, unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues) override
This is used for non static scheduled types and when the ordered clause is present on the loop constr...
llvm::Function * emitTaskOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, const VarDecl *PartIDVar, const VarDecl *TaskTVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts) override
Emits outlined function for the OpenMP task directive D.
void emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPLoopDirective &D, llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override
Emit task region for the taskloop directive.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
This class organizes the cross-function state that is used while generating LLVM code.
LValue - This represents an lvalue references.
Definition: CGValue.h:171
A basic class for pre|post-action for advanced codegen sequence for OpenMP region.
virtual void Exit(CodeGenFunction &CGF)
virtual void Enter(CodeGenFunction &CGF)
Class intended to support codegen of all kind of the reduction clauses.
LValue getSharedLValue(unsigned N) const
Returns LValue for the reduction item.
const Expr * getRefExpr(unsigned N) const
Returns the base declaration of the reduction item.
LValue getOrigLValue(unsigned N) const
Returns LValue for the original reduction item.
bool needCleanups(unsigned N)
Returns true if the private copy requires cleanups.
void emitAggregateType(CodeGenFunction &CGF, unsigned N)
Emits the code for the variable-modified type, if required.
const VarDecl * getBaseDecl(unsigned N) const
Returns the base declaration of the reduction item.
QualType getPrivateType(unsigned N) const
Return the type of the private item.
bool usesReductionInitializer(unsigned N) const
Returns true if the initialization of the reduction item uses initializer from declare reduction cons...
void emitSharedOrigLValue(CodeGenFunction &CGF, unsigned N)
Emits lvalue for the shared and original reduction item.
void emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr, Address SharedAddr, llvm::function_ref< bool(CodeGenFunction &)> DefaultInit)
Performs initialization of the private copy for the reduction item.
std::pair< llvm::Value *, llvm::Value * > getSizes(unsigned N) const
Returns the size of the reduction item (in chars and total number of elements in the item),...
void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Emits cleanup code for the reduction item.
Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N, Address PrivateAddr)
Adjusts PrivatedAddr for using instead of the original variable address in normal operations.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
RegionCodeGenTy(Callable &&CodeGen, std::enable_if_t<!std::is_same< std::remove_reference_t< Callable >, RegionCodeGenTy >::value > *=nullptr)
void operator()(CodeGenFunction &CGF) const
void setAction(PrePostActionTy &Action) const
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1247
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
This represents one expression.
Definition: Expr.h:110
Represents a member of a struct/union/class.
Definition: Decl.h:3025
Represents a function declaration or definition.
Definition: Decl.h:1959
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:287
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:177
This represents implicit clause 'depend' for the '#pragma omp task' directive.
This represents the 'doacross' clause for the '#pragma omp ordered' directive.
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1018
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:416
A (possibly-)qualified type.
Definition: Type.h:737
Represents a struct/union/class.
Definition: Decl.h:4133
Encodes a location in the source.
Stmt - This represents one statement.
Definition: Stmt.h:84
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:706
Represents a variable declaration or definition.
Definition: Decl.h:918
The JSON file list parser is used to communicate input to InstallAPI.
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Device
'device' clause, allowed on the 'update' construct.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:24
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:103
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
Definition: OpenMPKinds.h:54
@ OMPC_DEPEND_unknown
Definition: OpenMPKinds.h:58
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
Definition: OpenMPKinds.h:30
YAML serialization mapping.
Definition: Dominators.h:30
Definition: Format.h:5292
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type,...
Stores debug location and ThreadID for the function.
llvm::AssertingVH< llvm::Instruction > ServiceInsertPt
Insert point for the service instructions.
struct with the values to be passed to the dispatch runtime function
llvm::Value * Chunk
Chunk size specified using 'schedule' clause (nullptr if chunk was not specified)
DispatchRTInput(llvm::Value *LB, llvm::Value *UB, llvm::Value *Chunk)
Maps the expression for the lastprivate variable to the global copy used to store new value because o...
llvm::MapVector< CanonicalDeclPtr< const Decl >, SmallString< 16 > > DeclToUniqueName
Struct with the values to be passed to the static runtime function.
StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL, Address LB, Address UB, Address ST, llvm::Value *Chunk=nullptr)
bool IVSigned
Sign of the iteration variable.
Address UB
Address of the output variable in which the upper iteration number is returned.
Address IL
Address of the output variable in which the flag of the last iteration is returned.
llvm::Value * Chunk
Value of the chunk for the static_chunked scheduled loop.
unsigned IVSize
Size of the iteration variable in bits.
Address ST
Address of the output variable in which the stride value is returned necessary to generated the stati...
bool Ordered
true if loop is ordered, false otherwise.
Address LB
Address of the output variable in which the lower iteration number is returned.
DependData(OpenMPDependClauseKind DepKind, const Expr *IteratorExpr)
SmallVector< const Expr *, 4 > DepExprs
SmallVector< const Expr *, 4 > FirstprivateVars
SmallVector< CanonicalDeclPtr< const VarDecl >, 4 > PrivateLocals
SmallVector< const Expr *, 4 > LastprivateCopies
SmallVector< const Expr *, 4 > PrivateCopies
SmallVector< const Expr *, 4 > ReductionVars
llvm::PointerIntPair< llvm::Value *, 1, bool > Schedule
SmallVector< const Expr *, 4 > FirstprivateInits
llvm::PointerIntPair< llvm::Value *, 1, bool > Priority
SmallVector< const Expr *, 4 > ReductionOps
SmallVector< DependData, 4 > Dependences
SmallVector< const Expr *, 4 > ReductionCopies
SmallVector< const Expr *, 4 > PrivateVars
llvm::PointerIntPair< llvm::Value *, 1, bool > Final
SmallVector< const Expr *, 4 > FirstprivateCopies
SmallVector< const Expr *, 4 > LastprivateVars
SmallVector< const Expr *, 4 > ReductionOrigs
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:179