contrib/llvm/tools/clang/lib/Lex/Pragma.cpp

   1 //===- Pragma.cpp - Pragma registration and handling ----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the PragmaHandler/PragmaTable interfaces and implements
  11 // pragma related methods of the Preprocessor class.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Lex/Pragma.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/PTHLexer.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/StringSwitch.h"
  43 #include "llvm/ADT/StringRef.h"
  44 #include "llvm/Support/CrashRecoveryContext.h"
  45 #include "llvm/Support/Compiler.h"
  46 #include "llvm/Support/ErrorHandling.h"
  47 #include <algorithm>
  48 #include <cassert>
  49 #include <cstddef>
  50 #include <cstdint>
  51 #include <limits>
  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                                       PragmaIntroducerKind Introducer,
  69                                       Token &FirstToken) {}
  70
  71 //===----------------------------------------------------------------------===//
  72 // PragmaNamespace Implementation.
  73 //===----------------------------------------------------------------------===//
  74
  75 PragmaNamespace::~PragmaNamespace() {
  76   llvm::DeleteContainerSeconds(Handlers);
  77 }
  78
  79 /// FindHandler - Check to see if there is already a handler for the
  80 /// specified name.  If not, return the handler for the null identifier if it
  81 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  82 /// the null handler isn't returned on failure to match.
  83 PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
  84                                             bool IgnoreNull) const {
  85   if (PragmaHandler *Handler = Handlers.lookup(Name))
  86     return Handler;
  87   return IgnoreNull ? nullptr : Handlers.lookup(StringRef());
  88 }
  89
  90 void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
  91   assert(!Handlers.lookup(Handler->getName()) &&
  92          "A handler with this name is already registered in this namespace");
  93   Handlers[Handler->getName()] = Handler;
  94 }
  95
  96 void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
  97   assert(Handlers.lookup(Handler->getName()) &&
  98          "Handler not registered in this namespace");
  99   Handlers.erase(Handler->getName());
 100 }
 101
 102 void PragmaNamespace::HandlePragma(Preprocessor &PP,
 103                                    PragmaIntroducerKind Introducer,
 104                                    Token &Tok) {
 105   // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
 106   // expand it, the user can have a STDC #define, that should not affect this.
 107   PP.LexUnexpandedToken(Tok);
 108
 109   // Get the handler for this token.  If there is no handler, ignore the pragma.
 110   PragmaHandler *Handler
 111     = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
 112                                           : StringRef(),
 113                   /*IgnoreNull=*/false);
 114   if (!Handler) {
 115     PP.Diag(Tok, diag::warn_pragma_ignored);
 116     return;
 117   }
 118
 119   // Otherwise, pass it down.
 120   Handler->HandlePragma(PP, Introducer, Tok);
 121 }
 122
 123 //===----------------------------------------------------------------------===//
 124 // Preprocessor Pragma Directive Handling.
 125 //===----------------------------------------------------------------------===//
 126
 127 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 128 /// rest of the pragma, passing it to the registered pragma handlers.
 129 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
 130                                          PragmaIntroducerKind Introducer) {
 131   if (Callbacks)
 132     Callbacks->PragmaDirective(IntroducerLoc, Introducer);
 133
 134   if (!PragmasEnabled)
 135     return;
 136
 137   ++NumPragma;
 138
 139   // Invoke the first level of pragma handlers which reads the namespace id.
 140   Token Tok;
 141   PragmaHandlers->HandlePragma(*this, Introducer, Tok);
 142
 143   // If the pragma handler didn't read the rest of the line, consume it now.
 144   if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
 145    || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
 146     DiscardUntilEndOfDirective();
 147 }
 148
 149 namespace {
 150
 151 /// \brief Helper class for \see Preprocessor::Handle_Pragma.
 152 class LexingFor_PragmaRAII {
 153   Preprocessor &PP;
 154   bool InMacroArgPreExpansion;
 155   bool Failed = false;
 156   Token &OutTok;
 157   Token PragmaTok;
 158
 159 public:
 160   LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion,
 161                        Token &Tok)
 162       : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), OutTok(Tok) {
 163     if (InMacroArgPreExpansion) {
 164       PragmaTok = OutTok;
 165       PP.EnableBacktrackAtThisPos();
 166     }
 167   }
 168
 169   ~LexingFor_PragmaRAII() {
 170     if (InMacroArgPreExpansion) {
 171       // When committing/backtracking the cached pragma tokens in a macro
 172       // argument pre-expansion we want to ensure that either the tokens which
 173       // have been committed will be removed from the cache or that the tokens
 174       // over which we just backtracked won't remain in the cache after they're
 175       // consumed and that the caching will stop after consuming them.
 176       // Otherwise the caching will interfere with the way macro expansion
 177       // works, because we will continue to cache tokens after consuming the
 178       // backtracked tokens, which shouldn't happen when we're dealing with
 179       // macro argument pre-expansion.
 180       auto CachedTokenRange = PP.LastCachedTokenRange();
 181       if (Failed) {
 182         PP.CommitBacktrackedTokens();
 183       } else {
 184         PP.Backtrack();
 185         OutTok = PragmaTok;
 186       }
 187       PP.EraseCachedTokens(CachedTokenRange);
 188     }
 189   }
 190
 191   void failed() {
 192     Failed = true;
 193   }
 194 };
 195
 196 } // namespace
 197
 198 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
 199 /// return the first token after the directive.  The _Pragma token has just
 200 /// been read into 'Tok'.
 201 void Preprocessor::Handle_Pragma(Token &Tok) {
 202   // This works differently if we are pre-expanding a macro argument.
 203   // In that case we don't actually "activate" the pragma now, we only lex it
 204   // until we are sure it is lexically correct and then we backtrack so that
 205   // we activate the pragma whenever we encounter the tokens again in the token
 206   // stream. This ensures that we will activate it in the correct location
 207   // or that we will ignore it if it never enters the token stream, e.g:
 208   //
 209   //     #define EMPTY(x)
 210   //     #define INACTIVE(x) EMPTY(x)
 211   //     INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\""))
 212
 213   LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok);
 214
 215   // Remember the pragma token location.
 216   SourceLocation PragmaLoc = Tok.getLocation();
 217
 218   // Read the '('.
 219   Lex(Tok);
 220   if (Tok.isNot(tok::l_paren)) {
 221     Diag(PragmaLoc, diag::err__Pragma_malformed);
 222     return _PragmaLexing.failed();
 223   }
 224
 225   // Read the '"..."'.
 226   Lex(Tok);
 227   if (!tok::isStringLiteral(Tok.getKind())) {
 228     Diag(PragmaLoc, diag::err__Pragma_malformed);
 229     // Skip bad tokens, and the ')', if present.
 230     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
 231       Lex(Tok);
 232     while (Tok.isNot(tok::r_paren) &&
 233            !Tok.isAtStartOfLine() &&
 234            Tok.isNot(tok::eof))
 235       Lex(Tok);
 236     if (Tok.is(tok::r_paren))
 237       Lex(Tok);
 238     return _PragmaLexing.failed();
 239   }
 240
 241   if (Tok.hasUDSuffix()) {
 242     Diag(Tok, diag::err_invalid_string_udl);
 243     // Skip this token, and the ')', if present.
 244     Lex(Tok);
 245     if (Tok.is(tok::r_paren))
 246       Lex(Tok);
 247     return _PragmaLexing.failed();
 248   }
 249
 250   // Remember the string.
 251   Token StrTok = Tok;
 252
 253   // Read the ')'.
 254   Lex(Tok);
 255   if (Tok.isNot(tok::r_paren)) {
 256     Diag(PragmaLoc, diag::err__Pragma_malformed);
 257     return _PragmaLexing.failed();
 258   }
 259
 260   if (InMacroArgPreExpansion)
 261     return;
 262
 263   SourceLocation RParenLoc = Tok.getLocation();
 264   std::string StrVal = getSpelling(StrTok);
 265
 266   // The _Pragma is lexically sound.  Destringize according to C11 6.10.9.1:
 267   // "The string literal is destringized by deleting any encoding prefix,
 268   // deleting the leading and trailing double-quotes, replacing each escape
 269   // sequence \" by a double-quote, and replacing each escape sequence \\ by a
 270   // single backslash."
 271   if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
 272       (StrVal[0] == 'u' && StrVal[1] != '8'))
 273     StrVal.erase(StrVal.begin());
 274   else if (StrVal[0] == 'u')
 275     StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
 276
 277   if (StrVal[0] == 'R') {
 278     // FIXME: C++11 does not specify how to handle raw-string-literals here.
 279     // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
 280     assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
 281            "Invalid raw string token!");
 282
 283     // Measure the length of the d-char-sequence.
 284     unsigned NumDChars = 0;
 285     while (StrVal[2 + NumDChars] != '(') {
 286       assert(NumDChars < (StrVal.size() - 5) / 2 &&
 287              "Invalid raw string token!");
 288       ++NumDChars;
 289     }
 290     assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
 291
 292     // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
 293     // parens below.
 294     StrVal.erase(0, 2 + NumDChars);
 295     StrVal.erase(StrVal.size() - 1 - NumDChars);
 296   } else {
 297     assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 298            "Invalid string token!");
 299
 300     // Remove escaped quotes and escapes.
 301     unsigned ResultPos = 1;
 302     for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
 303       // Skip escapes.  \\ -> '\' and \" -> '"'.
 304       if (StrVal[i] == '\\' && i + 1 < e &&
 305           (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
 306         ++i;
 307       StrVal[ResultPos++] = StrVal[i];
 308     }
 309     StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
 310   }
 311
 312   // Remove the front quote, replacing it with a space, so that the pragma
 313   // contents appear to have a space before them.
 314   StrVal[0] = ' ';
 315
 316   // Replace the terminating quote with a \n.
 317   StrVal[StrVal.size()-1] = '\n';
 318
 319   // Plop the string (including the newline and trailing null) into a buffer
 320   // where we can lex it.
 321   Token TmpTok;
 322   TmpTok.startToken();
 323   CreateString(StrVal, TmpTok);
 324   SourceLocation TokLoc = TmpTok.getLocation();
 325
 326   // Make and enter a lexer object so that we lex and expand the tokens just
 327   // like any others.
 328   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
 329                                         StrVal.size(), *this);
 330
 331   EnterSourceFileWithLexer(TL, nullptr);
 332
 333   // With everything set up, lex this as a #pragma directive.
 334   HandlePragmaDirective(PragmaLoc, PIK__Pragma);
 335
 336   // Finally, return whatever came after the pragma directive.
 337   return Lex(Tok);
 338 }
 339
 340 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
 341 /// is not enclosed within a string literal.
 342 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
 343   // Remember the pragma token location.
 344   SourceLocation PragmaLoc = Tok.getLocation();
 345
 346   // Read the '('.
 347   Lex(Tok);
 348   if (Tok.isNot(tok::l_paren)) {
 349     Diag(PragmaLoc, diag::err__Pragma_malformed);
 350     return;
 351   }
 352
 353   // Get the tokens enclosed within the __pragma(), as well as the final ')'.
 354   SmallVector<Token, 32> PragmaToks;
 355   int NumParens = 0;
 356   Lex(Tok);
 357   while (Tok.isNot(tok::eof)) {
 358     PragmaToks.push_back(Tok);
 359     if (Tok.is(tok::l_paren))
 360       NumParens++;
 361     else if (Tok.is(tok::r_paren) && NumParens-- == 0)
 362       break;
 363     Lex(Tok);
 364   }
 365
 366   if (Tok.is(tok::eof)) {
 367     Diag(PragmaLoc, diag::err_unterminated___pragma);
 368     return;
 369   }
 370
 371   PragmaToks.front().setFlag(Token::LeadingSpace);
 372
 373   // Replace the ')' with an EOD to mark the end of the pragma.
 374   PragmaToks.back().setKind(tok::eod);
 375
 376   Token *TokArray = new Token[PragmaToks.size()];
 377   std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
 378
 379   // Push the tokens onto the stack.
 380   EnterTokenStream(TokArray, PragmaToks.size(), true, true);
 381
 382   // With everything set up, lex this as a #pragma directive.
 383   HandlePragmaDirective(PragmaLoc, PIK___pragma);
 384
 385   // Finally, return whatever came after the pragma directive.
 386   return Lex(Tok);
 387 }
 388
 389 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
 390 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
 391   // Don't honor the 'once' when handling the primary source file, unless
 392   // this is a prefix to a TU, which indicates we're generating a PCH file, or
 393   // when the main file is a header (e.g. when -xc-header is provided on the
 394   // commandline).
 395   if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
 396     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
 397     return;
 398   }
 399
 400   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 401   // Mark the file as a once-only file now.
 402   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
 403 }
 404
 405 void Preprocessor::HandlePragmaMark() {
 406   assert(CurPPLexer && "No current lexer?");
 407   if (CurLexer)
 408     CurLexer->ReadToEndOfLine();
 409   else
 410     CurPTHLexer->DiscardToEndOfLine();
 411 }
 412
 413 /// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
 414 void Preprocessor::HandlePragmaPoison() {
 415   Token Tok;
 416
 417   while (true) {
 418     // Read the next token to poison.  While doing this, pretend that we are
 419     // skipping while reading the identifier to poison.
 420     // This avoids errors on code like:
 421     //   #pragma GCC poison X
 422     //   #pragma GCC poison X
 423     if (CurPPLexer) CurPPLexer->LexingRawMode = true;
 424     LexUnexpandedToken(Tok);
 425     if (CurPPLexer) CurPPLexer->LexingRawMode = false;
 426
 427     // If we reached the end of line, we're done.
 428     if (Tok.is(tok::eod)) return;
 429
 430     // Can only poison identifiers.
 431     if (Tok.isNot(tok::raw_identifier)) {
 432       Diag(Tok, diag::err_pp_invalid_poison);
 433       return;
 434     }
 435
 436     // Look up the identifier info for the token.  We disabled identifier lookup
 437     // by saying we're skipping contents, so we need to do this manually.
 438     IdentifierInfo *II = LookUpIdentifierInfo(Tok);
 439
 440     // Already poisoned.
 441     if (II->isPoisoned()) continue;
 442
 443     // If this is a macro identifier, emit a warning.
 444     if (isMacroDefined(II))
 445       Diag(Tok, diag::pp_poisoning_existing_macro);
 446
 447     // Finally, poison it!
 448     II->setIsPoisoned();
 449     if (II->isFromAST())
 450       II->setChangedSinceDeserialization();
 451   }
 452 }
 453
 454 /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header.  We know
 455 /// that the whole directive has been parsed.
 456 void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
 457   if (isInPrimaryFile()) {
 458     Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
 459     return;
 460   }
 461
 462   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 463   PreprocessorLexer *TheLexer = getCurrentFileLexer();
 464
 465   // Mark the file as a system header.
 466   HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
 467
 468   PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
 469   if (PLoc.isInvalid())
 470     return;
 471
 472   unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
 473
 474   // Notify the client, if desired, that we are in a new source file.
 475   if (Callbacks)
 476     Callbacks->FileChanged(SysHeaderTok.getLocation(),
 477                            PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
 478
 479   // Emit a line marker.  This will change any source locations from this point
 480   // forward to realize they are in a system header.
 481   // Create a line note with this information.
 482   SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
 483                         FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
 484                         SrcMgr::C_System);
 485 }
 486
 487 /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
 488 void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
 489   Token FilenameTok;
 490   CurPPLexer->LexIncludeFilename(FilenameTok);
 491
 492   // If the token kind is EOD, the error has already been diagnosed.
 493   if (FilenameTok.is(tok::eod))
 494     return;
 495
 496   // Reserve a buffer to get the spelling.
 497   SmallString<128> FilenameBuffer;
 498   bool Invalid = false;
 499   StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
 500   if (Invalid)
 501     return;
 502
 503   bool isAngled =
 504     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
 505   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
 506   // error.
 507   if (Filename.empty())
 508     return;
 509
 510   // Search include directories for this file.
 511   const DirectoryLookup *CurDir;
 512   const FileEntry *File =
 513       LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
 514                  nullptr, CurDir, nullptr, nullptr, nullptr, nullptr);
 515   if (!File) {
 516     if (!SuppressIncludeNotFoundError)
 517       Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
 518     return;
 519   }
 520
 521   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
 522
 523   // If this file is older than the file it depends on, emit a diagnostic.
 524   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
 525     // Lex tokens at the end of the message and include them in the message.
 526     std::string Message;
 527     Lex(DependencyTok);
 528     while (DependencyTok.isNot(tok::eod)) {
 529       Message += getSpelling(DependencyTok) + " ";
 530       Lex(DependencyTok);
 531     }
 532
 533     // Remove the trailing ' ' if present.
 534     if (!Message.empty())
 535       Message.erase(Message.end()-1);
 536     Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
 537   }
 538 }
 539
 540 /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
 541 /// Return the IdentifierInfo* associated with the macro to push or pop.
 542 IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {
 543   // Remember the pragma token location.
 544   Token PragmaTok = Tok;
 545
 546   // Read the '('.
 547   Lex(Tok);
 548   if (Tok.isNot(tok::l_paren)) {
 549     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 550       << getSpelling(PragmaTok);
 551     return nullptr;
 552   }
 553
 554   // Read the macro name string.
 555   Lex(Tok);
 556   if (Tok.isNot(tok::string_literal)) {
 557     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 558       << getSpelling(PragmaTok);
 559     return nullptr;
 560   }
 561
 562   if (Tok.hasUDSuffix()) {
 563     Diag(Tok, diag::err_invalid_string_udl);
 564     return nullptr;
 565   }
 566
 567   // Remember the macro string.
 568   std::string StrVal = getSpelling(Tok);
 569
 570   // Read the ')'.
 571   Lex(Tok);
 572   if (Tok.isNot(tok::r_paren)) {
 573     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 574       << getSpelling(PragmaTok);
 575     return nullptr;
 576   }
 577
 578   assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 579          "Invalid string token!");
 580
 581   // Create a Token from the string.
 582   Token MacroTok;
 583   MacroTok.startToken();
 584   MacroTok.setKind(tok::raw_identifier);
 585   CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
 586
 587   // Get the IdentifierInfo of MacroToPushTok.
 588   return LookUpIdentifierInfo(MacroTok);
 589 }
 590
 591 /// \brief Handle \#pragma push_macro.
 592 ///
 593 /// The syntax is:
 594 /// \code
 595 ///   #pragma push_macro("macro")
 596 /// \endcode
 597 void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
 598   // Parse the pragma directive and get the macro IdentifierInfo*.
 599   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
 600   if (!IdentInfo) return;
 601
 602   // Get the MacroInfo associated with IdentInfo.
 603   MacroInfo *MI = getMacroInfo(IdentInfo);
 604
 605   if (MI) {
 606     // Allow the original MacroInfo to be redefined later.
 607     MI->setIsAllowRedefinitionsWithoutWarning(true);
 608   }
 609
 610   // Push the cloned MacroInfo so we can retrieve it later.
 611   PragmaPushMacroInfo[IdentInfo].push_back(MI);
 612 }
 613
 614 /// \brief Handle \#pragma pop_macro.
 615 ///
 616 /// The syntax is:
 617 /// \code
 618 ///   #pragma pop_macro("macro")
 619 /// \endcode
 620 void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
 621   SourceLocation MessageLoc = PopMacroTok.getLocation();
 622
 623   // Parse the pragma directive and get the macro IdentifierInfo*.
 624   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
 625   if (!IdentInfo) return;
 626
 627   // Find the vector<MacroInfo*> associated with the macro.
 628   llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
 629     PragmaPushMacroInfo.find(IdentInfo);
 630   if (iter != PragmaPushMacroInfo.end()) {
 631     // Forget the MacroInfo currently associated with IdentInfo.
 632     if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
 633       if (MI->isWarnIfUnused())
 634         WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 635       appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
 636     }
 637
 638     // Get the MacroInfo we want to reinstall.
 639     MacroInfo *MacroToReInstall = iter->second.back();
 640
 641     if (MacroToReInstall)
 642       // Reinstall the previously pushed macro.
 643       appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
 644
 645     // Pop PragmaPushMacroInfo stack.
 646     iter->second.pop_back();
 647     if (iter->second.empty())
 648       PragmaPushMacroInfo.erase(iter);
 649   } else {
 650     Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
 651       << IdentInfo->getName();
 652   }
 653 }
 654
 655 void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
 656   // We will either get a quoted filename or a bracketed filename, and we
 657   // have to track which we got.  The first filename is the source name,
 658   // and the second name is the mapped filename.  If the first is quoted,
 659   // the second must be as well (cannot mix and match quotes and brackets).
 660
 661   // Get the open paren
 662   Lex(Tok);
 663   if (Tok.isNot(tok::l_paren)) {
 664     Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
 665     return;
 666   }
 667
 668   // We expect either a quoted string literal, or a bracketed name
 669   Token SourceFilenameTok;
 670   CurPPLexer->LexIncludeFilename(SourceFilenameTok);
 671   if (SourceFilenameTok.is(tok::eod)) {
 672     // The diagnostic has already been handled
 673     return;
 674   }
 675
 676   StringRef SourceFileName;
 677   SmallString<128> FileNameBuffer;
 678   if (SourceFilenameTok.is(tok::string_literal) ||
 679       SourceFilenameTok.is(tok::angle_string_literal)) {
 680     SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
 681   } else if (SourceFilenameTok.is(tok::less)) {
 682     // This could be a path instead of just a name
 683     FileNameBuffer.push_back('<');
 684     SourceLocation End;
 685     if (ConcatenateIncludeName(FileNameBuffer, End))
 686       return; // Diagnostic already emitted
 687     SourceFileName = FileNameBuffer;
 688   } else {
 689     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 690     return;
 691   }
 692   FileNameBuffer.clear();
 693
 694   // Now we expect a comma, followed by another include name
 695   Lex(Tok);
 696   if (Tok.isNot(tok::comma)) {
 697     Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
 698     return;
 699   }
 700
 701   Token ReplaceFilenameTok;
 702   CurPPLexer->LexIncludeFilename(ReplaceFilenameTok);
 703   if (ReplaceFilenameTok.is(tok::eod)) {
 704     // The diagnostic has already been handled
 705     return;
 706   }
 707
 708   StringRef ReplaceFileName;
 709   if (ReplaceFilenameTok.is(tok::string_literal) ||
 710       ReplaceFilenameTok.is(tok::angle_string_literal)) {
 711     ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
 712   } else if (ReplaceFilenameTok.is(tok::less)) {
 713     // This could be a path instead of just a name
 714     FileNameBuffer.push_back('<');
 715     SourceLocation End;
 716     if (ConcatenateIncludeName(FileNameBuffer, End))
 717       return; // Diagnostic already emitted
 718     ReplaceFileName = FileNameBuffer;
 719   } else {
 720     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 721     return;
 722   }
 723
 724   // Finally, we expect the closing paren
 725   Lex(Tok);
 726   if (Tok.isNot(tok::r_paren)) {
 727     Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
 728     return;
 729   }
 730
 731   // Now that we have the source and target filenames, we need to make sure
 732   // they're both of the same type (angled vs non-angled)
 733   StringRef OriginalSource = SourceFileName;
 734
 735   bool SourceIsAngled =
 736     GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
 737                                 SourceFileName);
 738   bool ReplaceIsAngled =
 739     GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
 740                                 ReplaceFileName);
 741   if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
 742       (SourceIsAngled != ReplaceIsAngled)) {
 743     unsigned int DiagID;
 744     if (SourceIsAngled)
 745       DiagID = diag::warn_pragma_include_alias_mismatch_angle;
 746     else
 747       DiagID = diag::warn_pragma_include_alias_mismatch_quote;
 748
 749     Diag(SourceFilenameTok.getLocation(), DiagID)
 750       << SourceFileName
 751       << ReplaceFileName;
 752
 753     return;
 754   }
 755
 756   // Now we can let the include handler know about this mapping
 757   getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
 758 }
 759
 760 // Lex a component of a module name: either an identifier or a string literal;
 761 // for components that can be expressed both ways, the two forms are equivalent.
 762 static bool LexModuleNameComponent(
 763     Preprocessor &PP, Token &Tok,
 764     std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
 765     bool First) {
 766   PP.LexUnexpandedToken(Tok);
 767   if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
 768     StringLiteralParser Literal(Tok, PP);
 769     if (Literal.hadError)
 770       return true;
 771     ModuleNameComponent = std::make_pair(
 772         PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
 773   } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
 774     ModuleNameComponent =
 775         std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
 776   } else {
 777     PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
 778     return true;
 779   }
 780   return false;
 781 }
 782
 783 static bool LexModuleName(
 784     Preprocessor &PP, Token &Tok,
 785     llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
 786         &ModuleName) {
 787   while (true) {
 788     std::pair<IdentifierInfo*, SourceLocation> NameComponent;
 789     if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
 790       return true;
 791     ModuleName.push_back(NameComponent);
 792
 793     PP.LexUnexpandedToken(Tok);
 794     if (Tok.isNot(tok::period))
 795       return false;
 796   }
 797 }
 798
 799 void Preprocessor::HandlePragmaModuleBuild(Token &Tok) {
 800   SourceLocation Loc = Tok.getLocation();
 801
 802   std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
 803   if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
 804     return;
 805   IdentifierInfo *ModuleName = ModuleNameLoc.first;
 806
 807   LexUnexpandedToken(Tok);
 808   if (Tok.isNot(tok::eod)) {
 809     Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
 810     DiscardUntilEndOfDirective();
 811   }
 812
 813   if (CurPTHLexer) {
 814     // FIXME: Support this somehow?
 815     Diag(Loc, diag::err_pp_module_build_pth);
 816     return;
 817   }
 818
 819   CurLexer->LexingRawMode = true;
 820
 821   auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
 822     if (Tok.getKind() != tok::raw_identifier ||
 823         Tok.getRawIdentifier() != Ident)
 824       return false;
 825     CurLexer->Lex(Tok);
 826     return true;
 827   };
 828
 829   // Scan forward looking for the end of the module.
 830   const char *Start = CurLexer->getBufferLocation();
 831   const char *End = nullptr;
 832   unsigned NestingLevel = 1;
 833   while (true) {
 834     End = CurLexer->getBufferLocation();
 835     CurLexer->Lex(Tok);
 836
 837     if (Tok.is(tok::eof)) {
 838       Diag(Loc, diag::err_pp_module_build_missing_end);
 839       break;
 840     }
 841
 842     if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
 843       // Token was part of module; keep going.
 844       continue;
 845     }
 846
 847     // We hit something directive-shaped; check to see if this is the end
 848     // of the module build.
 849     CurLexer->ParsingPreprocessorDirective = true;
 850     CurLexer->Lex(Tok);
 851     if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
 852         TryConsumeIdentifier("module")) {
 853       if (TryConsumeIdentifier("build"))
 854         // #pragma clang module build -> entering a nested module build.
 855         ++NestingLevel;
 856       else if (TryConsumeIdentifier("endbuild")) {
 857         // #pragma clang module endbuild -> leaving a module build.
 858         if (--NestingLevel == 0)
 859           break;
 860       }
 861       // We should either be looking at the EOD or more of the current directive
 862       // preceding the EOD. Either way we can ignore this token and keep going.
 863       assert(Tok.getKind() != tok::eof && "missing EOD before EOF");
 864     }
 865   }
 866
 867   CurLexer->LexingRawMode = false;
 868
 869   // Load the extracted text as a preprocessed module.
 870   assert(CurLexer->getBuffer().begin() <= Start &&
 871          Start <= CurLexer->getBuffer().end() &&
 872          CurLexer->getBuffer().begin() <= End &&
 873          End <= CurLexer->getBuffer().end() &&
 874          "module source range not contained within same file buffer");
 875   TheModuleLoader.loadModuleFromSource(Loc, ModuleName->getName(),
 876                                        StringRef(Start, End - Start));
 877 }
 878
 879 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
 880 /// If 'Namespace' is non-null, then it is a token required to exist on the
 881 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
 882 void Preprocessor::AddPragmaHandler(StringRef Namespace,
 883                                     PragmaHandler *Handler) {
 884   PragmaNamespace *InsertNS = PragmaHandlers.get();
 885
 886   // If this is specified to be in a namespace, step down into it.
 887   if (!Namespace.empty()) {
 888     // If there is already a pragma handler with the name of this namespace,
 889     // we either have an error (directive with the same name as a namespace) or
 890     // we already have the namespace to insert into.
 891     if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
 892       InsertNS = Existing->getIfNamespace();
 893       assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
 894              " handler with the same name!");
 895     } else {
 896       // Otherwise, this namespace doesn't exist yet, create and insert the
 897       // handler for it.
 898       InsertNS = new PragmaNamespace(Namespace);
 899       PragmaHandlers->AddPragma(InsertNS);
 900     }
 901   }
 902
 903   // Check to make sure we don't already have a pragma for this identifier.
 904   assert(!InsertNS->FindHandler(Handler->getName()) &&
 905          "Pragma handler already exists for this identifier!");
 906   InsertNS->AddPragma(Handler);
 907 }
 908
 909 /// RemovePragmaHandler - Remove the specific pragma handler from the
 910 /// preprocessor. If \arg Namespace is non-null, then it should be the
 911 /// namespace that \arg Handler was added to. It is an error to remove
 912 /// a handler that has not been registered.
 913 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
 914                                        PragmaHandler *Handler) {
 915   PragmaNamespace *NS = PragmaHandlers.get();
 916
 917   // If this is specified to be in a namespace, step down into it.
 918   if (!Namespace.empty()) {
 919     PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
 920     assert(Existing && "Namespace containing handler does not exist!");
 921
 922     NS = Existing->getIfNamespace();
 923     assert(NS && "Invalid namespace, registered as a regular pragma handler!");
 924   }
 925
 926   NS->RemovePragmaHandler(Handler);
 927
 928   // If this is a non-default namespace and it is now empty, remove it.
 929   if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
 930     PragmaHandlers->RemovePragmaHandler(NS);
 931     delete NS;
 932   }
 933 }
 934
 935 bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
 936   Token Tok;
 937   LexUnexpandedToken(Tok);
 938
 939   if (Tok.isNot(tok::identifier)) {
 940     Diag(Tok, diag::ext_on_off_switch_syntax);
 941     return true;
 942   }
 943   IdentifierInfo *II = Tok.getIdentifierInfo();
 944   if (II->isStr("ON"))
 945     Result = tok::OOS_ON;
 946   else if (II->isStr("OFF"))
 947     Result = tok::OOS_OFF;
 948   else if (II->isStr("DEFAULT"))
 949     Result = tok::OOS_DEFAULT;
 950   else {
 951     Diag(Tok, diag::ext_on_off_switch_syntax);
 952     return true;
 953   }
 954
 955   // Verify that this is followed by EOD.
 956   LexUnexpandedToken(Tok);
 957   if (Tok.isNot(tok::eod))
 958     Diag(Tok, diag::ext_pragma_syntax_eod);
 959   return false;
 960 }
 961
 962 namespace {
 963
 964 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
 965 struct PragmaOnceHandler : public PragmaHandler {
 966   PragmaOnceHandler() : PragmaHandler("once") {}
 967
 968   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 969                     Token &OnceTok) override {
 970     PP.CheckEndOfDirective("pragma once");
 971     PP.HandlePragmaOnce(OnceTok);
 972   }
 973 };
 974
 975 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
 976 /// rest of the line is not lexed.
 977 struct PragmaMarkHandler : public PragmaHandler {
 978   PragmaMarkHandler() : PragmaHandler("mark") {}
 979
 980   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 981                     Token &MarkTok) override {
 982     PP.HandlePragmaMark();
 983   }
 984 };
 985
 986 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
 987 struct PragmaPoisonHandler : public PragmaHandler {
 988   PragmaPoisonHandler() : PragmaHandler("poison") {}
 989
 990   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 991                     Token &PoisonTok) override {
 992     PP.HandlePragmaPoison();
 993   }
 994 };
 995
 996 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
 997 /// as a system header, which silences warnings in it.
 998 struct PragmaSystemHeaderHandler : public PragmaHandler {
 999   PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1000
1001   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1002                     Token &SHToken) override {
1003     PP.HandlePragmaSystemHeader(SHToken);
1004     PP.CheckEndOfDirective("pragma");
1005   }
1006 };
1007
1008 struct PragmaDependencyHandler : public PragmaHandler {
1009   PragmaDependencyHandler() : PragmaHandler("dependency") {}
1010
1011   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1012                     Token &DepToken) override {
1013     PP.HandlePragmaDependency(DepToken);
1014   }
1015 };
1016
1017 struct PragmaDebugHandler : public PragmaHandler {
1018   PragmaDebugHandler() : PragmaHandler("__debug") {}
1019
1020   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1021                     Token &DepToken) override {
1022     Token Tok;
1023     PP.LexUnexpandedToken(Tok);
1024     if (Tok.isNot(tok::identifier)) {
1025       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1026       return;
1027     }
1028     IdentifierInfo *II = Tok.getIdentifierInfo();
1029
1030     if (II->isStr("assert")) {
1031       llvm_unreachable("This is an assertion!");
1032     } else if (II->isStr("crash")) {
1033       LLVM_BUILTIN_TRAP;
1034     } else if (II->isStr("parser_crash")) {
1035       Token Crasher;
1036       Crasher.startToken();
1037       Crasher.setKind(tok::annot_pragma_parser_crash);
1038       Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
1039       PP.EnterToken(Crasher);
1040     } else if (II->isStr("dump")) {
1041       Token Identifier;
1042       PP.LexUnexpandedToken(Identifier);
1043       if (auto *DumpII = Identifier.getIdentifierInfo()) {
1044         Token DumpAnnot;
1045         DumpAnnot.startToken();
1046         DumpAnnot.setKind(tok::annot_pragma_dump);
1047         DumpAnnot.setAnnotationRange(
1048             SourceRange(Tok.getLocation(), Identifier.getLocation()));
1049         DumpAnnot.setAnnotationValue(DumpII);
1050         PP.DiscardUntilEndOfDirective();
1051         PP.EnterToken(DumpAnnot);
1052       } else {
1053         PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
1054             << II->getName();
1055       }
1056     } else if (II->isStr("llvm_fatal_error")) {
1057       llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1058     } else if (II->isStr("llvm_unreachable")) {
1059       llvm_unreachable("#pragma clang __debug llvm_unreachable");
1060     } else if (II->isStr("macro")) {
1061       Token MacroName;
1062       PP.LexUnexpandedToken(MacroName);
1063       auto *MacroII = MacroName.getIdentifierInfo();
1064       if (MacroII)
1065         PP.dumpMacroInfo(MacroII);
1066       else
1067         PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1068             << II->getName();
1069     } else if (II->isStr("overflow_stack")) {
1070       DebugOverflowStack();
1071     } else if (II->isStr("handle_crash")) {
1072       llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent();
1073       if (CRC)
1074         CRC->HandleCrash();
1075     } else if (II->isStr("captured")) {
1076       HandleCaptured(PP);
1077     } else {
1078       PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1079         << II->getName();
1080     }
1081
1082     PPCallbacks *Callbacks = PP.getPPCallbacks();
1083     if (Callbacks)
1084       Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1085   }
1086
1087   void HandleCaptured(Preprocessor &PP) {
1088     // Skip if emitting preprocessed output.
1089     if (PP.isPreprocessedOutput())
1090       return;
1091
1092     Token Tok;
1093     PP.LexUnexpandedToken(Tok);
1094
1095     if (Tok.isNot(tok::eod)) {
1096       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1097         << "pragma clang __debug captured";
1098       return;
1099     }
1100
1101     SourceLocation NameLoc = Tok.getLocation();
1102     MutableArrayRef<Token> Toks(
1103         PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1104     Toks[0].startToken();
1105     Toks[0].setKind(tok::annot_pragma_captured);
1106     Toks[0].setLocation(NameLoc);
1107
1108     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1109   }
1110
1111 // Disable MSVC warning about runtime stack overflow.
1112 #ifdef _MSC_VER
1113     #pragma warning(disable : 4717)
1114 #endif
1115   static void DebugOverflowStack(void (*P)() = nullptr) {
1116     void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1117     Self(reinterpret_cast<void(*)()>(Self));
1118   }
1119 #ifdef _MSC_VER
1120     #pragma warning(default : 4717)
1121 #endif
1122 };
1123
1124 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1125 struct PragmaDiagnosticHandler : public PragmaHandler {
1126 private:
1127   const char *Namespace;
1128
1129 public:
1130   explicit PragmaDiagnosticHandler(const char *NS)
1131       : PragmaHandler("diagnostic"), Namespace(NS) {}
1132
1133   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1134                     Token &DiagToken) override {
1135     SourceLocation DiagLoc = DiagToken.getLocation();
1136     Token Tok;
1137     PP.LexUnexpandedToken(Tok);
1138     if (Tok.isNot(tok::identifier)) {
1139       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1140       return;
1141     }
1142     IdentifierInfo *II = Tok.getIdentifierInfo();
1143     PPCallbacks *Callbacks = PP.getPPCallbacks();
1144
1145     if (II->isStr("pop")) {
1146       if (!PP.getDiagnostics().popMappings(DiagLoc))
1147         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1148       else if (Callbacks)
1149         Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1150       return;
1151     } else if (II->isStr("push")) {
1152       PP.getDiagnostics().pushMappings(DiagLoc);
1153       if (Callbacks)
1154         Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1155       return;
1156     }
1157
1158     diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1159                             .Case("ignored", diag::Severity::Ignored)
1160                             .Case("warning", diag::Severity::Warning)
1161                             .Case("error", diag::Severity::Error)
1162                             .Case("fatal", diag::Severity::Fatal)
1163                             .Default(diag::Severity());
1164
1165     if (SV == diag::Severity()) {
1166       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1167       return;
1168     }
1169
1170     PP.LexUnexpandedToken(Tok);
1171     SourceLocation StringLoc = Tok.getLocation();
1172
1173     std::string WarningName;
1174     if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1175                                    /*MacroExpansion=*/false))
1176       return;
1177
1178     if (Tok.isNot(tok::eod)) {
1179       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1180       return;
1181     }
1182
1183     if (WarningName.size() < 3 || WarningName[0] != '-' ||
1184         (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1185       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1186       return;
1187     }
1188
1189     diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1190                                                 : diag::Flavor::Remark;
1191     StringRef Group = StringRef(WarningName).substr(2);
1192     bool unknownDiag = false;
1193     if (Group == "everything") {
1194       // Special handling for pragma clang diagnostic ... "-Weverything".
1195       // There is no formal group named "everything", so there has to be a
1196       // special case for it.
1197       PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1198     } else
1199       unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1200                                                             DiagLoc);
1201     if (unknownDiag)
1202       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1203         << WarningName;
1204     else if (Callbacks)
1205       Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1206   }
1207 };
1208
1209 /// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
1210 /// diagnostics, so we don't really implement this pragma.  We parse it and
1211 /// ignore it to avoid -Wunknown-pragma warnings.
1212 struct PragmaWarningHandler : public PragmaHandler {
1213   PragmaWarningHandler() : PragmaHandler("warning") {}
1214
1215   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1216                     Token &Tok) override {
1217     // Parse things like:
1218     // warning(push, 1)
1219     // warning(pop)
1220     // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1221     SourceLocation DiagLoc = Tok.getLocation();
1222     PPCallbacks *Callbacks = PP.getPPCallbacks();
1223
1224     PP.Lex(Tok);
1225     if (Tok.isNot(tok::l_paren)) {
1226       PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1227       return;
1228     }
1229
1230     PP.Lex(Tok);
1231     IdentifierInfo *II = Tok.getIdentifierInfo();
1232
1233     if (II && II->isStr("push")) {
1234       // #pragma warning( push[ ,n ] )
1235       int Level = -1;
1236       PP.Lex(Tok);
1237       if (Tok.is(tok::comma)) {
1238         PP.Lex(Tok);
1239         uint64_t Value;
1240         if (Tok.is(tok::numeric_constant) &&
1241             PP.parseSimpleIntegerLiteral(Tok, Value))
1242           Level = int(Value);
1243         if (Level < 0 || Level > 4) {
1244           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1245           return;
1246         }
1247       }
1248       if (Callbacks)
1249         Callbacks->PragmaWarningPush(DiagLoc, Level);
1250     } else if (II && II->isStr("pop")) {
1251       // #pragma warning( pop )
1252       PP.Lex(Tok);
1253       if (Callbacks)
1254         Callbacks->PragmaWarningPop(DiagLoc);
1255     } else {
1256       // #pragma warning( warning-specifier : warning-number-list
1257       //                  [; warning-specifier : warning-number-list...] )
1258       while (true) {
1259         II = Tok.getIdentifierInfo();
1260         if (!II && !Tok.is(tok::numeric_constant)) {
1261           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1262           return;
1263         }
1264
1265         // Figure out which warning specifier this is.
1266         bool SpecifierValid;
1267         StringRef Specifier;
1268         llvm::SmallString<1> SpecifierBuf;
1269         if (II) {
1270           Specifier = II->getName();
1271           SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1272                                .Cases("default", "disable", "error", "once",
1273                                       "suppress", true)
1274                                .Default(false);
1275           // If we read a correct specifier, snatch next token (that should be
1276           // ":", checked later).
1277           if (SpecifierValid)
1278             PP.Lex(Tok);
1279         } else {
1280           // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1281           uint64_t Value;
1282           Specifier = PP.getSpelling(Tok, SpecifierBuf);
1283           if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1284             SpecifierValid = (Value >= 1) && (Value <= 4);
1285           } else
1286             SpecifierValid = false;
1287           // Next token already snatched by parseSimpleIntegerLiteral.
1288         }
1289
1290         if (!SpecifierValid) {
1291           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1292           return;
1293         }
1294         if (Tok.isNot(tok::colon)) {
1295           PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1296           return;
1297         }
1298
1299         // Collect the warning ids.
1300         SmallVector<int, 4> Ids;
1301         PP.Lex(Tok);
1302         while (Tok.is(tok::numeric_constant)) {
1303           uint64_t Value;
1304           if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1305               Value > std::numeric_limits<int>::max()) {
1306             PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1307             return;
1308           }
1309           Ids.push_back(int(Value));
1310         }
1311         if (Callbacks)
1312           Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1313
1314         // Parse the next specifier if there is a semicolon.
1315         if (Tok.isNot(tok::semi))
1316           break;
1317         PP.Lex(Tok);
1318       }
1319     }
1320
1321     if (Tok.isNot(tok::r_paren)) {
1322       PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1323       return;
1324     }
1325
1326     PP.Lex(Tok);
1327     if (Tok.isNot(tok::eod))
1328       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1329   }
1330 };
1331
1332 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1333 struct PragmaIncludeAliasHandler : public PragmaHandler {
1334   PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1335
1336   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1337                     Token &IncludeAliasTok) override {
1338     PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1339   }
1340 };
1341
1342 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1343 /// extension.  The syntax is:
1344 /// \code
1345 ///   #pragma message(string)
1346 /// \endcode
1347 /// OR, in GCC mode:
1348 /// \code
1349 ///   #pragma message string
1350 /// \endcode
1351 /// string is a string, which is fully macro expanded, and permits string
1352 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1353 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1354 /// form as \#pragma message.
1355 struct PragmaMessageHandler : public PragmaHandler {
1356 private:
1357   const PPCallbacks::PragmaMessageKind Kind;
1358   const StringRef Namespace;
1359
1360   static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1361                                 bool PragmaNameOnly = false) {
1362     switch (Kind) {
1363       case PPCallbacks::PMK_Message:
1364         return PragmaNameOnly ? "message" : "pragma message";
1365       case PPCallbacks::PMK_Warning:
1366         return PragmaNameOnly ? "warning" : "pragma warning";
1367       case PPCallbacks::PMK_Error:
1368         return PragmaNameOnly ? "error" : "pragma error";
1369     }
1370     llvm_unreachable("Unknown PragmaMessageKind!");
1371   }
1372
1373 public:
1374   PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1375                        StringRef Namespace = StringRef())
1376       : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1377         Namespace(Namespace) {}
1378
1379   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1380                     Token &Tok) override {
1381     SourceLocation MessageLoc = Tok.getLocation();
1382     PP.Lex(Tok);
1383     bool ExpectClosingParen = false;
1384     switch (Tok.getKind()) {
1385     case tok::l_paren:
1386       // We have a MSVC style pragma message.
1387       ExpectClosingParen = true;
1388       // Read the string.
1389       PP.Lex(Tok);
1390       break;
1391     case tok::string_literal:
1392       // We have a GCC style pragma message, and we just read the string.
1393       break;
1394     default:
1395       PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1396       return;
1397     }
1398
1399     std::string MessageString;
1400     if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1401                                    /*MacroExpansion=*/true))
1402       return;
1403
1404     if (ExpectClosingParen) {
1405       if (Tok.isNot(tok::r_paren)) {
1406         PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1407         return;
1408       }
1409       PP.Lex(Tok);  // eat the r_paren.
1410     }
1411
1412     if (Tok.isNot(tok::eod)) {
1413       PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1414       return;
1415     }
1416
1417     // Output the message.
1418     PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1419                           ? diag::err_pragma_message
1420                           : diag::warn_pragma_message) << MessageString;
1421
1422     // If the pragma is lexically sound, notify any interested PPCallbacks.
1423     if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1424       Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1425   }
1426 };
1427
1428 /// Handle the clang \#pragma module import extension. The syntax is:
1429 /// \code
1430 ///   #pragma clang module import some.module.name
1431 /// \endcode
1432 struct PragmaModuleImportHandler : public PragmaHandler {
1433   PragmaModuleImportHandler() : PragmaHandler("import") {}
1434
1435   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1436                     Token &Tok) override {
1437     SourceLocation ImportLoc = Tok.getLocation();
1438
1439     // Read the module name.
1440     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1441         ModuleName;
1442     if (LexModuleName(PP, Tok, ModuleName))
1443       return;
1444
1445     if (Tok.isNot(tok::eod))
1446       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1447
1448     // If we have a non-empty module path, load the named module.
1449     Module *Imported =
1450         PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1451                                       /*IsIncludeDirective=*/false);
1452     if (!Imported)
1453       return;
1454
1455     PP.makeModuleVisible(Imported, ImportLoc);
1456     PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1457                             tok::annot_module_include, Imported);
1458     if (auto *CB = PP.getPPCallbacks())
1459       CB->moduleImport(ImportLoc, ModuleName, Imported);
1460   }
1461 };
1462
1463 /// Handle the clang \#pragma module begin extension. The syntax is:
1464 /// \code
1465 ///   #pragma clang module begin some.module.name
1466 ///   ...
1467 ///   #pragma clang module end
1468 /// \endcode
1469 struct PragmaModuleBeginHandler : public PragmaHandler {
1470   PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1471
1472   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1473                     Token &Tok) override {
1474     SourceLocation BeginLoc = Tok.getLocation();
1475
1476     // Read the module name.
1477     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1478         ModuleName;
1479     if (LexModuleName(PP, Tok, ModuleName))
1480       return;
1481
1482     if (Tok.isNot(tok::eod))
1483       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1484
1485     // We can only enter submodules of the current module.
1486     StringRef Current = PP.getLangOpts().CurrentModule;
1487     if (ModuleName.front().first->getName() != Current) {
1488       PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1489         << ModuleName.front().first << (ModuleName.size() > 1)
1490         << Current.empty() << Current;
1491       return;
1492     }
1493
1494     // Find the module we're entering. We require that a module map for it
1495     // be loaded or implicitly loadable.
1496     // FIXME: We could create the submodule here. We'd need to know whether
1497     // it's supposed to be explicit, but not much else.
1498     Module *M = PP.getHeaderSearchInfo().lookupModule(Current);
1499     if (!M) {
1500       PP.Diag(ModuleName.front().second,
1501               diag::err_pp_module_begin_no_module_map) << Current;
1502       return;
1503     }
1504     for (unsigned I = 1; I != ModuleName.size(); ++I) {
1505       auto *NewM = M->findSubmodule(ModuleName[I].first->getName());
1506       if (!NewM) {
1507         PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1508           << M->getFullModuleName() << ModuleName[I].first;
1509         return;
1510       }
1511       M = NewM;
1512     }
1513
1514     // If the module isn't available, it doesn't make sense to enter it.
1515     if (Preprocessor::checkModuleIsAvailable(
1516             PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {
1517       PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1518         << M->getTopLevelModuleName();
1519       return;
1520     }
1521
1522     // Enter the scope of the submodule.
1523     PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1524     PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1525                             tok::annot_module_begin, M);
1526   }
1527 };
1528
1529 /// Handle the clang \#pragma module end extension.
1530 struct PragmaModuleEndHandler : public PragmaHandler {
1531   PragmaModuleEndHandler() : PragmaHandler("end") {}
1532
1533   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1534                     Token &Tok) override {
1535     SourceLocation Loc = Tok.getLocation();
1536
1537     PP.LexUnexpandedToken(Tok);
1538     if (Tok.isNot(tok::eod))
1539       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1540
1541     Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1542     if (M)
1543       PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1544     else
1545       PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1546   }
1547 };
1548
1549 /// Handle the clang \#pragma module build extension.
1550 struct PragmaModuleBuildHandler : public PragmaHandler {
1551   PragmaModuleBuildHandler() : PragmaHandler("build") {}
1552
1553   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1554                     Token &Tok) override {
1555     PP.HandlePragmaModuleBuild(Tok);
1556   }
1557 };
1558
1559 /// Handle the clang \#pragma module load extension.
1560 struct PragmaModuleLoadHandler : public PragmaHandler {
1561   PragmaModuleLoadHandler() : PragmaHandler("load") {}
1562
1563   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1564                     Token &Tok) override {
1565     SourceLocation Loc = Tok.getLocation();
1566
1567     // Read the module name.
1568     llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1569         ModuleName;
1570     if (LexModuleName(PP, Tok, ModuleName))
1571       return;
1572
1573     if (Tok.isNot(tok::eod))
1574       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1575
1576     // Load the module, don't make it visible.
1577     PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1578                                     /*IsIncludeDirective=*/false);
1579   }
1580 };
1581
1582 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1583 /// macro on the top of the stack.
1584 struct PragmaPushMacroHandler : public PragmaHandler {
1585   PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1586
1587   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1588                     Token &PushMacroTok) override {
1589     PP.HandlePragmaPushMacro(PushMacroTok);
1590   }
1591 };
1592
1593 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1594 /// macro to the value on the top of the stack.
1595 struct PragmaPopMacroHandler : public PragmaHandler {
1596   PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1597
1598   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1599                     Token &PopMacroTok) override {
1600     PP.HandlePragmaPopMacro(PopMacroTok);
1601   }
1602 };
1603
1604 // Pragma STDC implementations.
1605
1606 /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
1607 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
1608   PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}
1609
1610   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1611                     Token &Tok) override {
1612     tok::OnOffSwitch OOS;
1613     if (PP.LexOnOffSwitch(OOS))
1614      return;
1615     if (OOS == tok::OOS_ON)
1616       PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
1617   }
1618 };
1619
1620 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
1621 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
1622   PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {}
1623
1624   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1625                     Token &Tok) override {
1626     tok::OnOffSwitch OOS;
1627     PP.LexOnOffSwitch(OOS);
1628   }
1629 };
1630
1631 /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
1632 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
1633   PragmaSTDC_UnknownHandler() = default;
1634
1635   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1636                     Token &UnknownTok) override {
1637     // C99 6.10.6p2, unknown forms are not allowed.
1638     PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
1639   }
1640 };
1641
1642 /// PragmaARCCFCodeAuditedHandler -
1643 ///   \#pragma clang arc_cf_code_audited begin/end
1644 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1645   PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1646
1647   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1648                     Token &NameTok) override {
1649     SourceLocation Loc = NameTok.getLocation();
1650     bool IsBegin;
1651
1652     Token Tok;
1653
1654     // Lex the 'begin' or 'end'.
1655     PP.LexUnexpandedToken(Tok);
1656     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1657     if (BeginEnd && BeginEnd->isStr("begin")) {
1658       IsBegin = true;
1659     } else if (BeginEnd && BeginEnd->isStr("end")) {
1660       IsBegin = false;
1661     } else {
1662       PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1663       return;
1664     }
1665
1666     // Verify that this is followed by EOD.
1667     PP.LexUnexpandedToken(Tok);
1668     if (Tok.isNot(tok::eod))
1669       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1670
1671     // The start location of the active audit.
1672     SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc();
1673
1674     // The start location we want after processing this.
1675     SourceLocation NewLoc;
1676
1677     if (IsBegin) {
1678       // Complain about attempts to re-enter an audit.
1679       if (BeginLoc.isValid()) {
1680         PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1681         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1682       }
1683       NewLoc = Loc;
1684     } else {
1685       // Complain about attempts to leave an audit that doesn't exist.
1686       if (!BeginLoc.isValid()) {
1687         PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1688         return;
1689       }
1690       NewLoc = SourceLocation();
1691     }
1692
1693     PP.setPragmaARCCFCodeAuditedLoc(NewLoc);
1694   }
1695 };
1696
1697 /// PragmaAssumeNonNullHandler -
1698 ///   \#pragma clang assume_nonnull begin/end
1699 struct PragmaAssumeNonNullHandler : public PragmaHandler {
1700   PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1701
1702   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1703                     Token &NameTok) override {
1704     SourceLocation Loc = NameTok.getLocation();
1705     bool IsBegin;
1706
1707     Token Tok;
1708
1709     // Lex the 'begin' or 'end'.
1710     PP.LexUnexpandedToken(Tok);
1711     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1712     if (BeginEnd && BeginEnd->isStr("begin")) {
1713       IsBegin = true;
1714     } else if (BeginEnd && BeginEnd->isStr("end")) {
1715       IsBegin = false;
1716     } else {
1717       PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1718       return;
1719     }
1720
1721     // Verify that this is followed by EOD.
1722     PP.LexUnexpandedToken(Tok);
1723     if (Tok.isNot(tok::eod))
1724       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1725
1726     // The start location of the active audit.
1727     SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1728
1729     // The start location we want after processing this.
1730     SourceLocation NewLoc;
1731     PPCallbacks *Callbacks = PP.getPPCallbacks();
1732
1733     if (IsBegin) {
1734       // Complain about attempts to re-enter an audit.
1735       if (BeginLoc.isValid()) {
1736         PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1737         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1738       }
1739       NewLoc = Loc;
1740       if (Callbacks)
1741         Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1742     } else {
1743       // Complain about attempts to leave an audit that doesn't exist.
1744       if (!BeginLoc.isValid()) {
1745         PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1746         return;
1747       }
1748       NewLoc = SourceLocation();
1749       if (Callbacks)
1750         Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1751     }
1752
1753     PP.setPragmaAssumeNonNullLoc(NewLoc);
1754   }
1755 };
1756
1757 /// \brief Handle "\#pragma region [...]"
1758 ///
1759 /// The syntax is
1760 /// \code
1761 ///   #pragma region [optional name]
1762 ///   #pragma endregion [optional comment]
1763 /// \endcode
1764 ///
1765 /// \note This is
1766 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1767 /// pragma, just skipped by compiler.
1768 struct PragmaRegionHandler : public PragmaHandler {
1769   PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1770
1771   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1772                     Token &NameTok) override {
1773     // #pragma region: endregion matches can be verified
1774     // __pragma(region): no sense, but ignored by msvc
1775     // _Pragma is not valid for MSVC, but there isn't any point
1776     // to handle a _Pragma differently.
1777   }
1778 };
1779
1780 } // namespace
1781
1782 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1783 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
1784 void Preprocessor::RegisterBuiltinPragmas() {
1785   AddPragmaHandler(new PragmaOnceHandler());
1786   AddPragmaHandler(new PragmaMarkHandler());
1787   AddPragmaHandler(new PragmaPushMacroHandler());
1788   AddPragmaHandler(new PragmaPopMacroHandler());
1789   AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1790
1791   // #pragma GCC ...
1792   AddPragmaHandler("GCC", new PragmaPoisonHandler());
1793   AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1794   AddPragmaHandler("GCC", new PragmaDependencyHandler());
1795   AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1796   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1797                                                    "GCC"));
1798   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1799                                                    "GCC"));
1800   // #pragma clang ...
1801   AddPragmaHandler("clang", new PragmaPoisonHandler());
1802   AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1803   AddPragmaHandler("clang", new PragmaDebugHandler());
1804   AddPragmaHandler("clang", new PragmaDependencyHandler());
1805   AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
1806   AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
1807   AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
1808
1809   // #pragma clang module ...
1810   auto *ModuleHandler = new PragmaNamespace("module");
1811   AddPragmaHandler("clang", ModuleHandler);
1812   ModuleHandler->AddPragma(new PragmaModuleImportHandler());
1813   ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
1814   ModuleHandler->AddPragma(new PragmaModuleEndHandler());
1815   ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
1816   ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
1817
1818   AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler());
1819   AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler());
1820   AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());
1821
1822   // MS extensions.
1823   if (LangOpts.MicrosoftExt) {
1824     AddPragmaHandler(new PragmaWarningHandler());
1825     AddPragmaHandler(new PragmaIncludeAliasHandler());
1826     AddPragmaHandler(new PragmaRegionHandler("region"));
1827     AddPragmaHandler(new PragmaRegionHandler("endregion"));
1828   }
1829
1830   // Pragmas added by plugins
1831   for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
1832                                        ie = PragmaHandlerRegistry::end();
1833        it != ie; ++it) {
1834     AddPragmaHandler(it->instantiate().release());
1835   }
1836 }
1837
1838 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
1839 /// warn about those pragmas being unknown.
1840 void Preprocessor::IgnorePragmas() {
1841   AddPragmaHandler(new EmptyPragmaHandler());
1842   // Also ignore all pragmas in all namespaces created
1843   // in Preprocessor::RegisterBuiltinPragmas().
1844   AddPragmaHandler("GCC", new EmptyPragmaHandler());
1845   AddPragmaHandler("clang", new EmptyPragmaHandler());
1846   if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) {
1847     // Preprocessor::RegisterBuiltinPragmas() already registers
1848     // PragmaSTDC_UnknownHandler as the empty handler, so remove it first,
1849     // otherwise there will be an assert about a duplicate handler.
1850     PragmaNamespace *STDCNamespace = NS->getIfNamespace();
1851     assert(STDCNamespace &&
1852            "Invalid namespace, registered as a regular pragma handler!");
1853     if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) {
1854       RemovePragmaHandler("STDC", Existing);
1855       delete Existing;
1856     }
1857   }
1858   AddPragmaHandler("STDC", new EmptyPragmaHandler());
1859 }