head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.2 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.23; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.03.04.19.54.52; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid 29z1hJonZISIXprx; 1.1.1.4 date 2014.05.30.18.14.42; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.34; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.30; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.03; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.35.27; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.34.56; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.31.04; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.25; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.03.04.19.54.52; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.28; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.34; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.29; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.39; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.25; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- Pragma.cpp - Pragma registration and handling --------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the PragmaHandler/PragmaTable interfaces and implements // pragma related methods of the Preprocessor class. // //===----------------------------------------------------------------------===// #include "clang/Lex/Pragma.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/ErrorHandling.h" #include using namespace clang; #include "llvm/Support/raw_ostream.h" // Out-of-line destructor to provide a home for the class. PragmaHandler::~PragmaHandler() { } //===----------------------------------------------------------------------===// // EmptyPragmaHandler Implementation. //===----------------------------------------------------------------------===// EmptyPragmaHandler::EmptyPragmaHandler() {} void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) {} //===----------------------------------------------------------------------===// // PragmaNamespace Implementation. //===----------------------------------------------------------------------===// PragmaNamespace::~PragmaNamespace() { for (llvm::StringMap::iterator I = Handlers.begin(), E = Handlers.end(); I != E; ++I) delete I->second; } /// FindHandler - Check to see if there is already a handler for the /// specified name. If not, return the handler for the null identifier if it /// exists, otherwise return null. If IgnoreNull is true (the default) then /// the null handler isn't returned on failure to match. PragmaHandler *PragmaNamespace::FindHandler(StringRef Name, bool IgnoreNull) const { if (PragmaHandler *Handler = Handlers.lookup(Name)) return Handler; return IgnoreNull ? 0 : Handlers.lookup(StringRef()); } void PragmaNamespace::AddPragma(PragmaHandler *Handler) { assert(!Handlers.lookup(Handler->getName()) && "A handler with this name is already registered in this namespace"); llvm::StringMapEntry &Entry = Handlers.GetOrCreateValue(Handler->getName()); Entry.setValue(Handler); } void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) { assert(Handlers.lookup(Handler->getName()) && "Handler not registered in this namespace"); Handlers.erase(Handler->getName()); } void PragmaNamespace::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro // expand it, the user can have a STDC #define, that should not affect this. PP.LexUnexpandedToken(Tok); // Get the handler for this token. If there is no handler, ignore the pragma. PragmaHandler *Handler = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName() : StringRef(), /*IgnoreNull=*/false); if (Handler == 0) { PP.Diag(Tok, diag::warn_pragma_ignored); return; } // Otherwise, pass it down. Handler->HandlePragma(PP, Introducer, Tok); } //===----------------------------------------------------------------------===// // Preprocessor Pragma Directive Handling. //===----------------------------------------------------------------------===// /// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the /// rest of the pragma, passing it to the registered pragma handlers. void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, PragmaIntroducerKind Introducer) { if (Callbacks) Callbacks->PragmaDirective(IntroducerLoc, Introducer); if (!PragmasEnabled) return; ++NumPragma; // Invoke the first level of pragma handlers which reads the namespace id. Token Tok; PragmaHandlers->HandlePragma(*this, Introducer, Tok); // If the pragma handler didn't read the rest of the line, consume it now. if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective)) DiscardUntilEndOfDirective(); } namespace { /// \brief Helper class for \see Preprocessor::Handle_Pragma. class LexingFor_PragmaRAII { Preprocessor &PP; bool InMacroArgPreExpansion; bool Failed; Token &OutTok; Token PragmaTok; public: LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion, Token &Tok) : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), Failed(false), OutTok(Tok) { if (InMacroArgPreExpansion) { PragmaTok = OutTok; PP.EnableBacktrackAtThisPos(); } } ~LexingFor_PragmaRAII() { if (InMacroArgPreExpansion) { if (Failed) { PP.CommitBacktrackedTokens(); } else { PP.Backtrack(); OutTok = PragmaTok; } } } void failed() { Failed = true; } }; } /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then /// return the first token after the directive. The _Pragma token has just /// been read into 'Tok'. void Preprocessor::Handle_Pragma(Token &Tok) { // This works differently if we are pre-expanding a macro argument. // In that case we don't actually "activate" the pragma now, we only lex it // until we are sure it is lexically correct and then we backtrack so that // we activate the pragma whenever we encounter the tokens again in the token // stream. This ensures that we will activate it in the correct location // or that we will ignore it if it never enters the token stream, e.g: // // #define EMPTY(x) // #define INACTIVE(x) EMPTY(x) // INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\"")) LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok); // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } // Read the '"..."'. Lex(Tok); if (!tok::isStringLiteral(Tok.getKind())) { Diag(PragmaLoc, diag::err__Pragma_malformed); // Skip this token, and the ')', if present. if (Tok.isNot(tok::r_paren)) Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); // Skip this token, and the ')', if present. Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } // Remember the string. Token StrTok = Tok; // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } if (InMacroArgPreExpansion) return; SourceLocation RParenLoc = Tok.getLocation(); std::string StrVal = getSpelling(StrTok); // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1: // "The string literal is destringized by deleting any encoding prefix, // deleting the leading and trailing double-quotes, replacing each escape // sequence \" by a double-quote, and replacing each escape sequence \\ by a // single backslash." if (StrVal[0] == 'L' || StrVal[0] == 'U' || (StrVal[0] == 'u' && StrVal[1] != '8')) StrVal.erase(StrVal.begin()); else if (StrVal[0] == 'u') StrVal.erase(StrVal.begin(), StrVal.begin() + 2); if (StrVal[0] == 'R') { // FIXME: C++11 does not specify how to handle raw-string-literals here. // We strip off the 'R', the quotes, the d-char-sequences, and the parens. assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' && "Invalid raw string token!"); // Measure the length of the d-char-sequence. unsigned NumDChars = 0; while (StrVal[2 + NumDChars] != '(') { assert(NumDChars < (StrVal.size() - 5) / 2 && "Invalid raw string token!"); ++NumDChars; } assert(StrVal[StrVal.size() - 2 - NumDChars] == ')'); // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the // parens below. StrVal.erase(0, 2 + NumDChars); StrVal.erase(StrVal.size() - 1 - NumDChars); } else { assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Remove escaped quotes and escapes. unsigned ResultPos = 1; for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) { // Skip escapes. \\ -> '\' and \" -> '"'. if (StrVal[i] == '\\' && i + 1 < e && (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"')) ++i; StrVal[ResultPos++] = StrVal[i]; } StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1); } // Remove the front quote, replacing it with a space, so that the pragma // contents appear to have a space before them. StrVal[0] = ' '; // Replace the terminating quote with a \n. StrVal[StrVal.size()-1] = '\n'; // Plop the string (including the newline and trailing null) into a buffer // where we can lex it. Token TmpTok; TmpTok.startToken(); CreateString(StrVal, TmpTok); SourceLocation TokLoc = TmpTok.getLocation(); // Make and enter a lexer object so that we lex and expand the tokens just // like any others. Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc, StrVal.size(), *this); EnterSourceFileWithLexer(TL, 0); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK__Pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text /// is not enclosed within a string literal. void Preprocessor::HandleMicrosoft__pragma(Token &Tok) { // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return; } // Get the tokens enclosed within the __pragma(), as well as the final ')'. SmallVector PragmaToks; int NumParens = 0; Lex(Tok); while (Tok.isNot(tok::eof)) { PragmaToks.push_back(Tok); if (Tok.is(tok::l_paren)) NumParens++; else if (Tok.is(tok::r_paren) && NumParens-- == 0) break; Lex(Tok); } if (Tok.is(tok::eof)) { Diag(PragmaLoc, diag::err_unterminated___pragma); return; } PragmaToks.front().setFlag(Token::LeadingSpace); // Replace the ')' with an EOD to mark the end of the pragma. PragmaToks.back().setKind(tok::eod); Token *TokArray = new Token[PragmaToks.size()]; std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray); // Push the tokens onto the stack. EnterTokenStream(TokArray, PragmaToks.size(), true, true); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK___pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'. /// void Preprocessor::HandlePragmaOnce(Token &OnceTok) { if (isInPrimaryFile()) { Diag(OnceTok, diag::pp_pragma_once_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. // Mark the file as a once-only file now. HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry()); } void Preprocessor::HandlePragmaMark() { assert(CurPPLexer && "No current lexer?"); if (CurLexer) CurLexer->ReadToEndOfLine(); else CurPTHLexer->DiscardToEndOfLine(); } /// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'. /// void Preprocessor::HandlePragmaPoison(Token &PoisonTok) { Token Tok; while (1) { // Read the next token to poison. While doing this, pretend that we are // skipping while reading the identifier to poison. // This avoids errors on code like: // #pragma GCC poison X // #pragma GCC poison X if (CurPPLexer) CurPPLexer->LexingRawMode = true; LexUnexpandedToken(Tok); if (CurPPLexer) CurPPLexer->LexingRawMode = false; // If we reached the end of line, we're done. if (Tok.is(tok::eod)) return; // Can only poison identifiers. if (Tok.isNot(tok::raw_identifier)) { Diag(Tok, diag::err_pp_invalid_poison); return; } // Look up the identifier info for the token. We disabled identifier lookup // by saying we're skipping contents, so we need to do this manually. IdentifierInfo *II = LookUpIdentifierInfo(Tok); // Already poisoned. if (II->isPoisoned()) continue; // If this is a macro identifier, emit a warning. if (II->hasMacroDefinition()) Diag(Tok, diag::pp_poisoning_existing_macro); // Finally, poison it! II->setIsPoisoned(); if (II->isFromAST()) II->setChangedSinceDeserialization(); } } /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know /// that the whole directive has been parsed. void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) { if (isInPrimaryFile()) { Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. PreprocessorLexer *TheLexer = getCurrentFileLexer(); // Mark the file as a system header. HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry()); PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation()); if (PLoc.isInvalid()) return; unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename()); // Notify the client, if desired, that we are in a new source file. if (Callbacks) Callbacks->FileChanged(SysHeaderTok.getLocation(), PPCallbacks::SystemHeaderPragma, SrcMgr::C_System); // Emit a line marker. This will change any source locations from this point // forward to realize they are in a system header. // Create a line note with this information. SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1, FilenameID, /*IsEntry=*/false, /*IsExit=*/false, /*IsSystem=*/true, /*IsExternC=*/false); } /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah. /// void Preprocessor::HandlePragmaDependency(Token &DependencyTok) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // If the token kind is EOD, the error has already been diagnosed. if (FilenameTok.is(tok::eod)) return; // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; bool Invalid = false; StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid); if (Invalid) return; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) return; // Search include directories for this file. const DirectoryLookup *CurDir; const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, isAngled, 0, CurDir, NULL, NULL, NULL); if (File == 0) { if (!SuppressIncludeNotFoundError) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; return; } const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry(); // If this file is older than the file it depends on, emit a diagnostic. if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) { // Lex tokens at the end of the message and include them in the message. std::string Message; Lex(DependencyTok); while (DependencyTok.isNot(tok::eod)) { Message += getSpelling(DependencyTok) + " "; Lex(DependencyTok); } // Remove the trailing ' ' if present. if (!Message.empty()) Message.erase(Message.end()-1); Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message; } } /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro. /// Return the IdentifierInfo* associated with the macro to push or pop. IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { // Remember the pragma token location. Token PragmaTok = Tok; // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } // Read the macro name string. Lex(Tok); if (Tok.isNot(tok::string_literal)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); return 0; } // Remember the macro string. std::string StrVal = getSpelling(Tok); // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Create a Token from the string. Token MacroTok; MacroTok.startToken(); MacroTok.setKind(tok::raw_identifier); CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok); // Get the IdentifierInfo of MacroToPushTok. return LookUpIdentifierInfo(MacroTok); } /// \brief Handle \#pragma push_macro. /// /// The syntax is: /// \code /// #pragma push_macro("macro") /// \endcode void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) { // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok); if (!IdentInfo) return; // Get the MacroInfo associated with IdentInfo. MacroInfo *MI = getMacroInfo(IdentInfo); if (MI) { // Allow the original MacroInfo to be redefined later. MI->setIsAllowRedefinitionsWithoutWarning(true); } // Push the cloned MacroInfo so we can retrieve it later. PragmaPushMacroInfo[IdentInfo].push_back(MI); } /// \brief Handle \#pragma pop_macro. /// /// The syntax is: /// \code /// #pragma pop_macro("macro") /// \endcode void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) { SourceLocation MessageLoc = PopMacroTok.getLocation(); // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok); if (!IdentInfo) return; // Find the vector associated with the macro. llvm::DenseMap >::iterator iter = PragmaPushMacroInfo.find(IdentInfo); if (iter != PragmaPushMacroInfo.end()) { // Forget the MacroInfo currently associated with IdentInfo. if (MacroDirective *CurrentMD = getMacroDirective(IdentInfo)) { MacroInfo *MI = CurrentMD->getMacroInfo(); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc)); } // Get the MacroInfo we want to reinstall. MacroInfo *MacroToReInstall = iter->second.back(); if (MacroToReInstall) { // Reinstall the previously pushed macro. appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc, /*isImported=*/false); } // Pop PragmaPushMacroInfo stack. iter->second.pop_back(); if (iter->second.size() == 0) PragmaPushMacroInfo.erase(iter); } else { Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push) << IdentInfo->getName(); } } void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) { // We will either get a quoted filename or a bracketed filename, and we // have to track which we got. The first filename is the source name, // and the second name is the mapped filename. If the first is quoted, // the second must be as well (cannot mix and match quotes and brackets). // Get the open paren Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << "("; return; } // We expect either a quoted string literal, or a bracketed name Token SourceFilenameTok; CurPPLexer->LexIncludeFilename(SourceFilenameTok); if (SourceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef SourceFileName; SmallString<128> FileNameBuffer; if (SourceFilenameTok.is(tok::string_literal) || SourceFilenameTok.is(tok::angle_string_literal)) { SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer); } else if (SourceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted SourceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } FileNameBuffer.clear(); // Now we expect a comma, followed by another include name Lex(Tok); if (Tok.isNot(tok::comma)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ","; return; } Token ReplaceFilenameTok; CurPPLexer->LexIncludeFilename(ReplaceFilenameTok); if (ReplaceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef ReplaceFileName; if (ReplaceFilenameTok.is(tok::string_literal) || ReplaceFilenameTok.is(tok::angle_string_literal)) { ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer); } else if (ReplaceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted ReplaceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } // Finally, we expect the closing paren Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ")"; return; } // Now that we have the source and target filenames, we need to make sure // they're both of the same type (angled vs non-angled) StringRef OriginalSource = SourceFileName; bool SourceIsAngled = GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(), SourceFileName); bool ReplaceIsAngled = GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(), ReplaceFileName); if (!SourceFileName.empty() && !ReplaceFileName.empty() && (SourceIsAngled != ReplaceIsAngled)) { unsigned int DiagID; if (SourceIsAngled) DiagID = diag::warn_pragma_include_alias_mismatch_angle; else DiagID = diag::warn_pragma_include_alias_mismatch_quote; Diag(SourceFilenameTok.getLocation(), DiagID) << SourceFileName << ReplaceFileName; return; } // Now we can let the include handler know about this mapping getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName); } /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. /// If 'Namespace' is non-null, then it is a token required to exist on the /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". void Preprocessor::AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *InsertNS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { // If there is already a pragma handler with the name of this namespace, // we either have an error (directive with the same name as a namespace) or // we already have the namespace to insert into. if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) { InsertNS = Existing->getIfNamespace(); assert(InsertNS != 0 && "Cannot have a pragma namespace and pragma" " handler with the same name!"); } else { // Otherwise, this namespace doesn't exist yet, create and insert the // handler for it. InsertNS = new PragmaNamespace(Namespace); PragmaHandlers->AddPragma(InsertNS); } } // Check to make sure we don't already have a pragma for this identifier. assert(!InsertNS->FindHandler(Handler->getName()) && "Pragma handler already exists for this identifier!"); InsertNS->AddPragma(Handler); } /// RemovePragmaHandler - Remove the specific pragma handler from the /// preprocessor. If \arg Namespace is non-null, then it should be the /// namespace that \arg Handler was added to. It is an error to remove /// a handler that has not been registered. void Preprocessor::RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *NS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace); assert(Existing && "Namespace containing handler does not exist!"); NS = Existing->getIfNamespace(); assert(NS && "Invalid namespace, registered as a regular pragma handler!"); } NS->RemovePragmaHandler(Handler); // If this is a non-default namespace and it is now empty, remove // it. if (NS != PragmaHandlers && NS->IsEmpty()) { PragmaHandlers->RemovePragmaHandler(NS); delete NS; } } bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) { Token Tok; LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("ON")) Result = tok::OOS_ON; else if (II->isStr("OFF")) Result = tok::OOS_OFF; else if (II->isStr("DEFAULT")) Result = tok::OOS_DEFAULT; else { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } // Verify that this is followed by EOD. LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) Diag(Tok, diag::ext_pragma_syntax_eod); return false; } namespace { /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. struct PragmaOnceHandler : public PragmaHandler { PragmaOnceHandler() : PragmaHandler("once") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OnceTok) { PP.CheckEndOfDirective("pragma once"); PP.HandlePragmaOnce(OnceTok); } }; /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the /// rest of the line is not lexed. struct PragmaMarkHandler : public PragmaHandler { PragmaMarkHandler() : PragmaHandler("mark") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) { PP.HandlePragmaMark(); } }; /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. struct PragmaPoisonHandler : public PragmaHandler { PragmaPoisonHandler() : PragmaHandler("poison") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) { PP.HandlePragmaPoison(PoisonTok); } }; /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file /// as a system header, which silences warnings in it. struct PragmaSystemHeaderHandler : public PragmaHandler { PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) { PP.HandlePragmaDependency(DepToken); } }; struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) { Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("assert")) { llvm_unreachable("This is an assertion!"); } else if (II->isStr("crash")) { LLVM_BUILTIN_TRAP; } else if (II->isStr("parser_crash")) { Token Crasher; Crasher.setKind(tok::annot_pragma_parser_crash); PP.EnterToken(Crasher); } else if (II->isStr("llvm_fatal_error")) { llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error"); } else if (II->isStr("llvm_unreachable")) { llvm_unreachable("#pragma clang __debug llvm_unreachable"); } else if (II->isStr("overflow_stack")) { DebugOverflowStack(); } else if (II->isStr("handle_crash")) { llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent(); if (CRC) CRC->HandleCrash(); } else if (II->isStr("captured")) { HandleCaptured(PP); } else { PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command) << II->getName(); } PPCallbacks *Callbacks = PP.getPPCallbacks(); if (Callbacks) Callbacks->PragmaDebug(Tok.getLocation(), II->getName()); } void HandleCaptured(Preprocessor &PP) { // Skip if emitting preprocessed output. if (PP.isPreprocessedOutput()) return; Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma clang __debug captured"; return; } SourceLocation NameLoc = Tok.getLocation(); Token *Toks = PP.getPreprocessorAllocator().Allocate(1); Toks->startToken(); Toks->setKind(tok::annot_pragma_captured); Toks->setLocation(NameLoc); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // Disable MSVC warning about runtime stack overflow. #ifdef _MSC_VER #pragma warning(disable : 4717) #endif void DebugOverflowStack() { DebugOverflowStack(); } #ifdef _MSC_VER #pragma warning(default : 4717) #endif }; /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"' struct PragmaDiagnosticHandler : public PragmaHandler { private: const char *Namespace; public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) { SourceLocation DiagLoc = DiagToken.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); PPCallbacks *Callbacks = PP.getPPCallbacks(); diag::Mapping Map; if (II->isStr("warning")) Map = diag::MAP_WARNING; else if (II->isStr("error")) Map = diag::MAP_ERROR; else if (II->isStr("ignored")) Map = diag::MAP_IGNORE; else if (II->isStr("fatal")) Map = diag::MAP_FATAL; else if (II->isStr("pop")) { if (!PP.getDiagnostics().popMappings(DiagLoc)) PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop); else if (Callbacks) Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace); return; } else if (II->isStr("push")) { PP.getDiagnostics().pushMappings(DiagLoc); if (Callbacks) Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace); return; } else { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } PP.LexUnexpandedToken(Tok); SourceLocation StringLoc = Tok.getLocation(); std::string WarningName; if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic", /*MacroExpansion=*/false)) return; if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); return; } if (WarningName.size() < 3 || WarningName[0] != '-' || WarningName[1] != 'W') { PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); return; } if (PP.getDiagnostics().setDiagnosticGroupMapping(WarningName.substr(2), Map, DiagLoc)) PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) << WarningName; else if (Callbacks) Callbacks->PragmaDiagnostic(DiagLoc, Namespace, Map, WarningName); } }; // Returns -1 on failure. static int LexSimpleInt(Preprocessor &PP, Token &Tok) { assert(Tok.is(tok::numeric_constant)); SmallString<8> IntegerBuffer; bool NumberInvalid = false; StringRef Spelling = PP.getSpelling(Tok, IntegerBuffer, &NumberInvalid); if (NumberInvalid) return -1; NumericLiteralParser Literal(Spelling, Tok.getLocation(), PP); if (Literal.hadError || !Literal.isIntegerLiteral() || Literal.hasUDSuffix()) return -1; llvm::APInt APVal(32, 0); if (Literal.GetIntegerValue(APVal)) return -1; PP.Lex(Tok); return int(APVal.getLimitedValue(INT_MAX)); } /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's /// diagnostics, so we don't really implement this pragma. We parse it and /// ignore it to avoid -Wunknown-pragma warnings. struct PragmaWarningHandler : public PragmaHandler { PragmaWarningHandler() : PragmaHandler("warning") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Parse things like: // warning(push, 1) // warning(pop) // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9) SourceLocation DiagLoc = Tok.getLocation(); PPCallbacks *Callbacks = PP.getPPCallbacks(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << "("; return; } PP.Lex(Tok); IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } if (II->isStr("push")) { // #pragma warning( push[ ,n ] ) int Level = -1; PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) Level = LexSimpleInt(PP, Tok); if (Level < 0 || Level > 4) { PP.Diag(Tok, diag::warn_pragma_warning_push_level); return; } } if (Callbacks) Callbacks->PragmaWarningPush(DiagLoc, Level); } else if (II->isStr("pop")) { // #pragma warning( pop ) PP.Lex(Tok); if (Callbacks) Callbacks->PragmaWarningPop(DiagLoc); } else { // #pragma warning( warning-specifier : warning-number-list // [; warning-specifier : warning-number-list...] ) while (true) { II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } // Figure out which warning specifier this is. StringRef Specifier = II->getName(); bool SpecifierValid = llvm::StringSwitch(Specifier) .Cases("1", "2", "3", "4", true) .Cases("default", "disable", "error", "once", "suppress", true) .Default(false); if (!SpecifierValid) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":"; return; } // Collect the warning ids. SmallVector Ids; PP.Lex(Tok); while (Tok.is(tok::numeric_constant)) { int Id = LexSimpleInt(PP, Tok); if (Id <= 0) { PP.Diag(Tok, diag::warn_pragma_warning_expected_number); return; } Ids.push_back(Id); } if (Callbacks) Callbacks->PragmaWarning(DiagLoc, Specifier, Ids); // Parse the next specifier if there is a semicolon. if (Tok.isNot(tok::semi)) break; PP.Lex(Tok); } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning"; } }; /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". struct PragmaIncludeAliasHandler : public PragmaHandler { PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &IncludeAliasTok) { PP.HandlePragmaIncludeAlias(IncludeAliasTok); } }; /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message /// extension. The syntax is: /// \code /// #pragma message(string) /// \endcode /// OR, in GCC mode: /// \code /// #pragma message string /// \endcode /// string is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters, etc... See MSDN for more details. /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same /// form as \#pragma message. struct PragmaMessageHandler : public PragmaHandler { private: const PPCallbacks::PragmaMessageKind Kind; const StringRef Namespace; static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind, bool PragmaNameOnly = false) { switch (Kind) { case PPCallbacks::PMK_Message: return PragmaNameOnly ? "message" : "pragma message"; case PPCallbacks::PMK_Warning: return PragmaNameOnly ? "warning" : "pragma warning"; case PPCallbacks::PMK_Error: return PragmaNameOnly ? "error" : "pragma error"; } llvm_unreachable("Unknown PragmaMessageKind!"); } public: PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind, StringRef Namespace = StringRef()) : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation MessageLoc = Tok.getLocation(); PP.Lex(Tok); bool ExpectClosingParen = false; switch (Tok.getKind()) { case tok::l_paren: // We have a MSVC style pragma message. ExpectClosingParen = true; // Read the string. PP.Lex(Tok); break; case tok::string_literal: // We have a GCC style pragma message, and we just read the string. break; default: PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind; return; } std::string MessageString; if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind), /*MacroExpansion=*/true)) return; if (ExpectClosingParen) { if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } PP.Lex(Tok); // eat the r_paren. } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } // Output the message. PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error) ? diag::err_pragma_message : diag::warn_pragma_message) << MessageString; // If the pragma is lexically sound, notify any interested PPCallbacks. if (PPCallbacks *Callbacks = PP.getPPCallbacks()) Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString); } }; /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the /// macro on the top of the stack. struct PragmaPushMacroHandler : public PragmaHandler { PragmaPushMacroHandler() : PragmaHandler("push_macro") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) { PP.HandlePragmaPushMacro(PushMacroTok); } }; /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the /// macro to the value on the top of the stack. struct PragmaPopMacroHandler : public PragmaHandler { PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) { PP.HandlePragmaPopMacro(PopMacroTok); } }; // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; /// PragmaARCCFCodeAuditedHandler - /// \#pragma clang arc_cf_code_audited begin/end struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; Token Tok; // Lex the 'begin' or 'end'. PP.LexUnexpandedToken(Tok); const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); if (BeginEnd && BeginEnd->isStr("begin")) { IsBegin = true; } else if (BeginEnd && BeginEnd->isStr("end")) { IsBegin = false; } else { PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax); return; } // Verify that this is followed by EOD. PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // The start location of the active audit. SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc(); // The start location we want after processing this. SourceLocation NewLoc; if (IsBegin) { // Complain about attempts to re-enter an audit. if (BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited); PP.Diag(BeginLoc, diag::note_pragma_entered_here); } NewLoc = Loc; } else { // Complain about attempts to leave an audit that doesn't exist. if (!BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited); return; } NewLoc = SourceLocation(); } PP.setPragmaARCCFCodeAuditedLoc(NewLoc); } }; /// \brief Handle "\#pragma region [...]" /// /// The syntax is /// \code /// #pragma region [optional name] /// #pragma endregion [optional comment] /// \endcode /// /// \note This is /// editor-only /// pragma, just skipped by compiler. struct PragmaRegionHandler : public PragmaHandler { PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) { // #pragma region: endregion matches can be verified // __pragma(region): no sense, but ignored by msvc // _Pragma is not valid for MSVC, but there isn't any point // to handle a _Pragma differently. } }; } // end anonymous namespace /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: /// \#pragma GCC poison/system_header/dependency and \#pragma once. void Preprocessor::RegisterBuiltinPragmas() { AddPragmaHandler(new PragmaOnceHandler()); AddPragmaHandler(new PragmaMarkHandler()); AddPragmaHandler(new PragmaPushMacroHandler()); AddPragmaHandler(new PragmaPopMacroHandler()); AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message)); // #pragma GCC ... AddPragmaHandler("GCC", new PragmaPoisonHandler()); AddPragmaHandler("GCC", new PragmaSystemHeaderHandler()); AddPragmaHandler("GCC", new PragmaDependencyHandler()); AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning, "GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error, "GCC")); // #pragma clang ... AddPragmaHandler("clang", new PragmaPoisonHandler()); AddPragmaHandler("clang", new PragmaSystemHeaderHandler()); AddPragmaHandler("clang", new PragmaDebugHandler()); AddPragmaHandler("clang", new PragmaDependencyHandler()); AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang")); AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler()); AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler()); AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler()); AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler()); // MS extensions. if (LangOpts.MicrosoftExt) { AddPragmaHandler(new PragmaWarningHandler()); AddPragmaHandler(new PragmaIncludeAliasHandler()); AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); } } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d929 2 a930 3 static void DebugOverflowStack() { void (*volatile Self)() = DebugOverflowStack; Self(); @ 1.1.1.3 log @Import Clang 3.5svn r202566. @ text @d51 3 a53 1 llvm::DeleteContainerSeconds(Handlers); d1011 18 d1063 2 a1064 4 uint64_t Value; if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) Level = int(Value); d1108 2 a1109 3 uint64_t Value; if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || Value > INT_MAX) { d1113 1 a1113 1 Ids.push_back(int(Value)); @ 1.1.1.3.2.1 log @Rebase. @ text @d62 1 a62 1 return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); d91 1 a91 1 if (!Handler) { d293 1 a293 1 EnterSourceFileWithLexer(TL, nullptr); d476 2 a477 3 isAngled, nullptr, CurDir, nullptr, nullptr, nullptr); if (!File) { d513 1 a513 1 return nullptr; d521 1 a521 1 return nullptr; d526 1 a526 1 return nullptr; d537 1 a537 1 return nullptr; d739 1 a739 1 assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma" d813 2 a814 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OnceTok) override { d824 2 a825 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) override { d833 2 a834 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) override { d843 2 a844 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) override { d851 2 a852 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { d859 2 a860 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { d944 2 a945 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) override { d1015 2 a1016 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1122 2 a1123 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &IncludeAliasTok) override { d1164 2 a1165 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1217 2 a1218 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) override { d1228 2 a1229 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) override { d1239 2 a1240 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1253 2 a1254 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1263 2 a1264 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { d1274 2 a1275 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { d1338 2 a1339 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { a1387 23 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise /// warn about those pragmas being unknown. void Preprocessor::IgnorePragmas() { AddPragmaHandler(new EmptyPragmaHandler()); // Also ignore all pragmas in all namespaces created // in Preprocessor::RegisterBuiltinPragmas(). AddPragmaHandler("GCC", new EmptyPragmaHandler()); AddPragmaHandler("clang", new EmptyPragmaHandler()); if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) { // Preprocessor::RegisterBuiltinPragmas() already registers // PragmaSTDC_UnknownHandler as the empty handler, so remove it first, // otherwise there will be an assert about a duplicate handler. PragmaNamespace *STDCNamespace = NS->getIfNamespace(); assert(STDCNamespace && "Invalid namespace, registered as a regular pragma handler!"); if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) { RemovePragmaHandler("STDC", Existing); delete Existing; } } AddPragmaHandler("STDC", new EmptyPragmaHandler()); } @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @d62 1 a62 1 return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); d91 1 a91 1 if (!Handler) { d293 1 a293 1 EnterSourceFileWithLexer(TL, nullptr); d476 2 a477 3 isAngled, nullptr, CurDir, nullptr, nullptr, nullptr); if (!File) { d513 1 a513 1 return nullptr; d521 1 a521 1 return nullptr; d526 1 a526 1 return nullptr; d537 1 a537 1 return nullptr; d739 1 a739 1 assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma" d813 2 a814 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OnceTok) override { d824 2 a825 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) override { d833 2 a834 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) override { d843 2 a844 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) override { d851 2 a852 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { d859 2 a860 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { d944 2 a945 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) override { d1015 2 a1016 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1122 2 a1123 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &IncludeAliasTok) override { d1164 2 a1165 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1217 2 a1218 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) override { d1228 2 a1229 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) override { d1239 2 a1240 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1253 2 a1254 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { d1263 2 a1264 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { d1274 2 a1275 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { d1338 2 a1339 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { a1387 23 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise /// warn about those pragmas being unknown. void Preprocessor::IgnorePragmas() { AddPragmaHandler(new EmptyPragmaHandler()); // Also ignore all pragmas in all namespaces created // in Preprocessor::RegisterBuiltinPragmas(). AddPragmaHandler("GCC", new EmptyPragmaHandler()); AddPragmaHandler("clang", new EmptyPragmaHandler()); if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) { // Preprocessor::RegisterBuiltinPragmas() already registers // PragmaSTDC_UnknownHandler as the empty handler, so remove it first, // otherwise there will be an assert about a duplicate handler. PragmaNamespace *STDCNamespace = NS->getIfNamespace(); assert(STDCNamespace && "Invalid namespace, registered as a regular pragma handler!"); if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) { RemovePragmaHandler("STDC", Existing); delete Existing; } } AddPragmaHandler("STDC", new EmptyPragmaHandler()); } @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d608 1 a608 1 /*isImported=*/false, /*Overrides*/None); d957 10 a966 1 if (II->isStr("pop")) { d977 1 a977 10 } diag::Severity SV = llvm::StringSwitch(II->getName()) .Case("ignored", diag::Severity::Ignored) .Case("warning", diag::Severity::Warning) .Case("error", diag::Severity::Error) .Case("fatal", diag::Severity::Fatal) .Default(diag::Severity()); if (SV == diag::Severity()) { d996 1 a996 1 (WarningName[1] != 'W' && WarningName[1] != 'R')) { d1001 2 a1002 4 if (PP.getDiagnostics().setSeverityForGroup( WarningName[1] == 'W' ? diag::Flavor::WarningOrError : diag::Flavor::Remark, WarningName.substr(2), SV, DiagLoc)) d1006 1 a1006 1 Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName); @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d68 3 a70 1 Handlers[Handler->getName()] = Handler; d196 1 a196 1 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof)) d475 3 a477 3 const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr, nullptr, CurDir, nullptr, nullptr, nullptr); d731 1 a731 1 PragmaNamespace *InsertNS = PragmaHandlers.get(); d762 1 a762 1 PragmaNamespace *NS = PragmaHandlers.get(); d775 3 a777 2 // If this is a non-default namespace and it is now empty, remove it. if (NS != PragmaHandlers.get() && NS->IsEmpty()) { @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d68 3 a70 1 Handlers[Handler->getName()] = Handler; d196 1 a196 1 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof)) d475 3 a477 3 const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr, nullptr, CurDir, nullptr, nullptr, nullptr); d731 1 a731 1 PragmaNamespace *InsertNS = PragmaHandlers.get(); d762 1 a762 1 PragmaNamespace *NS = PragmaHandlers.get(); d775 3 a777 2 // If this is a non-default namespace and it is now empty, remove it. if (NS != PragmaHandlers.get() && NS->IsEmpty()) { @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @a24 1 #include "llvm/ADT/StringExtras.h" d40 1 a40 1 EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {} d193 1 a193 1 // Skip bad tokens, and the ')', if present. a195 4 while (Tok.isNot(tok::r_paren) && !Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) Lex(Tok); d403 1 a403 1 if (isMacroDefined(II)) d593 2 a594 1 if (MacroInfo *MI = getMacroInfo(IdentInfo)) { d603 1 a603 1 if (MacroToReInstall) d605 3 a607 1 appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc); d651 1 a651 1 SourceFileName = FileNameBuffer; d682 1 a682 1 ReplaceFileName = FileNameBuffer; a872 1 Crasher.startToken(); a873 1 Crasher.setAnnotationRange(SourceRange(Tok.getLocation())); a874 16 } else if (II->isStr("dump")) { Token Identifier; PP.LexUnexpandedToken(Identifier); if (auto *DumpII = Identifier.getIdentifierInfo()) { Token DumpAnnot; DumpAnnot.startToken(); DumpAnnot.setKind(tok::annot_pragma_dump); DumpAnnot.setAnnotationRange( SourceRange(Tok.getLocation(), Identifier.getLocation())); DumpAnnot.setAnnotationValue(DumpII); PP.DiscardUntilEndOfDirective(); PP.EnterToken(DumpAnnot); } else { PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument) << II->getName(); } a878 9 } else if (II->isStr("macro")) { Token MacroName; PP.LexUnexpandedToken(MacroName); auto *MacroII = MacroName.getIdentifierInfo(); if (MacroII) PP.dumpMacroInfo(MacroII); else PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument) << II->getName(); d1032 4 d1037 1 a1037 1 if (II && II->isStr("push")) { d1054 1 a1054 1 } else if (II && II->isStr("pop")) { d1064 1 a1064 1 if (!II && !Tok.is(tok::numeric_constant)) { d1070 6 a1075 24 bool SpecifierValid; StringRef Specifier; llvm::SmallString<1> SpecifierBuf; if (II) { Specifier = II->getName(); SpecifierValid = llvm::StringSwitch(Specifier) .Cases("default", "disable", "error", "once", "suppress", true) .Default(false); // If we read a correct specifier, snatch next token (that should be // ":", checked later). if (SpecifierValid) PP.Lex(Tok); } else { // Token is a numeric constant. It should be either 1, 2, 3 or 4. uint64_t Value; Specifier = PP.getSpelling(Tok, SpecifierBuf); if (PP.parseSimpleIntegerLiteral(Tok, Value)) { SpecifierValid = (Value >= 1) && (Value <= 4); } else SpecifierValid = false; // Next token already snatched by parseSimpleIntegerLiteral. } d1080 1 a1323 54 /// PragmaAssumeNonNullHandler - /// \#pragma clang assume_nonnull begin/end struct PragmaAssumeNonNullHandler : public PragmaHandler { PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; Token Tok; // Lex the 'begin' or 'end'. PP.LexUnexpandedToken(Tok); const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); if (BeginEnd && BeginEnd->isStr("begin")) { IsBegin = true; } else if (BeginEnd && BeginEnd->isStr("end")) { IsBegin = false; } else { PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax); return; } // Verify that this is followed by EOD. PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // The start location of the active audit. SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc(); // The start location we want after processing this. SourceLocation NewLoc; if (IsBegin) { // Complain about attempts to re-enter an audit. if (BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull); PP.Diag(BeginLoc, diag::note_pragma_entered_here); } NewLoc = Loc; } else { // Complain about attempts to leave an audit that doesn't exist. if (!BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull); return; } NewLoc = SourceLocation(); } PP.setPragmaAssumeNonNullLoc(NewLoc); } }; a1374 1 AddPragmaHandler("clang", new PragmaAssumeNonNullHandler()); @ 1.1.1.7.2.1 log @Sync with HEAD @ text @a16 2 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/SourceLocation.h" a17 1 #include "clang/Basic/TokenKinds.h" d20 1 a21 1 #include "clang/Lex/PPCallbacks.h" a22 8 #include "clang/Lex/PreprocessorLexer.h" #include "clang/Lex/PTHLexer.h" #include "clang/Lex/Token.h" #include "clang/Lex/TokenLexer.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" d25 1 a26 1 #include "llvm/Support/Compiler.h" d29 1 a29 5 #include #include #include #include #include d31 1 a31 1 using namespace clang; a125 1 d160 1 a160 2 } // end anonymous namespace d267 1 a267 1 for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) { d357 1 a357 5 // Don't honor the 'once' when handling the primary source file, unless // this is a prefix to a TU, which indicates we're generating a PCH file, or // when the main file is a header (e.g. when -xc-header is provided on the // commandline). if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) { d375 1 d378 1 a378 1 void Preprocessor::HandlePragmaPoison() { d381 1 a381 1 while (true) { d613 1 a613 1 if (iter->second.empty()) a809 1 a823 1 a832 1 d835 1 a835 1 PP.HandlePragmaPoison(); a842 1 a848 1 a850 1 a858 1 d941 4 a944 5 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(1), 1); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_captured); Toks[0].setLocation(NameLoc); d946 2 a947 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); a967 1 a970 1 d1027 4 a1030 13 diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError : diag::Flavor::Remark; StringRef Group = StringRef(WarningName).substr(2); bool unknownDiag = false; if (Group == "everything") { // Special handling for pragma clang diagnostic ... "-Weverything". // There is no formal group named "everything", so there has to be a // special case for it. PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc); } else unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV, DiagLoc); if (unknownDiag) d1134 1 a1134 1 Value > std::numeric_limits::max()) { a1258 1 d1265 1 a1269 1 a1280 1 a1294 1 a1304 1 a1315 1 a1369 1 d1443 2 a1444 1 } // end anonymous namespace a1483 7 // Pragmas added by plugins for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(), ie = PragmaHandlerRegistry::end(); it != ie; ++it) { AddPragmaHandler(it->instantiate().release()); } @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @a16 2 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/SourceLocation.h" a17 1 #include "clang/Basic/TokenKinds.h" d20 1 a21 1 #include "clang/Lex/PPCallbacks.h" a22 8 #include "clang/Lex/PreprocessorLexer.h" #include "clang/Lex/PTHLexer.h" #include "clang/Lex/Token.h" #include "clang/Lex/TokenLexer.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" d25 1 a26 1 #include "llvm/Support/Compiler.h" d29 1 a29 5 #include #include #include #include #include d31 1 a31 1 using namespace clang; a125 1 d160 1 a160 2 } // end anonymous namespace d267 1 a267 1 for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) { d357 1 a357 5 // Don't honor the 'once' when handling the primary source file, unless // this is a prefix to a TU, which indicates we're generating a PCH file, or // when the main file is a header (e.g. when -xc-header is provided on the // commandline). if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) { d375 1 d378 1 a378 1 void Preprocessor::HandlePragmaPoison() { d381 1 a381 1 while (true) { d613 1 a613 1 if (iter->second.empty()) a809 1 a823 1 a832 1 d835 1 a835 1 PP.HandlePragmaPoison(); a842 1 a848 1 a850 1 a858 1 d941 4 a944 5 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(1), 1); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_captured); Toks[0].setLocation(NameLoc); d946 2 a947 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); a967 1 a970 1 d1027 4 a1030 13 diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError : diag::Flavor::Remark; StringRef Group = StringRef(WarningName).substr(2); bool unknownDiag = false; if (Group == "everything") { // Special handling for pragma clang diagnostic ... "-Weverything". // There is no formal group named "everything", so there has to be a // special case for it. PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc); } else unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV, DiagLoc); if (unknownDiag) d1134 1 a1134 1 Value > std::numeric_limits::max()) { a1258 1 d1265 1 a1269 1 a1280 1 a1294 1 a1304 1 a1315 1 a1369 1 d1443 2 a1444 1 } // end anonymous namespace a1483 7 // Pragmas added by plugins for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(), ie = PragmaHandlerRegistry::end(); it != ie; ++it) { AddPragmaHandler(it->instantiate().release()); } @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @a22 1 #include "clang/Lex/LiteralSupport.h" a162 10 // When committing/backtracking the cached pragma tokens in a macro // argument pre-expansion we want to ensure that either the tokens which // have been committed will be removed from the cache or that the tokens // over which we just backtracked won't remain in the cache after they're // consumed and that the caching will stop after consuming them. // Otherwise the caching will interfere with the way macro expansion // works, because we will continue to cache tokens after consuming the // backtracked tokens, which shouldn't happen when we're dealing with // macro argument pre-expansion. auto CachedTokenRange = PP.LastCachedTokenRange(); a168 1 PP.EraseCachedTokens(CachedTokenRange); d467 1 a467 1 SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1, d469 1 a469 1 SrcMgr::C_System); d500 1 a500 1 nullptr, CurDir, nullptr, nullptr, nullptr, nullptr); a745 119 // Lex a component of a module name: either an identifier or a string literal; // for components that can be expressed both ways, the two forms are equivalent. static bool LexModuleNameComponent( Preprocessor &PP, Token &Tok, std::pair &ModuleNameComponent, bool First) { PP.LexUnexpandedToken(Tok); if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) { StringLiteralParser Literal(Tok, PP); if (Literal.hadError) return true; ModuleNameComponent = std::make_pair( PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation()); } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) { ModuleNameComponent = std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation()); } else { PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First; return true; } return false; } static bool LexModuleName( Preprocessor &PP, Token &Tok, llvm::SmallVectorImpl> &ModuleName) { while (true) { std::pair NameComponent; if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty())) return true; ModuleName.push_back(NameComponent); PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::period)) return false; } } void Preprocessor::HandlePragmaModuleBuild(Token &Tok) { SourceLocation Loc = Tok.getLocation(); std::pair ModuleNameLoc; if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true)) return; IdentifierInfo *ModuleName = ModuleNameLoc.first; LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; DiscardUntilEndOfDirective(); } if (CurPTHLexer) { // FIXME: Support this somehow? Diag(Loc, diag::err_pp_module_build_pth); return; } CurLexer->LexingRawMode = true; auto TryConsumeIdentifier = [&](StringRef Ident) -> bool { if (Tok.getKind() != tok::raw_identifier || Tok.getRawIdentifier() != Ident) return false; CurLexer->Lex(Tok); return true; }; // Scan forward looking for the end of the module. const char *Start = CurLexer->getBufferLocation(); const char *End = nullptr; unsigned NestingLevel = 1; while (true) { End = CurLexer->getBufferLocation(); CurLexer->Lex(Tok); if (Tok.is(tok::eof)) { Diag(Loc, diag::err_pp_module_build_missing_end); break; } if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) { // Token was part of module; keep going. continue; } // We hit something directive-shaped; check to see if this is the end // of the module build. CurLexer->ParsingPreprocessorDirective = true; CurLexer->Lex(Tok); if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") && TryConsumeIdentifier("module")) { if (TryConsumeIdentifier("build")) // #pragma clang module build -> entering a nested module build. ++NestingLevel; else if (TryConsumeIdentifier("endbuild")) { // #pragma clang module endbuild -> leaving a module build. if (--NestingLevel == 0) break; } // We should either be looking at the EOD or more of the current directive // preceding the EOD. Either way we can ignore this token and keep going. assert(Tok.getKind() != tok::eof && "missing EOD before EOF"); } } CurLexer->LexingRawMode = false; // Load the extracted text as a preprocessed module. assert(CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && "module source range not contained within same file buffer"); TheModuleLoader.loadModuleFromSource(Loc, ModuleName->getName(), StringRef(Start, End - Start)); } d981 3 a983 3 static void DebugOverflowStack(void (*P)() = nullptr) { void (*volatile Self)(void(*P)()) = DebugOverflowStack; Self(reinterpret_cast(Self)); a1292 154 /// Handle the clang \#pragma module import extension. The syntax is: /// \code /// #pragma clang module import some.module.name /// \endcode struct PragmaModuleImportHandler : public PragmaHandler { PragmaModuleImportHandler() : PragmaHandler("import") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { SourceLocation ImportLoc = Tok.getLocation(); // Read the module name. llvm::SmallVector, 8> ModuleName; if (LexModuleName(PP, Tok, ModuleName)) return; if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // If we have a non-empty module path, load the named module. Module *Imported = PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden, /*IsIncludeDirective=*/false); if (!Imported) return; PP.makeModuleVisible(Imported, ImportLoc); PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second), tok::annot_module_include, Imported); if (auto *CB = PP.getPPCallbacks()) CB->moduleImport(ImportLoc, ModuleName, Imported); } }; /// Handle the clang \#pragma module begin extension. The syntax is: /// \code /// #pragma clang module begin some.module.name /// ... /// #pragma clang module end /// \endcode struct PragmaModuleBeginHandler : public PragmaHandler { PragmaModuleBeginHandler() : PragmaHandler("begin") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { SourceLocation BeginLoc = Tok.getLocation(); // Read the module name. llvm::SmallVector, 8> ModuleName; if (LexModuleName(PP, Tok, ModuleName)) return; if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // We can only enter submodules of the current module. StringRef Current = PP.getLangOpts().CurrentModule; if (ModuleName.front().first->getName() != Current) { PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module) << ModuleName.front().first << (ModuleName.size() > 1) << Current.empty() << Current; return; } // Find the module we're entering. We require that a module map for it // be loaded or implicitly loadable. // FIXME: We could create the submodule here. We'd need to know whether // it's supposed to be explicit, but not much else. Module *M = PP.getHeaderSearchInfo().lookupModule(Current); if (!M) { PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_no_module_map) << Current; return; } for (unsigned I = 1; I != ModuleName.size(); ++I) { auto *NewM = M->findSubmodule(ModuleName[I].first->getName()); if (!NewM) { PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule) << M->getFullModuleName() << ModuleName[I].first; return; } M = NewM; } // If the module isn't available, it doesn't make sense to enter it. if (Preprocessor::checkModuleIsAvailable( PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) { PP.Diag(BeginLoc, diag::note_pp_module_begin_here) << M->getTopLevelModuleName(); return; } // Enter the scope of the submodule. PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true); PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second), tok::annot_module_begin, M); } }; /// Handle the clang \#pragma module end extension. struct PragmaModuleEndHandler : public PragmaHandler { PragmaModuleEndHandler() : PragmaHandler("end") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { SourceLocation Loc = Tok.getLocation(); PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; Module *M = PP.LeaveSubmodule(/*ForPragma*/true); if (M) PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M); else PP.Diag(Loc, diag::err_pp_module_end_without_module_begin); } }; /// Handle the clang \#pragma module build extension. struct PragmaModuleBuildHandler : public PragmaHandler { PragmaModuleBuildHandler() : PragmaHandler("build") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { PP.HandlePragmaModuleBuild(Tok); } }; /// Handle the clang \#pragma module load extension. struct PragmaModuleLoadHandler : public PragmaHandler { PragmaModuleLoadHandler() : PragmaHandler("load") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { SourceLocation Loc = Tok.getLocation(); // Read the module name. llvm::SmallVector, 8> ModuleName; if (LexModuleName(PP, Tok, ModuleName)) return; if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // Load the module, don't make it visible. PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden, /*IsIncludeDirective=*/false); } }; a1515 9 // #pragma clang module ... auto *ModuleHandler = new PragmaNamespace("module"); AddPragmaHandler("clang", ModuleHandler); ModuleHandler->AddPragma(new PragmaModuleImportHandler()); ModuleHandler->AddPragma(new PragmaModuleBeginHandler()); ModuleHandler->AddPragma(new PragmaModuleEndHandler()); ModuleHandler->AddPragma(new PragmaModuleBuildHandler()); ModuleHandler->AddPragma(new PragmaModuleLoadHandler()); @ 1.1.1.9.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Pragma.cpp - Pragma registration and handling ----------------------===// a15 1 #include "clang/Basic/Diagnostic.h" a17 3 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Module.h" a22 1 #include "clang/Lex/Lexer.h" a24 1 #include "clang/Lex/ModuleLoader.h" a32 1 #include "llvm/ADT/STLExtras.h" d35 1 a36 1 #include "llvm/ADT/StringRef.h" a41 1 #include a44 1 #include d50 2 a51 1 PragmaHandler::~PragmaHandler() = default; d143 1 a143 1 /// Helper class for \see Preprocessor::Handle_Pragma. d147 1 a147 1 bool Failed = false; d154 2 a155 1 : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), OutTok(Tok) { d189 1 a189 1 } // namespace d195 1 d384 1 d409 1 d464 1 d485 1 d589 1 a589 1 /// Handle \#pragma push_macro. d612 1 a612 1 /// Handle \#pragma pop_macro. d626 1 a626 1 llvm::DenseMap>::iterator iter = a964 1 a1052 14 } else if (II->isStr("diag_mapping")) { Token DiagName; PP.LexUnexpandedToken(DiagName); if (DiagName.is(tok::eod)) PP.getDiagnostics().dump(); else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) { StringLiteralParser Literal(DiagName, PP); if (Literal.hadError) return; PP.getDiagnostics().dump(Literal.GetString()); } else { PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument) << II->getName(); } d1119 1 d1128 2 a1129 2 explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} a1332 1 d1373 1 a1373 2 : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} d1600 39 a1727 1 PPCallbacks *Callbacks = PP.getPPCallbacks(); a1735 2 if (Callbacks) Callbacks->PragmaAssumeNonNullBegin(NewLoc); a1742 2 if (Callbacks) Callbacks->PragmaAssumeNonNullEnd(NewLoc); d1749 1 a1749 1 /// Handle "\#pragma region [...]" d1761 1 a1761 1 PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {} d1772 1 a1772 1 } // namespace d1809 4 a1812 4 // Add region pragmas. AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); d1818 2 d1838 13 @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Pragma.cpp - Pragma registration and handling ----------------------===// a15 1 #include "clang/Basic/Diagnostic.h" a17 3 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Module.h" a22 1 #include "clang/Lex/Lexer.h" a24 1 #include "clang/Lex/ModuleLoader.h" a32 1 #include "llvm/ADT/STLExtras.h" d35 1 a36 1 #include "llvm/ADT/StringRef.h" a41 1 #include a44 1 #include d50 2 a51 1 PragmaHandler::~PragmaHandler() = default; d143 1 a143 1 /// Helper class for \see Preprocessor::Handle_Pragma. d147 1 a147 1 bool Failed = false; d154 2 a155 1 : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), OutTok(Tok) { d189 1 a189 1 } // namespace d195 1 d384 1 d409 1 d464 1 d485 1 d589 1 a589 1 /// Handle \#pragma push_macro. d612 1 a612 1 /// Handle \#pragma pop_macro. d626 1 a626 1 llvm::DenseMap>::iterator iter = a964 1 a1052 14 } else if (II->isStr("diag_mapping")) { Token DiagName; PP.LexUnexpandedToken(DiagName); if (DiagName.is(tok::eod)) PP.getDiagnostics().dump(); else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) { StringLiteralParser Literal(DiagName, PP); if (Literal.hadError) return; PP.getDiagnostics().dump(Literal.GetString()); } else { PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument) << II->getName(); } d1119 1 d1128 2 a1129 2 explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} a1332 1 d1373 1 a1373 2 : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} d1600 39 a1727 1 PPCallbacks *Callbacks = PP.getPPCallbacks(); a1735 2 if (Callbacks) Callbacks->PragmaAssumeNonNullBegin(NewLoc); a1742 2 if (Callbacks) Callbacks->PragmaAssumeNonNullEnd(NewLoc); d1749 1 a1749 1 /// Handle "\#pragma region [...]" d1761 1 a1761 1 PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {} d1772 1 a1772 1 } // namespace d1809 4 a1812 4 // Add region pragmas. AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); d1818 2 d1838 13 @ 1.1.1.10 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- Pragma.cpp - Pragma registration and handling ----------------------===// a15 1 #include "clang/Basic/Diagnostic.h" a17 3 #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Module.h" a22 1 #include "clang/Lex/Lexer.h" a24 1 #include "clang/Lex/ModuleLoader.h" a32 1 #include "llvm/ADT/STLExtras.h" d35 1 a36 1 #include "llvm/ADT/StringRef.h" a41 1 #include a44 1 #include d50 2 a51 1 PragmaHandler::~PragmaHandler() = default; d143 1 a143 1 /// Helper class for \see Preprocessor::Handle_Pragma. d147 1 a147 1 bool Failed = false; d154 2 a155 1 : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), OutTok(Tok) { d189 1 a189 1 } // namespace d195 1 d384 1 d409 1 d464 1 d485 1 d589 1 a589 1 /// Handle \#pragma push_macro. d612 1 a612 1 /// Handle \#pragma pop_macro. d626 1 a626 1 llvm::DenseMap>::iterator iter = a964 1 a1052 14 } else if (II->isStr("diag_mapping")) { Token DiagName; PP.LexUnexpandedToken(DiagName); if (DiagName.is(tok::eod)) PP.getDiagnostics().dump(); else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) { StringLiteralParser Literal(DiagName, PP); if (Literal.hadError) return; PP.getDiagnostics().dump(Literal.GetString()); } else { PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument) << II->getName(); } d1119 1 d1128 2 a1129 2 explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} a1332 1 d1373 1 a1373 2 : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} d1600 39 a1727 1 PPCallbacks *Callbacks = PP.getPPCallbacks(); a1735 2 if (Callbacks) Callbacks->PragmaAssumeNonNullBegin(NewLoc); a1742 2 if (Callbacks) Callbacks->PragmaAssumeNonNullEnd(NewLoc); d1749 1 a1749 1 /// Handle "\#pragma region [...]" d1761 1 a1761 1 PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {} d1772 1 a1772 1 } // namespace d1809 4 a1812 4 // Add region pragmas. AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); d1818 2 d1838 13 @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file Pragma.cpp was added on branch tls-maxphys on 2014-08-19 23:47:29 +0000 @ text @d1 1413 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1413 //===--- Pragma.cpp - Pragma registration and handling --------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the PragmaHandler/PragmaTable interfaces and implements // pragma related methods of the Preprocessor class. // //===----------------------------------------------------------------------===// #include "clang/Lex/Pragma.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/ErrorHandling.h" #include using namespace clang; #include "llvm/Support/raw_ostream.h" // Out-of-line destructor to provide a home for the class. PragmaHandler::~PragmaHandler() { } //===----------------------------------------------------------------------===// // EmptyPragmaHandler Implementation. //===----------------------------------------------------------------------===// EmptyPragmaHandler::EmptyPragmaHandler() {} void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) {} //===----------------------------------------------------------------------===// // PragmaNamespace Implementation. //===----------------------------------------------------------------------===// PragmaNamespace::~PragmaNamespace() { llvm::DeleteContainerSeconds(Handlers); } /// FindHandler - Check to see if there is already a handler for the /// specified name. If not, return the handler for the null identifier if it /// exists, otherwise return null. If IgnoreNull is true (the default) then /// the null handler isn't returned on failure to match. PragmaHandler *PragmaNamespace::FindHandler(StringRef Name, bool IgnoreNull) const { if (PragmaHandler *Handler = Handlers.lookup(Name)) return Handler; return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); } void PragmaNamespace::AddPragma(PragmaHandler *Handler) { assert(!Handlers.lookup(Handler->getName()) && "A handler with this name is already registered in this namespace"); llvm::StringMapEntry &Entry = Handlers.GetOrCreateValue(Handler->getName()); Entry.setValue(Handler); } void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) { assert(Handlers.lookup(Handler->getName()) && "Handler not registered in this namespace"); Handlers.erase(Handler->getName()); } void PragmaNamespace::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro // expand it, the user can have a STDC #define, that should not affect this. PP.LexUnexpandedToken(Tok); // Get the handler for this token. If there is no handler, ignore the pragma. PragmaHandler *Handler = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName() : StringRef(), /*IgnoreNull=*/false); if (!Handler) { PP.Diag(Tok, diag::warn_pragma_ignored); return; } // Otherwise, pass it down. Handler->HandlePragma(PP, Introducer, Tok); } //===----------------------------------------------------------------------===// // Preprocessor Pragma Directive Handling. //===----------------------------------------------------------------------===// /// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the /// rest of the pragma, passing it to the registered pragma handlers. void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, PragmaIntroducerKind Introducer) { if (Callbacks) Callbacks->PragmaDirective(IntroducerLoc, Introducer); if (!PragmasEnabled) return; ++NumPragma; // Invoke the first level of pragma handlers which reads the namespace id. Token Tok; PragmaHandlers->HandlePragma(*this, Introducer, Tok); // If the pragma handler didn't read the rest of the line, consume it now. if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective)) DiscardUntilEndOfDirective(); } namespace { /// \brief Helper class for \see Preprocessor::Handle_Pragma. class LexingFor_PragmaRAII { Preprocessor &PP; bool InMacroArgPreExpansion; bool Failed; Token &OutTok; Token PragmaTok; public: LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion, Token &Tok) : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), Failed(false), OutTok(Tok) { if (InMacroArgPreExpansion) { PragmaTok = OutTok; PP.EnableBacktrackAtThisPos(); } } ~LexingFor_PragmaRAII() { if (InMacroArgPreExpansion) { if (Failed) { PP.CommitBacktrackedTokens(); } else { PP.Backtrack(); OutTok = PragmaTok; } } } void failed() { Failed = true; } }; } /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then /// return the first token after the directive. The _Pragma token has just /// been read into 'Tok'. void Preprocessor::Handle_Pragma(Token &Tok) { // This works differently if we are pre-expanding a macro argument. // In that case we don't actually "activate" the pragma now, we only lex it // until we are sure it is lexically correct and then we backtrack so that // we activate the pragma whenever we encounter the tokens again in the token // stream. This ensures that we will activate it in the correct location // or that we will ignore it if it never enters the token stream, e.g: // // #define EMPTY(x) // #define INACTIVE(x) EMPTY(x) // INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\"")) LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok); // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } // Read the '"..."'. Lex(Tok); if (!tok::isStringLiteral(Tok.getKind())) { Diag(PragmaLoc, diag::err__Pragma_malformed); // Skip this token, and the ')', if present. if (Tok.isNot(tok::r_paren)) Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); // Skip this token, and the ')', if present. Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } // Remember the string. Token StrTok = Tok; // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } if (InMacroArgPreExpansion) return; SourceLocation RParenLoc = Tok.getLocation(); std::string StrVal = getSpelling(StrTok); // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1: // "The string literal is destringized by deleting any encoding prefix, // deleting the leading and trailing double-quotes, replacing each escape // sequence \" by a double-quote, and replacing each escape sequence \\ by a // single backslash." if (StrVal[0] == 'L' || StrVal[0] == 'U' || (StrVal[0] == 'u' && StrVal[1] != '8')) StrVal.erase(StrVal.begin()); else if (StrVal[0] == 'u') StrVal.erase(StrVal.begin(), StrVal.begin() + 2); if (StrVal[0] == 'R') { // FIXME: C++11 does not specify how to handle raw-string-literals here. // We strip off the 'R', the quotes, the d-char-sequences, and the parens. assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' && "Invalid raw string token!"); // Measure the length of the d-char-sequence. unsigned NumDChars = 0; while (StrVal[2 + NumDChars] != '(') { assert(NumDChars < (StrVal.size() - 5) / 2 && "Invalid raw string token!"); ++NumDChars; } assert(StrVal[StrVal.size() - 2 - NumDChars] == ')'); // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the // parens below. StrVal.erase(0, 2 + NumDChars); StrVal.erase(StrVal.size() - 1 - NumDChars); } else { assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Remove escaped quotes and escapes. unsigned ResultPos = 1; for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) { // Skip escapes. \\ -> '\' and \" -> '"'. if (StrVal[i] == '\\' && i + 1 < e && (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"')) ++i; StrVal[ResultPos++] = StrVal[i]; } StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1); } // Remove the front quote, replacing it with a space, so that the pragma // contents appear to have a space before them. StrVal[0] = ' '; // Replace the terminating quote with a \n. StrVal[StrVal.size()-1] = '\n'; // Plop the string (including the newline and trailing null) into a buffer // where we can lex it. Token TmpTok; TmpTok.startToken(); CreateString(StrVal, TmpTok); SourceLocation TokLoc = TmpTok.getLocation(); // Make and enter a lexer object so that we lex and expand the tokens just // like any others. Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc, StrVal.size(), *this); EnterSourceFileWithLexer(TL, nullptr); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK__Pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text /// is not enclosed within a string literal. void Preprocessor::HandleMicrosoft__pragma(Token &Tok) { // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return; } // Get the tokens enclosed within the __pragma(), as well as the final ')'. SmallVector PragmaToks; int NumParens = 0; Lex(Tok); while (Tok.isNot(tok::eof)) { PragmaToks.push_back(Tok); if (Tok.is(tok::l_paren)) NumParens++; else if (Tok.is(tok::r_paren) && NumParens-- == 0) break; Lex(Tok); } if (Tok.is(tok::eof)) { Diag(PragmaLoc, diag::err_unterminated___pragma); return; } PragmaToks.front().setFlag(Token::LeadingSpace); // Replace the ')' with an EOD to mark the end of the pragma. PragmaToks.back().setKind(tok::eod); Token *TokArray = new Token[PragmaToks.size()]; std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray); // Push the tokens onto the stack. EnterTokenStream(TokArray, PragmaToks.size(), true, true); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK___pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'. /// void Preprocessor::HandlePragmaOnce(Token &OnceTok) { if (isInPrimaryFile()) { Diag(OnceTok, diag::pp_pragma_once_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. // Mark the file as a once-only file now. HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry()); } void Preprocessor::HandlePragmaMark() { assert(CurPPLexer && "No current lexer?"); if (CurLexer) CurLexer->ReadToEndOfLine(); else CurPTHLexer->DiscardToEndOfLine(); } /// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'. /// void Preprocessor::HandlePragmaPoison(Token &PoisonTok) { Token Tok; while (1) { // Read the next token to poison. While doing this, pretend that we are // skipping while reading the identifier to poison. // This avoids errors on code like: // #pragma GCC poison X // #pragma GCC poison X if (CurPPLexer) CurPPLexer->LexingRawMode = true; LexUnexpandedToken(Tok); if (CurPPLexer) CurPPLexer->LexingRawMode = false; // If we reached the end of line, we're done. if (Tok.is(tok::eod)) return; // Can only poison identifiers. if (Tok.isNot(tok::raw_identifier)) { Diag(Tok, diag::err_pp_invalid_poison); return; } // Look up the identifier info for the token. We disabled identifier lookup // by saying we're skipping contents, so we need to do this manually. IdentifierInfo *II = LookUpIdentifierInfo(Tok); // Already poisoned. if (II->isPoisoned()) continue; // If this is a macro identifier, emit a warning. if (II->hasMacroDefinition()) Diag(Tok, diag::pp_poisoning_existing_macro); // Finally, poison it! II->setIsPoisoned(); if (II->isFromAST()) II->setChangedSinceDeserialization(); } } /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know /// that the whole directive has been parsed. void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) { if (isInPrimaryFile()) { Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. PreprocessorLexer *TheLexer = getCurrentFileLexer(); // Mark the file as a system header. HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry()); PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation()); if (PLoc.isInvalid()) return; unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename()); // Notify the client, if desired, that we are in a new source file. if (Callbacks) Callbacks->FileChanged(SysHeaderTok.getLocation(), PPCallbacks::SystemHeaderPragma, SrcMgr::C_System); // Emit a line marker. This will change any source locations from this point // forward to realize they are in a system header. // Create a line note with this information. SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1, FilenameID, /*IsEntry=*/false, /*IsExit=*/false, /*IsSystem=*/true, /*IsExternC=*/false); } /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah. /// void Preprocessor::HandlePragmaDependency(Token &DependencyTok) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // If the token kind is EOD, the error has already been diagnosed. if (FilenameTok.is(tok::eod)) return; // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; bool Invalid = false; StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid); if (Invalid) return; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) return; // Search include directories for this file. const DirectoryLookup *CurDir; const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr, CurDir, nullptr, nullptr, nullptr); if (!File) { if (!SuppressIncludeNotFoundError) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; return; } const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry(); // If this file is older than the file it depends on, emit a diagnostic. if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) { // Lex tokens at the end of the message and include them in the message. std::string Message; Lex(DependencyTok); while (DependencyTok.isNot(tok::eod)) { Message += getSpelling(DependencyTok) + " "; Lex(DependencyTok); } // Remove the trailing ' ' if present. if (!Message.empty()) Message.erase(Message.end()-1); Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message; } } /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro. /// Return the IdentifierInfo* associated with the macro to push or pop. IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { // Remember the pragma token location. Token PragmaTok = Tok; // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return nullptr; } // Read the macro name string. Lex(Tok); if (Tok.isNot(tok::string_literal)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return nullptr; } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); return nullptr; } // Remember the macro string. std::string StrVal = getSpelling(Tok); // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return nullptr; } assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Create a Token from the string. Token MacroTok; MacroTok.startToken(); MacroTok.setKind(tok::raw_identifier); CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok); // Get the IdentifierInfo of MacroToPushTok. return LookUpIdentifierInfo(MacroTok); } /// \brief Handle \#pragma push_macro. /// /// The syntax is: /// \code /// #pragma push_macro("macro") /// \endcode void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) { // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok); if (!IdentInfo) return; // Get the MacroInfo associated with IdentInfo. MacroInfo *MI = getMacroInfo(IdentInfo); if (MI) { // Allow the original MacroInfo to be redefined later. MI->setIsAllowRedefinitionsWithoutWarning(true); } // Push the cloned MacroInfo so we can retrieve it later. PragmaPushMacroInfo[IdentInfo].push_back(MI); } /// \brief Handle \#pragma pop_macro. /// /// The syntax is: /// \code /// #pragma pop_macro("macro") /// \endcode void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) { SourceLocation MessageLoc = PopMacroTok.getLocation(); // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok); if (!IdentInfo) return; // Find the vector associated with the macro. llvm::DenseMap >::iterator iter = PragmaPushMacroInfo.find(IdentInfo); if (iter != PragmaPushMacroInfo.end()) { // Forget the MacroInfo currently associated with IdentInfo. if (MacroDirective *CurrentMD = getMacroDirective(IdentInfo)) { MacroInfo *MI = CurrentMD->getMacroInfo(); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc)); } // Get the MacroInfo we want to reinstall. MacroInfo *MacroToReInstall = iter->second.back(); if (MacroToReInstall) { // Reinstall the previously pushed macro. appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc, /*isImported=*/false, /*Overrides*/None); } // Pop PragmaPushMacroInfo stack. iter->second.pop_back(); if (iter->second.size() == 0) PragmaPushMacroInfo.erase(iter); } else { Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push) << IdentInfo->getName(); } } void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) { // We will either get a quoted filename or a bracketed filename, and we // have to track which we got. The first filename is the source name, // and the second name is the mapped filename. If the first is quoted, // the second must be as well (cannot mix and match quotes and brackets). // Get the open paren Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << "("; return; } // We expect either a quoted string literal, or a bracketed name Token SourceFilenameTok; CurPPLexer->LexIncludeFilename(SourceFilenameTok); if (SourceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef SourceFileName; SmallString<128> FileNameBuffer; if (SourceFilenameTok.is(tok::string_literal) || SourceFilenameTok.is(tok::angle_string_literal)) { SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer); } else if (SourceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted SourceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } FileNameBuffer.clear(); // Now we expect a comma, followed by another include name Lex(Tok); if (Tok.isNot(tok::comma)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ","; return; } Token ReplaceFilenameTok; CurPPLexer->LexIncludeFilename(ReplaceFilenameTok); if (ReplaceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef ReplaceFileName; if (ReplaceFilenameTok.is(tok::string_literal) || ReplaceFilenameTok.is(tok::angle_string_literal)) { ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer); } else if (ReplaceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted ReplaceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } // Finally, we expect the closing paren Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ")"; return; } // Now that we have the source and target filenames, we need to make sure // they're both of the same type (angled vs non-angled) StringRef OriginalSource = SourceFileName; bool SourceIsAngled = GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(), SourceFileName); bool ReplaceIsAngled = GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(), ReplaceFileName); if (!SourceFileName.empty() && !ReplaceFileName.empty() && (SourceIsAngled != ReplaceIsAngled)) { unsigned int DiagID; if (SourceIsAngled) DiagID = diag::warn_pragma_include_alias_mismatch_angle; else DiagID = diag::warn_pragma_include_alias_mismatch_quote; Diag(SourceFilenameTok.getLocation(), DiagID) << SourceFileName << ReplaceFileName; return; } // Now we can let the include handler know about this mapping getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName); } /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. /// If 'Namespace' is non-null, then it is a token required to exist on the /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". void Preprocessor::AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *InsertNS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { // If there is already a pragma handler with the name of this namespace, // we either have an error (directive with the same name as a namespace) or // we already have the namespace to insert into. if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) { InsertNS = Existing->getIfNamespace(); assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma" " handler with the same name!"); } else { // Otherwise, this namespace doesn't exist yet, create and insert the // handler for it. InsertNS = new PragmaNamespace(Namespace); PragmaHandlers->AddPragma(InsertNS); } } // Check to make sure we don't already have a pragma for this identifier. assert(!InsertNS->FindHandler(Handler->getName()) && "Pragma handler already exists for this identifier!"); InsertNS->AddPragma(Handler); } /// RemovePragmaHandler - Remove the specific pragma handler from the /// preprocessor. If \arg Namespace is non-null, then it should be the /// namespace that \arg Handler was added to. It is an error to remove /// a handler that has not been registered. void Preprocessor::RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *NS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace); assert(Existing && "Namespace containing handler does not exist!"); NS = Existing->getIfNamespace(); assert(NS && "Invalid namespace, registered as a regular pragma handler!"); } NS->RemovePragmaHandler(Handler); // If this is a non-default namespace and it is now empty, remove // it. if (NS != PragmaHandlers && NS->IsEmpty()) { PragmaHandlers->RemovePragmaHandler(NS); delete NS; } } bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) { Token Tok; LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("ON")) Result = tok::OOS_ON; else if (II->isStr("OFF")) Result = tok::OOS_OFF; else if (II->isStr("DEFAULT")) Result = tok::OOS_DEFAULT; else { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } // Verify that this is followed by EOD. LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) Diag(Tok, diag::ext_pragma_syntax_eod); return false; } namespace { /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. struct PragmaOnceHandler : public PragmaHandler { PragmaOnceHandler() : PragmaHandler("once") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OnceTok) override { PP.CheckEndOfDirective("pragma once"); PP.HandlePragmaOnce(OnceTok); } }; /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the /// rest of the line is not lexed. struct PragmaMarkHandler : public PragmaHandler { PragmaMarkHandler() : PragmaHandler("mark") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) override { PP.HandlePragmaMark(); } }; /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. struct PragmaPoisonHandler : public PragmaHandler { PragmaPoisonHandler() : PragmaHandler("poison") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) override { PP.HandlePragmaPoison(PoisonTok); } }; /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file /// as a system header, which silences warnings in it. struct PragmaSystemHeaderHandler : public PragmaHandler { PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) override { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { PP.HandlePragmaDependency(DepToken); } }; struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("assert")) { llvm_unreachable("This is an assertion!"); } else if (II->isStr("crash")) { LLVM_BUILTIN_TRAP; } else if (II->isStr("parser_crash")) { Token Crasher; Crasher.setKind(tok::annot_pragma_parser_crash); PP.EnterToken(Crasher); } else if (II->isStr("llvm_fatal_error")) { llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error"); } else if (II->isStr("llvm_unreachable")) { llvm_unreachable("#pragma clang __debug llvm_unreachable"); } else if (II->isStr("overflow_stack")) { DebugOverflowStack(); } else if (II->isStr("handle_crash")) { llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent(); if (CRC) CRC->HandleCrash(); } else if (II->isStr("captured")) { HandleCaptured(PP); } else { PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command) << II->getName(); } PPCallbacks *Callbacks = PP.getPPCallbacks(); if (Callbacks) Callbacks->PragmaDebug(Tok.getLocation(), II->getName()); } void HandleCaptured(Preprocessor &PP) { // Skip if emitting preprocessed output. if (PP.isPreprocessedOutput()) return; Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma clang __debug captured"; return; } SourceLocation NameLoc = Tok.getLocation(); Token *Toks = PP.getPreprocessorAllocator().Allocate(1); Toks->startToken(); Toks->setKind(tok::annot_pragma_captured); Toks->setLocation(NameLoc); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // Disable MSVC warning about runtime stack overflow. #ifdef _MSC_VER #pragma warning(disable : 4717) #endif static void DebugOverflowStack() { void (*volatile Self)() = DebugOverflowStack; Self(); } #ifdef _MSC_VER #pragma warning(default : 4717) #endif }; /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"' struct PragmaDiagnosticHandler : public PragmaHandler { private: const char *Namespace; public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) override { SourceLocation DiagLoc = DiagToken.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); PPCallbacks *Callbacks = PP.getPPCallbacks(); if (II->isStr("pop")) { if (!PP.getDiagnostics().popMappings(DiagLoc)) PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop); else if (Callbacks) Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace); return; } else if (II->isStr("push")) { PP.getDiagnostics().pushMappings(DiagLoc); if (Callbacks) Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace); return; } diag::Severity SV = llvm::StringSwitch(II->getName()) .Case("ignored", diag::Severity::Ignored) .Case("warning", diag::Severity::Warning) .Case("error", diag::Severity::Error) .Case("fatal", diag::Severity::Fatal) .Default(diag::Severity()); if (SV == diag::Severity()) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } PP.LexUnexpandedToken(Tok); SourceLocation StringLoc = Tok.getLocation(); std::string WarningName; if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic", /*MacroExpansion=*/false)) return; if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); return; } if (WarningName.size() < 3 || WarningName[0] != '-' || (WarningName[1] != 'W' && WarningName[1] != 'R')) { PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); return; } if (PP.getDiagnostics().setSeverityForGroup( WarningName[1] == 'W' ? diag::Flavor::WarningOrError : diag::Flavor::Remark, WarningName.substr(2), SV, DiagLoc)) PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) << WarningName; else if (Callbacks) Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName); } }; /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's /// diagnostics, so we don't really implement this pragma. We parse it and /// ignore it to avoid -Wunknown-pragma warnings. struct PragmaWarningHandler : public PragmaHandler { PragmaWarningHandler() : PragmaHandler("warning") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { // Parse things like: // warning(push, 1) // warning(pop) // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9) SourceLocation DiagLoc = Tok.getLocation(); PPCallbacks *Callbacks = PP.getPPCallbacks(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << "("; return; } PP.Lex(Tok); IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } if (II->isStr("push")) { // #pragma warning( push[ ,n ] ) int Level = -1; PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); uint64_t Value; if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) Level = int(Value); if (Level < 0 || Level > 4) { PP.Diag(Tok, diag::warn_pragma_warning_push_level); return; } } if (Callbacks) Callbacks->PragmaWarningPush(DiagLoc, Level); } else if (II->isStr("pop")) { // #pragma warning( pop ) PP.Lex(Tok); if (Callbacks) Callbacks->PragmaWarningPop(DiagLoc); } else { // #pragma warning( warning-specifier : warning-number-list // [; warning-specifier : warning-number-list...] ) while (true) { II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } // Figure out which warning specifier this is. StringRef Specifier = II->getName(); bool SpecifierValid = llvm::StringSwitch(Specifier) .Cases("1", "2", "3", "4", true) .Cases("default", "disable", "error", "once", "suppress", true) .Default(false); if (!SpecifierValid) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":"; return; } // Collect the warning ids. SmallVector Ids; PP.Lex(Tok); while (Tok.is(tok::numeric_constant)) { uint64_t Value; if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || Value > INT_MAX) { PP.Diag(Tok, diag::warn_pragma_warning_expected_number); return; } Ids.push_back(int(Value)); } if (Callbacks) Callbacks->PragmaWarning(DiagLoc, Specifier, Ids); // Parse the next specifier if there is a semicolon. if (Tok.isNot(tok::semi)) break; PP.Lex(Tok); } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning"; } }; /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". struct PragmaIncludeAliasHandler : public PragmaHandler { PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &IncludeAliasTok) override { PP.HandlePragmaIncludeAlias(IncludeAliasTok); } }; /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message /// extension. The syntax is: /// \code /// #pragma message(string) /// \endcode /// OR, in GCC mode: /// \code /// #pragma message string /// \endcode /// string is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters, etc... See MSDN for more details. /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same /// form as \#pragma message. struct PragmaMessageHandler : public PragmaHandler { private: const PPCallbacks::PragmaMessageKind Kind; const StringRef Namespace; static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind, bool PragmaNameOnly = false) { switch (Kind) { case PPCallbacks::PMK_Message: return PragmaNameOnly ? "message" : "pragma message"; case PPCallbacks::PMK_Warning: return PragmaNameOnly ? "warning" : "pragma warning"; case PPCallbacks::PMK_Error: return PragmaNameOnly ? "error" : "pragma error"; } llvm_unreachable("Unknown PragmaMessageKind!"); } public: PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind, StringRef Namespace = StringRef()) : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { SourceLocation MessageLoc = Tok.getLocation(); PP.Lex(Tok); bool ExpectClosingParen = false; switch (Tok.getKind()) { case tok::l_paren: // We have a MSVC style pragma message. ExpectClosingParen = true; // Read the string. PP.Lex(Tok); break; case tok::string_literal: // We have a GCC style pragma message, and we just read the string. break; default: PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind; return; } std::string MessageString; if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind), /*MacroExpansion=*/true)) return; if (ExpectClosingParen) { if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } PP.Lex(Tok); // eat the r_paren. } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } // Output the message. PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error) ? diag::err_pragma_message : diag::warn_pragma_message) << MessageString; // If the pragma is lexically sound, notify any interested PPCallbacks. if (PPCallbacks *Callbacks = PP.getPPCallbacks()) Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString); } }; /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the /// macro on the top of the stack. struct PragmaPushMacroHandler : public PragmaHandler { PragmaPushMacroHandler() : PragmaHandler("push_macro") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) override { PP.HandlePragmaPushMacro(PushMacroTok); } }; /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the /// macro to the value on the top of the stack. struct PragmaPopMacroHandler : public PragmaHandler { PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) override { PP.HandlePragmaPopMacro(PopMacroTok); } }; // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; /// PragmaARCCFCodeAuditedHandler - /// \#pragma clang arc_cf_code_audited begin/end struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; Token Tok; // Lex the 'begin' or 'end'. PP.LexUnexpandedToken(Tok); const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); if (BeginEnd && BeginEnd->isStr("begin")) { IsBegin = true; } else if (BeginEnd && BeginEnd->isStr("end")) { IsBegin = false; } else { PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax); return; } // Verify that this is followed by EOD. PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // The start location of the active audit. SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc(); // The start location we want after processing this. SourceLocation NewLoc; if (IsBegin) { // Complain about attempts to re-enter an audit. if (BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited); PP.Diag(BeginLoc, diag::note_pragma_entered_here); } NewLoc = Loc; } else { // Complain about attempts to leave an audit that doesn't exist. if (!BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited); return; } NewLoc = SourceLocation(); } PP.setPragmaARCCFCodeAuditedLoc(NewLoc); } }; /// \brief Handle "\#pragma region [...]" /// /// The syntax is /// \code /// #pragma region [optional name] /// #pragma endregion [optional comment] /// \endcode /// /// \note This is /// editor-only /// pragma, just skipped by compiler. struct PragmaRegionHandler : public PragmaHandler { PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { // #pragma region: endregion matches can be verified // __pragma(region): no sense, but ignored by msvc // _Pragma is not valid for MSVC, but there isn't any point // to handle a _Pragma differently. } }; } // end anonymous namespace /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: /// \#pragma GCC poison/system_header/dependency and \#pragma once. void Preprocessor::RegisterBuiltinPragmas() { AddPragmaHandler(new PragmaOnceHandler()); AddPragmaHandler(new PragmaMarkHandler()); AddPragmaHandler(new PragmaPushMacroHandler()); AddPragmaHandler(new PragmaPopMacroHandler()); AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message)); // #pragma GCC ... AddPragmaHandler("GCC", new PragmaPoisonHandler()); AddPragmaHandler("GCC", new PragmaSystemHeaderHandler()); AddPragmaHandler("GCC", new PragmaDependencyHandler()); AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning, "GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error, "GCC")); // #pragma clang ... AddPragmaHandler("clang", new PragmaPoisonHandler()); AddPragmaHandler("clang", new PragmaSystemHeaderHandler()); AddPragmaHandler("clang", new PragmaDebugHandler()); AddPragmaHandler("clang", new PragmaDependencyHandler()); AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang")); AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler()); AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler()); AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler()); AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler()); // MS extensions. if (LangOpts.MicrosoftExt) { AddPragmaHandler(new PragmaWarningHandler()); AddPragmaHandler(new PragmaIncludeAliasHandler()); AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); } } /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise /// warn about those pragmas being unknown. void Preprocessor::IgnorePragmas() { AddPragmaHandler(new EmptyPragmaHandler()); // Also ignore all pragmas in all namespaces created // in Preprocessor::RegisterBuiltinPragmas(). AddPragmaHandler("GCC", new EmptyPragmaHandler()); AddPragmaHandler("clang", new EmptyPragmaHandler()); if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) { // Preprocessor::RegisterBuiltinPragmas() already registers // PragmaSTDC_UnknownHandler as the empty handler, so remove it first, // otherwise there will be an assert about a duplicate handler. PragmaNamespace *STDCNamespace = NS->getIfNamespace(); assert(STDCNamespace && "Invalid namespace, registered as a regular pragma handler!"); if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) { RemovePragmaHandler("STDC", Existing); delete Existing; } } AddPragmaHandler("STDC", new EmptyPragmaHandler()); } @ 1.1.1.3.4.1 log @file Pragma.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:28 +0000 @ text @d1 1387 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1387 //===--- Pragma.cpp - Pragma registration and handling --------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the PragmaHandler/PragmaTable interfaces and implements // pragma related methods of the Preprocessor class. // //===----------------------------------------------------------------------===// #include "clang/Lex/Pragma.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/ErrorHandling.h" #include using namespace clang; #include "llvm/Support/raw_ostream.h" // Out-of-line destructor to provide a home for the class. PragmaHandler::~PragmaHandler() { } //===----------------------------------------------------------------------===// // EmptyPragmaHandler Implementation. //===----------------------------------------------------------------------===// EmptyPragmaHandler::EmptyPragmaHandler() {} void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) {} //===----------------------------------------------------------------------===// // PragmaNamespace Implementation. //===----------------------------------------------------------------------===// PragmaNamespace::~PragmaNamespace() { llvm::DeleteContainerSeconds(Handlers); } /// FindHandler - Check to see if there is already a handler for the /// specified name. If not, return the handler for the null identifier if it /// exists, otherwise return null. If IgnoreNull is true (the default) then /// the null handler isn't returned on failure to match. PragmaHandler *PragmaNamespace::FindHandler(StringRef Name, bool IgnoreNull) const { if (PragmaHandler *Handler = Handlers.lookup(Name)) return Handler; return IgnoreNull ? 0 : Handlers.lookup(StringRef()); } void PragmaNamespace::AddPragma(PragmaHandler *Handler) { assert(!Handlers.lookup(Handler->getName()) && "A handler with this name is already registered in this namespace"); llvm::StringMapEntry &Entry = Handlers.GetOrCreateValue(Handler->getName()); Entry.setValue(Handler); } void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) { assert(Handlers.lookup(Handler->getName()) && "Handler not registered in this namespace"); Handlers.erase(Handler->getName()); } void PragmaNamespace::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro // expand it, the user can have a STDC #define, that should not affect this. PP.LexUnexpandedToken(Tok); // Get the handler for this token. If there is no handler, ignore the pragma. PragmaHandler *Handler = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName() : StringRef(), /*IgnoreNull=*/false); if (Handler == 0) { PP.Diag(Tok, diag::warn_pragma_ignored); return; } // Otherwise, pass it down. Handler->HandlePragma(PP, Introducer, Tok); } //===----------------------------------------------------------------------===// // Preprocessor Pragma Directive Handling. //===----------------------------------------------------------------------===// /// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the /// rest of the pragma, passing it to the registered pragma handlers. void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, PragmaIntroducerKind Introducer) { if (Callbacks) Callbacks->PragmaDirective(IntroducerLoc, Introducer); if (!PragmasEnabled) return; ++NumPragma; // Invoke the first level of pragma handlers which reads the namespace id. Token Tok; PragmaHandlers->HandlePragma(*this, Introducer, Tok); // If the pragma handler didn't read the rest of the line, consume it now. if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective)) DiscardUntilEndOfDirective(); } namespace { /// \brief Helper class for \see Preprocessor::Handle_Pragma. class LexingFor_PragmaRAII { Preprocessor &PP; bool InMacroArgPreExpansion; bool Failed; Token &OutTok; Token PragmaTok; public: LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion, Token &Tok) : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), Failed(false), OutTok(Tok) { if (InMacroArgPreExpansion) { PragmaTok = OutTok; PP.EnableBacktrackAtThisPos(); } } ~LexingFor_PragmaRAII() { if (InMacroArgPreExpansion) { if (Failed) { PP.CommitBacktrackedTokens(); } else { PP.Backtrack(); OutTok = PragmaTok; } } } void failed() { Failed = true; } }; } /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then /// return the first token after the directive. The _Pragma token has just /// been read into 'Tok'. void Preprocessor::Handle_Pragma(Token &Tok) { // This works differently if we are pre-expanding a macro argument. // In that case we don't actually "activate" the pragma now, we only lex it // until we are sure it is lexically correct and then we backtrack so that // we activate the pragma whenever we encounter the tokens again in the token // stream. This ensures that we will activate it in the correct location // or that we will ignore it if it never enters the token stream, e.g: // // #define EMPTY(x) // #define INACTIVE(x) EMPTY(x) // INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\"")) LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok); // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } // Read the '"..."'. Lex(Tok); if (!tok::isStringLiteral(Tok.getKind())) { Diag(PragmaLoc, diag::err__Pragma_malformed); // Skip this token, and the ')', if present. if (Tok.isNot(tok::r_paren)) Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); // Skip this token, and the ')', if present. Lex(Tok); if (Tok.is(tok::r_paren)) Lex(Tok); return _PragmaLexing.failed(); } // Remember the string. Token StrTok = Tok; // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return _PragmaLexing.failed(); } if (InMacroArgPreExpansion) return; SourceLocation RParenLoc = Tok.getLocation(); std::string StrVal = getSpelling(StrTok); // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1: // "The string literal is destringized by deleting any encoding prefix, // deleting the leading and trailing double-quotes, replacing each escape // sequence \" by a double-quote, and replacing each escape sequence \\ by a // single backslash." if (StrVal[0] == 'L' || StrVal[0] == 'U' || (StrVal[0] == 'u' && StrVal[1] != '8')) StrVal.erase(StrVal.begin()); else if (StrVal[0] == 'u') StrVal.erase(StrVal.begin(), StrVal.begin() + 2); if (StrVal[0] == 'R') { // FIXME: C++11 does not specify how to handle raw-string-literals here. // We strip off the 'R', the quotes, the d-char-sequences, and the parens. assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' && "Invalid raw string token!"); // Measure the length of the d-char-sequence. unsigned NumDChars = 0; while (StrVal[2 + NumDChars] != '(') { assert(NumDChars < (StrVal.size() - 5) / 2 && "Invalid raw string token!"); ++NumDChars; } assert(StrVal[StrVal.size() - 2 - NumDChars] == ')'); // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the // parens below. StrVal.erase(0, 2 + NumDChars); StrVal.erase(StrVal.size() - 1 - NumDChars); } else { assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Remove escaped quotes and escapes. unsigned ResultPos = 1; for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) { // Skip escapes. \\ -> '\' and \" -> '"'. if (StrVal[i] == '\\' && i + 1 < e && (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"')) ++i; StrVal[ResultPos++] = StrVal[i]; } StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1); } // Remove the front quote, replacing it with a space, so that the pragma // contents appear to have a space before them. StrVal[0] = ' '; // Replace the terminating quote with a \n. StrVal[StrVal.size()-1] = '\n'; // Plop the string (including the newline and trailing null) into a buffer // where we can lex it. Token TmpTok; TmpTok.startToken(); CreateString(StrVal, TmpTok); SourceLocation TokLoc = TmpTok.getLocation(); // Make and enter a lexer object so that we lex and expand the tokens just // like any others. Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc, StrVal.size(), *this); EnterSourceFileWithLexer(TL, 0); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK__Pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text /// is not enclosed within a string literal. void Preprocessor::HandleMicrosoft__pragma(Token &Tok) { // Remember the pragma token location. SourceLocation PragmaLoc = Tok.getLocation(); // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaLoc, diag::err__Pragma_malformed); return; } // Get the tokens enclosed within the __pragma(), as well as the final ')'. SmallVector PragmaToks; int NumParens = 0; Lex(Tok); while (Tok.isNot(tok::eof)) { PragmaToks.push_back(Tok); if (Tok.is(tok::l_paren)) NumParens++; else if (Tok.is(tok::r_paren) && NumParens-- == 0) break; Lex(Tok); } if (Tok.is(tok::eof)) { Diag(PragmaLoc, diag::err_unterminated___pragma); return; } PragmaToks.front().setFlag(Token::LeadingSpace); // Replace the ')' with an EOD to mark the end of the pragma. PragmaToks.back().setKind(tok::eod); Token *TokArray = new Token[PragmaToks.size()]; std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray); // Push the tokens onto the stack. EnterTokenStream(TokArray, PragmaToks.size(), true, true); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK___pragma); // Finally, return whatever came after the pragma directive. return Lex(Tok); } /// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'. /// void Preprocessor::HandlePragmaOnce(Token &OnceTok) { if (isInPrimaryFile()) { Diag(OnceTok, diag::pp_pragma_once_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. // Mark the file as a once-only file now. HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry()); } void Preprocessor::HandlePragmaMark() { assert(CurPPLexer && "No current lexer?"); if (CurLexer) CurLexer->ReadToEndOfLine(); else CurPTHLexer->DiscardToEndOfLine(); } /// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'. /// void Preprocessor::HandlePragmaPoison(Token &PoisonTok) { Token Tok; while (1) { // Read the next token to poison. While doing this, pretend that we are // skipping while reading the identifier to poison. // This avoids errors on code like: // #pragma GCC poison X // #pragma GCC poison X if (CurPPLexer) CurPPLexer->LexingRawMode = true; LexUnexpandedToken(Tok); if (CurPPLexer) CurPPLexer->LexingRawMode = false; // If we reached the end of line, we're done. if (Tok.is(tok::eod)) return; // Can only poison identifiers. if (Tok.isNot(tok::raw_identifier)) { Diag(Tok, diag::err_pp_invalid_poison); return; } // Look up the identifier info for the token. We disabled identifier lookup // by saying we're skipping contents, so we need to do this manually. IdentifierInfo *II = LookUpIdentifierInfo(Tok); // Already poisoned. if (II->isPoisoned()) continue; // If this is a macro identifier, emit a warning. if (II->hasMacroDefinition()) Diag(Tok, diag::pp_poisoning_existing_macro); // Finally, poison it! II->setIsPoisoned(); if (II->isFromAST()) II->setChangedSinceDeserialization(); } } /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know /// that the whole directive has been parsed. void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) { if (isInPrimaryFile()) { Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file); return; } // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. PreprocessorLexer *TheLexer = getCurrentFileLexer(); // Mark the file as a system header. HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry()); PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation()); if (PLoc.isInvalid()) return; unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename()); // Notify the client, if desired, that we are in a new source file. if (Callbacks) Callbacks->FileChanged(SysHeaderTok.getLocation(), PPCallbacks::SystemHeaderPragma, SrcMgr::C_System); // Emit a line marker. This will change any source locations from this point // forward to realize they are in a system header. // Create a line note with this information. SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1, FilenameID, /*IsEntry=*/false, /*IsExit=*/false, /*IsSystem=*/true, /*IsExternC=*/false); } /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah. /// void Preprocessor::HandlePragmaDependency(Token &DependencyTok) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // If the token kind is EOD, the error has already been diagnosed. if (FilenameTok.is(tok::eod)) return; // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; bool Invalid = false; StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid); if (Invalid) return; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) return; // Search include directories for this file. const DirectoryLookup *CurDir; const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, isAngled, 0, CurDir, NULL, NULL, NULL); if (File == 0) { if (!SuppressIncludeNotFoundError) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; return; } const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry(); // If this file is older than the file it depends on, emit a diagnostic. if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) { // Lex tokens at the end of the message and include them in the message. std::string Message; Lex(DependencyTok); while (DependencyTok.isNot(tok::eod)) { Message += getSpelling(DependencyTok) + " "; Lex(DependencyTok); } // Remove the trailing ' ' if present. if (!Message.empty()) Message.erase(Message.end()-1); Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message; } } /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro. /// Return the IdentifierInfo* associated with the macro to push or pop. IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { // Remember the pragma token location. Token PragmaTok = Tok; // Read the '('. Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } // Read the macro name string. Lex(Tok); if (Tok.isNot(tok::string_literal)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); return 0; } // Remember the macro string. std::string StrVal = getSpelling(Tok); // Read the ')'. Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); return 0; } assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && "Invalid string token!"); // Create a Token from the string. Token MacroTok; MacroTok.startToken(); MacroTok.setKind(tok::raw_identifier); CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok); // Get the IdentifierInfo of MacroToPushTok. return LookUpIdentifierInfo(MacroTok); } /// \brief Handle \#pragma push_macro. /// /// The syntax is: /// \code /// #pragma push_macro("macro") /// \endcode void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) { // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok); if (!IdentInfo) return; // Get the MacroInfo associated with IdentInfo. MacroInfo *MI = getMacroInfo(IdentInfo); if (MI) { // Allow the original MacroInfo to be redefined later. MI->setIsAllowRedefinitionsWithoutWarning(true); } // Push the cloned MacroInfo so we can retrieve it later. PragmaPushMacroInfo[IdentInfo].push_back(MI); } /// \brief Handle \#pragma pop_macro. /// /// The syntax is: /// \code /// #pragma pop_macro("macro") /// \endcode void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) { SourceLocation MessageLoc = PopMacroTok.getLocation(); // Parse the pragma directive and get the macro IdentifierInfo*. IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok); if (!IdentInfo) return; // Find the vector associated with the macro. llvm::DenseMap >::iterator iter = PragmaPushMacroInfo.find(IdentInfo); if (iter != PragmaPushMacroInfo.end()) { // Forget the MacroInfo currently associated with IdentInfo. if (MacroDirective *CurrentMD = getMacroDirective(IdentInfo)) { MacroInfo *MI = CurrentMD->getMacroInfo(); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc)); } // Get the MacroInfo we want to reinstall. MacroInfo *MacroToReInstall = iter->second.back(); if (MacroToReInstall) { // Reinstall the previously pushed macro. appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc, /*isImported=*/false); } // Pop PragmaPushMacroInfo stack. iter->second.pop_back(); if (iter->second.size() == 0) PragmaPushMacroInfo.erase(iter); } else { Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push) << IdentInfo->getName(); } } void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) { // We will either get a quoted filename or a bracketed filename, and we // have to track which we got. The first filename is the source name, // and the second name is the mapped filename. If the first is quoted, // the second must be as well (cannot mix and match quotes and brackets). // Get the open paren Lex(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << "("; return; } // We expect either a quoted string literal, or a bracketed name Token SourceFilenameTok; CurPPLexer->LexIncludeFilename(SourceFilenameTok); if (SourceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef SourceFileName; SmallString<128> FileNameBuffer; if (SourceFilenameTok.is(tok::string_literal) || SourceFilenameTok.is(tok::angle_string_literal)) { SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer); } else if (SourceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted SourceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } FileNameBuffer.clear(); // Now we expect a comma, followed by another include name Lex(Tok); if (Tok.isNot(tok::comma)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ","; return; } Token ReplaceFilenameTok; CurPPLexer->LexIncludeFilename(ReplaceFilenameTok); if (ReplaceFilenameTok.is(tok::eod)) { // The diagnostic has already been handled return; } StringRef ReplaceFileName; if (ReplaceFilenameTok.is(tok::string_literal) || ReplaceFilenameTok.is(tok::angle_string_literal)) { ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer); } else if (ReplaceFilenameTok.is(tok::less)) { // This could be a path instead of just a name FileNameBuffer.push_back('<'); SourceLocation End; if (ConcatenateIncludeName(FileNameBuffer, End)) return; // Diagnostic already emitted ReplaceFileName = FileNameBuffer.str(); } else { Diag(Tok, diag::warn_pragma_include_alias_expected_filename); return; } // Finally, we expect the closing paren Lex(Tok); if (Tok.isNot(tok::r_paren)) { Diag(Tok, diag::warn_pragma_include_alias_expected) << ")"; return; } // Now that we have the source and target filenames, we need to make sure // they're both of the same type (angled vs non-angled) StringRef OriginalSource = SourceFileName; bool SourceIsAngled = GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(), SourceFileName); bool ReplaceIsAngled = GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(), ReplaceFileName); if (!SourceFileName.empty() && !ReplaceFileName.empty() && (SourceIsAngled != ReplaceIsAngled)) { unsigned int DiagID; if (SourceIsAngled) DiagID = diag::warn_pragma_include_alias_mismatch_angle; else DiagID = diag::warn_pragma_include_alias_mismatch_quote; Diag(SourceFilenameTok.getLocation(), DiagID) << SourceFileName << ReplaceFileName; return; } // Now we can let the include handler know about this mapping getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName); } /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. /// If 'Namespace' is non-null, then it is a token required to exist on the /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". void Preprocessor::AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *InsertNS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { // If there is already a pragma handler with the name of this namespace, // we either have an error (directive with the same name as a namespace) or // we already have the namespace to insert into. if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) { InsertNS = Existing->getIfNamespace(); assert(InsertNS != 0 && "Cannot have a pragma namespace and pragma" " handler with the same name!"); } else { // Otherwise, this namespace doesn't exist yet, create and insert the // handler for it. InsertNS = new PragmaNamespace(Namespace); PragmaHandlers->AddPragma(InsertNS); } } // Check to make sure we don't already have a pragma for this identifier. assert(!InsertNS->FindHandler(Handler->getName()) && "Pragma handler already exists for this identifier!"); InsertNS->AddPragma(Handler); } /// RemovePragmaHandler - Remove the specific pragma handler from the /// preprocessor. If \arg Namespace is non-null, then it should be the /// namespace that \arg Handler was added to. It is an error to remove /// a handler that has not been registered. void Preprocessor::RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler) { PragmaNamespace *NS = PragmaHandlers; // If this is specified to be in a namespace, step down into it. if (!Namespace.empty()) { PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace); assert(Existing && "Namespace containing handler does not exist!"); NS = Existing->getIfNamespace(); assert(NS && "Invalid namespace, registered as a regular pragma handler!"); } NS->RemovePragmaHandler(Handler); // If this is a non-default namespace and it is now empty, remove // it. if (NS != PragmaHandlers && NS->IsEmpty()) { PragmaHandlers->RemovePragmaHandler(NS); delete NS; } } bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) { Token Tok; LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("ON")) Result = tok::OOS_ON; else if (II->isStr("OFF")) Result = tok::OOS_OFF; else if (II->isStr("DEFAULT")) Result = tok::OOS_DEFAULT; else { Diag(Tok, diag::ext_on_off_switch_syntax); return true; } // Verify that this is followed by EOD. LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) Diag(Tok, diag::ext_pragma_syntax_eod); return false; } namespace { /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. struct PragmaOnceHandler : public PragmaHandler { PragmaOnceHandler() : PragmaHandler("once") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OnceTok) { PP.CheckEndOfDirective("pragma once"); PP.HandlePragmaOnce(OnceTok); } }; /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the /// rest of the line is not lexed. struct PragmaMarkHandler : public PragmaHandler { PragmaMarkHandler() : PragmaHandler("mark") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) { PP.HandlePragmaMark(); } }; /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. struct PragmaPoisonHandler : public PragmaHandler { PragmaPoisonHandler() : PragmaHandler("poison") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) { PP.HandlePragmaPoison(PoisonTok); } }; /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file /// as a system header, which silences warnings in it. struct PragmaSystemHeaderHandler : public PragmaHandler { PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) { PP.HandlePragmaDependency(DepToken); } }; struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) { Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("assert")) { llvm_unreachable("This is an assertion!"); } else if (II->isStr("crash")) { LLVM_BUILTIN_TRAP; } else if (II->isStr("parser_crash")) { Token Crasher; Crasher.setKind(tok::annot_pragma_parser_crash); PP.EnterToken(Crasher); } else if (II->isStr("llvm_fatal_error")) { llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error"); } else if (II->isStr("llvm_unreachable")) { llvm_unreachable("#pragma clang __debug llvm_unreachable"); } else if (II->isStr("overflow_stack")) { DebugOverflowStack(); } else if (II->isStr("handle_crash")) { llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent(); if (CRC) CRC->HandleCrash(); } else if (II->isStr("captured")) { HandleCaptured(PP); } else { PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command) << II->getName(); } PPCallbacks *Callbacks = PP.getPPCallbacks(); if (Callbacks) Callbacks->PragmaDebug(Tok.getLocation(), II->getName()); } void HandleCaptured(Preprocessor &PP) { // Skip if emitting preprocessed output. if (PP.isPreprocessedOutput()) return; Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma clang __debug captured"; return; } SourceLocation NameLoc = Tok.getLocation(); Token *Toks = PP.getPreprocessorAllocator().Allocate(1); Toks->startToken(); Toks->setKind(tok::annot_pragma_captured); Toks->setLocation(NameLoc); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // Disable MSVC warning about runtime stack overflow. #ifdef _MSC_VER #pragma warning(disable : 4717) #endif static void DebugOverflowStack() { void (*volatile Self)() = DebugOverflowStack; Self(); } #ifdef _MSC_VER #pragma warning(default : 4717) #endif }; /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"' struct PragmaDiagnosticHandler : public PragmaHandler { private: const char *Namespace; public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) { SourceLocation DiagLoc = DiagToken.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } IdentifierInfo *II = Tok.getIdentifierInfo(); PPCallbacks *Callbacks = PP.getPPCallbacks(); diag::Mapping Map; if (II->isStr("warning")) Map = diag::MAP_WARNING; else if (II->isStr("error")) Map = diag::MAP_ERROR; else if (II->isStr("ignored")) Map = diag::MAP_IGNORE; else if (II->isStr("fatal")) Map = diag::MAP_FATAL; else if (II->isStr("pop")) { if (!PP.getDiagnostics().popMappings(DiagLoc)) PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop); else if (Callbacks) Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace); return; } else if (II->isStr("push")) { PP.getDiagnostics().pushMappings(DiagLoc); if (Callbacks) Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace); return; } else { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } PP.LexUnexpandedToken(Tok); SourceLocation StringLoc = Tok.getLocation(); std::string WarningName; if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic", /*MacroExpansion=*/false)) return; if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); return; } if (WarningName.size() < 3 || WarningName[0] != '-' || WarningName[1] != 'W') { PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); return; } if (PP.getDiagnostics().setDiagnosticGroupMapping(WarningName.substr(2), Map, DiagLoc)) PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) << WarningName; else if (Callbacks) Callbacks->PragmaDiagnostic(DiagLoc, Namespace, Map, WarningName); } }; /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's /// diagnostics, so we don't really implement this pragma. We parse it and /// ignore it to avoid -Wunknown-pragma warnings. struct PragmaWarningHandler : public PragmaHandler { PragmaWarningHandler() : PragmaHandler("warning") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Parse things like: // warning(push, 1) // warning(pop) // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9) SourceLocation DiagLoc = Tok.getLocation(); PPCallbacks *Callbacks = PP.getPPCallbacks(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << "("; return; } PP.Lex(Tok); IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } if (II->isStr("push")) { // #pragma warning( push[ ,n ] ) int Level = -1; PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); uint64_t Value; if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) Level = int(Value); if (Level < 0 || Level > 4) { PP.Diag(Tok, diag::warn_pragma_warning_push_level); return; } } if (Callbacks) Callbacks->PragmaWarningPush(DiagLoc, Level); } else if (II->isStr("pop")) { // #pragma warning( pop ) PP.Lex(Tok); if (Callbacks) Callbacks->PragmaWarningPop(DiagLoc); } else { // #pragma warning( warning-specifier : warning-number-list // [; warning-specifier : warning-number-list...] ) while (true) { II = Tok.getIdentifierInfo(); if (!II) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } // Figure out which warning specifier this is. StringRef Specifier = II->getName(); bool SpecifierValid = llvm::StringSwitch(Specifier) .Cases("1", "2", "3", "4", true) .Cases("default", "disable", "error", "once", "suppress", true) .Default(false); if (!SpecifierValid) { PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); return; } PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":"; return; } // Collect the warning ids. SmallVector Ids; PP.Lex(Tok); while (Tok.is(tok::numeric_constant)) { uint64_t Value; if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || Value > INT_MAX) { PP.Diag(Tok, diag::warn_pragma_warning_expected_number); return; } Ids.push_back(int(Value)); } if (Callbacks) Callbacks->PragmaWarning(DiagLoc, Specifier, Ids); // Parse the next specifier if there is a semicolon. if (Tok.isNot(tok::semi)) break; PP.Lex(Tok); } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning"; } }; /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". struct PragmaIncludeAliasHandler : public PragmaHandler { PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &IncludeAliasTok) { PP.HandlePragmaIncludeAlias(IncludeAliasTok); } }; /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message /// extension. The syntax is: /// \code /// #pragma message(string) /// \endcode /// OR, in GCC mode: /// \code /// #pragma message string /// \endcode /// string is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters, etc... See MSDN for more details. /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same /// form as \#pragma message. struct PragmaMessageHandler : public PragmaHandler { private: const PPCallbacks::PragmaMessageKind Kind; const StringRef Namespace; static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind, bool PragmaNameOnly = false) { switch (Kind) { case PPCallbacks::PMK_Message: return PragmaNameOnly ? "message" : "pragma message"; case PPCallbacks::PMK_Warning: return PragmaNameOnly ? "warning" : "pragma warning"; case PPCallbacks::PMK_Error: return PragmaNameOnly ? "error" : "pragma error"; } llvm_unreachable("Unknown PragmaMessageKind!"); } public: PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind, StringRef Namespace = StringRef()) : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation MessageLoc = Tok.getLocation(); PP.Lex(Tok); bool ExpectClosingParen = false; switch (Tok.getKind()) { case tok::l_paren: // We have a MSVC style pragma message. ExpectClosingParen = true; // Read the string. PP.Lex(Tok); break; case tok::string_literal: // We have a GCC style pragma message, and we just read the string. break; default: PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind; return; } std::string MessageString; if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind), /*MacroExpansion=*/true)) return; if (ExpectClosingParen) { if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } PP.Lex(Tok); // eat the r_paren. } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; return; } // Output the message. PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error) ? diag::err_pragma_message : diag::warn_pragma_message) << MessageString; // If the pragma is lexically sound, notify any interested PPCallbacks. if (PPCallbacks *Callbacks = PP.getPPCallbacks()) Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString); } }; /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the /// macro on the top of the stack. struct PragmaPushMacroHandler : public PragmaHandler { PragmaPushMacroHandler() : PragmaHandler("push_macro") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) { PP.HandlePragmaPushMacro(PushMacroTok); } }; /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the /// macro to the value on the top of the stack. struct PragmaPopMacroHandler : public PragmaHandler { PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) { PP.HandlePragmaPopMacro(PopMacroTok); } }; // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; /// PragmaARCCFCodeAuditedHandler - /// \#pragma clang arc_cf_code_audited begin/end struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; Token Tok; // Lex the 'begin' or 'end'. PP.LexUnexpandedToken(Tok); const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); if (BeginEnd && BeginEnd->isStr("begin")) { IsBegin = true; } else if (BeginEnd && BeginEnd->isStr("end")) { IsBegin = false; } else { PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax); return; } // Verify that this is followed by EOD. PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; // The start location of the active audit. SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc(); // The start location we want after processing this. SourceLocation NewLoc; if (IsBegin) { // Complain about attempts to re-enter an audit. if (BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited); PP.Diag(BeginLoc, diag::note_pragma_entered_here); } NewLoc = Loc; } else { // Complain about attempts to leave an audit that doesn't exist. if (!BeginLoc.isValid()) { PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited); return; } NewLoc = SourceLocation(); } PP.setPragmaARCCFCodeAuditedLoc(NewLoc); } }; /// \brief Handle "\#pragma region [...]" /// /// The syntax is /// \code /// #pragma region [optional name] /// #pragma endregion [optional comment] /// \endcode /// /// \note This is /// editor-only /// pragma, just skipped by compiler. struct PragmaRegionHandler : public PragmaHandler { PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) { // #pragma region: endregion matches can be verified // __pragma(region): no sense, but ignored by msvc // _Pragma is not valid for MSVC, but there isn't any point // to handle a _Pragma differently. } }; } // end anonymous namespace /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: /// \#pragma GCC poison/system_header/dependency and \#pragma once. void Preprocessor::RegisterBuiltinPragmas() { AddPragmaHandler(new PragmaOnceHandler()); AddPragmaHandler(new PragmaMarkHandler()); AddPragmaHandler(new PragmaPushMacroHandler()); AddPragmaHandler(new PragmaPopMacroHandler()); AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message)); // #pragma GCC ... AddPragmaHandler("GCC", new PragmaPoisonHandler()); AddPragmaHandler("GCC", new PragmaSystemHeaderHandler()); AddPragmaHandler("GCC", new PragmaDependencyHandler()); AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning, "GCC")); AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error, "GCC")); // #pragma clang ... AddPragmaHandler("clang", new PragmaPoisonHandler()); AddPragmaHandler("clang", new PragmaSystemHeaderHandler()); AddPragmaHandler("clang", new PragmaDebugHandler()); AddPragmaHandler("clang", new PragmaDependencyHandler()); AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang")); AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler()); AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler()); AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler()); AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler()); // MS extensions. if (LangOpts.MicrosoftExt) { AddPragmaHandler(new PragmaWarningHandler()); AddPragmaHandler(new PragmaIncludeAliasHandler()); AddPragmaHandler(new PragmaRegionHandler("region")); AddPragmaHandler(new PragmaRegionHandler("endregion")); } } @