Author: erichkeane Date: 2023-12-06T07:12:01-08:00 New Revision: 26f8e1461e24bd71dcd409d1fe88ddc1c7cf5da1
URL: https://github.com/llvm/llvm-project/commit/26f8e1461e24bd71dcd409d1fe88ddc1c7cf5da1 DIFF: https://github.com/llvm/llvm-project/commit/26f8e1461e24bd71dcd409d1fe88ddc1c7cf5da1.diff LOG: [OpenACC] NFC: Stop using 'getSpelling' while parsing OpenACC It was brought up during the cache review that we shouldn't be using 'getSpelling', and instead should use the IdentifierInfo itself. This patch replaces all uses of it. Added: Modified: clang/include/clang/Basic/DiagnosticParseKinds.td clang/lib/Parse/ParseOpenACC.cpp clang/test/ParserOpenACC/parse-constructs.c clang/test/ParserOpenACC/unimplemented.c clang/test/ParserOpenACC/unimplemented.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td index 21fe6066d5876..e0e199e0d7300 100644 --- a/clang/include/clang/Basic/DiagnosticParseKinds.td +++ b/clang/include/clang/Basic/DiagnosticParseKinds.td @@ -1362,7 +1362,7 @@ def warn_pragma_acc_unimplemented_clause_parsing : Warning<"OpenACC clause parsing not yet implemented">, InGroup<SourceUsesOpenACC>; def err_acc_invalid_directive - : Error<"invalid OpenACC directive '%select{%1|%1 %2}0'">; + : Error<"invalid OpenACC directive %select{%1|'%1 %2'}0">; def err_acc_missing_directive : Error<"expected OpenACC directive">; def err_acc_invalid_open_paren : Error<"expected clause-list or newline in OpenACC directive">; diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp index fb292f270d916..71cb665a56327 100644 --- a/clang/lib/Parse/ParseOpenACC.cpp +++ b/clang/lib/Parse/ParseOpenACC.cpp @@ -36,9 +36,12 @@ enum class OpenACCDirectiveKindEx { // identifies the first token), and doesn't fully handle 'enter data', 'exit // data', nor any of the 'atomic' variants, just the first token of each. So // this should only be used by `ParseOpenACCDirectiveKind`. -OpenACCDirectiveKindEx getOpenACCDirectiveKind(StringRef Name) { +OpenACCDirectiveKindEx getOpenACCDirectiveKind(Token Tok) { + if (!Tok.is(tok::identifier)) + return OpenACCDirectiveKindEx::Invalid; OpenACCDirectiveKind DirKind = - llvm::StringSwitch<OpenACCDirectiveKind>(Name) + llvm::StringSwitch<OpenACCDirectiveKind>( + Tok.getIdentifierInfo()->getName()) .Case("parallel", OpenACCDirectiveKind::Parallel) .Case("serial", OpenACCDirectiveKind::Serial) .Case("kernels", OpenACCDirectiveKind::Kernels) @@ -58,7 +61,8 @@ OpenACCDirectiveKindEx getOpenACCDirectiveKind(StringRef Name) { if (DirKind != OpenACCDirectiveKind::Invalid) return static_cast<OpenACCDirectiveKindEx>(DirKind); - return llvm::StringSwitch<OpenACCDirectiveKindEx>(Name) + return llvm::StringSwitch<OpenACCDirectiveKindEx>( + Tok.getIdentifierInfo()->getName()) .Case("enter", OpenACCDirectiveKindEx::Enter) .Case("exit", OpenACCDirectiveKindEx::Exit) .Default(OpenACCDirectiveKindEx::Invalid); @@ -66,8 +70,11 @@ OpenACCDirectiveKindEx getOpenACCDirectiveKind(StringRef Name) { // Since 'atomic' is effectively a compound directive, this will decode the // second part of the directive. -OpenACCAtomicKind getOpenACCAtomicKind(StringRef Name) { - return llvm::StringSwitch<OpenACCAtomicKind>(Name) +OpenACCAtomicKind getOpenACCAtomicKind(Token Tok) { + if (!Tok.is(tok::identifier)) + return OpenACCAtomicKind::Invalid; + return llvm::StringSwitch<OpenACCAtomicKind>( + Tok.getIdentifierInfo()->getName()) .Case("read", OpenACCAtomicKind::Read) .Case("write", OpenACCAtomicKind::Write) .Case("update", OpenACCAtomicKind::Update) @@ -75,22 +82,25 @@ OpenACCAtomicKind getOpenACCAtomicKind(StringRef Name) { .Default(OpenACCAtomicKind::Invalid); } -bool isOpenACCDirectiveKind(OpenACCDirectiveKind Kind, StringRef Tok) { +bool isOpenACCDirectiveKind(OpenACCDirectiveKind Kind, Token Tok) { + if (!Tok.is(tok::identifier)) + return false; + switch (Kind) { case OpenACCDirectiveKind::Parallel: - return Tok == "parallel"; + return Tok.getIdentifierInfo()->isStr("parallel"); case OpenACCDirectiveKind::Serial: - return Tok == "serial"; + return Tok.getIdentifierInfo()->isStr("serial"); case OpenACCDirectiveKind::Kernels: - return Tok == "kernels"; + return Tok.getIdentifierInfo()->isStr("kernels"); case OpenACCDirectiveKind::Data: - return Tok == "data"; + return Tok.getIdentifierInfo()->isStr("data"); case OpenACCDirectiveKind::HostData: - return Tok == "host_data"; + return Tok.getIdentifierInfo()->isStr("host_data"); case OpenACCDirectiveKind::Loop: - return Tok == "loop"; + return Tok.getIdentifierInfo()->isStr("loop"); case OpenACCDirectiveKind::Cache: - return Tok == "cache"; + return Tok.getIdentifierInfo()->isStr("cache"); case OpenACCDirectiveKind::ParallelLoop: case OpenACCDirectiveKind::SerialLoop: @@ -100,19 +110,19 @@ bool isOpenACCDirectiveKind(OpenACCDirectiveKind Kind, StringRef Tok) { return false; case OpenACCDirectiveKind::Atomic: - return Tok == "atomic"; + return Tok.getIdentifierInfo()->isStr("atomic"); case OpenACCDirectiveKind::Routine: - return Tok == "routine"; + return Tok.getIdentifierInfo()->isStr("routine"); case OpenACCDirectiveKind::Declare: - return Tok == "declare"; + return Tok.getIdentifierInfo()->isStr("declare"); case OpenACCDirectiveKind::Init: - return Tok == "init"; + return Tok.getIdentifierInfo()->isStr("init"); case OpenACCDirectiveKind::Shutdown: - return Tok == "shutdown"; + return Tok.getIdentifierInfo()->isStr("shutdown"); case OpenACCDirectiveKind::Set: - return Tok == "set"; + return Tok.getIdentifierInfo()->isStr("set"); case OpenACCDirectiveKind::Update: - return Tok == "update"; + return Tok.getIdentifierInfo()->isStr("update"); case OpenACCDirectiveKind::Invalid: return false; } @@ -121,20 +131,22 @@ bool isOpenACCDirectiveKind(OpenACCDirectiveKind Kind, StringRef Tok) { OpenACCDirectiveKind ParseOpenACCEnterExitDataDirective(Parser &P, Token FirstTok, - StringRef FirstTokSpelling, OpenACCDirectiveKindEx ExtDirKind) { Token SecondTok = P.getCurToken(); if (SecondTok.isAnnotation()) { - P.Diag(FirstTok, diag::err_acc_invalid_directive) << 0 << FirstTokSpelling; + P.Diag(FirstTok, diag::err_acc_invalid_directive) + << 0 << FirstTok.getIdentifierInfo(); return OpenACCDirectiveKind::Invalid; } - std::string SecondTokSpelling = P.getPreprocessor().getSpelling(SecondTok); - - if (!isOpenACCDirectiveKind(OpenACCDirectiveKind::Data, SecondTokSpelling)) { - P.Diag(FirstTok, diag::err_acc_invalid_directive) - << 1 << FirstTokSpelling << SecondTokSpelling; + if (!isOpenACCDirectiveKind(OpenACCDirectiveKind::Data, SecondTok)) { + if (!SecondTok.is(tok::identifier)) + P.Diag(SecondTok, diag::err_expected) << tok::identifier; + else + P.Diag(FirstTok, diag::err_acc_invalid_directive) + << 1 << FirstTok.getIdentifierInfo()->getName() + << SecondTok.getIdentifierInfo()->getName(); return OpenACCDirectiveKind::Invalid; } @@ -152,9 +164,7 @@ OpenACCAtomicKind ParseOpenACCAtomicKind(Parser &P) { if (AtomicClauseToken.isAnnotation()) return OpenACCAtomicKind::Update; - std::string AtomicClauseSpelling = - P.getPreprocessor().getSpelling(AtomicClauseToken); - OpenACCAtomicKind AtomicKind = getOpenACCAtomicKind(AtomicClauseSpelling); + OpenACCAtomicKind AtomicKind = getOpenACCAtomicKind(AtomicClauseToken); // If we don't know what this is, treat it as 'nothing', and treat the rest of // this as a clause list, which, despite being invalid, is likely what the @@ -178,9 +188,8 @@ OpenACCDirectiveKind ParseOpenACCDirectiveKind(Parser &P) { } P.ConsumeToken(); - std::string FirstTokSpelling = P.getPreprocessor().getSpelling(FirstTok); - OpenACCDirectiveKindEx ExDirKind = getOpenACCDirectiveKind(FirstTokSpelling); + OpenACCDirectiveKindEx ExDirKind = getOpenACCDirectiveKind(FirstTok); // OpenACCDirectiveKindEx is meant to be an extended list // over OpenACCDirectiveKind, so any value below Invalid is one of the @@ -190,14 +199,17 @@ OpenACCDirectiveKind ParseOpenACCDirectiveKind(Parser &P) { // immediately cast it and use it as that. if (ExDirKind >= OpenACCDirectiveKindEx::Invalid) { switch (ExDirKind) { - case OpenACCDirectiveKindEx::Invalid: - P.Diag(FirstTok, diag::err_acc_invalid_directive) - << 0 << FirstTokSpelling; + case OpenACCDirectiveKindEx::Invalid: { + if (!FirstTok.is(tok::identifier)) + P.Diag(FirstTok, diag::err_expected) << tok::identifier; + else + P.Diag(FirstTok, diag::err_acc_invalid_directive) + << 0 << FirstTok.getIdentifierInfo(); return OpenACCDirectiveKind::Invalid; + } case OpenACCDirectiveKindEx::Enter: case OpenACCDirectiveKindEx::Exit: - return ParseOpenACCEnterExitDataDirective(P, FirstTok, FirstTokSpelling, - ExDirKind); + return ParseOpenACCEnterExitDataDirective(P, FirstTok, ExDirKind); } } @@ -208,8 +220,7 @@ OpenACCDirectiveKind ParseOpenACCDirectiveKind(Parser &P) { // clause. Token SecondTok = P.getCurToken(); if (!SecondTok.isAnnotation() && - isOpenACCDirectiveKind(OpenACCDirectiveKind::Loop, - P.getPreprocessor().getSpelling(SecondTok))) { + isOpenACCDirectiveKind(OpenACCDirectiveKind::Loop, SecondTok)) { switch (DirKind) { default: // Nothing to do except in the below cases, as they should be diagnosed as diff --git a/clang/test/ParserOpenACC/parse-constructs.c b/clang/test/ParserOpenACC/parse-constructs.c index f0f9d75ade1fb..b745f54bd715c 100644 --- a/clang/test/ParserOpenACC/parse-constructs.c +++ b/clang/test/ParserOpenACC/parse-constructs.c @@ -61,7 +61,7 @@ void func() { // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} #pragma acc enter for(;;){} - // expected-error@+3{{invalid OpenACC directive 'exit }'}} + // expected-error@+3{{expected identifier}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} #pragma acc exit } diff --git a/clang/test/ParserOpenACC/unimplemented.c b/clang/test/ParserOpenACC/unimplemented.c index dd2e8bea74709..2927e685d30b5 100644 --- a/clang/test/ParserOpenACC/unimplemented.c +++ b/clang/test/ParserOpenACC/unimplemented.c @@ -1,26 +1,26 @@ // RUN: %clang_cc1 %s -verify -fopenacc // Parser::ParseExternalDeclaration -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented int foo; struct S { // Parser::ParseStructUnionBody -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented int foo; }; void func() { // Parser::ParseStmtOrDeclarationAfterAttributes -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented while(0) {} } diff --git a/clang/test/ParserOpenACC/unimplemented.cpp b/clang/test/ParserOpenACC/unimplemented.cpp index 4f6c5a649065e..77619c9ae6551 100644 --- a/clang/test/ParserOpenACC/unimplemented.cpp +++ b/clang/test/ParserOpenACC/unimplemented.cpp @@ -1,26 +1,26 @@ // RUN: %clang_cc1 %s -verify -fopenacc // Parser::ParseExternalDeclaration -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented int foo; struct S { // Parser::ParseCXXClassMemberDeclarationWithPragmas -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented int foo; }; void func() { // Parser::ParseStmtOrDeclarationAfterAttributes -// expected-error@+3{{invalid OpenACC directive 'not'}} +// expected-error@+3{{invalid OpenACC directive 'havent'}} // expected-warning@+2{{OpenACC clause parsing not yet implemented}} // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}} -#pragma acc not yet implemented +#pragma acc havent implemented while(false) {} } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
