maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[OPENMP50]Simplify processing of context selector scores. 

If the context selector score was not specified, its value must be set
to 0. Simplify the processing of unspecified scores + save memory in
attribute representation.
This commit is contained in:
Alexey Bataev 2019-11-05 15:33:18 -05:00
parent a078c77d72
commit dcec2ac4f3
6 changed files with 32 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/include/clang/Basic/Attr.td
View File

@ -3312,12 +3312,6 @@ def OMPDeclareVariant : InheritableAttr {
[ [
"CtxSetUnknown", "CtxSetImplementation" "CtxSetUnknown", "CtxSetImplementation"
]>, ]>,
EnumArgument<"CtxScore", "ScoreType",
[ "", "score"
],
[
"ScoreUnknown", "ScoreSpecified"
]>,
EnumArgument<"CtxSelector", "CtxSelectorType", EnumArgument<"CtxSelector", "CtxSelectorType",
[ "", "vendor" [ "", "vendor"
], ],

38
clang/lib/CodeGen/CGOpenMPRuntime.cpp
View File

@ -11044,41 +11044,11 @@ bool checkContext<OMPDeclareVariantAttr::CtxSetImplementation,
} }
static bool greaterCtxScore(ASTContext &Ctx, const Expr *LHS, const Expr *RHS) { static bool greaterCtxScore(ASTContext &Ctx, const Expr *LHS, const Expr *RHS) {
// If both scores are unknown, choose the very first one.
if (!LHS && !RHS)
return true;
// If only one is known, return this one.
if (LHS && !RHS)
return true;
if (!LHS && RHS)
return false;
llvm::APSInt LHSVal = LHS->EvaluateKnownConstInt(Ctx); llvm::APSInt LHSVal = LHS->EvaluateKnownConstInt(Ctx);
llvm::APSInt RHSVal = RHS->EvaluateKnownConstInt(Ctx); llvm::APSInt RHSVal = RHS->EvaluateKnownConstInt(Ctx);
return llvm::APSInt::compareValues(LHSVal, RHSVal) >= 0; return llvm::APSInt::compareValues(LHSVal, RHSVal) >= 0;
} }
namespace {
/// Comparator for the priority queue for context selector.
class OMPDeclareVariantAttrComparer
: public std::greater<const OMPDeclareVariantAttr *> {
private:
ASTContext &Ctx;
public:
OMPDeclareVariantAttrComparer(ASTContext &Ctx) : Ctx(Ctx) {}
bool operator()(const OMPDeclareVariantAttr *LHS,
const OMPDeclareVariantAttr *RHS) const {
const Expr *LHSExpr = nullptr;
const Expr *RHSExpr = nullptr;
if (LHS->getCtxScore() == OMPDeclareVariantAttr::ScoreSpecified)
LHSExpr = LHS->getScore();
if (RHS->getCtxScore() == OMPDeclareVariantAttr::ScoreSpecified)
RHSExpr = RHS->getScore();
return greaterCtxScore(Ctx, LHSExpr, RHSExpr);
}
};
} // anonymous namespace
/// Finds the variant function that matches current context with its context /// Finds the variant function that matches current context with its context
/// selector. /// selector.
static const FunctionDecl *getDeclareVariantFunction(ASTContext &Ctx, static const FunctionDecl *getDeclareVariantFunction(ASTContext &Ctx,
@ -11088,13 +11058,7 @@ static const FunctionDecl *getDeclareVariantFunction(ASTContext &Ctx,
// Iterate through all DeclareVariant attributes and check context selectors. // Iterate through all DeclareVariant attributes and check context selectors.
auto &&Comparer = [&Ctx](const OMPDeclareVariantAttr *LHS, auto &&Comparer = [&Ctx](const OMPDeclareVariantAttr *LHS,
const OMPDeclareVariantAttr *RHS) { const OMPDeclareVariantAttr *RHS) {
const Expr *LHSExpr = nullptr; return greaterCtxScore(Ctx, LHS->getScore(), RHS->getScore());
const Expr *RHSExpr = nullptr;
if (LHS->getCtxScore() == OMPDeclareVariantAttr::ScoreSpecified)
LHSExpr = LHS->getScore();
if (RHS->getCtxScore() == OMPDeclareVariantAttr::ScoreSpecified)
RHSExpr = RHS->getScore();
return greaterCtxScore(Ctx, LHSExpr, RHSExpr);
}; };
const OMPDeclareVariantAttr *TopMostAttr = nullptr; const OMPDeclareVariantAttr *TopMostAttr = nullptr;
for (const auto *A : FD->specific_attrs<OMPDeclareVariantAttr>()) { for (const auto *A : FD->specific_attrs<OMPDeclareVariantAttr>()) {

7
clang/lib/Parse/ParseOpenMP.cpp
View File

@ -800,13 +800,8 @@ static ExprResult parseContextScore(Parser &P) {
SmallString<16> Buffer; SmallString<16> Buffer;
StringRef SelectorName = StringRef SelectorName =
P.getPreprocessor().getSpelling(P.getCurToken(), Buffer); P.getPreprocessor().getSpelling(P.getCurToken(), Buffer);
OMPDeclareVariantAttr::ScoreType ScoreKind = if (!SelectorName.equals("score"))
OMPDeclareVariantAttr::ScoreUnknown;
(void)OMPDeclareVariantAttr::ConvertStrToScoreType(SelectorName, ScoreKind);
if (ScoreKind == OMPDeclareVariantAttr::ScoreUnknown)
return ScoreExpr; return ScoreExpr;
assert(ScoreKind == OMPDeclareVariantAttr::ScoreSpecified &&
"Expected \"score\" clause.");
(void)P.ConsumeToken(); (void)P.ConsumeToken();
SourceLocation RLoc; SourceLocation RLoc;
ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc); ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc);

6
clang/lib/Sema/SemaOpenMP.cpp
View File

@ -5197,9 +5197,7 @@ void Sema::ActOnOpenMPDeclareVariantDirective(
Data.Ctx == OMPDeclareVariantAttr::CtxUnknown) Data.Ctx == OMPDeclareVariantAttr::CtxUnknown)
return; return;
Expr *Score = nullptr; Expr *Score = nullptr;
OMPDeclareVariantAttr::ScoreType ST = OMPDeclareVariantAttr::ScoreUnknown;
if (Data.CtxScore.isUsable()) { if (Data.CtxScore.isUsable()) {
ST = OMPDeclareVariantAttr::ScoreSpecified;
Score = Data.CtxScore.get(); Score = Data.CtxScore.get();
if (!Score->isTypeDependent() && !Score->isValueDependent() && if (!Score->isTypeDependent() && !Score->isValueDependent() &&
!Score->isInstantiationDependent() && !Score->isInstantiationDependent() &&
@ -5209,9 +5207,11 @@ void Sema::ActOnOpenMPDeclareVariantDirective(
if (ICE.isInvalid()) if (ICE.isInvalid())
return; return;
} }
} else {
Score = ActOnIntegerConstant(SourceLocation(), 0).get();
} }
auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit( auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit(
Context, VariantRef, Score, Data.CtxSet, ST, Data.Ctx, Context, VariantRef, Score, Data.CtxSet, Data.Ctx,
Data.ImplVendors.begin(), Data.ImplVendors.size(), SR); Data.ImplVendors.begin(), Data.ImplVendors.size(), SR);
FD->addAttr(NewAttr); FD->addAttr(NewAttr);
} }

6
clang/test/OpenMP/declare_variant_ast_print.c
View File

@ -16,7 +16,7 @@ int bar(void);
// CHECK: int foo(); // CHECK: int foo();
// CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(score(5):ibm, xxx)}) // CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(score(5):ibm, xxx)})
// CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(foo) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: int bar(); // CHECK-NEXT: int bar();

48
clang/test/OpenMP/declare_variant_ast_print.cpp
View File

@ -18,8 +18,8 @@ T foofoo() { return T(); }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(5):ibm)}) // CHECK: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(5):ibm)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: int bar(); // CHECK-NEXT: int bar();
#pragma omp declare variant(foofoo <int>) match(xxx = {}) #pragma omp declare variant(foofoo <int>) match(xxx = {})
#pragma omp declare variant(foofoo <int>) match(xxx = {vvv}) #pragma omp declare variant(foofoo <int>) match(xxx = {vvv})
@ -29,8 +29,8 @@ T foofoo() { return T(); }
int bar(); int bar();
// CHECK: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(C + 5):ibm, xxx)}) // CHECK: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(C + 5):ibm, xxx)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<T>) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: template <typename T, int C> T barbar(); // CHECK-NEXT: template <typename T, int C> T barbar();
#pragma omp declare variant(foofoo <T>) match(xxx = {}) #pragma omp declare variant(foofoo <T>) match(xxx = {})
#pragma omp declare variant(foofoo <T>) match(xxx = {vvv}) #pragma omp declare variant(foofoo <T>) match(xxx = {vvv})
@ -45,8 +45,8 @@ template <typename T, int C>
T barbar(); T barbar();
// CHECK: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(3 + 5):ibm, xxx)}) // CHECK: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(3 + 5):ibm, xxx)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(foofoo<int>) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: template<> int barbar<int, 3>(); // CHECK-NEXT: template<> int barbar<int, 3>();
// CHECK-NEXT: int baz() { // CHECK-NEXT: int baz() {
@ -66,8 +66,8 @@ template <class C>
void h_ref(C *hp, C *hp2, C *hq, C *lin) { void h_ref(C *hp, C *hp2, C *hq, C *lin) {
} }
// CHECK: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(h_ref<C>) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: template <class C> void h(C *hp, C *hp2, C *hq, C *lin) { // CHECK-NEXT: template <class C> void h(C *hp, C *hp2, C *hq, C *lin) {
// CHECK-NEXT: } // CHECK-NEXT: }
#pragma omp declare variant(h_ref <C>) match(xxx = {}) #pragma omp declare variant(h_ref <C>) match(xxx = {})
@ -77,8 +77,8 @@ template <class C>
void h(C *hp, C *hp2, C *hq, C *lin) { void h(C *hp, C *hp2, C *hq, C *lin) {
} }
// CHECK: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(h_ref<float>) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: template<> void h<float>(float *hp, float *hp2, float *hq, float *lin) { // CHECK-NEXT: template<> void h<float>(float *hp, float *hp2, float *hq, float *lin) {
// CHECK-NEXT: } // CHECK-NEXT: }
@ -97,8 +97,8 @@ void h(double *hp, double *hp2, double *hq, double *lin) {
int fn(); int fn();
// CHECK: int fn(int); // CHECK: int fn(int);
int fn(int); int fn(int);
// CHECK: #pragma omp declare variant(fn) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(fn) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(fn) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(fn) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: int overload(); // CHECK-NEXT: int overload();
#pragma omp declare variant(fn) match(xxx = {}) #pragma omp declare variant(fn) match(xxx = {})
#pragma omp declare variant(fn) match(implementation={vendor(llvm)}) #pragma omp declare variant(fn) match(implementation={vendor(llvm)})
@ -109,8 +109,8 @@ int overload(void);
// CHECK-NEXT: return 0; // CHECK-NEXT: return 0;
// CHECK-NEXT: } // CHECK-NEXT: }
auto fn_deduced_variant() { return 0; } auto fn_deduced_variant() { return 0; }
// CHECK: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: int fn_deduced(); // CHECK-NEXT: int fn_deduced();
#pragma omp declare variant(fn_deduced_variant) match(xxx = {}) #pragma omp declare variant(fn_deduced_variant) match(xxx = {})
#pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(llvm)}) #pragma omp declare variant(fn_deduced_variant) match(implementation={vendor(llvm)})
@ -119,8 +119,8 @@ int fn_deduced();
// CHECK: int fn_deduced_variant1(); // CHECK: int fn_deduced_variant1();
int fn_deduced_variant1(); int fn_deduced_variant1();
// CHECK: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(ibm)}) // CHECK-NEXT: #pragma omp declare variant(fn_deduced_variant1) match(implementation={vendor(score(0):ibm)})
// CHECK-NEXT: int fn_deduced1() { // CHECK-NEXT: int fn_deduced1() {
// CHECK-NEXT: return 0; // CHECK-NEXT: return 0;
// CHECK-NEXT: } // CHECK-NEXT: }
@ -140,11 +140,11 @@ auto fn_deduced1() { return 0; }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: void bar(int) { // CHECK-NEXT: void bar(int) {
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(ibm)}) // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::bar) match(implementation={vendor(score(0):ibm)})
// CHECK-NEXT: void foo1() { // CHECK-NEXT: void foo1() {
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)}) // CHECK-NEXT: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: void xxx(); // CHECK-NEXT: void xxx();
// CHECK-NEXT: } s; // CHECK-NEXT: } s;
struct SpecialFuncs { struct SpecialFuncs {
@ -164,7 +164,7 @@ struct SpecialFuncs {
void xxx(); void xxx();
} s; } s;
// CHECK: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(SpecialFuncs::baz) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: void SpecialFuncs::xxx() { // CHECK-NEXT: void SpecialFuncs::xxx() {
// CHECK-NEXT: } // CHECK-NEXT: }
void SpecialFuncs::xxx() {} void SpecialFuncs::xxx() {}
@ -172,8 +172,8 @@ void SpecialFuncs::xxx() {}
// CHECK: static void static_f_variant() { // CHECK: static void static_f_variant() {
// CHECK-NEXT: } // CHECK-NEXT: }
static void static_f_variant() {} static void static_f_variant() {}
// CHECK: #pragma omp declare variant(static_f_variant) match(implementation={vendor(unknown)}) // CHECK: #pragma omp declare variant(static_f_variant) match(implementation={vendor(score(0):unknown)})
// CHECK-NEXT: #pragma omp declare variant(static_f_variant) match(implementation={vendor(llvm)}) // CHECK-NEXT: #pragma omp declare variant(static_f_variant) match(implementation={vendor(score(0):llvm)})
// CHECK-NEXT: static void static_f() { // CHECK-NEXT: static void static_f() {
// CHECK-NEXT: } // CHECK-NEXT: }
#pragma omp declare variant(static_f_variant) match(xxx = {}) #pragma omp declare variant(static_f_variant) match(xxx = {})
@ -192,7 +192,7 @@ void bazzzz() {
// CHECK: int fn_linkage_variant(); // CHECK: int fn_linkage_variant();
// CHECK: extern "C" { // CHECK: extern "C" {
// CHECK: #pragma omp declare variant(fn_linkage_variant) match(implementation={vendor(xxx)}) // CHECK: #pragma omp declare variant(fn_linkage_variant) match(implementation={vendor(score(0):xxx)})
// CHECK: int fn_linkage(); // CHECK: int fn_linkage();
// CHECK: } // CHECK: }
int fn_linkage_variant(); int fn_linkage_variant();
@ -202,7 +202,7 @@ int fn_linkage();
} }
// CHECK: extern "C" int fn_linkage_variant1() // CHECK: extern "C" int fn_linkage_variant1()
// CHECK: #pragma omp declare variant(fn_linkage_variant1) match(implementation={vendor(xxx)}) // CHECK: #pragma omp declare variant(fn_linkage_variant1) match(implementation={vendor(score(0):xxx)})
// CHECK: int fn_linkage1(); // CHECK: int fn_linkage1();
extern "C" int fn_linkage_variant1(); extern "C" int fn_linkage_variant1();
#pragma omp declare variant(fn_linkage_variant1) match(implementation = {vendor(xxx)}) #pragma omp declare variant(fn_linkage_variant1) match(implementation = {vendor(xxx)})