This is an archive of the discontinued LLVM Phabricator instance.

Differential D158381

[OpenMP] Properly set static thread limit (w/o analysis)
ClosedPublic

Authored by jdoerfert on Aug 20 2023, 8:03 PM.

Details

Reviewers
ABataev
tianshilei1992
JonChesterfield
ye-luo
jhuber6
josemonsalve2
Commits
rGc5488c8dcc8c: [OpenMP] Properly set static thread limit (w/o analysis)
Summary

We used to have two separate implementations to derive the number of
threads used in a target region. This lead us to sometimes miss out on
user provided thread bounds (num_threads, or thread_limit) when we
looked for "constant default values". If we might miss out on the
presence of those bounds, we cannot set the thread_limit statically
since the runtime will try to honor user input rather than cap it at the
"preferred default". This patch replaces the secondary implementation
with the primary in a mode that will not emit code but just look for the
presence, and potentially upper bounds, of thread limiting clauses.

The runtime test would not pass without this rewrite as we missed some
clauses, set the static limit on the device to the preferred value, but
then violated that value at runtime.

Fixes: https://github.com/llvm/llvm-project/issues/64845

Diff Detail

Event Timeline

jdoerfert created this revision.Aug 20 2023, 8:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 20 2023, 8:03 PM
Herald added subscribers: mattd, asavonic, guansong and 2 others. · View Herald Transcript
jdoerfert requested review of this revision.Aug 20 2023, 8:03 PM
Herald added subscribers: jplehr, sstefan1. · View Herald TranscriptAug 20 2023, 8:03 PM
Harbormaster completed remote builds in B253753: Diff 551882.Aug 20 2023, 8:04 PM
jdoerfert added a child revision: D158382: [OpenMP] Use default grid value for static grid size.Aug 20 2023, 8:06 PM
jhuber6 accepted this revision.Aug 21 2023, 11:49 AM

A few nits. Lots of code but it's mostly just shuffling around stuff that exists. Probably fine given the tests pass.

clang/lib/CodeGen/CGOpenMPRuntime.cpp
6007

Why is this signed but the threads are unsigned now?

6011

The LLVM style uses /*Value=*/ for inline comments https://llvm.org/docs/CodingStandards.html#comment-formatting

6326

Favor C++ style casts?

6329

Should probably be UINT32_MAX

6377

Ditto

This revision is now accepted and ready to land.Aug 21 2023, 11:49 AM
tianshilei1992 added inline comments.Aug 21 2023, 11:56 AM
clang/lib/CodeGen/CGOpenMPRuntime.cpp
6008

to have an unsigned value assigned with -1 is really a bad idea

jhuber6 added inline comments.Aug 21 2023, 11:58 AM
clang/lib/CodeGen/CGOpenMPRuntime.cpp
6008

-1 is well defined for unsigned as 0xffffffff, but it's far clearer to use UINT32_MAX like I suggested.

tianshilei1992 added inline comments.Aug 21 2023, 11:58 AM
clang/lib/CodeGen/CGOpenMPRuntime.cpp
6008

even ~0U is much better

jdoerfert added inline comments.Aug 21 2023, 12:58 PM
clang/lib/CodeGen/CGOpenMPRuntime.cpp
6007

I did not touch the team stuff yet. Same rewrite is necessary there, but not required right now.

6008

I can do ~0U but the point is really that we look for the -1 later on. I don't do arithmetic, just comparisons.

6326

like reinterpret_cast<uint32_t>(...)? sure.

6329

I figured this way it's more obvious.

jdoerfert marked 8 inline comments as done.Aug 22 2023, 1:53 PM
This revision was landed with ongoing or failed builds.Aug 23 2023, 11:13 AM
Closed by commit rGc5488c8dcc8c: [OpenMP] Properly set static thread limit (w/o analysis) (authored by jdoerfert). · Explain Why
This revision was automatically updated to reflect the committed changes.
jdoerfert added a commit: rGc5488c8dcc8c: [OpenMP] Properly set static thread limit (w/o analysis).
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptAug 23 2023, 11:13 AM
Herald added subscribers: openmp-commits, cfe-commits. · View Herald Transcript

Large Diff

This large diff affects 118 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
clang/
lib/
CodeGen/
25 lines
549 lines
test/
OpenMP/
4 lines
64 lines
72 lines
72 lines
236 lines
100 lines
62 lines
100 lines
304 lines
100 lines
22 lines
348 lines
116 lines
384 lines
116 lines
400 lines
116 lines
34 lines
80 lines
128 lines
72 lines
72 lines
80 lines
28 lines
42 lines
8 lines
4 lines
42 lines
60 lines
4 lines
88 lines
20 lines
72 lines
48 lines
36 lines
84 lines
14 lines
72 lines
12 lines
48 lines
120 lines
246 lines
68 lines
100 lines
8 lines
158 lines
22 lines
58 lines
384 lines
20 lines
48 lines
120 lines
246 lines
280 lines
100 lines
158 lines
22 lines
58 lines
384 lines
14 lines
290 lines
12 lines
48 lines
2 lines
68 lines
8 lines
158 lines
58 lines
6 lines
152 lines
92 lines
96 lines
60 lines
36 lines
84 lines
14 lines
72 lines
576 lines
48 lines
44 lines
120 lines
24 lines
62 lines
100 lines
172 lines
24 lines
22 lines
58 lines
384 lines
608 lines
48 lines
120 lines
24 lines
256 lines
100 lines
172 lines
24 lines
22 lines
58 lines
384 lines
14 lines
38 lines
736 lines
36 lines
84 lines
14 lines
72 lines
14 lines
38 lines
136 lines
576 lines
48 lines
24 lines
58 lines
104 lines
openmp/
libomptarget/
test/
offloading/
29 lines

Diff 552808

clang/lib/CodeGen/CGOpenMPRuntime.h

clang/lib/CodeGen/CGOpenMPRuntime.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show All 35 Lines
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/GlobalValue.h" #include "llvm/IR/GlobalValue.h"
#include "llvm/IR/InstrTypes.h" #include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Value.h" #include "llvm/IR/Value.h"
#include "llvm/Support/AtomicOrdering.h" #include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <cassert> #include <cassert>
#include <cstdint>
#include <numeric> #include <numeric>
#include <optional> #include <optional>
using namespace clang; using namespace clang;
using namespace CodeGen; using namespace CodeGen;
using namespace llvm::omp; using namespace llvm::omp;
namespace { namespace {
▲ Show 20 Lines • Show All 5,946 Lines • ▼ Show 20 Lines llvm::OpenMPIRBuilder::FunctionGenCallback &&GenerateOutlinedFunction =
const CapturedStmt &CS = *D.getCapturedStmt(OMPD_target); const CapturedStmt &CS = *D.getCapturedStmt(OMPD_target);
CGOpenMPTargetRegionInfo CGInfo(CS, CodeGen, EntryFnName); CGOpenMPTargetRegionInfo CGInfo(CS, CodeGen, EntryFnName);
CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
return CGF.GenerateOpenMPCapturedStmtFunction(CS, D.getBeginLoc()); return CGF.GenerateOpenMPCapturedStmtFunction(CS, D.getBeginLoc());
}; };
// Get NumTeams and ThreadLimit attributes // Get NumTeams and ThreadLimit attributes
int32_t DefaultValTeams = -1; int32_t DefaultValTeams = -1;
jhuber6Unsubmitted
Done
ReplyInline Actions

Why is this signed but the threads are unsigned now?

jhuber6: Why is this signed but the threads are unsigned now?
jdoerfertAuthorUnsubmitted
Done
ReplyInline Actions

I did not touch the team stuff yet. Same rewrite is necessary there, but not required right now.

jdoerfert: I did not touch the team stuff yet. Same rewrite is necessary there, but not required right now.
int32_t DefaultValThreads = -1; uint32_t DefaultValThreads = UINT32_MAX;
tianshilei1992Unsubmitted
Done
ReplyInline Actions

to have an unsigned value assigned with -1 is really a bad idea

tianshilei1992: to have an unsigned value assigned with -1 is really a bad idea
jhuber6Unsubmitted
Done
ReplyInline Actions

-1 is well defined for unsigned as 0xffffffff, but it's far clearer to use UINT32_MAX like I suggested.

jhuber6: `-1` is well defined for unsigned as `0xffffffff`, but it's far clearer to use `UINT32_MAX`…
tianshilei1992Unsubmitted
Done
ReplyInline Actions

even ~0U is much better

tianshilei1992: even `~0U` is much better
jdoerfertAuthorUnsubmitted
Done
ReplyInline Actions

I can do ~0U but the point is really that we look for the -1 later on. I don't do arithmetic, just comparisons.

jdoerfert: I can do `~0U` but the point is really that we look for the -1 later on. I don't do arithmetic…
getNumTeamsExprForTargetDirective(CGF, D, DefaultValTeams); getNumTeamsExprForTargetDirective(CGF, D, DefaultValTeams);
getNumThreadsExprForTargetDirective(CGF, D, DefaultValThreads); getNumThreadsExprForTargetDirective(CGF, D, DefaultValThreads,
/*UpperBoundOnly=*/true);
jhuber6Unsubmitted
Done
ReplyInline Actions

The LLVM style uses /*Value=*/ for inline comments https://llvm.org/docs/CodingStandards.html#comment-formatting

jhuber6: The LLVM style uses `/*Value=*/` for inline comments https://llvm.org/docs/CodingStandards.
OMPBuilder.emitTargetRegionFunction(EntryInfo, GenerateOutlinedFunction, OMPBuilder.emitTargetRegionFunction(EntryInfo, GenerateOutlinedFunction,
DefaultValTeams, DefaultValThreads, DefaultValTeams, DefaultValThreads,
IsOffloadEntry, OutlinedFn, OutlinedFnID); IsOffloadEntry, OutlinedFn, OutlinedFnID);
if (!OutlinedFn) if (!OutlinedFn)
return; return;
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines if (NumTeams != nullptr) {
default: default:
break; break;
} }
} }
return llvm::ConstantInt::get(CGF.Int32Ty, DefaultNT); return llvm::ConstantInt::get(CGF.Int32Ty, DefaultNT);
} }
static llvm::Value *getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS, /// Check for a num threads constant value (stored in \p DefaultVal), or
llvm::Value *DefaultThreadLimitVal) { /// expression (stored in \p E). If the value is conditional (via an if-clause),
/// store the condition in \p CondVal. If \p E, and \p CondVal respectively, are
/// nullptr, no expression evaluation is perfomed.
static void getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
const Expr **E, uint32_t &UpperBound,
bool UpperBoundOnly, llvm::Value **CondVal) {
const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild( const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
CGF.getContext(), CS->getCapturedStmt()); CGF.getContext(), CS->getCapturedStmt());
if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) { const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child);
if (!Dir)
return;
if (isOpenMPParallelDirective(Dir->getDirectiveKind())) { if (isOpenMPParallelDirective(Dir->getDirectiveKind())) {
llvm::Value *NumThreads = nullptr;
llvm::Value *CondVal = nullptr;
// Handle if clause. If if clause present, the number of threads is // Handle if clause. If if clause present, the number of threads is
// calculated as <cond> ? (<numthreads> ? <numthreads> : 0 ) : 1. // calculated as <cond> ? (<numthreads> ? <numthreads> : 0 ) : 1.
if (Dir->hasClausesOfKind<OMPIfClause>()) { if (CondVal && Dir->hasClausesOfKind<OMPIfClause>()) {
CGOpenMPInnerExprInfo CGInfo(CGF, *CS); CGOpenMPInnerExprInfo CGInfo(CGF, *CS);
CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
const OMPIfClause *IfClause = nullptr; const OMPIfClause *IfClause = nullptr;
for (const auto *C : Dir->getClausesOfKind<OMPIfClause>()) { for (const auto *C : Dir->getClausesOfKind<OMPIfClause>()) {
if (C->getNameModifier() == OMPD_unknown || if (C->getNameModifier() == OMPD_unknown ||
C->getNameModifier() == OMPD_parallel) { C->getNameModifier() == OMPD_parallel) {
IfClause = C; IfClause = C;
break; break;
} }
} }
if (IfClause) { if (IfClause) {
const Expr *Cond = IfClause->getCondition(); const Expr *CondExpr = IfClause->getCondition();
bool Result; bool Result;
if (Cond->EvaluateAsBooleanCondition(Result, CGF.getContext())) { if (CondExpr->EvaluateAsBooleanCondition(Result, CGF.getContext())) {
if (!Result) if (!Result) {
return CGF.Builder.getInt32(1); UpperBound = 1;
return;
}
} else { } else {
CodeGenFunction::LexicalScope Scope(CGF, Cond->getSourceRange()); CodeGenFunction::LexicalScope Scope(CGF, CondExpr->getSourceRange());
if (const auto *PreInit = if (const auto *PreInit =
cast_or_null<DeclStmt>(IfClause->getPreInitStmt())) { cast_or_null<DeclStmt>(IfClause->getPreInitStmt())) {
for (const auto *I : PreInit->decls()) { for (const auto *I : PreInit->decls()) {
if (!I->hasAttr<OMPCaptureNoInitAttr>()) { if (!I->hasAttr<OMPCaptureNoInitAttr>()) {
CGF.EmitVarDecl(cast<VarDecl>(*I)); CGF.EmitVarDecl(cast<VarDecl>(*I));
} else { } else {
CodeGenFunction::AutoVarEmission Emission = CodeGenFunction::AutoVarEmission Emission =
CGF.EmitAutoVarAlloca(cast<VarDecl>(*I)); CGF.EmitAutoVarAlloca(cast<VarDecl>(*I));
CGF.EmitAutoVarCleanups(Emission); CGF.EmitAutoVarCleanups(Emission);
} }
} }
*CondVal = CGF.EvaluateExprAsBool(CondExpr);
} }
CondVal = CGF.EvaluateExprAsBool(Cond);
} }
} }
} }
// Check the value of num_threads clause iff if clause was not specified // Check the value of num_threads clause iff if clause was not specified
// or is not evaluated to false. // or is not evaluated to false.
if (Dir->hasClausesOfKind<OMPNumThreadsClause>()) { if (Dir->hasClausesOfKind<OMPNumThreadsClause>()) {
CGOpenMPInnerExprInfo CGInfo(CGF, *CS); CGOpenMPInnerExprInfo CGInfo(CGF, *CS);
CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
const auto *NumThreadsClause = const auto *NumThreadsClause =
Dir->getSingleClause<OMPNumThreadsClause>(); Dir->getSingleClause<OMPNumThreadsClause>();
CodeGenFunction::LexicalScope Scope( const Expr *NTExpr = NumThreadsClause->getNumThreads();
CGF, NumThreadsClause->getNumThreads()->getSourceRange()); if (NTExpr->isIntegerConstantExpr(CGF.getContext()))
if (auto Constant = NTExpr->getIntegerConstantExpr(CGF.getContext()))
UpperBound =
UpperBound
? Constant->getZExtValue()
: std::min(UpperBound,
jhuber6Unsubmitted
Done
ReplyInline Actions

Favor C++ style casts?

jhuber6: Favor C++ style casts?
jdoerfertAuthorUnsubmitted
Done
ReplyInline Actions

like reinterpret_cast<uint32_t>(...)? sure.

jdoerfert: like `reinterpret_cast<uint32_t>(...)`? sure.
static_cast<uint32_t>(Constant->getZExtValue()));
// If we haven't found a upper bound, remember we saw a thread limiting
// clause.
jhuber6Unsubmitted
Done
ReplyInline Actions

Should probably be UINT32_MAX

jhuber6: Should probably be `UINT32_MAX`
jdoerfertAuthorUnsubmitted
Done
ReplyInline Actions

I figured this way it's more obvious.

jdoerfert: I figured this way it's more obvious.
if (UpperBound == UINT32_MAX)
UpperBound = 0;
if (!E)
return;
CodeGenFunction::LexicalScope Scope(CGF, NTExpr->getSourceRange());
if (const auto *PreInit = if (const auto *PreInit =
cast_or_null<DeclStmt>(NumThreadsClause->getPreInitStmt())) { cast_or_null<DeclStmt>(NumThreadsClause->getPreInitStmt())) {
for (const auto *I : PreInit->decls()) { for (const auto *I : PreInit->decls()) {
if (!I->hasAttr<OMPCaptureNoInitAttr>()) { if (!I->hasAttr<OMPCaptureNoInitAttr>()) {
CGF.EmitVarDecl(cast<VarDecl>(*I)); CGF.EmitVarDecl(cast<VarDecl>(*I));
} else { } else {
CodeGenFunction::AutoVarEmission Emission = CodeGenFunction::AutoVarEmission Emission =
CGF.EmitAutoVarAlloca(cast<VarDecl>(*I)); CGF.EmitAutoVarAlloca(cast<VarDecl>(*I));
CGF.EmitAutoVarCleanups(Emission); CGF.EmitAutoVarCleanups(Emission);
} }
} }
} }
NumThreads = CGF.EmitScalarExpr(NumThreadsClause->getNumThreads()); *E = NTExpr;
NumThreads = CGF.Builder.CreateIntCast(NumThreads, CGF.Int32Ty,
/*isSigned=*/false);
if (DefaultThreadLimitVal)
NumThreads = CGF.Builder.CreateSelect(
CGF.Builder.CreateICmpULT(DefaultThreadLimitVal, NumThreads),
DefaultThreadLimitVal, NumThreads);
} else {
NumThreads = DefaultThreadLimitVal ? DefaultThreadLimitVal
: CGF.Builder.getInt32(0);
} }
// Process condition of the if clause. return;
if (CondVal) {
NumThreads = CGF.Builder.CreateSelect(CondVal, NumThreads,
CGF.Builder.getInt32(1));
}
return NumThreads;
} }
if (isOpenMPSimdDirective(Dir->getDirectiveKind())) if (isOpenMPSimdDirective(Dir->getDirectiveKind()))
return CGF.Builder.getInt32(1); UpperBound = 1;
} return;
return DefaultThreadLimitVal;
} }
const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective( const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
CodeGenFunction &CGF, const OMPExecutableDirective &D, CodeGenFunction &CGF, const OMPExecutableDirective &D, uint32_t &UpperBound,
int32_t &DefaultVal) { bool UpperBoundOnly, llvm::Value **CondVal, const Expr **ThreadLimitExpr) {
OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind(); assert((!CGF.getLangOpts().OpenMPIsTargetDevice || UpperBoundOnly) &&
assert(isOpenMPTargetExecutionDirective(DirectiveKind) &&
"Expected target-based executable directive.");
switch (DirectiveKind) {
case OMPD_target:
// Teams have no clause thread_limit
return nullptr;
case OMPD_target_teams:
case OMPD_target_teams_distribute:
if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
const Expr *ThreadLimit = ThreadLimitClause->getThreadLimit();
if (ThreadLimit->isIntegerConstantExpr(CGF.getContext()))
if (auto Constant =
ThreadLimit->getIntegerConstantExpr(CGF.getContext()))
DefaultVal = Constant->getExtValue();
return ThreadLimit;
}
return nullptr;
case OMPD_target_teams_loop:
case OMPD_target_parallel_loop:
case OMPD_target_parallel:
case OMPD_target_parallel_for:
case OMPD_target_parallel_for_simd:
case OMPD_target_teams_distribute_parallel_for:
case OMPD_target_teams_distribute_parallel_for_simd: {
Expr *ThreadLimit = nullptr;
Expr *NumThreads = nullptr;
if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
ThreadLimit = ThreadLimitClause->getThreadLimit();
if (ThreadLimit->isIntegerConstantExpr(CGF.getContext()))
if (auto Constant =
ThreadLimit->getIntegerConstantExpr(CGF.getContext()))
DefaultVal = Constant->getExtValue();
}
if (D.hasClausesOfKind<OMPNumThreadsClause>()) {
const auto *NumThreadsClause = D.getSingleClause<OMPNumThreadsClause>();
NumThreads = NumThreadsClause->getNumThreads();
if (NumThreads->isIntegerConstantExpr(CGF.getContext())) {
if (auto Constant =
NumThreads->getIntegerConstantExpr(CGF.getContext())) {
if (Constant->getExtValue() < DefaultVal) {
DefaultVal = Constant->getExtValue();
ThreadLimit = NumThreads;
}
}
}
}
return ThreadLimit;
}
case OMPD_target_teams_distribute_simd:
case OMPD_target_simd:
DefaultVal = 1;
return nullptr;
case OMPD_parallel:
case OMPD_for:
case OMPD_parallel_for:
case OMPD_parallel_master:
case OMPD_parallel_sections:
case OMPD_for_simd:
case OMPD_parallel_for_simd:
case OMPD_cancel:
case OMPD_cancellation_point:
case OMPD_ordered:
case OMPD_threadprivate:
case OMPD_allocate:
case OMPD_task:
case OMPD_simd:
case OMPD_tile:
case OMPD_unroll:
case OMPD_sections:
case OMPD_section:
case OMPD_single:
case OMPD_master:
case OMPD_critical:
case OMPD_taskyield:
case OMPD_barrier:
case OMPD_taskwait:
case OMPD_taskgroup:
case OMPD_atomic:
case OMPD_flush:
case OMPD_depobj:
case OMPD_scan:
case OMPD_teams:
case OMPD_target_data:
case OMPD_target_exit_data:
case OMPD_target_enter_data:
case OMPD_distribute:
case OMPD_distribute_simd:
case OMPD_distribute_parallel_for:
case OMPD_distribute_parallel_for_simd:
case OMPD_teams_distribute:
case OMPD_teams_distribute_simd:
case OMPD_teams_distribute_parallel_for:
case OMPD_teams_distribute_parallel_for_simd:
case OMPD_target_update:
case OMPD_declare_simd:
case OMPD_declare_variant:
case OMPD_begin_declare_variant:
case OMPD_end_declare_variant:
case OMPD_declare_target:
case OMPD_end_declare_target:
case OMPD_declare_reduction:
case OMPD_declare_mapper:
case OMPD_taskloop:
case OMPD_taskloop_simd:
case OMPD_master_taskloop:
case OMPD_master_taskloop_simd:
case OMPD_parallel_master_taskloop:
case OMPD_parallel_master_taskloop_simd:
case OMPD_requires:
case OMPD_unknown:
break;
default:
break;
}
llvm_unreachable("Unsupported directive kind.");
}
llvm::Value *CGOpenMPRuntime::emitNumThreadsForTargetDirective(
CodeGenFunction &CGF, const OMPExecutableDirective &D) {
assert(!CGF.getLangOpts().OpenMPIsTargetDevice &&
"Clauses associated with the teams directive expected to be emitted " "Clauses associated with the teams directive expected to be emitted "
"only for the host!"); "only for the host!");
OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind(); OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind();
assert(isOpenMPTargetExecutionDirective(DirectiveKind) && assert(isOpenMPTargetExecutionDirective(DirectiveKind) &&
"Expected target-based executable directive."); "Expected target-based executable directive.");
CGBuilderTy &Bld = CGF.Builder;
llvm::Value *ThreadLimitVal = nullptr; const Expr *NT = nullptr;
llvm::Value *NumThreadsVal = nullptr; const Expr **NTPtr = UpperBoundOnly ? nullptr : &NT;
auto CheckForConstExpr = [&](const Expr *E, const Expr **EPtr) {
if (E->isIntegerConstantExpr(CGF.getContext())) {
if (auto Constant = E->getIntegerConstantExpr(CGF.getContext()))
UpperBound = UpperBound ? Constant->getZExtValue()
: std::min(UpperBound,
uint32_t(Constant->getZExtValue()));
}
// If we haven't found a upper bound, remember we saw a thread limiting
// clause.
jhuber6Unsubmitted
Done
ReplyInline Actions

Ditto

jhuber6: Ditto
if (UpperBound == UINT32_MAX)
UpperBound = 0;
if (EPtr)
*EPtr = E;
};
auto ReturnSequential = [&]() {
UpperBound = 1;
return NT;
};
switch (DirectiveKind) { switch (DirectiveKind) {
case OMPD_target: { case OMPD_target: {
const CapturedStmt *CS = D.getInnermostCapturedStmt(); const CapturedStmt *CS = D.getInnermostCapturedStmt();
if (llvm::Value *NumThreads = getNumThreads(CGF, CS, ThreadLimitVal)) getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
return NumThreads;
const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild( const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
CGF.getContext(), CS->getCapturedStmt()); CGF.getContext(), CS->getCapturedStmt());
// TODO: The standard is not clear how to resolve two thread limit clauses, // TODO: The standard is not clear how to resolve two thread limit clauses,
// let's pick the teams one if it's present, otherwise the target one. // let's pick the teams one if it's present, otherwise the target one.
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>(); const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) { if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) {
if (const auto *TLC = Dir->getSingleClause<OMPThreadLimitClause>()) { if (const auto *TLC = Dir->getSingleClause<OMPThreadLimitClause>()) {
ThreadLimitClause = TLC; ThreadLimitClause = TLC;
if (ThreadLimitExpr) {
CGOpenMPInnerExprInfo CGInfo(CGF, *CS); CGOpenMPInnerExprInfo CGInfo(CGF, *CS);
CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
CodeGenFunction::LexicalScope Scope( CodeGenFunction::LexicalScope Scope(
CGF, ThreadLimitClause->getThreadLimit()->getSourceRange()); CGF, ThreadLimitClause->getThreadLimit()->getSourceRange());
if (const auto *PreInit = if (const auto *PreInit =
cast_or_null<DeclStmt>(ThreadLimitClause->getPreInitStmt())) { cast_or_null<DeclStmt>(ThreadLimitClause->getPreInitStmt())) {
for (const auto *I : PreInit->decls()) { for (const auto *I : PreInit->decls()) {
if (!I->hasAttr<OMPCaptureNoInitAttr>()) { if (!I->hasAttr<OMPCaptureNoInitAttr>()) {
CGF.EmitVarDecl(cast<VarDecl>(*I)); CGF.EmitVarDecl(cast<VarDecl>(*I));
} else { } else {
CodeGenFunction::AutoVarEmission Emission = CodeGenFunction::AutoVarEmission Emission =
CGF.EmitAutoVarAlloca(cast<VarDecl>(*I)); CGF.EmitAutoVarAlloca(cast<VarDecl>(*I));
CGF.EmitAutoVarCleanups(Emission); CGF.EmitAutoVarCleanups(Emission);
} }
} }
} }
} }
} }
if (ThreadLimitClause) {
llvm::Value *ThreadLimit = CGF.EmitScalarExpr(
ThreadLimitClause->getThreadLimit(), /*IgnoreResultAssign=*/true);
ThreadLimitVal =
Bld.CreateIntCast(ThreadLimit, CGF.Int32Ty, /*isSigned=*/false);
} }
if (ThreadLimitClause)
CheckForConstExpr(ThreadLimitClause->getThreadLimit(), ThreadLimitExpr);
if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) { if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) {
if (isOpenMPTeamsDirective(Dir->getDirectiveKind()) && if (isOpenMPTeamsDirective(Dir->getDirectiveKind()) &&
!isOpenMPDistributeDirective(Dir->getDirectiveKind())) { !isOpenMPDistributeDirective(Dir->getDirectiveKind())) {
CS = Dir->getInnermostCapturedStmt(); CS = Dir->getInnermostCapturedStmt();
const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild( const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
CGF.getContext(), CS->getCapturedStmt()); CGF.getContext(), CS->getCapturedStmt());
Dir = dyn_cast_or_null<OMPExecutableDirective>(Child); Dir = dyn_cast_or_null<OMPExecutableDirective>(Child);
} }
if (Dir && isOpenMPDistributeDirective(Dir->getDirectiveKind()) && if (Dir && isOpenMPParallelDirective(Dir->getDirectiveKind())) {
!isOpenMPSimdDirective(Dir->getDirectiveKind())) {
CS = Dir->getInnermostCapturedStmt(); CS = Dir->getInnermostCapturedStmt();
if (llvm::Value *NumThreads = getNumThreads(CGF, CS, ThreadLimitVal)) getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
return NumThreads; } else if (Dir && isOpenMPSimdDirective(Dir->getDirectiveKind()))
} return ReturnSequential();
if (Dir && isOpenMPSimdDirective(Dir->getDirectiveKind()))
return Bld.getInt32(1);
} }
return ThreadLimitVal ? ThreadLimitVal : Bld.getInt32(0); return NT;
} }
case OMPD_target_teams: { case OMPD_target_teams: {
if (D.hasClausesOfKind<OMPThreadLimitClause>()) { if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF); CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF);
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>(); const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
llvm::Value *ThreadLimit = CGF.EmitScalarExpr( CheckForConstExpr(ThreadLimitClause->getThreadLimit(), ThreadLimitExpr);
ThreadLimitClause->getThreadLimit(), /*IgnoreResultAssign=*/true);
ThreadLimitVal =
Bld.CreateIntCast(ThreadLimit, CGF.Int32Ty, /*isSigned=*/false);
} }
const CapturedStmt *CS = D.getInnermostCapturedStmt(); const CapturedStmt *CS = D.getInnermostCapturedStmt();
if (llvm::Value *NumThreads = getNumThreads(CGF, CS, ThreadLimitVal)) getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
return NumThreads;
const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild( const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
CGF.getContext(), CS->getCapturedStmt()); CGF.getContext(), CS->getCapturedStmt());
if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) { if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) {
if (Dir->getDirectiveKind() == OMPD_distribute) { if (Dir->getDirectiveKind() == OMPD_distribute) {
CS = Dir->getInnermostCapturedStmt(); CS = Dir->getInnermostCapturedStmt();
if (llvm::Value *NumThreads = getNumThreads(CGF, CS, ThreadLimitVal)) getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
return NumThreads;
} }
} }
return ThreadLimitVal ? ThreadLimitVal : Bld.getInt32(0); return NT;
} }
case OMPD_target_teams_distribute: case OMPD_target_teams_distribute:
if (D.hasClausesOfKind<OMPThreadLimitClause>()) { if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF); CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF);
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>(); const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
llvm::Value *ThreadLimit = CGF.EmitScalarExpr( CheckForConstExpr(ThreadLimitClause->getThreadLimit(), ThreadLimitExpr);
ThreadLimitClause->getThreadLimit(), /*IgnoreResultAssign=*/true);
ThreadLimitVal =
Bld.CreateIntCast(ThreadLimit, CGF.Int32Ty, /*isSigned=*/false);
} }
if (llvm::Value *NumThreads = getNumThreads(CGF, D.getInnermostCapturedStmt(), NTPtr, UpperBound,
getNumThreads(CGF, D.getInnermostCapturedStmt(), ThreadLimitVal)) UpperBoundOnly, CondVal);
return NumThreads; return NT;
return Bld.getInt32(0);
case OMPD_target_teams_loop: case OMPD_target_teams_loop:
case OMPD_target_parallel_loop: case OMPD_target_parallel_loop:
case OMPD_target_parallel: case OMPD_target_parallel:
case OMPD_target_parallel_for: case OMPD_target_parallel_for:
case OMPD_target_parallel_for_simd: case OMPD_target_parallel_for_simd:
case OMPD_target_teams_distribute_parallel_for: case OMPD_target_teams_distribute_parallel_for:
case OMPD_target_teams_distribute_parallel_for_simd: { case OMPD_target_teams_distribute_parallel_for_simd: {
llvm::Value *CondVal = nullptr; if (CondVal && D.hasClausesOfKind<OMPIfClause>()) {
// Handle if clause. If if clause present, the number of threads is
// calculated as <cond> ? (<numthreads> ? <numthreads> : 0 ) : 1.
if (D.hasClausesOfKind<OMPIfClause>()) {
const OMPIfClause *IfClause = nullptr; const OMPIfClause *IfClause = nullptr;
for (const auto *C : D.getClausesOfKind<OMPIfClause>()) { for (const auto *C : D.getClausesOfKind<OMPIfClause>()) {
if (C->getNameModifier() == OMPD_unknown || if (C->getNameModifier() == OMPD_unknown ||
C->getNameModifier() == OMPD_parallel) { C->getNameModifier() == OMPD_parallel) {
IfClause = C; IfClause = C;
break; break;
} }
} }
if (IfClause) { if (IfClause) {
const Expr *Cond = IfClause->getCondition(); const Expr *Cond = IfClause->getCondition();
bool Result; bool Result;
if (Cond->EvaluateAsBooleanCondition(Result, CGF.getContext())) { if (Cond->EvaluateAsBooleanCondition(Result, CGF.getContext())) {
if (!Result) if (!Result)
return Bld.getInt32(1); return ReturnSequential();
} else { } else {
CodeGenFunction::RunCleanupsScope Scope(CGF); CodeGenFunction::RunCleanupsScope Scope(CGF);
CondVal = CGF.EvaluateExprAsBool(Cond); *CondVal = CGF.EvaluateExprAsBool(Cond);
} }
} }
} }
if (D.hasClausesOfKind<OMPThreadLimitClause>()) { if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF); CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF);
const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>(); const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
llvm::Value *ThreadLimit = CGF.EmitScalarExpr( CheckForConstExpr(ThreadLimitClause->getThreadLimit(), ThreadLimitExpr);
ThreadLimitClause->getThreadLimit(), /*IgnoreResultAssign=*/true);
ThreadLimitVal =
Bld.CreateIntCast(ThreadLimit, CGF.Int32Ty, /*isSigned=*/false);
} }
if (D.hasClausesOfKind<OMPNumThreadsClause>()) { if (D.hasClausesOfKind<OMPNumThreadsClause>()) {
CodeGenFunction::RunCleanupsScope NumThreadsScope(CGF); CodeGenFunction::RunCleanupsScope NumThreadsScope(CGF);
const auto *NumThreadsClause = D.getSingleClause<OMPNumThreadsClause>(); const auto *NumThreadsClause = D.getSingleClause<OMPNumThreadsClause>();
llvm::Value *NumThreads = CGF.EmitScalarExpr( CheckForConstExpr(NumThreadsClause->getNumThreads(), nullptr);
NumThreadsClause->getNumThreads(), /*IgnoreResultAssign=*/true); return NumThreadsClause->getNumThreads();
NumThreadsVal = }
Bld.CreateIntCast(NumThreads, CGF.Int32Ty, /*isSigned=*/false); return NT;
ThreadLimitVal = ThreadLimitVal
? Bld.CreateSelect(Bld.CreateICmpULT(NumThreadsVal,
ThreadLimitVal),
NumThreadsVal, ThreadLimitVal)
: NumThreadsVal;
}
if (!ThreadLimitVal)
ThreadLimitVal = Bld.getInt32(0);
if (CondVal)
return Bld.CreateSelect(CondVal, ThreadLimitVal, Bld.getInt32(1));
return ThreadLimitVal;
} }
case OMPD_target_teams_distribute_simd: case OMPD_target_teams_distribute_simd:
case OMPD_target_simd: case OMPD_target_simd:
return Bld.getInt32(1); return ReturnSequential();
case OMPD_parallel:
case OMPD_for:
case OMPD_parallel_for:
case OMPD_parallel_master:
case OMPD_parallel_sections:
case OMPD_for_simd:
case OMPD_parallel_for_simd:
case OMPD_cancel:
case OMPD_cancellation_point:
case OMPD_ordered:
case OMPD_threadprivate:
case OMPD_allocate:
case OMPD_task:
case OMPD_simd:
case OMPD_tile:
case OMPD_unroll:
case OMPD_sections:
case OMPD_section:
case OMPD_single:
case OMPD_master:
case OMPD_critical:
case OMPD_taskyield:
case OMPD_barrier:
case OMPD_taskwait:
case OMPD_taskgroup:
case OMPD_atomic:
case OMPD_flush:
case OMPD_depobj:
case OMPD_scan:
case OMPD_teams:
case OMPD_target_data:
case OMPD_target_exit_data:
case OMPD_target_enter_data:
case OMPD_distribute:
case OMPD_distribute_simd:
case OMPD_distribute_parallel_for:
case OMPD_distribute_parallel_for_simd:
case OMPD_teams_distribute:
case OMPD_teams_distribute_simd:
case OMPD_teams_distribute_parallel_for:
case OMPD_teams_distribute_parallel_for_simd:
case OMPD_target_update:
case OMPD_declare_simd:
case OMPD_declare_variant:
case OMPD_begin_declare_variant:
case OMPD_end_declare_variant:
case OMPD_declare_target:
case OMPD_end_declare_target:
case OMPD_declare_reduction:
case OMPD_declare_mapper:
case OMPD_taskloop:
case OMPD_taskloop_simd:
case OMPD_master_taskloop:
case OMPD_master_taskloop_simd:
case OMPD_parallel_master_taskloop:
case OMPD_parallel_master_taskloop_simd:
case OMPD_requires:
case OMPD_metadirective:
case OMPD_unknown:
break;
default: default:
break; break;
} }
llvm_unreachable("Unsupported directive kind."); llvm_unreachable("Unsupported directive kind.");
} }
llvm::Value *CGOpenMPRuntime::emitNumThreadsForTargetDirective(
CodeGenFunction &CGF, const OMPExecutableDirective &D) {
llvm::Value *NumThreadsVal = nullptr;
llvm::Value *CondVal = nullptr;
llvm::Value *ThreadLimitVal = nullptr;
const Expr *ThreadLimitExpr = nullptr;
uint32_t UpperBound = -1;
const Expr *NT = getNumThreadsExprForTargetDirective(
CGF, D, UpperBound, /* UpperBoundOnly */ false, &CondVal,
&ThreadLimitExpr);
// Thread limit expressions are used below, emit them.
if (ThreadLimitExpr) {
ThreadLimitVal =
CGF.EmitScalarExpr(ThreadLimitExpr, /*IgnoreResultAssign=*/true);
ThreadLimitVal = CGF.Builder.CreateIntCast(ThreadLimitVal, CGF.Int32Ty,
/*isSigned=*/false);
}
// Generate the num teams expression.
if (UpperBound == 1) {
NumThreadsVal = CGF.Builder.getInt32(UpperBound);
} else if (NT) {
NumThreadsVal = CGF.EmitScalarExpr(NT, /*IgnoreResultAssign=*/true);
NumThreadsVal = CGF.Builder.CreateIntCast(NumThreadsVal, CGF.Int32Ty,
/*isSigned=*/false);
} else if (ThreadLimitVal) {
// If we do not have a num threads value but a thread limit, replace the
// former with the latter. We know handled the thread limit expression.
NumThreadsVal = ThreadLimitVal;
ThreadLimitVal = nullptr;
} else {
// Default to "0" which means runtime choice.
assert(!ThreadLimitVal && "Default not applicable with thread limit value");
NumThreadsVal = CGF.Builder.getInt32(0);
}
// Handle if clause. If if clause present, the number of threads is
// calculated as <cond> ? (<numthreads> ? <numthreads> : 0 ) : 1.
if (CondVal) {
CodeGenFunction::RunCleanupsScope Scope(CGF);
NumThreadsVal = CGF.Builder.CreateSelect(CondVal, NumThreadsVal,
CGF.Builder.getInt32(1));
}
// If the thread limit and num teams expression were present, take the
// minimum.
if (ThreadLimitVal) {
NumThreadsVal = CGF.Builder.CreateSelect(
CGF.Builder.CreateICmpULT(ThreadLimitVal, NumThreadsVal),
ThreadLimitVal, NumThreadsVal);
}
return NumThreadsVal;
}
namespace { namespace {
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
// Utility to handle information from clauses associated with a given // Utility to handle information from clauses associated with a given
// construct that use mappable expressions (e.g. 'map' clause, 'to' clause). // construct that use mappable expressions (e.g. 'map' clause, 'to' clause).
// It provides a convenient interface to obtain the information and generate // It provides a convenient interface to obtain the information and generate
// code for that information. // code for that information.
class MappableExprsHandler { class MappableExprsHandler {
▲ Show 20 Lines • Show All 5,641 Lines • Show Last 20 Lines

clang/test/OpenMP/bug60602.cpp

clang/test/OpenMP/distribute_codegen.cpp

clang/test/OpenMP/distribute_firstprivate_codegen.cpp

clang/test/OpenMP/distribute_lastprivate_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_firstprivate_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_if_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_lastprivate_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_num_threads_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_private_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_proc_bind_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_firstprivate_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_if_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_lastprivate_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_num_threads_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_private_codegen.cpp

clang/test/OpenMP/distribute_parallel_for_simd_proc_bind_codegen.cpp

clang/test/OpenMP/distribute_private_codegen.cpp

clang/test/OpenMP/distribute_simd_codegen.cpp

clang/test/OpenMP/distribute_simd_firstprivate_codegen.cpp

clang/test/OpenMP/distribute_simd_lastprivate_codegen.cpp

clang/test/OpenMP/distribute_simd_private_codegen.cpp

clang/test/OpenMP/distribute_simd_reduction_codegen.cpp

clang/test/OpenMP/nvptx_SPMD_codegen.cpp

clang/test/OpenMP/nvptx_lambda_capturing.cpp

clang/test/OpenMP/nvptx_target_parallel_num_threads_codegen.cpp

clang/test/OpenMP/reduction_implicit_map.cpp

clang/test/OpenMP/target_codegen_global_capture.cpp

clang/test/OpenMP/target_map_member_expr_codegen.cpp

clang/test/OpenMP/target_ompx_dyn_cgroup_mem_codegen.cpp

clang/test/OpenMP/target_parallel_num_threads_codegen.cpp

clang/test/OpenMP/target_teams_codegen.cpp

clang/test/OpenMP/target_teams_distribute_codegen.cpp

clang/test/OpenMP/target_teams_distribute_collapse_codegen.cpp

clang/test/OpenMP/target_teams_distribute_dist_schedule_codegen.cpp

clang/test/OpenMP/target_teams_distribute_firstprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_lastprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_collapse_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_dist_schedule_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_firstprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_if_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_lastprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_order_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_private_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_proc_bind_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_reduction_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_schedule_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_collapse_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_dist_schedule_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_firstprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_if_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_lastprivate_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_private_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_proc_bind_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_reduction_codegen.cpp

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_schedule_codegen.cpp

clang/test/OpenMP/target_teams_distribute_private_codegen.cpp

clang/test/OpenMP/target_teams_distribute_reduction_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_codegen-1.cpp

clang/test/OpenMP/target_teams_generic_loop_collapse_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_depend_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_if_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_order_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_private_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_reduction_codegen.cpp

clang/test/OpenMP/target_teams_generic_loop_uses_allocators_codegen.cpp

clang/test/OpenMP/target_teams_map_codegen.cpp

clang/test/OpenMP/target_teams_num_teams_codegen.cpp

clang/test/OpenMP/teams_codegen.cpp

clang/test/OpenMP/teams_distribute_codegen.cpp

clang/test/OpenMP/teams_distribute_collapse_codegen.cpp

clang/test/OpenMP/teams_distribute_dist_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_firstprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_lastprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_collapse_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_copyin_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_dist_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_firstprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_if_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_lastprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_num_threads_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_private_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_proc_bind_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_reduction_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_collapse_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_dist_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_firstprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_if_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_lastprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_num_threads_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_private_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_proc_bind_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_reduction_codegen.cpp

clang/test/OpenMP/teams_distribute_parallel_for_simd_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_private_codegen.cpp

clang/test/OpenMP/teams_distribute_reduction_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_collapse_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_dist_schedule_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_firstprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_lastprivate_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_private_codegen.cpp

clang/test/OpenMP/teams_distribute_simd_reduction_codegen.cpp

clang/test/OpenMP/teams_firstprivate_codegen.cpp

clang/test/OpenMP/teams_generic_loop_codegen-1.cpp

clang/test/OpenMP/teams_generic_loop_collapse_codegen.cpp

clang/test/OpenMP/teams_generic_loop_private_codegen.cpp

clang/test/OpenMP/teams_generic_loop_reduction_codegen.cpp

clang/test/OpenMP/teams_private_codegen.cpp

openmp/libomptarget/test/offloading/thread_limit.c