clang/lib/Lex/Pragma.cpp

   1 //===- Pragma.cpp - Pragma registration and handling ----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the PragmaHandler/PragmaTable interfaces and implements
  10 // pragma related methods of the Preprocessor class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Lex/Pragma.h"
  15 #include "clang/Basic/CLWarnings.h"
  16 #include "clang/Basic/Diagnostic.h"
  17 #include "clang/Basic/FileManager.h"
  18 #include "clang/Basic/IdentifierTable.h"
  19 #include "clang/Basic/LLVM.h"
  20 #include "clang/Basic/LangOptions.h"
  21 #include "clang/Basic/Module.h"
  22 #include "clang/Basic/SourceLocation.h"
  23 #include "clang/Basic/SourceManager.h"
  24 #include "clang/Basic/TokenKinds.h"
  25 #include "clang/Lex/HeaderSearch.h"
  26 #include "clang/Lex/LexDiagnostic.h"
  27 #include "clang/Lex/Lexer.h"
  28 #include "clang/Lex/LiteralSupport.h"
  29 #include "clang/Lex/MacroInfo.h"
  30 #include "clang/Lex/ModuleLoader.h"
  31 #include "clang/Lex/PPCallbacks.h"
  32 #include "clang/Lex/Preprocessor.h"
  33 #include "clang/Lex/PreprocessorLexer.h"
  34 #include "clang/Lex/PreprocessorOptions.h"
  35 #include "clang/Lex/Token.h"
  36 #include "clang/Lex/TokenLexer.h"
  37 #include "llvm/ADT/ArrayRef.h"
  38 #include "llvm/ADT/DenseMap.h"
  39 #include "llvm/ADT/STLExtras.h"
  40 #include "llvm/ADT/SmallString.h"
  41 #include "llvm/ADT/SmallVector.h"
  42 #include "llvm/ADT/StringRef.h"
  43 #include "llvm/Support/Compiler.h"
  44 #include "llvm/Support/ErrorHandling.h"
  45 #include "llvm/Support/Timer.h"
  46 #include <algorithm>
  47 #include <cassert>
  48 #include <cstddef>
  49 #include <cstdint>
  50 #include <limits>
  51 #include <optional>
  52 #include <string>
  53 #include <utility>
  54 #include <vector>
  55
  56 using namespace clang;
  57
  58 // Out-of-line destructor to provide a home for the class.
  59 PragmaHandler::~PragmaHandler() = default;
  60
  61 //===----------------------------------------------------------------------===//
  62 // EmptyPragmaHandler Implementation.
  63 //===----------------------------------------------------------------------===//
  64
  65 EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}
  66
  67 void EmptyPragmaHandler::HandlePragma(Preprocessor &PP,
  68                                       PragmaIntroducer Introducer,
  69                                       Token &FirstToken) {}
  70
  71 //===----------------------------------------------------------------------===//
  72 // PragmaNamespace Implementation.
  73 //===----------------------------------------------------------------------===//
  74
  75 /// FindHandler - Check to see if there is already a handler for the
  76 /// specified name.  If not, return the handler for the null identifier if it
  77 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  78 /// the null handler isn't returned on failure to match.
  79 PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
  80                                             bool IgnoreNull) const {
  81   auto I = Handlers.find(Name);
  82   if (I != Handlers.end())
  83     return I->getValue().get();
  84   if (IgnoreNull)
  85     return nullptr;
  86   I = Handlers.find(StringRef());
  87   if (I != Handlers.end())
  88     return I->getValue().get();
  89   return nullptr;
  90 }
  91
  92 void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
  93   assert(!Handlers.count(Handler->getName()) &&
  94          "A handler with this name is already registered in this namespace");
  95   Handlers[Handler->getName()].reset(Handler);
  96 }
  97
  98 void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
  99   auto I = Handlers.find(Handler->getName());
 100   assert(I != Handlers.end() &&
 101          "Handler not registered in this namespace");
 102   // Release ownership back to the caller.
 103   I->getValue().release();
 104   Handlers.erase(I);
 105 }
 106
 107 void PragmaNamespace::HandlePragma(Preprocessor &PP,
 108                                    PragmaIntroducer Introducer, Token &Tok) {
 109   // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
 110   // expand it, the user can have a STDC #define, that should not affect this.
 111   PP.LexUnexpandedToken(Tok);
 112
 113   // Get the handler for this token.  If there is no handler, ignore the pragma.
 114   PragmaHandler *Handler
 115     = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
 116                                           : StringRef(),
 117                   /*IgnoreNull=*/false);
 118   if (!Handler) {
 119     PP.Diag(Tok, diag::warn_pragma_ignored);
 120     return;
 121   }
 122
 123   // Otherwise, pass it down.
 124   Handler->HandlePragma(PP, Introducer, Tok);
 125 }
 126
 127 //===----------------------------------------------------------------------===//
 128 // Preprocessor Pragma Directive Handling.
 129 //===----------------------------------------------------------------------===//
 130
 131 namespace {
 132 // TokenCollector provides the option to collect tokens that were "read"
 133 // and return them to the stream to be read later.
 134 // Currently used when reading _Pragma/__pragma directives.
 135 struct TokenCollector {
 136   Preprocessor &Self;
 137   bool Collect;
 138   SmallVector<Token, 3> Tokens;
 139   Token &Tok;
 140
 141   void lex() {
 142     if (Collect)
 143       Tokens.push_back(Tok);
 144     Self.Lex(Tok);
 145   }
 146
 147   void revert() {
 148     assert(Collect && "did not collect tokens");
 149     assert(!Tokens.empty() && "collected unexpected number of tokens");
 150
 151     // Push the ( "string" ) tokens into the token stream.
 152     auto Toks = std::make_unique<Token[]>(Tokens.size());
 153     std::copy(Tokens.begin() + 1, Tokens.end(), Toks.get());
 154     Toks[Tokens.size() - 1] = Tok;
 155     Self.EnterTokenStream(std::move(Toks), Tokens.size(),
 156                           /*DisableMacroExpansion*/ true,
 157                           /*IsReinject*/ true);
 158
 159     // ... and return the pragma token unchanged.
 160     Tok = *Tokens.begin();
 161   }
 162 };
 163 } // namespace
 164
 165 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 166 /// rest of the pragma, passing it to the registered pragma handlers.
 167 void Preprocessor::HandlePragmaDirective(PragmaIntroducer Introducer) {
 168   if (Callbacks)
 169     Callbacks->PragmaDirective(Introducer.Loc, Introducer.Kind);
 170
 171   if (!PragmasEnabled)
 172     return;
 173
 174   ++NumPragma;
 175
 176   // Invoke the first level of pragma handlers which reads the namespace id.
 177   Token Tok;
 178   PragmaHandlers->HandlePragma(*this, Introducer, Tok);
 179
 180   // If the pragma handler didn't read the rest of the line, consume it now.
 181   if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
 182    || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
 183     DiscardUntilEndOfDirective();
 184 }
 185
 186 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
 187 /// return the first token after the directive.  The _Pragma token has just
 188 /// been read into 'Tok'.
 189 void Preprocessor::Handle_Pragma(Token &Tok) {
 190   // C11 6.10.3.4/3:
 191   //   all pragma unary operator expressions within [a completely
 192   //   macro-replaced preprocessing token sequence] are [...] processed [after
 193   //   rescanning is complete]
 194   //
 195   // This means that we execute _Pragma operators in two cases:
 196   //
 197   //  1) on token sequences that would otherwise be produced as the output of
 198   //     phase 4 of preprocessing, and
 199   //  2) on token sequences formed as the macro-replaced token sequence of a
 200   //     macro argument
 201   //
 202   // Case #2 appears to be a wording bug: only _Pragmas that would survive to
 203   // the end of phase 4 should actually be executed. Discussion on the WG14
 204   // mailing list suggests that a _Pragma operator is notionally checked early,
 205   // but only pragmas that survive to the end of phase 4 should be executed.
 206   //
 207   // In Case #2, we check the syntax now, but then put the tokens back into the
 208   // token stream for later consumption.
 209
 210   TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
 211
 212   // Remember the pragma token location.
 213   SourceLocation PragmaLoc = Tok.getLocation();
 214
 215   // Read the '('.
 216   Toks.lex();
 217   if (Tok.isNot(tok::l_paren)) {
 218     Diag(PragmaLoc, diag::err__Pragma_malformed);
 219     return;
 220   }
 221
 222   // Read the '"..."'.
 223   Toks.lex();
 224   if (!tok::isStringLiteral(Tok.getKind())) {
 225     Diag(PragmaLoc, diag::err__Pragma_malformed);
 226     // Skip bad tokens, and the ')', if present.
 227     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
 228       Lex(Tok);
 229     while (Tok.isNot(tok::r_paren) &&
 230            !Tok.isAtStartOfLine() &&
 231            Tok.isNot(tok::eof))
 232       Lex(Tok);
 233     if (Tok.is(tok::r_paren))
 234       Lex(Tok);
 235     return;
 236   }
 237
 238   if (Tok.hasUDSuffix()) {
 239     Diag(Tok, diag::err_invalid_string_udl);
 240     // Skip this token, and the ')', if present.
 241     Lex(Tok);
 242     if (Tok.is(tok::r_paren))
 243       Lex(Tok);
 244     return;
 245   }
 246
 247   // Remember the string.
 248   Token StrTok = Tok;
 249
 250   // Read the ')'.
 251   Toks.lex();
 252   if (Tok.isNot(tok::r_paren)) {
 253     Diag(PragmaLoc, diag::err__Pragma_malformed);
 254     return;
 255   }
 256
 257   // If we're expanding a macro argument, put the tokens back.
 258   if (InMacroArgPreExpansion) {
 259     Toks.revert();
 260     return;
 261   }
 262
 263   SourceLocation RParenLoc = Tok.getLocation();
 264   bool Invalid = false;
 265   SmallString<64> StrVal;
 266   StrVal.resize(StrTok.getLength());
 267   StringRef StrValRef = getSpelling(StrTok, StrVal, &Invalid);
 268   if (Invalid) {
 269     Diag(PragmaLoc, diag::err__Pragma_malformed);
 270     return;
 271   }
 272
 273   assert(StrValRef.size() <= StrVal.size());
 274
 275   // If the token was spelled somewhere else, copy it.
 276   if (StrValRef.begin() != StrVal.begin())
 277     StrVal.assign(StrValRef);
 278   // Truncate if necessary.
 279   else if (StrValRef.size() != StrVal.size())
 280     StrVal.resize(StrValRef.size());
 281
 282   // The _Pragma is lexically sound.  Destringize according to C11 6.10.9.1.
 283   prepare_PragmaString(StrVal);
 284
 285   // Plop the string (including the newline and trailing null) into a buffer
 286   // where we can lex it.
 287   Token TmpTok;
 288   TmpTok.startToken();
 289   CreateString(StrVal, TmpTok);
 290   SourceLocation TokLoc = TmpTok.getLocation();
 291
 292   // Make and enter a lexer object so that we lex and expand the tokens just
 293   // like any others.
 294   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
 295                                         StrVal.size(), *this);
 296
 297   EnterSourceFileWithLexer(TL, nullptr);
 298
 299   // With everything set up, lex this as a #pragma directive.
 300   HandlePragmaDirective({PIK__Pragma, PragmaLoc});
 301
 302   // Finally, return whatever came after the pragma directive.
 303   return Lex(Tok);
 304 }
 305
 306 void clang::prepare_PragmaString(SmallVectorImpl<char> &StrVal) {
 307   if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
 308       (StrVal[0] == 'u' && StrVal[1] != '8'))
 309     StrVal.erase(StrVal.begin());
 310   else if (StrVal[0] == 'u')
 311     StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
 312
 313   if (StrVal[0] == 'R') {
 314     // FIXME: C++11 does not specify how to handle raw-string-literals here.
 315     // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
 316     assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
 317            "Invalid raw string token!");
 318
 319     // Measure the length of the d-char-sequence.
 320     unsigned NumDChars = 0;
 321     while (StrVal[2 + NumDChars] != '(') {
 322       assert(NumDChars < (StrVal.size() - 5) / 2 &&
 323              "Invalid raw string token!");
 324       ++NumDChars;
 325     }
 326     assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
 327
 328     // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
 329     // parens below.
 330     StrVal.erase(StrVal.begin(), StrVal.begin() + 2 + NumDChars);
 331     StrVal.erase(StrVal.end() - 1 - NumDChars, StrVal.end());
 332   } else {
 333     assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 334            "Invalid string token!");
 335
 336     // Remove escaped quotes and escapes.
 337     unsigned ResultPos = 1;
 338     for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
 339       // Skip escapes.  \\ -> '\' and \" -> '"'.
 340       if (StrVal[i] == '\\' && i + 1 < e &&
 341           (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
 342         ++i;
 343       StrVal[ResultPos++] = StrVal[i];
 344     }
 345     StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
 346   }
 347
 348   // Remove the front quote, replacing it with a space, so that the pragma
 349   // contents appear to have a space before them.
 350   StrVal[0] = ' ';
 351
 352   // Replace the terminating quote with a \n.
 353   StrVal[StrVal.size() - 1] = '\n';
 354 }
 355
 356 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
 357 /// is not enclosed within a string literal.
 358 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
 359   // During macro pre-expansion, check the syntax now but put the tokens back
 360   // into the token stream for later consumption. Same as Handle_Pragma.
 361   TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
 362
 363   // Remember the pragma token location.
 364   SourceLocation PragmaLoc = Tok.getLocation();
 365
 366   // Read the '('.
 367   Toks.lex();
 368   if (Tok.isNot(tok::l_paren)) {
 369     Diag(PragmaLoc, diag::err__Pragma_malformed);
 370     return;
 371   }
 372
 373   // Get the tokens enclosed within the __pragma(), as well as the final ')'.
 374   SmallVector<Token, 32> PragmaToks;
 375   int NumParens = 0;
 376   Toks.lex();
 377   while (Tok.isNot(tok::eof)) {
 378     PragmaToks.push_back(Tok);
 379     if (Tok.is(tok::l_paren))
 380       NumParens++;
 381     else if (Tok.is(tok::r_paren) && NumParens-- == 0)
 382       break;
 383     Toks.lex();
 384   }
 385
 386   if (Tok.is(tok::eof)) {
 387     Diag(PragmaLoc, diag::err_unterminated___pragma);
 388     return;
 389   }
 390
 391   // If we're expanding a macro argument, put the tokens back.
 392   if (InMacroArgPreExpansion) {
 393     Toks.revert();
 394     return;
 395   }
 396
 397   PragmaToks.front().setFlag(Token::LeadingSpace);
 398
 399   // Replace the ')' with an EOD to mark the end of the pragma.
 400   PragmaToks.back().setKind(tok::eod);
 401
 402   Token *TokArray = new Token[PragmaToks.size()];
 403   std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
 404
 405   // Push the tokens onto the stack.
 406   EnterTokenStream(TokArray, PragmaToks.size(), true, true,
 407                    /*IsReinject*/ false);
 408
 409   // With everything set up, lex this as a #pragma directive.
 410   HandlePragmaDirective({PIK___pragma, PragmaLoc});
 411
 412   // Finally, return whatever came after the pragma directive.
 413   return Lex(Tok);
 414 }
 415
 416 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
 417 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
 418   // Don't honor the 'once' when handling the primary source file, unless
 419   // this is a prefix to a TU, which indicates we're generating a PCH file, or
 420   // when the main file is a header (e.g. when -xc-header is provided on the
 421   // commandline).
 422   if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
 423     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
 424     return;
 425   }
 426
 427   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 428   // Mark the file as a once-only file now.
 429   HeaderInfo.MarkFileIncludeOnce(*getCurrentFileLexer()->getFileEntry());
 430 }
 431
 432 void Preprocessor::HandlePragmaMark(Token &MarkTok) {
 433   assert(CurPPLexer && "No current lexer?");
 434
 435   SmallString<64> Buffer;
 436   CurLexer->ReadToEndOfLine(&Buffer);
 437   if (Callbacks)
 438     Callbacks->PragmaMark(MarkTok.getLocation(), Buffer);
 439 }
 440
 441 /// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
 442 void Preprocessor::HandlePragmaPoison() {
 443   Token Tok;
 444
 445   while (true) {
 446     // Read the next token to poison.  While doing this, pretend that we are
 447     // skipping while reading the identifier to poison.
 448     // This avoids errors on code like:
 449     //   #pragma GCC poison X
 450     //   #pragma GCC poison X
 451     if (CurPPLexer) CurPPLexer->LexingRawMode = true;
 452     LexUnexpandedToken(Tok);
 453     if (CurPPLexer) CurPPLexer->LexingRawMode = false;
 454
 455     // If we reached the end of line, we're done.
 456     if (Tok.is(tok::eod)) return;
 457
 458     // Can only poison identifiers.
 459     if (Tok.isNot(tok::raw_identifier)) {
 460       Diag(Tok, diag::err_pp_invalid_poison);
 461       return;
 462     }
 463
 464     // Look up the identifier info for the token.  We disabled identifier lookup
 465     // by saying we're skipping contents, so we need to do this manually.
 466     IdentifierInfo *II = LookUpIdentifierInfo(Tok);
 467
 468     // Already poisoned.
 469     if (II->isPoisoned()) continue;
 470
 471     // If this is a macro identifier, emit a warning.
 472     if (isMacroDefined(II))
 473       Diag(Tok, diag::pp_poisoning_existing_macro);
 474
 475     // Finally, poison it!
 476     II->setIsPoisoned();
 477     if (II->isFromAST())
 478       II->setChangedSinceDeserialization();
 479   }
 480 }
 481
 482 /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header.  We know
 483 /// that the whole directive has been parsed.
 484 void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
 485   if (isInPrimaryFile()) {
 486     Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
 487     return;
 488   }
 489
 490   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 491   PreprocessorLexer *TheLexer = getCurrentFileLexer();
 492
 493   // Mark the file as a system header.
 494   HeaderInfo.MarkFileSystemHeader(*TheLexer->getFileEntry());
 495
 496   PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
 497   if (PLoc.isInvalid())
 498     return;
 499
 500   unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
 501
 502   // Notify the client, if desired, that we are in a new source file.
 503   if (Callbacks)
 504     Callbacks->FileChanged(SysHeaderTok.getLocation(),
 505                            PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
 506
 507   // Emit a line marker.  This will change any source locations from this point
 508   // forward to realize they are in a system header.
 509   // Create a line note with this information.
 510   SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
 511                         FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
 512                         SrcMgr::C_System);
 513 }
 514
 515 /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
 516 void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
 517   Token FilenameTok;
 518   if (LexHeaderName(FilenameTok, /*AllowConcatenation*/false))
 519     return;
 520
 521   // If the next token wasn't a header-name, diagnose the error.
 522   if (FilenameTok.isNot(tok::header_name)) {
 523     Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
 524     return;
 525   }
 526
 527   // Reserve a buffer to get the spelling.
 528   SmallString<128> FilenameBuffer;
 529   bool Invalid = false;
 530   StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
 531   if (Invalid)
 532     return;
 533
 534   bool isAngled =
 535     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
 536   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
 537   // error.
 538   if (Filename.empty())
 539     return;
 540
 541   // Search include directories for this file.
 542   OptionalFileEntryRef File =
 543       LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
 544                  nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
 545   if (!File) {
 546     if (!SuppressIncludeNotFoundError)
 547       Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
 548     return;
 549   }
 550
 551   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
 552
 553   // If this file is older than the file it depends on, emit a diagnostic.
 554   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
 555     // Lex tokens at the end of the message and include them in the message.
 556     std::string Message;
 557     Lex(DependencyTok);
 558     while (DependencyTok.isNot(tok::eod)) {
 559       Message += getSpelling(DependencyTok) + " ";
 560       Lex(DependencyTok);
 561     }
 562
 563     // Remove the trailing ' ' if present.
 564     if (!Message.empty())
 565       Message.erase(Message.end()-1);
 566     Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
 567   }
 568 }
 569
 570 /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
 571 /// Return the IdentifierInfo* associated with the macro to push or pop.
 572 IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {
 573   // Remember the pragma token location.
 574   Token PragmaTok = Tok;
 575
 576   // Read the '('.
 577   Lex(Tok);
 578   if (Tok.isNot(tok::l_paren)) {
 579     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 580       << getSpelling(PragmaTok);
 581     return nullptr;
 582   }
 583
 584   // Read the macro name string.
 585   Lex(Tok);
 586   if (Tok.isNot(tok::string_literal)) {
 587     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 588       << getSpelling(PragmaTok);
 589     return nullptr;
 590   }
 591
 592   if (Tok.hasUDSuffix()) {
 593     Diag(Tok, diag::err_invalid_string_udl);
 594     return nullptr;
 595   }
 596
 597   // Remember the macro string.
 598   std::string StrVal = getSpelling(Tok);
 599
 600   // Read the ')'.
 601   Lex(Tok);
 602   if (Tok.isNot(tok::r_paren)) {
 603     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 604       << getSpelling(PragmaTok);
 605     return nullptr;
 606   }
 607
 608   assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 609          "Invalid string token!");
 610
 611   // Create a Token from the string.
 612   Token MacroTok;
 613   MacroTok.startToken();
 614   MacroTok.setKind(tok::raw_identifier);
 615   CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
 616
 617   // Get the IdentifierInfo of MacroToPushTok.
 618   return LookUpIdentifierInfo(MacroTok);
 619 }
 620
 621 /// Handle \#pragma push_macro.
 622 ///
 623 /// The syntax is:
 624 /// \code
 625 ///   #pragma push_macro("macro")
 626 /// \endcode
 627 void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
 628   // Parse the pragma directive and get the macro IdentifierInfo*.
 629   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
 630   if (!IdentInfo) return;
 631
 632   // Get the MacroInfo associated with IdentInfo.
 633   MacroInfo *MI = getMacroInfo(IdentInfo);
 634
 635   if (MI) {
 636     // Allow the original MacroInfo to be redefined later.
 637     MI->setIsAllowRedefinitionsWithoutWarning(true);
 638   }
 639
 640   // Push the cloned MacroInfo so we can retrieve it later.
 641   PragmaPushMacroInfo[IdentInfo].push_back(MI);
 642 }
 643
 644 /// Handle \#pragma pop_macro.
 645 ///
 646 /// The syntax is:
 647 /// \code
 648 ///   #pragma pop_macro("macro")
 649 /// \endcode
 650 void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
 651   SourceLocation MessageLoc = PopMacroTok.getLocation();
 652
 653   // Parse the pragma directive and get the macro IdentifierInfo*.
 654   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
 655   if (!IdentInfo) return;
 656
 657   // Find the vector<MacroInfo*> associated with the macro.
 658   llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
 659     PragmaPushMacroInfo.find(IdentInfo);
 660   if (iter != PragmaPushMacroInfo.end()) {
 661     // Forget the MacroInfo currently associated with IdentInfo.
 662     if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
 663       if (MI->isWarnIfUnused())
 664         WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 665       appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
 666     }
 667
 668     // Get the MacroInfo we want to reinstall.
 669     MacroInfo *MacroToReInstall = iter->second.back();
 670
 671     if (MacroToReInstall)
 672       // Reinstall the previously pushed macro.
 673       appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
 674
 675     // Pop PragmaPushMacroInfo stack.
 676     iter->second.pop_back();
 677     if (iter->second.empty())
 678       PragmaPushMacroInfo.erase(iter);
 679   } else {
 680     Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
 681       << IdentInfo->getName();
 682   }
 683 }
 684
 685 void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
 686   // We will either get a quoted filename or a bracketed filename, and we
 687   // have to track which we got.  The first filename is the source name,
 688   // and the second name is the mapped filename.  If the first is quoted,
 689   // the second must be as well (cannot mix and match quotes and brackets).
 690
 691   // Get the open paren
 692   Lex(Tok);
 693   if (Tok.isNot(tok::l_paren)) {
 694     Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
 695     return;
 696   }
 697
 698   // We expect either a quoted string literal, or a bracketed name
 699   Token SourceFilenameTok;
 700   if (LexHeaderName(SourceFilenameTok))
 701     return;
 702
 703   StringRef SourceFileName;
 704   SmallString<128> FileNameBuffer;
 705   if (SourceFilenameTok.is(tok::header_name)) {
 706     SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
 707   } else {
 708     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 709     return;
 710   }
 711   FileNameBuffer.clear();
 712
 713   // Now we expect a comma, followed by another include name
 714   Lex(Tok);
 715   if (Tok.isNot(tok::comma)) {
 716     Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
 717     return;
 718   }
 719
 720   Token ReplaceFilenameTok;
 721   if (LexHeaderName(ReplaceFilenameTok))
 722     return;
 723
 724   StringRef ReplaceFileName;
 725   if (ReplaceFilenameTok.is(tok::header_name)) {
 726     ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
 727   } else {
 728     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 729     return;
 730   }
 731
 732   // Finally, we expect the closing paren
 733   Lex(Tok);
 734   if (Tok.isNot(tok::r_paren)) {
 735     Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
 736     return;
 737   }
 738
 739   // Now that we have the source and target filenames, we need to make sure
 740   // they're both of the same type (angled vs non-angled)
 741   StringRef OriginalSource = SourceFileName;
 742
 743   bool SourceIsAngled =
 744     GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
 745                                 SourceFileName);
 746   bool ReplaceIsAngled =
 747     GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
 748                                 ReplaceFileName);
 749   if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
 750       (SourceIsAngled != ReplaceIsAngled)) {
 751     unsigned int DiagID;
 752     if (SourceIsAngled)
 753       DiagID = diag::warn_pragma_include_alias_mismatch_angle;
 754     else
 755       DiagID = diag::warn_pragma_include_alias_mismatch_quote;
 756
 757     Diag(SourceFilenameTok.getLocation(), DiagID)
 758       << SourceFileName
 759       << ReplaceFileName;
 760
 761     return;
 762   }
 763
 764   // Now we can let the include handler know about this mapping
 765   getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
 766 }
 767
 768 // Lex a component of a module name: either an identifier or a string literal;
 769 // for components that can be expressed both ways, the two forms are equivalent.
 770 static bool LexModuleNameComponent(
 771     Preprocessor &PP, Token &Tok,
 772     std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
 773     bool First) {
 774   PP.LexUnexpandedToken(Tok);
 775   if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
 776     StringLiteralParser Literal(Tok, PP);
 777     if (Literal.hadError)
 778       return true;
 779     ModuleNameComponent = std::make_pair(
 780         PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
 781   } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
 782     ModuleNameComponent =
 783         std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
 784   } else {
 785     PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
 786     return true;
 787   }
 788   return false;
 789 }
 790
 791 static bool LexModuleName(
 792     Preprocessor &PP, Token &Tok,
 793     llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
 794         &ModuleName) {
 795   while (true) {
 796     std::pair<IdentifierInfo*, SourceLocation> NameComponent;
 797     if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
 798       return true;
 799     ModuleName.push_back(NameComponent);
 800
 801     PP.LexUnexpandedToken(Tok);
 802     if (Tok.isNot(tok::period))
 803       return false;
 804   }
 805 }
 806
 807 void Preprocessor::HandlePragmaModuleBuild(Token &Tok) {
 808   SourceLocation Loc = Tok.getLocation();
 809
 810   std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
 811   if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
 812     return;
 813   IdentifierInfo *ModuleName = ModuleNameLoc.first;
 814
 815   LexUnexpandedToken(Tok);
 816   if (Tok.isNot(tok::eod)) {
 817     Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
 818     DiscardUntilEndOfDirective();
 819   }
 820
 821   CurLexer->LexingRawMode = true;
 822
 823   auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
 824     if (Tok.getKind() != tok::raw_identifier ||
 825         Tok.getRawIdentifier() != Ident)
 826       return false;
 827     CurLexer->Lex(Tok);
 828     return true;
 829   };
 830
 831   // Scan forward looking for the end of the module.
 832   const char *Start = CurLexer->getBufferLocation();
 833   const char *End = nullptr;
 834   unsigned NestingLevel = 1;
 835   while (true) {
 836     End = CurLexer->getBufferLocation();
 837     CurLexer->Lex(Tok);
 838
 839     if (Tok.is(tok::eof)) {
 840       Diag(Loc, diag::err_pp_module_build_missing_end);
 841       break;
 842     }
 843
 844     if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
 845       // Token was part of module; keep going.
 846       continue;
 847     }
 848
 849     // We hit something directive-shaped; check to see if this is the end
 850     // of the module build.
 851     CurLexer->ParsingPreprocessorDirective = true;
 852     CurLexer->Lex(Tok);
 853     if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
 854         TryConsumeIdentifier("module")) {
 855       if (TryConsumeIdentifier("build"))
 856         // #pragma clang module build -> entering a nested module build.
 857         ++NestingLevel;
 858       else if (TryConsumeIdentifier("endbuild")) {
 859         // #pragma clang module endbuild -> leaving a module build.
 860         if (--NestingLevel == 0)
 861           break;
 862       }
 863       // We should either be looking at the EOD or more of the current directive
 864       // preceding the EOD. Either way we can ignore this token and keep going.
 865       assert(Tok.getKind() != tok::eof && "missing EOD before EOF");
 866     }
 867   }
 868
 869   CurLexer->LexingRawMode = false;
 870
 871   // Load the extracted text as a preprocessed module.
 872   assert(CurLexer->getBuffer().begin() <= Start &&
 873          Start <= CurLexer->getBuffer().end() &&
 874          CurLexer->getBuffer().begin() <= End &&
 875          End <= CurLexer->getBuffer().end() &&
 876          "module source range not contained within same file buffer");
 877   TheModuleLoader.createModuleFromSource(Loc, ModuleName->getName(),
 878                                          StringRef(Start, End - Start));
 879 }
 880
 881 void Preprocessor::HandlePragmaHdrstop(Token &Tok) {
 882   Lex(Tok);
 883   if (Tok.is(tok::l_paren)) {
 884     Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);
 885
 886     std::string FileName;
 887     if (!LexStringLiteral(Tok, FileName, "pragma hdrstop", false))
 888       return;
 889
 890     if (Tok.isNot(tok::r_paren)) {
 891       Diag(Tok, diag::err_expected) << tok::r_paren;
 892       return;
 893     }
 894     Lex(Tok);
 895   }
 896   if (Tok.isNot(tok::eod))
 897     Diag(Tok.getLocation(), diag::ext_pp_extra_tokens_at_eol)
 898         << "pragma hdrstop";
 899
 900   if (creatingPCHWithPragmaHdrStop() &&
 901       SourceMgr.isInMainFile(Tok.getLocation())) {
 902     assert(CurLexer && "no lexer for #pragma hdrstop processing");
 903     Token &Result = Tok;
 904     Result.startToken();
 905     CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
 906     CurLexer->cutOffLexing();
 907   }
 908   if (usingPCHWithPragmaHdrStop())
 909     SkippingUntilPragmaHdrStop = false;
 910 }
 911
 912 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
 913 /// If 'Namespace' is non-null, then it is a token required to exist on the
 914 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
 915 void Preprocessor::AddPragmaHandler(StringRef Namespace,
 916                                     PragmaHandler *Handler) {
 917   PragmaNamespace *InsertNS = PragmaHandlers.get();
 918
 919   // If this is specified to be in a namespace, step down into it.
 920   if (!Namespace.empty()) {
 921     // If there is already a pragma handler with the name of this namespace,
 922     // we either have an error (directive with the same name as a namespace) or
 923     // we already have the namespace to insert into.
 924     if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
 925       InsertNS = Existing->getIfNamespace();
 926       assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
 927              " handler with the same name!");
 928     } else {
 929       // Otherwise, this namespace doesn't exist yet, create and insert the
 930       // handler for it.
 931       InsertNS = new PragmaNamespace(Namespace);
 932       PragmaHandlers->AddPragma(InsertNS);
 933     }
 934   }
 935
 936   // Check to make sure we don't already have a pragma for this identifier.
 937   assert(!InsertNS->FindHandler(Handler->getName()) &&
 938          "Pragma handler already exists for this identifier!");
 939   InsertNS->AddPragma(Handler);
 940 }
 941
 942 /// RemovePragmaHandler - Remove the specific pragma handler from the
 943 /// preprocessor. If \arg Namespace is non-null, then it should be the
 944 /// namespace that \arg Handler was added to. It is an error to remove
 945 /// a handler that has not been registered.
 946 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
 947                                        PragmaHandler *Handler) {
 948   PragmaNamespace *NS = PragmaHandlers.get();
 949
 950   // If this is specified to be in a namespace, step down into it.
 951   if (!Namespace.empty()) {
 952     PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
 953     assert(Existing && "Namespace containing handler does not exist!");
 954
 955     NS = Existing->getIfNamespace();
 956     assert(NS && "Invalid namespace, registered as a regular pragma handler!");
 957   }
 958
 959   NS->RemovePragmaHandler(Handler);
 960
 961   // If this is a non-default namespace and it is now empty, remove it.
 962   if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
 963     PragmaHandlers->RemovePragmaHandler(NS);
 964     delete NS;
 965   }
 966 }
 967
 968 bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
 969   Token Tok;
 970   LexUnexpandedToken(Tok);
 971
 972   if (Tok.isNot(tok::identifier)) {
 973     Diag(Tok, diag::ext_on_off_switch_syntax);
 974     return true;
 975   }
 976   IdentifierInfo *II = Tok.getIdentifierInfo();
 977   if (II->isStr("ON"))
 978     Result = tok::OOS_ON;
 979   else if (II->isStr("OFF"))
 980     Result = tok::OOS_OFF;
 981   else if (II->isStr("DEFAULT"))
 982     Result = tok::OOS_DEFAULT;
 983   else {
 984     Diag(Tok, diag::ext_on_off_switch_syntax);
 985     return true;
 986   }
 987
 988   // Verify that this is followed by EOD.
 989   LexUnexpandedToken(Tok);
 990   if (Tok.isNot(tok::eod))
 991     Diag(Tok, diag::ext_pragma_syntax_eod);
 992   return false;
 993 }
 994
 995 namespace {
 996
 997 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
 998 struct PragmaOnceHandler : public PragmaHandler {
 999   PragmaOnceHandler() : PragmaHandler("once") {}
1000
1001   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1002                     Token &OnceTok) override {
1003     PP.CheckEndOfDirective("pragma once");
1004     PP.HandlePragmaOnce(OnceTok);
1005   }
1006 };
1007
1008 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
1009 /// rest of the line is not lexed.
1010 struct PragmaMarkHandler : public PragmaHandler {
1011   PragmaMarkHandler() : PragmaHandler("mark") {}
1012
1013   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1014                     Token &MarkTok) override {
1015     PP.HandlePragmaMark(MarkTok);
1016   }
1017 };
1018
1019 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
1020 struct PragmaPoisonHandler : public PragmaHandler {
1021   PragmaPoisonHandler() : PragmaHandler("poison") {}
1022
1023   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1024                     Token &PoisonTok) override {
1025     PP.HandlePragmaPoison();
1026   }
1027 };
1028
1029 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
1030 /// as a system header, which silences warnings in it.
1031 struct PragmaSystemHeaderHandler : public PragmaHandler {
1032   PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1033
1034   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1035                     Token &SHToken) override {
1036     PP.HandlePragmaSystemHeader(SHToken);
1037     PP.CheckEndOfDirective("pragma");
1038   }
1039 };
1040
1041 struct PragmaDependencyHandler : public PragmaHandler {
1042   PragmaDependencyHandler() : PragmaHandler("dependency") {}
1043
1044   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1045                     Token &DepToken) override {
1046     PP.HandlePragmaDependency(DepToken);
1047   }
1048 };
1049
1050 struct PragmaDebugHandler : public PragmaHandler {
1051   PragmaDebugHandler() : PragmaHandler("__debug") {}
1052
1053   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1054                     Token &DebugToken) override {
1055     Token Tok;
1056     PP.LexUnexpandedToken(Tok);
1057     if (Tok.isNot(tok::identifier)) {
1058       PP.Diag(Tok, diag::warn_pragma_debug_missing_command);
1059       return;
1060     }
1061     IdentifierInfo *II = Tok.getIdentifierInfo();
1062
1063     if (II->isStr("assert")) {
1064       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1065         llvm_unreachable("This is an assertion!");
1066     } else if (II->isStr("crash")) {
1067       llvm::Timer T("crash", "pragma crash");
1068       llvm::TimeRegion R(&T);
1069       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1070         LLVM_BUILTIN_TRAP;
1071     } else if (II->isStr("parser_crash")) {
1072       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash) {
1073         Token Crasher;
1074         Crasher.startToken();
1075         Crasher.setKind(tok::annot_pragma_parser_crash);
1076         Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
1077         PP.EnterToken(Crasher, /*IsReinject*/ false);
1078       }
1079     } else if (II->isStr("dump")) {
1080       Token DumpAnnot;
1081       DumpAnnot.startToken();
1082       DumpAnnot.setKind(tok::annot_pragma_dump);
1083       DumpAnnot.setAnnotationRange(SourceRange(Tok.getLocation()));
1084       PP.EnterToken(DumpAnnot, /*IsReinject*/false);
1085     } else if (II->isStr("diag_mapping")) {
1086       Token DiagName;
1087       PP.LexUnexpandedToken(DiagName);
1088       if (DiagName.is(tok::eod))
1089         PP.getDiagnostics().dump();
1090       else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) {
1091         StringLiteralParser Literal(DiagName, PP,
1092                                     StringLiteralEvalMethod::Unevaluated);
1093         if (Literal.hadError)
1094           return;
1095         PP.getDiagnostics().dump(Literal.GetString());
1096       } else {
1097         PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument)
1098             << II->getName();
1099       }
1100     } else if (II->isStr("llvm_fatal_error")) {
1101       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1102         llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1103     } else if (II->isStr("llvm_unreachable")) {
1104       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1105         llvm_unreachable("#pragma clang __debug llvm_unreachable");
1106     } else if (II->isStr("macro")) {
1107       Token MacroName;
1108       PP.LexUnexpandedToken(MacroName);
1109       auto *MacroII = MacroName.getIdentifierInfo();
1110       if (MacroII)
1111         PP.dumpMacroInfo(MacroII);
1112       else
1113         PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1114             << II->getName();
1115     } else if (II->isStr("module_map")) {
1116       llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1117           ModuleName;
1118       if (LexModuleName(PP, Tok, ModuleName))
1119         return;
1120       ModuleMap &MM = PP.getHeaderSearchInfo().getModuleMap();
1121       Module *M = nullptr;
1122       for (auto IIAndLoc : ModuleName) {
1123         M = MM.lookupModuleQualified(IIAndLoc.first->getName(), M);
1124         if (!M) {
1125           PP.Diag(IIAndLoc.second, diag::warn_pragma_debug_unknown_module)
1126               << IIAndLoc.first;
1127           return;
1128         }
1129       }
1130       M->dump();
1131     } else if (II->isStr("overflow_stack")) {
1132       if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1133         DebugOverflowStack();
1134     } else if (II->isStr("captured")) {
1135       HandleCaptured(PP);
1136     } else if (II->isStr("modules")) {
1137       struct ModuleVisitor {
1138         Preprocessor &PP;
1139         void visit(Module *M, bool VisibleOnly) {
1140           SourceLocation ImportLoc = PP.getModuleImportLoc(M);
1141           if (!VisibleOnly || ImportLoc.isValid()) {
1142             llvm::errs() << M->getFullModuleName() << " ";
1143             if (ImportLoc.isValid()) {
1144               llvm::errs() << M << " visible ";
1145               ImportLoc.print(llvm::errs(), PP.getSourceManager());
1146             }
1147             llvm::errs() << "\n";
1148           }
1149           for (Module *Sub : M->submodules()) {
1150             if (!VisibleOnly || ImportLoc.isInvalid() || Sub->IsExplicit)
1151               visit(Sub, VisibleOnly);
1152           }
1153         }
1154         void visitAll(bool VisibleOnly) {
1155           for (auto &NameAndMod :
1156                PP.getHeaderSearchInfo().getModuleMap().modules())
1157             visit(NameAndMod.second, VisibleOnly);
1158         }
1159       } Visitor{PP};
1160
1161       Token Kind;
1162       PP.LexUnexpandedToken(Kind);
1163       auto *DumpII = Kind.getIdentifierInfo();
1164       if (!DumpII) {
1165         PP.Diag(Kind, diag::warn_pragma_debug_missing_argument)
1166             << II->getName();
1167       } else if (DumpII->isStr("all")) {
1168         Visitor.visitAll(false);
1169       } else if (DumpII->isStr("visible")) {
1170         Visitor.visitAll(true);
1171       } else if (DumpII->isStr("building")) {
1172         for (auto &Building : PP.getBuildingSubmodules()) {
1173           llvm::errs() << "in " << Building.M->getFullModuleName();
1174           if (Building.ImportLoc.isValid()) {
1175             llvm::errs() << " imported ";
1176             if (Building.IsPragma)
1177               llvm::errs() << "via pragma ";
1178             llvm::errs() << "at ";
1179             Building.ImportLoc.print(llvm::errs(), PP.getSourceManager());
1180             llvm::errs() << "\n";
1181           }
1182         }
1183       } else {
1184         PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1185           << DumpII->getName();
1186       }
1187     } else if (II->isStr("sloc_usage")) {
1188       // An optional integer literal argument specifies the number of files to
1189       // specifically report information about.
1190       std::optional<unsigned> MaxNotes;
1191       Token ArgToken;
1192       PP.Lex(ArgToken);
1193       uint64_t Value;
1194       if (ArgToken.is(tok::numeric_constant) &&
1195           PP.parseSimpleIntegerLiteral(ArgToken, Value)) {
1196         MaxNotes = Value;
1197       } else if (ArgToken.isNot(tok::eod)) {
1198         PP.Diag(ArgToken, diag::warn_pragma_debug_unexpected_argument);
1199       }
1200
1201       PP.Diag(Tok, diag::remark_sloc_usage);
1202       PP.getSourceManager().noteSLocAddressSpaceUsage(PP.getDiagnostics(),
1203                                                       MaxNotes);
1204     } else {
1205       PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1206         << II->getName();
1207     }
1208
1209     PPCallbacks *Callbacks = PP.getPPCallbacks();
1210     if (Callbacks)
1211       Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1212   }
1213
1214   void HandleCaptured(Preprocessor &PP) {
1215     Token Tok;
1216     PP.LexUnexpandedToken(Tok);
1217
1218     if (Tok.isNot(tok::eod)) {
1219       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1220         << "pragma clang __debug captured";
1221       return;
1222     }
1223
1224     SourceLocation NameLoc = Tok.getLocation();
1225     MutableArrayRef<Token> Toks(
1226         PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1227     Toks[0].startToken();
1228     Toks[0].setKind(tok::annot_pragma_captured);
1229     Toks[0].setLocation(NameLoc);
1230
1231     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
1232                         /*IsReinject=*/false);
1233   }
1234
1235 // Disable MSVC warning about runtime stack overflow.
1236 #ifdef _MSC_VER
1237     #pragma warning(disable : 4717)
1238 #endif
1239   static void DebugOverflowStack(void (*P)() = nullptr) {
1240     void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1241     Self(reinterpret_cast<void(*)()>(Self));
1242   }
1243 #ifdef _MSC_VER
1244     #pragma warning(default : 4717)
1245 #endif
1246 };
1247
1248 struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {
1249   PragmaUnsafeBufferUsageHandler() : PragmaHandler("unsafe_buffer_usage") {}
1250   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1251                     Token &FirstToken) override {
1252     Token Tok;
1253
1254     PP.LexUnexpandedToken(Tok);
1255     if (Tok.isNot(tok::identifier)) {
1256       PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
1257       return;
1258     }
1259
1260     IdentifierInfo *II = Tok.getIdentifierInfo();
1261     SourceLocation Loc = Tok.getLocation();
1262
1263     if (II->isStr("begin")) {
1264       if (PP.enterOrExitSafeBufferOptOutRegion(true, Loc))
1265         PP.Diag(Loc, diag::err_pp_double_begin_pragma_unsafe_buffer_usage);
1266     } else if (II->isStr("end")) {
1267       if (PP.enterOrExitSafeBufferOptOutRegion(false, Loc))
1268         PP.Diag(Loc, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);
1269     } else
1270       PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
1271   }
1272 };
1273
1274 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1275 struct PragmaDiagnosticHandler : public PragmaHandler {
1276 private:
1277   const char *Namespace;
1278
1279 public:
1280   explicit PragmaDiagnosticHandler(const char *NS)
1281       : PragmaHandler("diagnostic"), Namespace(NS) {}
1282
1283   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1284                     Token &DiagToken) override {
1285     SourceLocation DiagLoc = DiagToken.getLocation();
1286     Token Tok;
1287     PP.LexUnexpandedToken(Tok);
1288     if (Tok.isNot(tok::identifier)) {
1289       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1290       return;
1291     }
1292     IdentifierInfo *II = Tok.getIdentifierInfo();
1293     PPCallbacks *Callbacks = PP.getPPCallbacks();
1294
1295     // Get the next token, which is either an EOD or a string literal. We lex
1296     // it now so that we can early return if the previous token was push or pop.
1297     PP.LexUnexpandedToken(Tok);
1298
1299     if (II->isStr("pop")) {
1300       if (!PP.getDiagnostics().popMappings(DiagLoc))
1301         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1302       else if (Callbacks)
1303         Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1304
1305       if (Tok.isNot(tok::eod))
1306         PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1307       return;
1308     } else if (II->isStr("push")) {
1309       PP.getDiagnostics().pushMappings(DiagLoc);
1310       if (Callbacks)
1311         Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1312
1313       if (Tok.isNot(tok::eod))
1314         PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1315       return;
1316     }
1317
1318     diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1319                             .Case("ignored", diag::Severity::Ignored)
1320                             .Case("warning", diag::Severity::Warning)
1321                             .Case("error", diag::Severity::Error)
1322                             .Case("fatal", diag::Severity::Fatal)
1323                             .Default(diag::Severity());
1324
1325     if (SV == diag::Severity()) {
1326       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1327       return;
1328     }
1329
1330     // At this point, we expect a string literal.
1331     SourceLocation StringLoc = Tok.getLocation();
1332     std::string WarningName;
1333     if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1334                                    /*AllowMacroExpansion=*/false))
1335       return;
1336
1337     if (Tok.isNot(tok::eod)) {
1338       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1339       return;
1340     }
1341
1342     if (WarningName.size() < 3 || WarningName[0] != '-' ||
1343         (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1344       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1345       return;
1346     }
1347
1348     diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1349                                                 : diag::Flavor::Remark;
1350     StringRef Group = StringRef(WarningName).substr(2);
1351     bool unknownDiag = false;
1352     if (Group == "everything") {
1353       // Special handling for pragma clang diagnostic ... "-Weverything".
1354       // There is no formal group named "everything", so there has to be a
1355       // special case for it.
1356       PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1357     } else
1358       unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1359                                                             DiagLoc);
1360     if (unknownDiag)
1361       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1362         << WarningName;
1363     else if (Callbacks)
1364       Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1365   }
1366 };
1367
1368 /// "\#pragma hdrstop [<header-name-string>]"
1369 struct PragmaHdrstopHandler : public PragmaHandler {
1370   PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
1371   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1372                     Token &DepToken) override {
1373     PP.HandlePragmaHdrstop(DepToken);
1374   }
1375 };
1376
1377 /// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
1378 /// diagnostics, so we don't really implement this pragma.  We parse it and
1379 /// ignore it to avoid -Wunknown-pragma warnings.
1380 struct PragmaWarningHandler : public PragmaHandler {
1381   PragmaWarningHandler() : PragmaHandler("warning") {}
1382
1383   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1384                     Token &Tok) override {
1385     // Parse things like:
1386     // warning(push, 1)
1387     // warning(pop)
1388     // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1389     SourceLocation DiagLoc = Tok.getLocation();
1390     PPCallbacks *Callbacks = PP.getPPCallbacks();
1391
1392     PP.Lex(Tok);
1393     if (Tok.isNot(tok::l_paren)) {
1394       PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1395       return;
1396     }
1397
1398     PP.Lex(Tok);
1399     IdentifierInfo *II = Tok.getIdentifierInfo();
1400
1401     if (II && II->isStr("push")) {
1402       // #pragma warning( push[ ,n ] )
1403       int Level = -1;
1404       PP.Lex(Tok);
1405       if (Tok.is(tok::comma)) {
1406         PP.Lex(Tok);
1407         uint64_t Value;
1408         if (Tok.is(tok::numeric_constant) &&
1409             PP.parseSimpleIntegerLiteral(Tok, Value))
1410           Level = int(Value);
1411         if (Level < 0 || Level > 4) {
1412           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1413           return;
1414         }
1415       }
1416       PP.getDiagnostics().pushMappings(DiagLoc);
1417       if (Callbacks)
1418         Callbacks->PragmaWarningPush(DiagLoc, Level);
1419     } else if (II && II->isStr("pop")) {
1420       // #pragma warning( pop )
1421       PP.Lex(Tok);
1422       if (!PP.getDiagnostics().popMappings(DiagLoc))
1423         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1424       else if (Callbacks)
1425         Callbacks->PragmaWarningPop(DiagLoc);
1426     } else {
1427       // #pragma warning( warning-specifier : warning-number-list
1428       //                  [; warning-specifier : warning-number-list...] )
1429       while (true) {
1430         II = Tok.getIdentifierInfo();
1431         if (!II && !Tok.is(tok::numeric_constant)) {
1432           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1433           return;
1434         }
1435
1436         // Figure out which warning specifier this is.
1437         bool SpecifierValid;
1438         PPCallbacks::PragmaWarningSpecifier Specifier;
1439         if (II) {
1440           int SpecifierInt = llvm::StringSwitch<int>(II->getName())
1441                                  .Case("default", PPCallbacks::PWS_Default)
1442                                  .Case("disable", PPCallbacks::PWS_Disable)
1443                                  .Case("error", PPCallbacks::PWS_Error)
1444                                  .Case("once", PPCallbacks::PWS_Once)
1445                                  .Case("suppress", PPCallbacks::PWS_Suppress)
1446                                  .Default(-1);
1447           if ((SpecifierValid = SpecifierInt != -1))
1448             Specifier =
1449                 static_cast<PPCallbacks::PragmaWarningSpecifier>(SpecifierInt);
1450
1451           // If we read a correct specifier, snatch next token (that should be
1452           // ":", checked later).
1453           if (SpecifierValid)
1454             PP.Lex(Tok);
1455         } else {
1456           // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1457           uint64_t Value;
1458           if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1459             if ((SpecifierValid = (Value >= 1) && (Value <= 4)))
1460               Specifier = static_cast<PPCallbacks::PragmaWarningSpecifier>(
1461                   PPCallbacks::PWS_Level1 + Value - 1);
1462           } else
1463             SpecifierValid = false;
1464           // Next token already snatched by parseSimpleIntegerLiteral.
1465         }
1466
1467         if (!SpecifierValid) {
1468           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1469           return;
1470         }
1471         if (Tok.isNot(tok::colon)) {
1472           PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1473           return;
1474         }
1475
1476         // Collect the warning ids.
1477         SmallVector<int, 4> Ids;
1478         PP.Lex(Tok);
1479         while (Tok.is(tok::numeric_constant)) {
1480           uint64_t Value;
1481           if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1482               Value > INT_MAX) {
1483             PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1484             return;
1485           }
1486           Ids.push_back(int(Value));
1487         }
1488
1489         // Only act on disable for now.
1490         diag::Severity SV = diag::Severity();
1491         if (Specifier == PPCallbacks::PWS_Disable)
1492           SV = diag::Severity::Ignored;
1493         if (SV != diag::Severity())
1494           for (int Id : Ids) {
1495             if (auto Group = diagGroupFromCLWarningID(Id)) {
1496               bool unknownDiag = PP.getDiagnostics().setSeverityForGroup(
1497                   diag::Flavor::WarningOrError, *Group, SV, DiagLoc);
1498               assert(!unknownDiag &&
1499                      "wd table should only contain known diags");
1500               (void)unknownDiag;
1501             }
1502           }
1503
1504         if (Callbacks)
1505           Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1506
1507         // Parse the next specifier if there is a semicolon.
1508         if (Tok.isNot(tok::semi))
1509           break;
1510         PP.Lex(Tok);
1511       }
1512     }
1513
1514     if (Tok.isNot(tok::r_paren)) {
1515       PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1516       return;
1517     }
1518
1519     PP.Lex(Tok);
1520     if (Tok.isNot(tok::eod))
1521       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1522   }
1523 };
1524
1525 /// "\#pragma execution_character_set(...)". MSVC supports this pragma only
1526 /// for "UTF-8". We parse it and ignore it if UTF-8 is provided and warn
1527 /// otherwise to avoid -Wunknown-pragma warnings.
1528 struct PragmaExecCharsetHandler : public PragmaHandler {
1529   PragmaExecCharsetHandler() : PragmaHandler("execution_character_set") {}
1530
1531   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1532                     Token &Tok) override {
1533     // Parse things like:
1534     // execution_character_set(push, "UTF-8")
1535     // execution_character_set(pop)
1536     SourceLocation DiagLoc = Tok.getLocation();
1537     PPCallbacks *Callbacks = PP.getPPCallbacks();
1538
1539     PP.Lex(Tok);
1540     if (Tok.isNot(tok::l_paren)) {
1541       PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << "(";
1542       return;
1543     }
1544
1545     PP.Lex(Tok);
1546     IdentifierInfo *II = Tok.getIdentifierInfo();
1547
1548     if (II && II->isStr("push")) {
1549       // #pragma execution_character_set( push[ , string ] )
1550       PP.Lex(Tok);
1551       if (Tok.is(tok::comma)) {
1552         PP.Lex(Tok);
1553
1554         std::string ExecCharset;
1555         if (!PP.FinishLexStringLiteral(Tok, ExecCharset,
1556                                        "pragma execution_character_set",
1557                                        /*AllowMacroExpansion=*/false))
1558           return;
1559
1560         // MSVC supports either of these, but nothing else.
1561         if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") {
1562           PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;
1563           return;
1564         }
1565       }
1566       if (Callbacks)
1567         Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8");
1568     } else if (II && II->isStr("pop")) {
1569       // #pragma execution_character_set( pop )
1570       PP.Lex(Tok);
1571       if (Callbacks)
1572         Callbacks->PragmaExecCharsetPop(DiagLoc);
1573     } else {
1574       PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid);
1575       return;
1576     }
1577
1578     if (Tok.isNot(tok::r_paren)) {
1579       PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")";
1580       return;
1581     }
1582
1583     PP.Lex(Tok);
1584     if (Tok.isNot(tok::eod))
1585       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma execution_character_set";
1586   }
1587 };
1588
1589 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1590 struct PragmaIncludeAliasHandler : public PragmaHandler {
1591   PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1592
1593   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1594                     Token &IncludeAliasTok) override {
1595     PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1596   }
1597 };
1598
1599 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1600 /// extension.  The syntax is:
1601 /// \code
1602 ///   #pragma message(string)
1603 /// \endcode
1604 /// OR, in GCC mode:
1605 /// \code
1606 ///   #pragma message string
1607 /// \endcode
1608 /// string is a string, which is fully macro expanded, and permits string
1609 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1610 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1611 /// form as \#pragma message.
1612 struct PragmaMessageHandler : public PragmaHandler {
1613 private:
1614   const PPCallbacks::PragmaMessageKind Kind;
1615   const StringRef Namespace;
1616
1617   static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1618                                 bool PragmaNameOnly = false) {
1619     switch (Kind) {
1620       case PPCallbacks::PMK_Message:
1621         return PragmaNameOnly ? "message" : "pragma message";
1622       case PPCallbacks::PMK_Warning:
1623         return PragmaNameOnly ? "warning" : "pragma warning";
1624       case PPCallbacks::PMK_Error:
1625         return PragmaNameOnly ? "error" : "pragma error";
1626     }
1627     llvm_unreachable("Unknown PragmaMessageKind!");
1628   }
1629
1630 public:
1631   PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1632                        StringRef Namespace = StringRef())
1633       : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1634         Namespace(Namespace) {}
1635
1636   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1637                     Token &Tok) override {
1638     SourceLocation MessageLoc = Tok.getLocation();
1639     PP.Lex(Tok);
1640     bool ExpectClosingParen = false;
1641     switch (Tok.getKind()) {
1642     case tok::l_paren:
1643       // We have a MSVC style pragma message.
1644       ExpectClosingParen = true;
1645       // Read the string.
1646       PP.Lex(Tok);
1647       break;
1648     case tok::string_literal:
1649       // We have a GCC style pragma message, and we just read the string.
1650       break;
1651     default:
1652       PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1653       return;
1654     }
1655
1656     std::string MessageString;
1657     if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1658                                    /*AllowMacroExpansion=*/true))
1659       return;
1660
1661     if (ExpectClosingParen) {
1662       if (Tok.isNot(tok::r_paren)) {
1663         PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1664         return;
1665       }
1666       PP.Lex(Tok);  // eat the r_paren.
1667     }
1668
1669     if (Tok.isNot(tok::eod)) {
1670       PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1671       return;
1672     }
1673
1674     // Output the message.
1675     PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1676                           ? diag::err_pragma_message
1677                           : diag::warn_pragma_message) << MessageString;
1678
1679     // If the pragma is lexically sound, notify any interested PPCallbacks.
1680     if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1681       Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1682   }
1683 };
1684
1685 /// Handle the clang \#pragma module import extension. The syntax is:
1686 /// \code
1687 ///   #pragma clang module import some.module.name
1688 /// \endcode
1689 struct PragmaModuleImportHandler : public PragmaHandler {
1690   PragmaModuleImportHandler() : PragmaHandler("import") {}
1691
1692   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1693                     Token &Tok) override {
1694     SourceLocation ImportLoc = Tok.getLocation();
1695
1696     // Read the module name.
1697     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1698         ModuleName;
1699     if (LexModuleName(PP, Tok, ModuleName))
1700       return;
1701
1702     if (Tok.isNot(tok::eod))
1703       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1704
1705     // If we have a non-empty module path, load the named module.
1706     Module *Imported =
1707         PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1708                                       /*IsInclusionDirective=*/false);
1709     if (!Imported)
1710       return;
1711
1712     PP.makeModuleVisible(Imported, ImportLoc);
1713     PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1714                             tok::annot_module_include, Imported);
1715     if (auto *CB = PP.getPPCallbacks())
1716       CB->moduleImport(ImportLoc, ModuleName, Imported);
1717   }
1718 };
1719
1720 /// Handle the clang \#pragma module begin extension. The syntax is:
1721 /// \code
1722 ///   #pragma clang module begin some.module.name
1723 ///   ...
1724 ///   #pragma clang module end
1725 /// \endcode
1726 struct PragmaModuleBeginHandler : public PragmaHandler {
1727   PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1728
1729   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1730                     Token &Tok) override {
1731     SourceLocation BeginLoc = Tok.getLocation();
1732
1733     // Read the module name.
1734     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1735         ModuleName;
1736     if (LexModuleName(PP, Tok, ModuleName))
1737       return;
1738
1739     if (Tok.isNot(tok::eod))
1740       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1741
1742     // We can only enter submodules of the current module.
1743     StringRef Current = PP.getLangOpts().CurrentModule;
1744     if (ModuleName.front().first->getName() != Current) {
1745       PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1746         << ModuleName.front().first << (ModuleName.size() > 1)
1747         << Current.empty() << Current;
1748       return;
1749     }
1750
1751     // Find the module we're entering. We require that a module map for it
1752     // be loaded or implicitly loadable.
1753     auto &HSI = PP.getHeaderSearchInfo();
1754     Module *M = HSI.lookupModule(Current, ModuleName.front().second);
1755     if (!M) {
1756       PP.Diag(ModuleName.front().second,
1757               diag::err_pp_module_begin_no_module_map) << Current;
1758       return;
1759     }
1760     for (unsigned I = 1; I != ModuleName.size(); ++I) {
1761       auto *NewM = M->findOrInferSubmodule(ModuleName[I].first->getName());
1762       if (!NewM) {
1763         PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1764           << M->getFullModuleName() << ModuleName[I].first;
1765         return;
1766       }
1767       M = NewM;
1768     }
1769
1770     // If the module isn't available, it doesn't make sense to enter it.
1771     if (Preprocessor::checkModuleIsAvailable(
1772             PP.getLangOpts(), PP.getTargetInfo(), *M, PP.getDiagnostics())) {
1773       PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1774         << M->getTopLevelModuleName();
1775       return;
1776     }
1777
1778     // Enter the scope of the submodule.
1779     PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1780     PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1781                             tok::annot_module_begin, M);
1782   }
1783 };
1784
1785 /// Handle the clang \#pragma module end extension.
1786 struct PragmaModuleEndHandler : public PragmaHandler {
1787   PragmaModuleEndHandler() : PragmaHandler("end") {}
1788
1789   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1790                     Token &Tok) override {
1791     SourceLocation Loc = Tok.getLocation();
1792
1793     PP.LexUnexpandedToken(Tok);
1794     if (Tok.isNot(tok::eod))
1795       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1796
1797     Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1798     if (M)
1799       PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1800     else
1801       PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1802   }
1803 };
1804
1805 /// Handle the clang \#pragma module build extension.
1806 struct PragmaModuleBuildHandler : public PragmaHandler {
1807   PragmaModuleBuildHandler() : PragmaHandler("build") {}
1808
1809   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1810                     Token &Tok) override {
1811     PP.HandlePragmaModuleBuild(Tok);
1812   }
1813 };
1814
1815 /// Handle the clang \#pragma module load extension.
1816 struct PragmaModuleLoadHandler : public PragmaHandler {
1817   PragmaModuleLoadHandler() : PragmaHandler("load") {}
1818
1819   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1820                     Token &Tok) override {
1821     SourceLocation Loc = Tok.getLocation();
1822
1823     // Read the module name.
1824     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1825         ModuleName;
1826     if (LexModuleName(PP, Tok, ModuleName))
1827       return;
1828
1829     if (Tok.isNot(tok::eod))
1830       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1831
1832     // Load the module, don't make it visible.
1833     PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1834                                     /*IsInclusionDirective=*/false);
1835   }
1836 };
1837
1838 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1839 /// macro on the top of the stack.
1840 struct PragmaPushMacroHandler : public PragmaHandler {
1841   PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1842
1843   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1844                     Token &PushMacroTok) override {
1845     PP.HandlePragmaPushMacro(PushMacroTok);
1846   }
1847 };
1848
1849 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1850 /// macro to the value on the top of the stack.
1851 struct PragmaPopMacroHandler : public PragmaHandler {
1852   PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1853
1854   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1855                     Token &PopMacroTok) override {
1856     PP.HandlePragmaPopMacro(PopMacroTok);
1857   }
1858 };
1859
1860 /// PragmaARCCFCodeAuditedHandler -
1861 ///   \#pragma clang arc_cf_code_audited begin/end
1862 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1863   PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1864
1865   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1866                     Token &NameTok) override {
1867     SourceLocation Loc = NameTok.getLocation();
1868     bool IsBegin;
1869
1870     Token Tok;
1871
1872     // Lex the 'begin' or 'end'.
1873     PP.LexUnexpandedToken(Tok);
1874     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1875     if (BeginEnd && BeginEnd->isStr("begin")) {
1876       IsBegin = true;
1877     } else if (BeginEnd && BeginEnd->isStr("end")) {
1878       IsBegin = false;
1879     } else {
1880       PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1881       return;
1882     }
1883
1884     // Verify that this is followed by EOD.
1885     PP.LexUnexpandedToken(Tok);
1886     if (Tok.isNot(tok::eod))
1887       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1888
1889     // The start location of the active audit.
1890     SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedInfo().second;
1891
1892     // The start location we want after processing this.
1893     SourceLocation NewLoc;
1894
1895     if (IsBegin) {
1896       // Complain about attempts to re-enter an audit.
1897       if (BeginLoc.isValid()) {
1898         PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1899         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1900       }
1901       NewLoc = Loc;
1902     } else {
1903       // Complain about attempts to leave an audit that doesn't exist.
1904       if (!BeginLoc.isValid()) {
1905         PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1906         return;
1907       }
1908       NewLoc = SourceLocation();
1909     }
1910
1911     PP.setPragmaARCCFCodeAuditedInfo(NameTok.getIdentifierInfo(), NewLoc);
1912   }
1913 };
1914
1915 /// PragmaAssumeNonNullHandler -
1916 ///   \#pragma clang assume_nonnull begin/end
1917 struct PragmaAssumeNonNullHandler : public PragmaHandler {
1918   PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1919
1920   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1921                     Token &NameTok) override {
1922     SourceLocation Loc = NameTok.getLocation();
1923     bool IsBegin;
1924
1925     Token Tok;
1926
1927     // Lex the 'begin' or 'end'.
1928     PP.LexUnexpandedToken(Tok);
1929     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1930     if (BeginEnd && BeginEnd->isStr("begin")) {
1931       IsBegin = true;
1932     } else if (BeginEnd && BeginEnd->isStr("end")) {
1933       IsBegin = false;
1934     } else {
1935       PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1936       return;
1937     }
1938
1939     // Verify that this is followed by EOD.
1940     PP.LexUnexpandedToken(Tok);
1941     if (Tok.isNot(tok::eod))
1942       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1943
1944     // The start location of the active audit.
1945     SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1946
1947     // The start location we want after processing this.
1948     SourceLocation NewLoc;
1949     PPCallbacks *Callbacks = PP.getPPCallbacks();
1950
1951     if (IsBegin) {
1952       // Complain about attempts to re-enter an audit.
1953       if (BeginLoc.isValid()) {
1954         PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1955         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1956       }
1957       NewLoc = Loc;
1958       if (Callbacks)
1959         Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1960     } else {
1961       // Complain about attempts to leave an audit that doesn't exist.
1962       if (!BeginLoc.isValid()) {
1963         PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1964         return;
1965       }
1966       NewLoc = SourceLocation();
1967       if (Callbacks)
1968         Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1969     }
1970
1971     PP.setPragmaAssumeNonNullLoc(NewLoc);
1972   }
1973 };
1974
1975 /// Handle "\#pragma region [...]"
1976 ///
1977 /// The syntax is
1978 /// \code
1979 ///   #pragma region [optional name]
1980 ///   #pragma endregion [optional comment]
1981 /// \endcode
1982 ///
1983 /// \note This is
1984 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1985 /// pragma, just skipped by compiler.
1986 struct PragmaRegionHandler : public PragmaHandler {
1987   PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1988
1989   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1990                     Token &NameTok) override {
1991     // #pragma region: endregion matches can be verified
1992     // __pragma(region): no sense, but ignored by msvc
1993     // _Pragma is not valid for MSVC, but there isn't any point
1994     // to handle a _Pragma differently.
1995   }
1996 };
1997
1998 /// "\#pragma managed"
1999 /// "\#pragma managed(...)"
2000 /// "\#pragma unmanaged"
2001 /// MSVC ignores this pragma when not compiling using /clr, which clang doesn't
2002 /// support. We parse it and ignore it to avoid -Wunknown-pragma warnings.
2003 struct PragmaManagedHandler : public EmptyPragmaHandler {
2004   PragmaManagedHandler(const char *pragma) : EmptyPragmaHandler(pragma) {}
2005 };
2006
2007 /// This handles parsing pragmas that take a macro name and optional message
2008 static IdentifierInfo *HandleMacroAnnotationPragma(Preprocessor &PP, Token &Tok,
2009                                                    const char *Pragma,
2010                                                    std::string &MessageString) {
2011   PP.Lex(Tok);
2012   if (Tok.isNot(tok::l_paren)) {
2013     PP.Diag(Tok, diag::err_expected) << "(";
2014     return nullptr;
2015   }
2016
2017   PP.LexUnexpandedToken(Tok);
2018   if (!Tok.is(tok::identifier)) {
2019     PP.Diag(Tok, diag::err_expected) << tok::identifier;
2020     return nullptr;
2021   }
2022   IdentifierInfo *II = Tok.getIdentifierInfo();
2023
2024   if (!II->hasMacroDefinition()) {
2025     PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
2026     return nullptr;
2027   }
2028
2029   PP.Lex(Tok);
2030   if (Tok.is(tok::comma)) {
2031     PP.Lex(Tok);
2032     if (!PP.FinishLexStringLiteral(Tok, MessageString, Pragma,
2033                                    /*AllowMacroExpansion=*/true))
2034       return nullptr;
2035   }
2036
2037   if (Tok.isNot(tok::r_paren)) {
2038     PP.Diag(Tok, diag::err_expected) << ")";
2039     return nullptr;
2040   }
2041   return II;
2042 }
2043
2044 /// "\#pragma clang deprecated(...)"
2045 ///
2046 /// The syntax is
2047 /// \code
2048 ///   #pragma clang deprecate(MACRO_NAME [, Message])
2049 /// \endcode
2050 struct PragmaDeprecatedHandler : public PragmaHandler {
2051   PragmaDeprecatedHandler() : PragmaHandler("deprecated") {}
2052
2053   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2054                     Token &Tok) override {
2055     std::string MessageString;
2056
2057     if (IdentifierInfo *II = HandleMacroAnnotationPragma(
2058             PP, Tok, "#pragma clang deprecated", MessageString)) {
2059       II->setIsDeprecatedMacro(true);
2060       PP.addMacroDeprecationMsg(II, std::move(MessageString),
2061                                 Tok.getLocation());
2062     }
2063   }
2064 };
2065
2066 /// "\#pragma clang restrict_expansion(...)"
2067 ///
2068 /// The syntax is
2069 /// \code
2070 ///   #pragma clang restrict_expansion(MACRO_NAME [, Message])
2071 /// \endcode
2072 struct PragmaRestrictExpansionHandler : public PragmaHandler {
2073   PragmaRestrictExpansionHandler() : PragmaHandler("restrict_expansion") {}
2074
2075   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2076                     Token &Tok) override {
2077     std::string MessageString;
2078
2079     if (IdentifierInfo *II = HandleMacroAnnotationPragma(
2080             PP, Tok, "#pragma clang restrict_expansion", MessageString)) {
2081       II->setIsRestrictExpansion(true);
2082       PP.addRestrictExpansionMsg(II, std::move(MessageString),
2083                                  Tok.getLocation());
2084     }
2085   }
2086 };
2087
2088 /// "\#pragma clang final(...)"
2089 ///
2090 /// The syntax is
2091 /// \code
2092 ///   #pragma clang final(MACRO_NAME)
2093 /// \endcode
2094 struct PragmaFinalHandler : public PragmaHandler {
2095   PragmaFinalHandler() : PragmaHandler("final") {}
2096
2097   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2098                     Token &Tok) override {
2099     PP.Lex(Tok);
2100     if (Tok.isNot(tok::l_paren)) {
2101       PP.Diag(Tok, diag::err_expected) << "(";
2102       return;
2103     }
2104
2105     PP.LexUnexpandedToken(Tok);
2106     if (!Tok.is(tok::identifier)) {
2107       PP.Diag(Tok, diag::err_expected) << tok::identifier;
2108       return;
2109     }
2110     IdentifierInfo *II = Tok.getIdentifierInfo();
2111
2112     if (!II->hasMacroDefinition()) {
2113       PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
2114       return;
2115     }
2116
2117     PP.Lex(Tok);
2118     if (Tok.isNot(tok::r_paren)) {
2119       PP.Diag(Tok, diag::err_expected) << ")";
2120       return;
2121     }
2122     II->setIsFinal(true);
2123     PP.addFinalLoc(II, Tok.getLocation());
2124   }
2125 };
2126
2127 } // namespace
2128
2129 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
2130 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
2131 void Preprocessor::RegisterBuiltinPragmas() {
2132   AddPragmaHandler(new PragmaOnceHandler());
2133   AddPragmaHandler(new PragmaMarkHandler());
2134   AddPragmaHandler(new PragmaPushMacroHandler());
2135   AddPragmaHandler(new PragmaPopMacroHandler());
2136   AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
2137
2138   // #pragma GCC ...
2139   AddPragmaHandler("GCC", new PragmaPoisonHandler());
2140   AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
2141   AddPragmaHandler("GCC", new PragmaDependencyHandler());
2142   AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
2143   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
2144                                                    "GCC"));
2145   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
2146                                                    "GCC"));
2147   // #pragma clang ...
2148   AddPragmaHandler("clang", new PragmaPoisonHandler());
2149   AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
2150   AddPragmaHandler("clang", new PragmaDebugHandler());
2151   AddPragmaHandler("clang", new PragmaDependencyHandler());
2152   AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
2153   AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
2154   AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
2155   AddPragmaHandler("clang", new PragmaDeprecatedHandler());
2156   AddPragmaHandler("clang", new PragmaRestrictExpansionHandler());
2157   AddPragmaHandler("clang", new PragmaFinalHandler());
2158
2159   // #pragma clang module ...
2160   auto *ModuleHandler = new PragmaNamespace("module");
2161   AddPragmaHandler("clang", ModuleHandler);
2162   ModuleHandler->AddPragma(new PragmaModuleImportHandler());
2163   ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
2164   ModuleHandler->AddPragma(new PragmaModuleEndHandler());
2165   ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
2166   ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
2167
2168   // Safe Buffers pragmas
2169   AddPragmaHandler("clang", new PragmaUnsafeBufferUsageHandler);
2170
2171   // Add region pragmas.
2172   AddPragmaHandler(new PragmaRegionHandler("region"));
2173   AddPragmaHandler(new PragmaRegionHandler("endregion"));
2174
2175   // MS extensions.
2176   if (LangOpts.MicrosoftExt) {
2177     AddPragmaHandler(new PragmaWarningHandler());
2178     AddPragmaHandler(new PragmaExecCharsetHandler());
2179     AddPragmaHandler(new PragmaIncludeAliasHandler());
2180     AddPragmaHandler(new PragmaHdrstopHandler());
2181     AddPragmaHandler(new PragmaSystemHeaderHandler());
2182     AddPragmaHandler(new PragmaManagedHandler("managed"));
2183     AddPragmaHandler(new PragmaManagedHandler("unmanaged"));
2184   }
2185
2186   // Pragmas added by plugins
2187   for (const PragmaHandlerRegistry::entry &handler :
2188        PragmaHandlerRegistry::entries()) {
2189     AddPragmaHandler(handler.instantiate().release());
2190   }
2191 }
2192
2193 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
2194 /// warn about those pragmas being unknown.
2195 void Preprocessor::IgnorePragmas() {
2196   AddPragmaHandler(new EmptyPragmaHandler());
2197   // Also ignore all pragmas in all namespaces created
2198   // in Preprocessor::RegisterBuiltinPragmas().
2199   AddPragmaHandler("GCC", new EmptyPragmaHandler());
2200   AddPragmaHandler("clang", new EmptyPragmaHandler());
2201 }