This is an archive of the discontinued LLVM Phabricator instance.

Differential D64471

Loop pragma parsing. NFC.
ClosedPublic

Authored by SjoerdMeijer on Jul 10 2019, 1:16 AM.

Details

Reviewers
Meinersbur
dmgreen
samparker
Commits
rG6b61519995e7: Loop pragma parsing. NFC.
rL365629: Loop pragma parsing. NFC.
rC365629: Loop pragma parsing. NFC.
Summary

I would like to add some pragma handling here, but couldn't resist a little NFC and tidy up first.

Diff Detail

Event Timeline

SjoerdMeijer created this revision.Jul 10 2019, 1:16 AM
samparker accepted this revision.Jul 10 2019, 5:03 AM

LGTM

This revision is now accepted and ready to land.Jul 10 2019, 5:03 AM
Closed by commit rL365629: Loop pragma parsing. NFC. (authored by SjoerdMeijer). · Explain WhyJul 10 2019, 6:34 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptJul 10 2019, 6:34 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
SjoerdMeijer mentioned this in D64564: Loop pragma parsing. NFC..Jul 11 2019, 6:14 AM

Revision Contents

PathSize
clang/
lib/
Sema/
70 lines

Diff 208888

clang/lib/Sema/SemaStmtAttr.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A, static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange) { SourceRange) {
IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0); IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
IdentifierLoc *OptionLoc = A.getArgAsIdent(1); IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
IdentifierLoc *StateLoc = A.getArgAsIdent(2); IdentifierLoc *StateLoc = A.getArgAsIdent(2);
Expr *ValueExpr = A.getArgAsExpr(3); Expr *ValueExpr = A.getArgAsExpr(3);
bool PragmaUnroll = PragmaNameLoc->Ident->getName() == "unroll"; StringRef PragmaName =
bool PragmaNoUnroll = PragmaNameLoc->Ident->getName() == "nounroll"; llvm::StringSwitch<StringRef>(PragmaNameLoc->Ident->getName())
bool PragmaUnrollAndJam = PragmaNameLoc->Ident->getName() == "unroll_and_jam"; .Cases("unroll", "nounroll", "unroll_and_jam", "nounroll_and_jam",
bool PragmaNoUnrollAndJam = PragmaNameLoc->Ident->getName())
PragmaNameLoc->Ident->getName() == "nounroll_and_jam"; .Default("clang loop");
if (St->getStmtClass() != Stmt::DoStmtClass && if (St->getStmtClass() != Stmt::DoStmtClass &&
St->getStmtClass() != Stmt::ForStmtClass && St->getStmtClass() != Stmt::ForStmtClass &&
St->getStmtClass() != Stmt::CXXForRangeStmtClass && St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
St->getStmtClass() != Stmt::WhileStmtClass) { St->getStmtClass() != Stmt::WhileStmtClass) {
const char *Pragma = std::string Pragma = "#pragma " + std::string(PragmaName);
llvm::StringSwitch<const char *>(PragmaNameLoc->Ident->getName())
.Case("unroll", "#pragma unroll")
.Case("nounroll", "#pragma nounroll")
.Case("unroll_and_jam", "#pragma unroll_and_jam")
.Case("nounroll_and_jam", "#pragma nounroll_and_jam")
.Default("#pragma clang loop");
S.Diag(St->getBeginLoc(), diag::err_pragma_loop_precedes_nonloop) << Pragma; S.Diag(St->getBeginLoc(), diag::err_pragma_loop_precedes_nonloop) << Pragma;
return nullptr; return nullptr;
} }
LoopHintAttr::Spelling Spelling = LoopHintAttr::Spelling Spelling =
LoopHintAttr::Spelling(A.getAttributeSpellingListIndex()); LoopHintAttr::Spelling(A.getAttributeSpellingListIndex());
LoopHintAttr::OptionType Option; LoopHintAttr::OptionType Option;
LoopHintAttr::LoopHintState State; LoopHintAttr::LoopHintState State;
if (PragmaNoUnroll) {
// #pragma nounroll auto SetHints = [&Option, &State](LoopHintAttr::OptionType O,
Option = LoopHintAttr::Unroll; LoopHintAttr::LoopHintState S) {
State = LoopHintAttr::Disable; Option = O;
} else if (PragmaUnroll) { State = S;
if (ValueExpr) { };
if (PragmaName == "nounroll") {
SetHints(LoopHintAttr::Unroll, LoopHintAttr::Disable);
} else if (PragmaName == "unroll") {
// #pragma unroll N // #pragma unroll N
Option = LoopHintAttr::UnrollCount; if (ValueExpr)
State = LoopHintAttr::Numeric; SetHints(LoopHintAttr::UnrollCount, LoopHintAttr::Numeric);
} else { else
// #pragma unroll SetHints(LoopHintAttr::Unroll, LoopHintAttr::Enable);
Option = LoopHintAttr::Unroll; } else if (PragmaName == "nounroll_and_jam") {
State = LoopHintAttr::Enable; SetHints(LoopHintAttr::UnrollAndJam, LoopHintAttr::Disable);
} } else if (PragmaName == "unroll_and_jam") {
} else if (PragmaNoUnrollAndJam) {
// #pragma nounroll_and_jam
Option = LoopHintAttr::UnrollAndJam;
State = LoopHintAttr::Disable;
} else if (PragmaUnrollAndJam) {
if (ValueExpr) {
// #pragma unroll_and_jam N // #pragma unroll_and_jam N
Option = LoopHintAttr::UnrollAndJamCount; if (ValueExpr)
State = LoopHintAttr::Numeric; SetHints(LoopHintAttr::UnrollAndJamCount, LoopHintAttr::Numeric);
} else { else
// #pragma unroll_and_jam SetHints(LoopHintAttr::UnrollAndJam, LoopHintAttr::Enable);
Option = LoopHintAttr::UnrollAndJam;
State = LoopHintAttr::Enable;
}
} else { } else {
// #pragma clang loop ... // #pragma clang loop ...
assert(OptionLoc && OptionLoc->Ident && assert(OptionLoc && OptionLoc->Ident &&
"Attribute must have valid option info."); "Attribute must have valid option info.");
Option = llvm::StringSwitch<LoopHintAttr::OptionType>( Option = llvm::StringSwitch<LoopHintAttr::OptionType>(
OptionLoc->Ident->getName()) OptionLoc->Ident->getName())
.Case("vectorize", LoopHintAttr::Vectorize) .Case("vectorize", LoopHintAttr::Vectorize)
.Case("vectorize_width", LoopHintAttr::VectorizeWidth) .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines