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

   1 //===--- Preprocess.cpp - C Language Family Preprocessor Implementation ---===//
   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 Preprocessor interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 //
  14 // Options to support:
  15 //   -H       - Print the name of each header file used.
  16 //   -d[DNI] - Dump various things.
  17 //   -fworking-directory - #line's with preprocessor's working dir.
  18 //   -fpreprocessed
  19 //   -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD
  20 //   -W*
  21 //   -w
  22 //
  23 // Messages to emit:
  24 //   "Multiple include guards may be useful for:\n"
  25 //
  26 //===----------------------------------------------------------------------===//
  27
  28 #include "clang/Lex/Preprocessor.h"
  29 #include "clang/Basic/FileManager.h"
  30 #include "clang/Basic/FileSystemStatCache.h"
  31 #include "clang/Basic/SourceManager.h"
  32 #include "clang/Basic/TargetInfo.h"
  33 #include "clang/Lex/CodeCompletionHandler.h"
  34 #include "clang/Lex/ExternalPreprocessorSource.h"
  35 #include "clang/Lex/HeaderSearch.h"
  36 #include "clang/Lex/LexDiagnostic.h"
  37 #include "clang/Lex/LiteralSupport.h"
  38 #include "clang/Lex/MacroArgs.h"
  39 #include "clang/Lex/MacroInfo.h"
  40 #include "clang/Lex/ModuleLoader.h"
  41 #include "clang/Lex/PTHManager.h"
  42 #include "clang/Lex/Pragma.h"
  43 #include "clang/Lex/PreprocessingRecord.h"
  44 #include "clang/Lex/PreprocessorOptions.h"
  45 #include "clang/Lex/ScratchBuffer.h"
  46 #include "llvm/ADT/APInt.h"
  47 #include "llvm/ADT/DenseMap.h"
  48 #include "llvm/ADT/SmallString.h"
  49 #include "llvm/ADT/SmallVector.h"
  50 #include "llvm/ADT/STLExtras.h"
  51 #include "llvm/ADT/StringRef.h"
  52 #include "llvm/ADT/StringSwitch.h"
  53 #include "llvm/Support/Capacity.h"
  54 #include "llvm/Support/ErrorHandling.h"
  55 #include "llvm/Support/MemoryBuffer.h"
  56 #include "llvm/Support/raw_ostream.h"
  57 #include <algorithm>
  58 #include <cassert>
  59 #include <memory>
  60 #include <string>
  61 #include <utility>
  62 #include <vector>
  63
  64 using namespace clang;
  65
  66 LLVM_INSTANTIATE_REGISTRY(PragmaHandlerRegistry)
  67
  68 //===----------------------------------------------------------------------===//
  69 ExternalPreprocessorSource::~ExternalPreprocessorSource() { }
  70
  71 Preprocessor::Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
  72                            DiagnosticsEngine &diags, LangOptions &opts,
  73                            SourceManager &SM, MemoryBufferCache &PCMCache,
  74                            HeaderSearch &Headers, ModuleLoader &TheModuleLoader,
  75                            IdentifierInfoLookup *IILookup, bool OwnsHeaders,
  76                            TranslationUnitKind TUKind)
  77     : PPOpts(std::move(PPOpts)), Diags(&diags), LangOpts(opts), Target(nullptr),
  78       AuxTarget(nullptr), FileMgr(Headers.getFileMgr()), SourceMgr(SM),
  79       PCMCache(PCMCache), ScratchBuf(new ScratchBuffer(SourceMgr)),
  80       HeaderInfo(Headers), TheModuleLoader(TheModuleLoader),
  81       ExternalSource(nullptr), Identifiers(opts, IILookup),
  82       PragmaHandlers(new PragmaNamespace(StringRef())),
  83       IncrementalProcessing(false), TUKind(TUKind), CodeComplete(nullptr),
  84       CodeCompletionFile(nullptr), CodeCompletionOffset(0),
  85       LastTokenWasAt(false), ModuleImportExpectsIdentifier(false),
  86       CodeCompletionReached(false), CodeCompletionII(nullptr),
  87       MainFileDir(nullptr), SkipMainFilePreamble(0, true), CurPPLexer(nullptr),
  88       CurDirLookup(nullptr), CurLexerKind(CLK_Lexer),
  89       CurLexerSubmodule(nullptr), Callbacks(nullptr),
  90       CurSubmoduleState(&NullSubmoduleState), MacroArgCache(nullptr),
  91       Record(nullptr), MIChainHead(nullptr) {
  92   OwnsHeaderSearch = OwnsHeaders;
  93
  94   CounterValue = 0; // __COUNTER__ starts at 0.
  95
  96   // Clear stats.
  97   NumDirectives = NumDefined = NumUndefined = NumPragma = 0;
  98   NumIf = NumElse = NumEndif = 0;
  99   NumEnteredSourceFiles = 0;
 100   NumMacroExpanded = NumFnMacroExpanded = NumBuiltinMacroExpanded = 0;
 101   NumFastMacroExpanded = NumTokenPaste = NumFastTokenPaste = 0;
 102   MaxIncludeStackDepth = 0;
 103   NumSkipped = 0;
 104
 105   // Default to discarding comments.
 106   KeepComments = false;
 107   KeepMacroComments = false;
 108   SuppressIncludeNotFoundError = false;
 109
 110   // Macro expansion is enabled.
 111   DisableMacroExpansion = false;
 112   MacroExpansionInDirectivesOverride = false;
 113   InMacroArgs = false;
 114   InMacroArgPreExpansion = false;
 115   NumCachedTokenLexers = 0;
 116   PragmasEnabled = true;
 117   ParsingIfOrElifDirective = false;
 118   PreprocessedOutput = false;
 119
 120   CachedLexPos = 0;
 121
 122   // We haven't read anything from the external source.
 123   ReadMacrosFromExternalSource = false;
 124
 125   // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
 126   // This gets unpoisoned where it is allowed.
 127   (Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned();
 128   SetPoisonReason(Ident__VA_ARGS__,diag::ext_pp_bad_vaargs_use);
 129
 130   // Initialize the pragma handlers.
 131   RegisterBuiltinPragmas();
 132
 133   // Initialize builtin macros like __LINE__ and friends.
 134   RegisterBuiltinMacros();
 135
 136   if(LangOpts.Borland) {
 137     Ident__exception_info        = getIdentifierInfo("_exception_info");
 138     Ident___exception_info       = getIdentifierInfo("__exception_info");
 139     Ident_GetExceptionInfo       = getIdentifierInfo("GetExceptionInformation");
 140     Ident__exception_code        = getIdentifierInfo("_exception_code");
 141     Ident___exception_code       = getIdentifierInfo("__exception_code");
 142     Ident_GetExceptionCode       = getIdentifierInfo("GetExceptionCode");
 143     Ident__abnormal_termination  = getIdentifierInfo("_abnormal_termination");
 144     Ident___abnormal_termination = getIdentifierInfo("__abnormal_termination");
 145     Ident_AbnormalTermination    = getIdentifierInfo("AbnormalTermination");
 146   } else {
 147     Ident__exception_info = Ident__exception_code = nullptr;
 148     Ident__abnormal_termination = Ident___exception_info = nullptr;
 149     Ident___exception_code = Ident___abnormal_termination = nullptr;
 150     Ident_GetExceptionInfo = Ident_GetExceptionCode = nullptr;
 151     Ident_AbnormalTermination = nullptr;
 152   }
 153
 154   if (this->PPOpts->GeneratePreamble)
 155     PreambleConditionalStack.startRecording();
 156 }
 157
 158 Preprocessor::~Preprocessor() {
 159   assert(BacktrackPositions.empty() && "EnableBacktrack/Backtrack imbalance!");
 160
 161   IncludeMacroStack.clear();
 162
 163   // Destroy any macro definitions.
 164   while (MacroInfoChain *I = MIChainHead) {
 165     MIChainHead = I->Next;
 166     I->~MacroInfoChain();
 167   }
 168
 169   // Free any cached macro expanders.
 170   // This populates MacroArgCache, so all TokenLexers need to be destroyed
 171   // before the code below that frees up the MacroArgCache list.
 172   std::fill(TokenLexerCache, TokenLexerCache + NumCachedTokenLexers, nullptr);
 173   CurTokenLexer.reset();
 174
 175   // Free any cached MacroArgs.
 176   for (MacroArgs *ArgList = MacroArgCache; ArgList;)
 177     ArgList = ArgList->deallocate();
 178
 179   // Delete the header search info, if we own it.
 180   if (OwnsHeaderSearch)
 181     delete &HeaderInfo;
 182 }
 183
 184 void Preprocessor::Initialize(const TargetInfo &Target,
 185                               const TargetInfo *AuxTarget) {
 186   assert((!this->Target || this->Target == &Target) &&
 187          "Invalid override of target information");
 188   this->Target = &Target;
 189
 190   assert((!this->AuxTarget || this->AuxTarget == AuxTarget) &&
 191          "Invalid override of aux target information.");
 192   this->AuxTarget = AuxTarget;
 193
 194   // Initialize information about built-ins.
 195   BuiltinInfo.InitializeTarget(Target, AuxTarget);
 196   HeaderInfo.setTarget(Target);
 197 }
 198
 199 void Preprocessor::InitializeForModelFile() {
 200   NumEnteredSourceFiles = 0;
 201
 202   // Reset pragmas
 203   PragmaHandlersBackup = std::move(PragmaHandlers);
 204   PragmaHandlers = llvm::make_unique<PragmaNamespace>(StringRef());
 205   RegisterBuiltinPragmas();
 206
 207   // Reset PredefinesFileID
 208   PredefinesFileID = FileID();
 209 }
 210
 211 void Preprocessor::FinalizeForModelFile() {
 212   NumEnteredSourceFiles = 1;
 213
 214   PragmaHandlers = std::move(PragmaHandlersBackup);
 215 }
 216
 217 void Preprocessor::setPTHManager(PTHManager* pm) {
 218   PTH.reset(pm);
 219   FileMgr.addStatCache(PTH->createStatCache());
 220 }
 221
 222 void Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const {
 223   llvm::errs() << tok::getTokenName(Tok.getKind()) << " '"
 224                << getSpelling(Tok) << "'";
 225
 226   if (!DumpFlags) return;
 227
 228   llvm::errs() << "\t";
 229   if (Tok.isAtStartOfLine())
 230     llvm::errs() << " [StartOfLine]";
 231   if (Tok.hasLeadingSpace())
 232     llvm::errs() << " [LeadingSpace]";
 233   if (Tok.isExpandDisabled())
 234     llvm::errs() << " [ExpandDisabled]";
 235   if (Tok.needsCleaning()) {
 236     const char *Start = SourceMgr.getCharacterData(Tok.getLocation());
 237     llvm::errs() << " [UnClean='" << StringRef(Start, Tok.getLength())
 238                  << "']";
 239   }
 240
 241   llvm::errs() << "\tLoc=<";
 242   DumpLocation(Tok.getLocation());
 243   llvm::errs() << ">";
 244 }
 245
 246 void Preprocessor::DumpLocation(SourceLocation Loc) const {
 247   Loc.dump(SourceMgr);
 248 }
 249
 250 void Preprocessor::DumpMacro(const MacroInfo &MI) const {
 251   llvm::errs() << "MACRO: ";
 252   for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) {
 253     DumpToken(MI.getReplacementToken(i));
 254     llvm::errs() << "  ";
 255   }
 256   llvm::errs() << "\n";
 257 }
 258
 259 void Preprocessor::PrintStats() {
 260   llvm::errs() << "\n*** Preprocessor Stats:\n";
 261   llvm::errs() << NumDirectives << " directives found:\n";
 262   llvm::errs() << "  " << NumDefined << " #define.\n";
 263   llvm::errs() << "  " << NumUndefined << " #undef.\n";
 264   llvm::errs() << "  #include/#include_next/#import:\n";
 265   llvm::errs() << "    " << NumEnteredSourceFiles << " source files entered.\n";
 266   llvm::errs() << "    " << MaxIncludeStackDepth << " max include stack depth\n";
 267   llvm::errs() << "  " << NumIf << " #if/#ifndef/#ifdef.\n";
 268   llvm::errs() << "  " << NumElse << " #else/#elif.\n";
 269   llvm::errs() << "  " << NumEndif << " #endif.\n";
 270   llvm::errs() << "  " << NumPragma << " #pragma.\n";
 271   llvm::errs() << NumSkipped << " #if/#ifndef#ifdef regions skipped\n";
 272
 273   llvm::errs() << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
 274              << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
 275              << NumFastMacroExpanded << " on the fast path.\n";
 276   llvm::errs() << (NumFastTokenPaste+NumTokenPaste)
 277              << " token paste (##) operations performed, "
 278              << NumFastTokenPaste << " on the fast path.\n";
 279
 280   llvm::errs() << "\nPreprocessor Memory: " << getTotalMemory() << "B total";
 281
 282   llvm::errs() << "\n  BumpPtr: " << BP.getTotalMemory();
 283   llvm::errs() << "\n  Macro Expanded Tokens: "
 284                << llvm::capacity_in_bytes(MacroExpandedTokens);
 285   llvm::errs() << "\n  Predefines Buffer: " << Predefines.capacity();
 286   // FIXME: List information for all submodules.
 287   llvm::errs() << "\n  Macros: "
 288                << llvm::capacity_in_bytes(CurSubmoduleState->Macros);
 289   llvm::errs() << "\n  #pragma push_macro Info: "
 290                << llvm::capacity_in_bytes(PragmaPushMacroInfo);
 291   llvm::errs() << "\n  Poison Reasons: "
 292                << llvm::capacity_in_bytes(PoisonReasons);
 293   llvm::errs() << "\n  Comment Handlers: "
 294                << llvm::capacity_in_bytes(CommentHandlers) << "\n";
 295 }
 296
 297 Preprocessor::macro_iterator
 298 Preprocessor::macro_begin(bool IncludeExternalMacros) const {
 299   if (IncludeExternalMacros && ExternalSource &&
 300       !ReadMacrosFromExternalSource) {
 301     ReadMacrosFromExternalSource = true;
 302     ExternalSource->ReadDefinedMacros();
 303   }
 304
 305   // Make sure we cover all macros in visible modules.
 306   for (const ModuleMacro &Macro : ModuleMacros)
 307     CurSubmoduleState->Macros.insert(std::make_pair(Macro.II, MacroState()));
 308
 309   return CurSubmoduleState->Macros.begin();
 310 }
 311
 312 size_t Preprocessor::getTotalMemory() const {
 313   return BP.getTotalMemory()
 314     + llvm::capacity_in_bytes(MacroExpandedTokens)
 315     + Predefines.capacity() /* Predefines buffer. */
 316     // FIXME: Include sizes from all submodules, and include MacroInfo sizes,
 317     // and ModuleMacros.
 318     + llvm::capacity_in_bytes(CurSubmoduleState->Macros)
 319     + llvm::capacity_in_bytes(PragmaPushMacroInfo)
 320     + llvm::capacity_in_bytes(PoisonReasons)
 321     + llvm::capacity_in_bytes(CommentHandlers);
 322 }
 323
 324 Preprocessor::macro_iterator
 325 Preprocessor::macro_end(bool IncludeExternalMacros) const {
 326   if (IncludeExternalMacros && ExternalSource &&
 327       !ReadMacrosFromExternalSource) {
 328     ReadMacrosFromExternalSource = true;
 329     ExternalSource->ReadDefinedMacros();
 330   }
 331
 332   return CurSubmoduleState->Macros.end();
 333 }
 334
 335 /// \brief Compares macro tokens with a specified token value sequence.
 336 static bool MacroDefinitionEquals(const MacroInfo *MI,
 337                                   ArrayRef<TokenValue> Tokens) {
 338   return Tokens.size() == MI->getNumTokens() &&
 339       std::equal(Tokens.begin(), Tokens.end(), MI->tokens_begin());
 340 }
 341
 342 StringRef Preprocessor::getLastMacroWithSpelling(
 343                                     SourceLocation Loc,
 344                                     ArrayRef<TokenValue> Tokens) const {
 345   SourceLocation BestLocation;
 346   StringRef BestSpelling;
 347   for (Preprocessor::macro_iterator I = macro_begin(), E = macro_end();
 348        I != E; ++I) {
 349     const MacroDirective::DefInfo
 350       Def = I->second.findDirectiveAtLoc(Loc, SourceMgr);
 351     if (!Def || !Def.getMacroInfo())
 352       continue;
 353     if (!Def.getMacroInfo()->isObjectLike())
 354       continue;
 355     if (!MacroDefinitionEquals(Def.getMacroInfo(), Tokens))
 356       continue;
 357     SourceLocation Location = Def.getLocation();
 358     // Choose the macro defined latest.
 359     if (BestLocation.isInvalid() ||
 360         (Location.isValid() &&
 361          SourceMgr.isBeforeInTranslationUnit(BestLocation, Location))) {
 362       BestLocation = Location;
 363       BestSpelling = I->first->getName();
 364     }
 365   }
 366   return BestSpelling;
 367 }
 368
 369 void Preprocessor::recomputeCurLexerKind() {
 370   if (CurLexer)
 371     CurLexerKind = CLK_Lexer;
 372   else if (CurPTHLexer)
 373     CurLexerKind = CLK_PTHLexer;
 374   else if (CurTokenLexer)
 375     CurLexerKind = CLK_TokenLexer;
 376   else
 377     CurLexerKind = CLK_CachingLexer;
 378 }
 379
 380 bool Preprocessor::SetCodeCompletionPoint(const FileEntry *File,
 381                                           unsigned CompleteLine,
 382                                           unsigned CompleteColumn) {
 383   assert(File);
 384   assert(CompleteLine && CompleteColumn && "Starts from 1:1");
 385   assert(!CodeCompletionFile && "Already set");
 386
 387   using llvm::MemoryBuffer;
 388
 389   // Load the actual file's contents.
 390   bool Invalid = false;
 391   const MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File, &Invalid);
 392   if (Invalid)
 393     return true;
 394
 395   // Find the byte position of the truncation point.
 396   const char *Position = Buffer->getBufferStart();
 397   for (unsigned Line = 1; Line < CompleteLine; ++Line) {
 398     for (; *Position; ++Position) {
 399       if (*Position != '\r' && *Position != '\n')
 400         continue;
 401
 402       // Eat \r\n or \n\r as a single line.
 403       if ((Position[1] == '\r' || Position[1] == '\n') &&
 404           Position[0] != Position[1])
 405         ++Position;
 406       ++Position;
 407       break;
 408     }
 409   }
 410
 411   Position += CompleteColumn - 1;
 412
 413   // If pointing inside the preamble, adjust the position at the beginning of
 414   // the file after the preamble.
 415   if (SkipMainFilePreamble.first &&
 416       SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()) == File) {
 417     if (Position - Buffer->getBufferStart() < SkipMainFilePreamble.first)
 418       Position = Buffer->getBufferStart() + SkipMainFilePreamble.first;
 419   }
 420
 421   if (Position > Buffer->getBufferEnd())
 422     Position = Buffer->getBufferEnd();
 423
 424   CodeCompletionFile = File;
 425   CodeCompletionOffset = Position - Buffer->getBufferStart();
 426
 427   std::unique_ptr<MemoryBuffer> NewBuffer =
 428       MemoryBuffer::getNewUninitMemBuffer(Buffer->getBufferSize() + 1,
 429                                           Buffer->getBufferIdentifier());
 430   char *NewBuf = const_cast<char*>(NewBuffer->getBufferStart());
 431   char *NewPos = std::copy(Buffer->getBufferStart(), Position, NewBuf);
 432   *NewPos = '\0';
 433   std::copy(Position, Buffer->getBufferEnd(), NewPos+1);
 434   SourceMgr.overrideFileContents(File, std::move(NewBuffer));
 435
 436   return false;
 437 }
 438
 439 void Preprocessor::CodeCompleteNaturalLanguage() {
 440   if (CodeComplete)
 441     CodeComplete->CodeCompleteNaturalLanguage();
 442   setCodeCompletionReached();
 443 }
 444
 445 /// getSpelling - This method is used to get the spelling of a token into a
 446 /// SmallVector. Note that the returned StringRef may not point to the
 447 /// supplied buffer if a copy can be avoided.
 448 StringRef Preprocessor::getSpelling(const Token &Tok,
 449                                           SmallVectorImpl<char> &Buffer,
 450                                           bool *Invalid) const {
 451   // NOTE: this has to be checked *before* testing for an IdentifierInfo.
 452   if (Tok.isNot(tok::raw_identifier) && !Tok.hasUCN()) {
 453     // Try the fast path.
 454     if (const IdentifierInfo *II = Tok.getIdentifierInfo())
 455       return II->getName();
 456   }
 457
 458   // Resize the buffer if we need to copy into it.
 459   if (Tok.needsCleaning())
 460     Buffer.resize(Tok.getLength());
 461
 462   const char *Ptr = Buffer.data();
 463   unsigned Len = getSpelling(Tok, Ptr, Invalid);
 464   return StringRef(Ptr, Len);
 465 }
 466
 467 /// CreateString - Plop the specified string into a scratch buffer and return a
 468 /// location for it.  If specified, the source location provides a source
 469 /// location for the token.
 470 void Preprocessor::CreateString(StringRef Str, Token &Tok,
 471                                 SourceLocation ExpansionLocStart,
 472                                 SourceLocation ExpansionLocEnd) {
 473   Tok.setLength(Str.size());
 474
 475   const char *DestPtr;
 476   SourceLocation Loc = ScratchBuf->getToken(Str.data(), Str.size(), DestPtr);
 477
 478   if (ExpansionLocStart.isValid())
 479     Loc = SourceMgr.createExpansionLoc(Loc, ExpansionLocStart,
 480                                        ExpansionLocEnd, Str.size());
 481   Tok.setLocation(Loc);
 482
 483   // If this is a raw identifier or a literal token, set the pointer data.
 484   if (Tok.is(tok::raw_identifier))
 485     Tok.setRawIdentifierData(DestPtr);
 486   else if (Tok.isLiteral())
 487     Tok.setLiteralData(DestPtr);
 488 }
 489
 490 Module *Preprocessor::getCurrentModule() {
 491   if (!getLangOpts().isCompilingModule())
 492     return nullptr;
 493
 494   return getHeaderSearchInfo().lookupModule(getLangOpts().CurrentModule);
 495 }
 496
 497 //===----------------------------------------------------------------------===//
 498 // Preprocessor Initialization Methods
 499 //===----------------------------------------------------------------------===//
 500
 501 /// EnterMainSourceFile - Enter the specified FileID as the main source file,
 502 /// which implicitly adds the builtin defines etc.
 503 void Preprocessor::EnterMainSourceFile() {
 504   // We do not allow the preprocessor to reenter the main file.  Doing so will
 505   // cause FileID's to accumulate information from both runs (e.g. #line
 506   // information) and predefined macros aren't guaranteed to be set properly.
 507   assert(NumEnteredSourceFiles == 0 && "Cannot reenter the main file!");
 508   FileID MainFileID = SourceMgr.getMainFileID();
 509
 510   // If MainFileID is loaded it means we loaded an AST file, no need to enter
 511   // a main file.
 512   if (!SourceMgr.isLoadedFileID(MainFileID)) {
 513     // Enter the main file source buffer.
 514     EnterSourceFile(MainFileID, nullptr, SourceLocation());
 515
 516     // If we've been asked to skip bytes in the main file (e.g., as part of a
 517     // precompiled preamble), do so now.
 518     if (SkipMainFilePreamble.first > 0)
 519       CurLexer->SkipBytes(SkipMainFilePreamble.first,
 520                           SkipMainFilePreamble.second);
 521
 522     // Tell the header info that the main file was entered.  If the file is later
 523     // #imported, it won't be re-entered.
 524     if (const FileEntry *FE = SourceMgr.getFileEntryForID(MainFileID))
 525       HeaderInfo.IncrementIncludeCount(FE);
 526   }
 527
 528   // Preprocess Predefines to populate the initial preprocessor state.
 529   std::unique_ptr<llvm::MemoryBuffer> SB =
 530     llvm::MemoryBuffer::getMemBufferCopy(Predefines, "<built-in>");
 531   assert(SB && "Cannot create predefined source buffer");
 532   FileID FID = SourceMgr.createFileID(std::move(SB));
 533   assert(FID.isValid() && "Could not create FileID for predefines?");
 534   setPredefinesFileID(FID);
 535
 536   // Start parsing the predefines.
 537   EnterSourceFile(FID, nullptr, SourceLocation());
 538
 539   // Restore the conditional stack from the preamble, if there is one.
 540   if (PreambleConditionalStack.isReplaying()) {
 541     CurPPLexer->setConditionalLevels(PreambleConditionalStack.getStack());
 542     PreambleConditionalStack.doneReplaying();
 543   }
 544 }
 545
 546 void Preprocessor::EndSourceFile() {
 547   // Notify the client that we reached the end of the source file.
 548   if (Callbacks)
 549     Callbacks->EndOfMainFile();
 550 }
 551
 552 //===----------------------------------------------------------------------===//
 553 // Lexer Event Handling.
 554 //===----------------------------------------------------------------------===//
 555
 556 /// LookUpIdentifierInfo - Given a tok::raw_identifier token, look up the
 557 /// identifier information for the token and install it into the token,
 558 /// updating the token kind accordingly.
 559 IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier) const {
 560   assert(!Identifier.getRawIdentifier().empty() && "No raw identifier data!");
 561
 562   // Look up this token, see if it is a macro, or if it is a language keyword.
 563   IdentifierInfo *II;
 564   if (!Identifier.needsCleaning() && !Identifier.hasUCN()) {
 565     // No cleaning needed, just use the characters from the lexed buffer.
 566     II = getIdentifierInfo(Identifier.getRawIdentifier());
 567   } else {
 568     // Cleaning needed, alloca a buffer, clean into it, then use the buffer.
 569     SmallString<64> IdentifierBuffer;
 570     StringRef CleanedStr = getSpelling(Identifier, IdentifierBuffer);
 571
 572     if (Identifier.hasUCN()) {
 573       SmallString<64> UCNIdentifierBuffer;
 574       expandUCNs(UCNIdentifierBuffer, CleanedStr);
 575       II = getIdentifierInfo(UCNIdentifierBuffer);
 576     } else {
 577       II = getIdentifierInfo(CleanedStr);
 578     }
 579   }
 580
 581   // Update the token info (identifier info and appropriate token kind).
 582   Identifier.setIdentifierInfo(II);
 583   Identifier.setKind(II->getTokenID());
 584
 585   return II;
 586 }
 587
 588 void Preprocessor::SetPoisonReason(IdentifierInfo *II, unsigned DiagID) {
 589   PoisonReasons[II] = DiagID;
 590 }
 591
 592 void Preprocessor::PoisonSEHIdentifiers(bool Poison) {
 593   assert(Ident__exception_code && Ident__exception_info);
 594   assert(Ident___exception_code && Ident___exception_info);
 595   Ident__exception_code->setIsPoisoned(Poison);
 596   Ident___exception_code->setIsPoisoned(Poison);
 597   Ident_GetExceptionCode->setIsPoisoned(Poison);
 598   Ident__exception_info->setIsPoisoned(Poison);
 599   Ident___exception_info->setIsPoisoned(Poison);
 600   Ident_GetExceptionInfo->setIsPoisoned(Poison);
 601   Ident__abnormal_termination->setIsPoisoned(Poison);
 602   Ident___abnormal_termination->setIsPoisoned(Poison);
 603   Ident_AbnormalTermination->setIsPoisoned(Poison);
 604 }
 605
 606 void Preprocessor::HandlePoisonedIdentifier(Token & Identifier) {
 607   assert(Identifier.getIdentifierInfo() &&
 608          "Can't handle identifiers without identifier info!");
 609   llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =
 610     PoisonReasons.find(Identifier.getIdentifierInfo());
 611   if(it == PoisonReasons.end())
 612     Diag(Identifier, diag::err_pp_used_poisoned_id);
 613   else
 614     Diag(Identifier,it->second) << Identifier.getIdentifierInfo();
 615 }
 616
 617 /// \brief Returns a diagnostic message kind for reporting a future keyword as
 618 /// appropriate for the identifier and specified language.
 619 static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
 620                                           const LangOptions &LangOpts) {
 621   assert(II.isFutureCompatKeyword() && "diagnostic should not be needed");
 622
 623   if (LangOpts.CPlusPlus)
 624     return llvm::StringSwitch<diag::kind>(II.getName())
 625 #define CXX11_KEYWORD(NAME, FLAGS)                                             \
 626         .Case(#NAME, diag::warn_cxx11_keyword)
 627 #include "clang/Basic/TokenKinds.def"
 628         ;
 629
 630   llvm_unreachable(
 631       "Keyword not known to come from a newer Standard or proposed Standard");
 632 }
 633
 634 void Preprocessor::updateOutOfDateIdentifier(IdentifierInfo &II) const {
 635   assert(II.isOutOfDate() && "not out of date");
 636   getExternalSource()->updateOutOfDateIdentifier(II);
 637 }
 638
 639 /// HandleIdentifier - This callback is invoked when the lexer reads an
 640 /// identifier.  This callback looks up the identifier in the map and/or
 641 /// potentially macro expands it or turns it into a named token (like 'for').
 642 ///
 643 /// Note that callers of this method are guarded by checking the
 644 /// IdentifierInfo's 'isHandleIdentifierCase' bit.  If this method changes, the
 645 /// IdentifierInfo methods that compute these properties will need to change to
 646 /// match.
 647 bool Preprocessor::HandleIdentifier(Token &Identifier) {
 648   assert(Identifier.getIdentifierInfo() &&
 649          "Can't handle identifiers without identifier info!");
 650
 651   IdentifierInfo &II = *Identifier.getIdentifierInfo();
 652
 653   // If the information about this identifier is out of date, update it from
 654   // the external source.
 655   // We have to treat __VA_ARGS__ in a special way, since it gets
 656   // serialized with isPoisoned = true, but our preprocessor may have
 657   // unpoisoned it if we're defining a C99 macro.
 658   if (II.isOutOfDate()) {
 659     bool CurrentIsPoisoned = false;
 660     if (&II == Ident__VA_ARGS__)
 661       CurrentIsPoisoned = Ident__VA_ARGS__->isPoisoned();
 662
 663     updateOutOfDateIdentifier(II);
 664     Identifier.setKind(II.getTokenID());
 665
 666     if (&II == Ident__VA_ARGS__)
 667       II.setIsPoisoned(CurrentIsPoisoned);
 668   }
 669
 670   // If this identifier was poisoned, and if it was not produced from a macro
 671   // expansion, emit an error.
 672   if (II.isPoisoned() && CurPPLexer) {
 673     HandlePoisonedIdentifier(Identifier);
 674   }
 675
 676   // If this is a macro to be expanded, do it.
 677   if (MacroDefinition MD = getMacroDefinition(&II)) {
 678     auto *MI = MD.getMacroInfo();
 679     assert(MI && "macro definition with no macro info?");
 680     if (!DisableMacroExpansion) {
 681       if (!Identifier.isExpandDisabled() && MI->isEnabled()) {
 682         // C99 6.10.3p10: If the preprocessing token immediately after the
 683         // macro name isn't a '(', this macro should not be expanded.
 684         if (!MI->isFunctionLike() || isNextPPTokenLParen())
 685           return HandleMacroExpandedIdentifier(Identifier, MD);
 686       } else {
 687         // C99 6.10.3.4p2 says that a disabled macro may never again be
 688         // expanded, even if it's in a context where it could be expanded in the
 689         // future.
 690         Identifier.setFlag(Token::DisableExpand);
 691         if (MI->isObjectLike() || isNextPPTokenLParen())
 692           Diag(Identifier, diag::pp_disabled_macro_expansion);
 693       }
 694     }
 695   }
 696
 697   // If this identifier is a keyword in a newer Standard or proposed Standard,
 698   // produce a warning. Don't warn if we're not considering macro expansion,
 699   // since this identifier might be the name of a macro.
 700   // FIXME: This warning is disabled in cases where it shouldn't be, like
 701   //   "#define constexpr constexpr", "int constexpr;"
 702   if (II.isFutureCompatKeyword() && !DisableMacroExpansion) {
 703     Diag(Identifier, getFutureCompatDiagKind(II, getLangOpts()))
 704         << II.getName();
 705     // Don't diagnose this keyword again in this translation unit.
 706     II.setIsFutureCompatKeyword(false);
 707   }
 708
 709   // C++ 2.11p2: If this is an alternative representation of a C++ operator,
 710   // then we act as if it is the actual operator and not the textual
 711   // representation of it.
 712   if (II.isCPlusPlusOperatorKeyword())
 713     Identifier.setIdentifierInfo(nullptr);
 714
 715   // If this is an extension token, diagnose its use.
 716   // We avoid diagnosing tokens that originate from macro definitions.
 717   // FIXME: This warning is disabled in cases where it shouldn't be,
 718   // like "#define TY typeof", "TY(1) x".
 719   if (II.isExtensionToken() && !DisableMacroExpansion)
 720     Diag(Identifier, diag::ext_token_used);
 721
 722   // If this is the 'import' contextual keyword following an '@', note
 723   // that the next token indicates a module name.
 724   //
 725   // Note that we do not treat 'import' as a contextual
 726   // keyword when we're in a caching lexer, because caching lexers only get
 727   // used in contexts where import declarations are disallowed.
 728   //
 729   // Likewise if this is the C++ Modules TS import keyword.
 730   if (((LastTokenWasAt && II.isModulesImport()) ||
 731        Identifier.is(tok::kw_import)) &&
 732       !InMacroArgs && !DisableMacroExpansion &&
 733       (getLangOpts().Modules || getLangOpts().DebuggerSupport) &&
 734       CurLexerKind != CLK_CachingLexer) {
 735     ModuleImportLoc = Identifier.getLocation();
 736     ModuleImportPath.clear();
 737     ModuleImportExpectsIdentifier = true;
 738     CurLexerKind = CLK_LexAfterModuleImport;
 739   }
 740   return true;
 741 }
 742
 743 void Preprocessor::Lex(Token &Result) {
 744   // We loop here until a lex function returns a token; this avoids recursion.
 745   bool ReturnedToken;
 746   do {
 747     switch (CurLexerKind) {
 748     case CLK_Lexer:
 749       ReturnedToken = CurLexer->Lex(Result);
 750       break;
 751     case CLK_PTHLexer:
 752       ReturnedToken = CurPTHLexer->Lex(Result);
 753       break;
 754     case CLK_TokenLexer:
 755       ReturnedToken = CurTokenLexer->Lex(Result);
 756       break;
 757     case CLK_CachingLexer:
 758       CachingLex(Result);
 759       ReturnedToken = true;
 760       break;
 761     case CLK_LexAfterModuleImport:
 762       LexAfterModuleImport(Result);
 763       ReturnedToken = true;
 764       break;
 765     }
 766   } while (!ReturnedToken);
 767
 768   if (Result.is(tok::code_completion))
 769     setCodeCompletionIdentifierInfo(Result.getIdentifierInfo());
 770
 771   LastTokenWasAt = Result.is(tok::at);
 772 }
 773
 774 /// \brief Lex a token following the 'import' contextual keyword.
 775 ///
 776 void Preprocessor::LexAfterModuleImport(Token &Result) {
 777   // Figure out what kind of lexer we actually have.
 778   recomputeCurLexerKind();
 779
 780   // Lex the next token.
 781   Lex(Result);
 782
 783   // The token sequence
 784   //
 785   //   import identifier (. identifier)*
 786   //
 787   // indicates a module import directive. We already saw the 'import'
 788   // contextual keyword, so now we're looking for the identifiers.
 789   if (ModuleImportExpectsIdentifier && Result.getKind() == tok::identifier) {
 790     // We expected to see an identifier here, and we did; continue handling
 791     // identifiers.
 792     ModuleImportPath.push_back(std::make_pair(Result.getIdentifierInfo(),
 793                                               Result.getLocation()));
 794     ModuleImportExpectsIdentifier = false;
 795     CurLexerKind = CLK_LexAfterModuleImport;
 796     return;
 797   }
 798
 799   // If we're expecting a '.' or a ';', and we got a '.', then wait until we
 800   // see the next identifier. (We can also see a '[[' that begins an
 801   // attribute-specifier-seq here under the C++ Modules TS.)
 802   if (!ModuleImportExpectsIdentifier && Result.getKind() == tok::period) {
 803     ModuleImportExpectsIdentifier = true;
 804     CurLexerKind = CLK_LexAfterModuleImport;
 805     return;
 806   }
 807
 808   // If we have a non-empty module path, load the named module.
 809   if (!ModuleImportPath.empty()) {
 810     // Under the Modules TS, the dot is just part of the module name, and not
 811     // a real hierarachy separator. Flatten such module names now.
 812     //
 813     // FIXME: Is this the right level to be performing this transformation?
 814     std::string FlatModuleName;
 815     if (getLangOpts().ModulesTS) {
 816       for (auto &Piece : ModuleImportPath) {
 817         if (!FlatModuleName.empty())
 818           FlatModuleName += ".";
 819         FlatModuleName += Piece.first->getName();
 820       }
 821       SourceLocation FirstPathLoc = ModuleImportPath[0].second;
 822       ModuleImportPath.clear();
 823       ModuleImportPath.push_back(
 824           std::make_pair(getIdentifierInfo(FlatModuleName), FirstPathLoc));
 825     }
 826
 827     Module *Imported = nullptr;
 828     if (getLangOpts().Modules) {
 829       Imported = TheModuleLoader.loadModule(ModuleImportLoc,
 830                                             ModuleImportPath,
 831                                             Module::Hidden,
 832                                             /*IsIncludeDirective=*/false);
 833       if (Imported)
 834         makeModuleVisible(Imported, ModuleImportLoc);
 835     }
 836     if (Callbacks && (getLangOpts().Modules || getLangOpts().DebuggerSupport))
 837       Callbacks->moduleImport(ModuleImportLoc, ModuleImportPath, Imported);
 838   }
 839 }
 840
 841 void Preprocessor::makeModuleVisible(Module *M, SourceLocation Loc) {
 842   CurSubmoduleState->VisibleModules.setVisible(
 843       M, Loc, [](Module *) {},
 844       [&](ArrayRef<Module *> Path, Module *Conflict, StringRef Message) {
 845         // FIXME: Include the path in the diagnostic.
 846         // FIXME: Include the import location for the conflicting module.
 847         Diag(ModuleImportLoc, diag::warn_module_conflict)
 848             << Path[0]->getFullModuleName()
 849             << Conflict->getFullModuleName()
 850             << Message;
 851       });
 852
 853   // Add this module to the imports list of the currently-built submodule.
 854   if (!BuildingSubmoduleStack.empty() && M != BuildingSubmoduleStack.back().M)
 855     BuildingSubmoduleStack.back().M->Imports.insert(M);
 856 }
 857
 858 bool Preprocessor::FinishLexStringLiteral(Token &Result, std::string &String,
 859                                           const char *DiagnosticTag,
 860                                           bool AllowMacroExpansion) {
 861   // We need at least one string literal.
 862   if (Result.isNot(tok::string_literal)) {
 863     Diag(Result, diag::err_expected_string_literal)
 864       << /*Source='in...'*/0 << DiagnosticTag;
 865     return false;
 866   }
 867
 868   // Lex string literal tokens, optionally with macro expansion.
 869   SmallVector<Token, 4> StrToks;
 870   do {
 871     StrToks.push_back(Result);
 872
 873     if (Result.hasUDSuffix())
 874       Diag(Result, diag::err_invalid_string_udl);
 875
 876     if (AllowMacroExpansion)
 877       Lex(Result);
 878     else
 879       LexUnexpandedToken(Result);
 880   } while (Result.is(tok::string_literal));
 881
 882   // Concatenate and parse the strings.
 883   StringLiteralParser Literal(StrToks, *this);
 884   assert(Literal.isAscii() && "Didn't allow wide strings in");
 885
 886   if (Literal.hadError)
 887     return false;
 888
 889   if (Literal.Pascal) {
 890     Diag(StrToks[0].getLocation(), diag::err_expected_string_literal)
 891       << /*Source='in...'*/0 << DiagnosticTag;
 892     return false;
 893   }
 894
 895   String = Literal.GetString();
 896   return true;
 897 }
 898
 899 bool Preprocessor::parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value) {
 900   assert(Tok.is(tok::numeric_constant));
 901   SmallString<8> IntegerBuffer;
 902   bool NumberInvalid = false;
 903   StringRef Spelling = getSpelling(Tok, IntegerBuffer, &NumberInvalid);
 904   if (NumberInvalid)
 905     return false;
 906   NumericLiteralParser Literal(Spelling, Tok.getLocation(), *this);
 907   if (Literal.hadError || !Literal.isIntegerLiteral() || Literal.hasUDSuffix())
 908     return false;
 909   llvm::APInt APVal(64, 0);
 910   if (Literal.GetIntegerValue(APVal))
 911     return false;
 912   Lex(Tok);
 913   Value = APVal.getLimitedValue();
 914   return true;
 915 }
 916
 917 void Preprocessor::addCommentHandler(CommentHandler *Handler) {
 918   assert(Handler && "NULL comment handler");
 919   assert(std::find(CommentHandlers.begin(), CommentHandlers.end(), Handler) ==
 920          CommentHandlers.end() && "Comment handler already registered");
 921   CommentHandlers.push_back(Handler);
 922 }
 923
 924 void Preprocessor::removeCommentHandler(CommentHandler *Handler) {
 925   std::vector<CommentHandler *>::iterator Pos
 926   = std::find(CommentHandlers.begin(), CommentHandlers.end(), Handler);
 927   assert(Pos != CommentHandlers.end() && "Comment handler not registered");
 928   CommentHandlers.erase(Pos);
 929 }
 930
 931 bool Preprocessor::HandleComment(Token &result, SourceRange Comment) {
 932   bool AnyPendingTokens = false;
 933   for (std::vector<CommentHandler *>::iterator H = CommentHandlers.begin(),
 934        HEnd = CommentHandlers.end();
 935        H != HEnd; ++H) {
 936     if ((*H)->HandleComment(*this, Comment))
 937       AnyPendingTokens = true;
 938   }
 939   if (!AnyPendingTokens || getCommentRetentionState())
 940     return false;
 941   Lex(result);
 942   return true;
 943 }
 944
 945 ModuleLoader::~ModuleLoader() { }
 946
 947 CommentHandler::~CommentHandler() { }
 948
 949 CodeCompletionHandler::~CodeCompletionHandler() { }
 950
 951 void Preprocessor::createPreprocessingRecord() {
 952   if (Record)
 953     return;
 954
 955   Record = new PreprocessingRecord(getSourceManager());
 956   addPPCallbacks(std::unique_ptr<PPCallbacks>(Record));
 957 }