/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include/llvm/Support/Alignment.h

Bug Summary

File:	src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include/llvm/Support/Alignment.h
Warning:	line 85, column 47 The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Preprocessor.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangLex/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangLex/../include -I /usr/src/gnu/usr.bin/clang/libclangLex/obj -I /usr/src/gnu/usr.bin/clang/libclangLex/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangLex/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Preprocessor.cpp

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Preprocessor.cpp

→

1//===- Preprocessor.cpp - C Language Family Preprocessor Implementation ---===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements the Preprocessor interface.
10//
11//===----------------------------------------------------------------------===//
12//
13// Options to support:
14//   -H       - Print the name of each header file used.
15//   -d[DNI] - Dump various things.
16//   -fworking-directory - #line's with preprocessor's working dir.
17//   -fpreprocessed
18//   -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD
19//   -W*
20//   -w
21//
22// Messages to emit:
23//   "Multiple include guards may be useful for:\n"
24//
25//===----------------------------------------------------------------------===//

27#include "clang/Lex/Preprocessor.h"
28#include "clang/Basic/Builtins.h"
29#include "clang/Basic/FileManager.h"
30#include "clang/Basic/FileSystemStatCache.h"
31#include "clang/Basic/IdentifierTable.h"
32#include "clang/Basic/LLVM.h"
33#include "clang/Basic/LangOptions.h"
34#include "clang/Basic/Module.h"
35#include "clang/Basic/SourceLocation.h"
36#include "clang/Basic/SourceManager.h"
37#include "clang/Basic/TargetInfo.h"
38#include "clang/Lex/CodeCompletionHandler.h"
39#include "clang/Lex/ExternalPreprocessorSource.h"
40#include "clang/Lex/HeaderSearch.h"
41#include "clang/Lex/LexDiagnostic.h"
42#include "clang/Lex/Lexer.h"
43#include "clang/Lex/LiteralSupport.h"
44#include "clang/Lex/MacroArgs.h"
45#include "clang/Lex/MacroInfo.h"
46#include "clang/Lex/ModuleLoader.h"
47#include "clang/Lex/Pragma.h"
48#include "clang/Lex/PreprocessingRecord.h"
49#include "clang/Lex/PreprocessorLexer.h"
50#include "clang/Lex/PreprocessorOptions.h"
51#include "clang/Lex/ScratchBuffer.h"
52#include "clang/Lex/Token.h"
53#include "clang/Lex/TokenLexer.h"
54#include "llvm/ADT/APInt.h"
55#include "llvm/ADT/ArrayRef.h"
56#include "llvm/ADT/DenseMap.h"
57#include "llvm/ADT/STLExtras.h"
58#include "llvm/ADT/SmallString.h"
59#include "llvm/ADT/SmallVector.h"
60#include "llvm/ADT/StringRef.h"
61#include "llvm/ADT/StringSwitch.h"
62#include "llvm/Support/Capacity.h"
63#include "llvm/Support/ErrorHandling.h"
64#include "llvm/Support/MemoryBuffer.h"
65#include "llvm/Support/raw_ostream.h"
66#include <algorithm>
67#include <cassert>
68#include <memory>
69#include <string>
70#include <utility>
71#include <vector>

73using namespace clang;

75LLVM_INSTANTIATE_REGISTRY(PragmaHandlerRegistry)namespace llvm { template<typename T> typename Registry
<T>::node *Registry<T>::Head = nullptr; template<
typename T> typename Registry<T>::node *Registry<
T>::Tail = nullptr; template<typename T> void Registry
<T>::add_node(typename Registry<T>::node *N) { if
 (Tail) Tail->Next = N; else Head = N; Tail = N; } template
<typename T> typename Registry<T>::iterator Registry
<T>::begin() { return iterator(Head); } template PragmaHandlerRegistry
::node *Registry<PragmaHandlerRegistry::type>::Head; template
 PragmaHandlerRegistry::node *Registry<PragmaHandlerRegistry
::type>::Tail; template void Registry<PragmaHandlerRegistry
::type>::add_node(PragmaHandlerRegistry::node*); template PragmaHandlerRegistry
::iterator Registry<PragmaHandlerRegistry::type>::begin
(); }

77ExternalPreprocessorSource::~ExternalPreprocessorSource() = default;

79Preprocessor::Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
                         DiagnosticsEngine &diags, LangOptions &opts,
                         SourceManager &SM, HeaderSearch &Headers,
                         ModuleLoader &TheModuleLoader,
                         IdentifierInfoLookup *IILookup, bool OwnsHeaders,
                         TranslationUnitKind TUKind)
  : PPOpts(std::move(PPOpts)), Diags(&diags), LangOpts(opts),
    FileMgr(Headers.getFileMgr()), SourceMgr(SM),
    ScratchBuf(new ScratchBuffer(SourceMgr)), HeaderInfo(Headers),
    TheModuleLoader(TheModuleLoader), ExternalSource(nullptr),
    // As the language options may have not been loaded yet (when
    // deserializing an ASTUnit), adding keywords to the identifier table is
    // deferred to Preprocessor::Initialize().
    Identifiers(IILookup), PragmaHandlers(new PragmaNamespace(StringRef())),
    TUKind(TUKind), SkipMainFilePreamble(0, true),
    CurSubmoduleState(&NullSubmoduleState) {
OwnsHeaderSearch = OwnsHeaders;

// Default to discarding comments.
KeepComments = false;
KeepMacroComments = false;
SuppressIncludeNotFoundError = false;

// Macro expansion is enabled.
DisableMacroExpansion = false;
MacroExpansionInDirectivesOverride = false;
InMacroArgs = false;
ArgMacro = nullptr;
InMacroArgPreExpansion = false;
NumCachedTokenLexers = 0;
PragmasEnabled = true;
ParsingIfOrElifDirective = false;
PreprocessedOutput = false;

// We haven't read anything from the external source.
ReadMacrosFromExternalSource = false;

BuiltinInfo = std::make_unique<Builtin::Context>();

// "Poison" __VA_ARGS__, __VA_OPT__ which can only appear in the expansion of
// a macro. They get unpoisoned where it is allowed.
(Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned();
SetPoisonReason(Ident__VA_ARGS__,diag::ext_pp_bad_vaargs_use);
(Ident__VA_OPT__ = getIdentifierInfo("__VA_OPT__"))->setIsPoisoned();
SetPoisonReason(Ident__VA_OPT__,diag::ext_pp_bad_vaopt_use);

// Initialize the pragma handlers.
RegisterBuiltinPragmas();

// Initialize builtin macros like __LINE__ and friends.
RegisterBuiltinMacros();

if(LangOpts.Borland) {
  Ident__exception_info        = getIdentifierInfo("_exception_info");
  Ident___exception_info       = getIdentifierInfo("__exception_info");
  Ident_GetExceptionInfo       = getIdentifierInfo("GetExceptionInformation");
  Ident__exception_code        = getIdentifierInfo("_exception_code");
  Ident___exception_code       = getIdentifierInfo("__exception_code");
  Ident_GetExceptionCode       = getIdentifierInfo("GetExceptionCode");
  Ident__abnormal_termination  = getIdentifierInfo("_abnormal_termination");
  Ident___abnormal_termination = getIdentifierInfo("__abnormal_termination");
  Ident_AbnormalTermination    = getIdentifierInfo("AbnormalTermination");
} else {
  Ident__exception_info = Ident__exception_code = nullptr;
  Ident__abnormal_termination = Ident___exception_info = nullptr;
  Ident___exception_code = Ident___abnormal_termination = nullptr;
  Ident_GetExceptionInfo = Ident_GetExceptionCode = nullptr;
  Ident_AbnormalTermination = nullptr;
}

// If using a PCH where a #pragma hdrstop is expected, start skipping tokens.
if (usingPCHWithPragmaHdrStop())
  SkippingUntilPragmaHdrStop = true;

// If using a PCH with a through header, start skipping tokens.
if (!this->PPOpts->PCHThroughHeader.empty() &&
    !this->PPOpts->ImplicitPCHInclude.empty())
  SkippingUntilPCHThroughHeader = true;

if (this->PPOpts->GeneratePreamble)
  PreambleConditionalStack.startRecording();

ExcludedConditionalDirectiveSkipMappings =
    this->PPOpts->ExcludedConditionalDirectiveSkipMappings;
if (ExcludedConditionalDirectiveSkipMappings)
  ExcludedConditionalDirectiveSkipMappings->clear();

MaxTokens = LangOpts.MaxTokens;
167}

169Preprocessor::~Preprocessor() {
assert(BacktrackPositions.empty() && "EnableBacktrack/Backtrack imbalance!")((void)0);

IncludeMacroStack.clear();

// Destroy any macro definitions.
while (MacroInfoChain *I = MIChainHead) {
  MIChainHead = I->Next;
  I->~MacroInfoChain();
}

// Free any cached macro expanders.
// This populates MacroArgCache, so all TokenLexers need to be destroyed
// before the code below that frees up the MacroArgCache list.
std::fill(TokenLexerCache, TokenLexerCache + NumCachedTokenLexers, nullptr);
CurTokenLexer.reset();

// Free any cached MacroArgs.
for (MacroArgs *ArgList = MacroArgCache; ArgList;)
  ArgList = ArgList->deallocate();

// Delete the header search info, if we own it.
if (OwnsHeaderSearch)
  delete &HeaderInfo;
193}

195void Preprocessor::Initialize(const TargetInfo &Target,
                            const TargetInfo *AuxTarget) {
assert((!this->Target || this->Target == &Target) &&((void)0)
       "Invalid override of target information")((void)0);
this->Target = &Target;

assert((!this->AuxTarget || this->AuxTarget == AuxTarget) &&((void)0)
       "Invalid override of aux target information.")((void)0);
this->AuxTarget = AuxTarget;

// Initialize information about built-ins.
BuiltinInfo->InitializeTarget(Target, AuxTarget);
HeaderInfo.setTarget(Target);

// Populate the identifier table with info about keywords for the current language.
Identifiers.AddKeywords(LangOpts);
211}

213void Preprocessor::InitializeForModelFile() {
NumEnteredSourceFiles = 0;

// Reset pragmas
PragmaHandlersBackup = std::move(PragmaHandlers);
PragmaHandlers = std::make_unique<PragmaNamespace>(StringRef());
RegisterBuiltinPragmas();

// Reset PredefinesFileID
PredefinesFileID = FileID();
223}

225void Preprocessor::FinalizeForModelFile() {
NumEnteredSourceFiles = 1;

PragmaHandlers = std::move(PragmaHandlersBackup);
229}

231void Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const {
llvm::errs() << tok::getTokenName(Tok.getKind()) << " '"
             << getSpelling(Tok) << "'";

if (!DumpFlags) return;

llvm::errs() << "\t";
if (Tok.isAtStartOfLine())
  llvm::errs() << " [StartOfLine]";
if (Tok.hasLeadingSpace())
  llvm::errs() << " [LeadingSpace]";
if (Tok.isExpandDisabled())
  llvm::errs() << " [ExpandDisabled]";
if (Tok.needsCleaning()) {
  const char *Start = SourceMgr.getCharacterData(Tok.getLocation());
  llvm::errs() << " [UnClean='" << StringRef(Start, Tok.getLength())
               << "']";
}

llvm::errs() << "\tLoc=<";
DumpLocation(Tok.getLocation());
llvm::errs() << ">";
253}

255void Preprocessor::DumpLocation(SourceLocation Loc) const {
Loc.print(llvm::errs(), SourceMgr);
257}

259void Preprocessor::DumpMacro(const MacroInfo &MI) const {
llvm::errs() << "MACRO: ";
for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) {
  DumpToken(MI.getReplacementToken(i));
  llvm::errs() << "  ";
}
llvm::errs() << "\n";
266}

268void Preprocessor::PrintStats() {
llvm::errs() << "\n*** Preprocessor Stats:\n";
llvm::errs() << NumDirectives << " directives found:\n";
llvm::errs() << "  " << NumDefined << " #define.\n";
llvm::errs() << "  " << NumUndefined << " #undef.\n";
llvm::errs() << "  #include/#include_next/#import:\n";
llvm::errs() << "    " << NumEnteredSourceFiles << " source files entered.\n";
llvm::errs() << "    " << MaxIncludeStackDepth << " max include stack depth\n";
llvm::errs() << "  " << NumIf << " #if/#ifndef/#ifdef.\n";
llvm::errs() << "  " << NumElse << " #else/#elif/#elifdef/#elifndef.\n";
llvm::errs() << "  " << NumEndif << " #endif.\n";
llvm::errs() << "  " << NumPragma << " #pragma.\n";
llvm::errs() << NumSkipped << " #if/#ifndef#ifdef regions skipped\n";

llvm::errs() << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
           << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
           << NumFastMacroExpanded << " on the fast path.\n";
llvm::errs() << (NumFastTokenPaste+NumTokenPaste)
           << " token paste (##) operations performed, "
           << NumFastTokenPaste << " on the fast path.\n";

llvm::errs() << "\nPreprocessor Memory: " << getTotalMemory() << "B total";

llvm::errs() << "\n  BumpPtr: " << BP.getTotalMemory();
llvm::errs() << "\n  Macro Expanded Tokens: "
             << llvm::capacity_in_bytes(MacroExpandedTokens);
llvm::errs() << "\n  Predefines Buffer: " << Predefines.capacity();
// FIXME: List information for all submodules.
llvm::errs() << "\n  Macros: "
             << llvm::capacity_in_bytes(CurSubmoduleState->Macros);
llvm::errs() << "\n  #pragma push_macro Info: "
             << llvm::capacity_in_bytes(PragmaPushMacroInfo);
llvm::errs() << "\n  Poison Reasons: "
             << llvm::capacity_in_bytes(PoisonReasons);
llvm::errs() << "\n  Comment Handlers: "
             << llvm::capacity_in_bytes(CommentHandlers) << "\n";
304}

306Preprocessor::macro_iterator
307Preprocessor::macro_begin(bool IncludeExternalMacros) const {
if (IncludeExternalMacros && ExternalSource &&
    !ReadMacrosFromExternalSource) {
  ReadMacrosFromExternalSource = true;
  ExternalSource->ReadDefinedMacros();
}

// Make sure we cover all macros in visible modules.
for (const ModuleMacro &Macro : ModuleMacros)
  CurSubmoduleState->Macros.insert(std::make_pair(Macro.II, MacroState()));

return CurSubmoduleState->Macros.begin();
319}

321size_t Preprocessor::getTotalMemory() const {
return BP.getTotalMemory()
  + llvm::capacity_in_bytes(MacroExpandedTokens)
  + Predefines.capacity() /* Predefines buffer. */
  // FIXME: Include sizes from all submodules, and include MacroInfo sizes,
  // and ModuleMacros.
  + llvm::capacity_in_bytes(CurSubmoduleState->Macros)
  + llvm::capacity_in_bytes(PragmaPushMacroInfo)
  + llvm::capacity_in_bytes(PoisonReasons)
  + llvm::capacity_in_bytes(CommentHandlers);
331}

333Preprocessor::macro_iterator
334Preprocessor::macro_end(bool IncludeExternalMacros) const {
if (IncludeExternalMacros && ExternalSource &&
    !ReadMacrosFromExternalSource) {
  ReadMacrosFromExternalSource = true;
  ExternalSource->ReadDefinedMacros();
}

return CurSubmoduleState->Macros.end();
342}

344/// Compares macro tokens with a specified token value sequence.
345static bool MacroDefinitionEquals(const MacroInfo *MI,
                                ArrayRef<TokenValue> Tokens) {
return Tokens.size() == MI->getNumTokens() &&
    std::equal(Tokens.begin(), Tokens.end(), MI->tokens_begin());
349}

351StringRef Preprocessor::getLastMacroWithSpelling(
                                  SourceLocation Loc,
                                  ArrayRef<TokenValue> Tokens) const {
SourceLocation BestLocation;
StringRef BestSpelling;
for (Preprocessor::macro_iterator I = macro_begin(), E = macro_end();
     I != E; ++I) {
  const MacroDirective::DefInfo
    Def = I->second.findDirectiveAtLoc(Loc, SourceMgr);
  if (!Def || !Def.getMacroInfo())
    continue;
  if (!Def.getMacroInfo()->isObjectLike())
    continue;
  if (!MacroDefinitionEquals(Def.getMacroInfo(), Tokens))
    continue;
  SourceLocation Location = Def.getLocation();
  // Choose the macro defined latest.
  if (BestLocation.isInvalid() ||
      (Location.isValid() &&
       SourceMgr.isBeforeInTranslationUnit(BestLocation, Location))) {
    BestLocation = Location;
    BestSpelling = I->first->getName();
  }
}
return BestSpelling;
376}

378void Preprocessor::recomputeCurLexerKind() {
if (CurLexer)
  CurLexerKind = CLK_Lexer;
else if (CurTokenLexer)
  CurLexerKind = CLK_TokenLexer;
else
  CurLexerKind = CLK_CachingLexer;
385}

387bool Preprocessor::SetCodeCompletionPoint(const FileEntry *File,
                                        unsigned CompleteLine,
                                        unsigned CompleteColumn) {
assert(File)((void)0);
assert(CompleteLine && CompleteColumn && "Starts from 1:1")((void)0);
assert(!CodeCompletionFile && "Already set")((void)0);

// Load the actual file's contents.
Optional<llvm::MemoryBufferRef> Buffer =
    SourceMgr.getMemoryBufferForFileOrNone(File);
if (!Buffer)
  return true;

// Find the byte position of the truncation point.
const char *Position = Buffer->getBufferStart();
for (unsigned Line = 1; Line < CompleteLine; ++Line) {
  for (; *Position; ++Position) {
    if (*Position != '\r' && *Position != '\n')
      continue;

    // Eat \r\n or \n\r as a single line.
    if ((Position[1] == '\r' || Position[1] == '\n') &&
        Position[0] != Position[1])
      ++Position;
    ++Position;
    break;
  }
}

Position += CompleteColumn - 1;

// If pointing inside the preamble, adjust the position at the beginning of
// the file after the preamble.
if (SkipMainFilePreamble.first &&
    SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()) == File) {
  if (Position - Buffer->getBufferStart() < SkipMainFilePreamble.first)
    Position = Buffer->getBufferStart() + SkipMainFilePreamble.first;
}

if (Position > Buffer->getBufferEnd())
  Position = Buffer->getBufferEnd();

CodeCompletionFile = File;
CodeCompletionOffset = Position - Buffer->getBufferStart();

auto NewBuffer = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(
    Buffer->getBufferSize() + 1, Buffer->getBufferIdentifier());
char *NewBuf = NewBuffer->getBufferStart();
char *NewPos = std::copy(Buffer->getBufferStart(), Position, NewBuf);
*NewPos = '\0';
std::copy(Position, Buffer->getBufferEnd(), NewPos+1);
SourceMgr.overrideFileContents(File, std::move(NewBuffer));

return false;
441}

443void Preprocessor::CodeCompleteIncludedFile(llvm::StringRef Dir,
                                          bool IsAngled) {
setCodeCompletionReached();
if (CodeComplete)
  CodeComplete->CodeCompleteIncludedFile(Dir, IsAngled);
448}

450void Preprocessor::CodeCompleteNaturalLanguage() {
setCodeCompletionReached();
if (CodeComplete)
  CodeComplete->CodeCompleteNaturalLanguage();
454}

456/// getSpelling - This method is used to get the spelling of a token into a
457/// SmallVector. Note that the returned StringRef may not point to the
458/// supplied buffer if a copy can be avoided.
459StringRef Preprocessor::getSpelling(const Token &Tok,
                                        SmallVectorImpl<char> &Buffer,
                                        bool *Invalid) const {
// NOTE: this has to be checked *before* testing for an IdentifierInfo.
if (Tok.isNot(tok::raw_identifier) && !Tok.hasUCN()) {
  // Try the fast path.
  if (const IdentifierInfo *II = Tok.getIdentifierInfo())
    return II->getName();
}

// Resize the buffer if we need to copy into it.
if (Tok.needsCleaning())
  Buffer.resize(Tok.getLength());

const char *Ptr = Buffer.data();
unsigned Len = getSpelling(Tok, Ptr, Invalid);
return StringRef(Ptr, Len);
476}

478/// CreateString - Plop the specified string into a scratch buffer and return a
479/// location for it.  If specified, the source location provides a source
480/// location for the token.
481void Preprocessor::CreateString(StringRef Str, Token &Tok,
                              SourceLocation ExpansionLocStart,
                              SourceLocation ExpansionLocEnd) {
Tok.setLength(Str.size());

const char *DestPtr;
SourceLocation Loc = ScratchBuf->getToken(Str.data(), Str.size(), DestPtr);

if (ExpansionLocStart.isValid())
  Loc = SourceMgr.createExpansionLoc(Loc, ExpansionLocStart,
                                     ExpansionLocEnd, Str.size());
Tok.setLocation(Loc);

// If this is a raw identifier or a literal token, set the pointer data.
if (Tok.is(tok::raw_identifier))
  Tok.setRawIdentifierData(DestPtr);
else if (Tok.isLiteral())
  Tok.setLiteralData(DestPtr);
499}

501SourceLocation Preprocessor::SplitToken(SourceLocation Loc, unsigned Length) {
auto &SM = getSourceManager();
SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellingLoc);
bool Invalid = false;
StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
if (Invalid)
  return SourceLocation();

// FIXME: We could consider re-using spelling for tokens we see repeatedly.
const char *DestPtr;
SourceLocation Spelling =
    ScratchBuf->getToken(Buffer.data() + LocInfo.second, Length, DestPtr);
return SM.createTokenSplitLoc(Spelling, Loc, Loc.getLocWithOffset(Length));
515}

517Module *Preprocessor::getCurrentModule() {
if (!getLangOpts().isCompilingModule())
  return nullptr;

return getHeaderSearchInfo().lookupModule(getLangOpts().CurrentModule);
522}

524//===----------------------------------------------------------------------===//
525// Preprocessor Initialization Methods
526//===----------------------------------------------------------------------===//

528/// EnterMainSourceFile - Enter the specified FileID as the main source file,
529/// which implicitly adds the builtin defines etc.
530void Preprocessor::EnterMainSourceFile() {
// We do not allow the preprocessor to reenter the main file.  Doing so will
// cause FileID's to accumulate information from both runs (e.g. #line
// information) and predefined macros aren't guaranteed to be set properly.
assert(NumEnteredSourceFiles == 0 && "Cannot reenter the main file!")((void)0);
FileID MainFileID = SourceMgr.getMainFileID();

// If MainFileID is loaded it means we loaded an AST file, no need to enter
// a main file.
if (!SourceMgr.isLoadedFileID(MainFileID)) {
  // Enter the main file source buffer.
  EnterSourceFile(MainFileID, nullptr, SourceLocation());

  // If we've been asked to skip bytes in the main file (e.g., as part of a
  // precompiled preamble), do so now.
  if (SkipMainFilePreamble.first > 0)
    CurLexer->SetByteOffset(SkipMainFilePreamble.first,
                            SkipMainFilePreamble.second);

  // Tell the header info that the main file was entered.  If the file is later
  // #imported, it won't be re-entered.
  if (const FileEntry *FE = SourceMgr.getFileEntryForID(MainFileID))
    HeaderInfo.IncrementIncludeCount(FE);
}

// Preprocess Predefines to populate the initial preprocessor state.
std::unique_ptr<llvm::MemoryBuffer> SB =
  llvm::MemoryBuffer::getMemBufferCopy(Predefines, "<built-in>");
assert(SB && "Cannot create predefined source buffer")((void)0);
FileID FID = SourceMgr.createFileID(std::move(SB));
assert(FID.isValid() && "Could not create FileID for predefines?")((void)0);
setPredefinesFileID(FID);

// Start parsing the predefines.
EnterSourceFile(FID, nullptr, SourceLocation());

if (!PPOpts->PCHThroughHeader.empty()) {
  // Lookup and save the FileID for the through header. If it isn't found
  // in the search path, it's a fatal error.
  const DirectoryLookup *CurDir;
  Optional<FileEntryRef> File = LookupFile(
      SourceLocation(), PPOpts->PCHThroughHeader,
      /*isAngled=*/false, /*FromDir=*/nullptr, /*FromFile=*/nullptr, CurDir,
      /*SearchPath=*/nullptr, /*RelativePath=*/nullptr,
      /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
      /*IsFrameworkFound=*/nullptr);
  if (!File) {
    Diag(SourceLocation(), diag::err_pp_through_header_not_found)
        << PPOpts->PCHThroughHeader;
    return;
  }
  setPCHThroughHeaderFileID(
      SourceMgr.createFileID(*File, SourceLocation(), SrcMgr::C_User));
}

// Skip tokens from the Predefines and if needed the main file.
if ((usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) ||
    (usingPCHWithPragmaHdrStop() && SkippingUntilPragmaHdrStop))
  SkipTokensWhileUsingPCH();
589}

591void Preprocessor::setPCHThroughHeaderFileID(FileID FID) {
assert(PCHThroughHeaderFileID.isInvalid() &&((void)0)
       "PCHThroughHeaderFileID already set!")((void)0);
PCHThroughHeaderFileID = FID;
595}

597bool Preprocessor::isPCHThroughHeader(const FileEntry *FE) {
assert(PCHThroughHeaderFileID.isValid() &&((void)0)
       "Invalid PCH through header FileID")((void)0);
return FE == SourceMgr.getFileEntryForID(PCHThroughHeaderFileID);
601}

603bool Preprocessor::creatingPCHWithThroughHeader() {
return TUKind == TU_Prefix && !PPOpts->PCHThroughHeader.empty() &&
       PCHThroughHeaderFileID.isValid();
606}

608bool Preprocessor::usingPCHWithThroughHeader() {
return TUKind != TU_Prefix && !PPOpts->PCHThroughHeader.empty() &&
       PCHThroughHeaderFileID.isValid();
611}

613bool Preprocessor::creatingPCHWithPragmaHdrStop() {
return TUKind == TU_Prefix && PPOpts->PCHWithHdrStop;
615}

617bool Preprocessor::usingPCHWithPragmaHdrStop() {
return TUKind != TU_Prefix && PPOpts->PCHWithHdrStop;
619}

621/// Skip tokens until after the #include of the through header or
622/// until after a #pragma hdrstop is seen. Tokens in the predefines file
623/// and the main file may be skipped. If the end of the predefines file
624/// is reached, skipping continues into the main file. If the end of the
625/// main file is reached, it's a fatal error.
626void Preprocessor::SkipTokensWhileUsingPCH() {
bool ReachedMainFileEOF = false;
bool UsingPCHThroughHeader = SkippingUntilPCHThroughHeader;
bool UsingPragmaHdrStop = SkippingUntilPragmaHdrStop;
Token Tok;
while (true) {
  bool InPredefines =
      (CurLexer && CurLexer->getFileID() == getPredefinesFileID());
  switch (CurLexerKind) {
  case CLK_Lexer:
    CurLexer->Lex(Tok);
   break;
  case CLK_TokenLexer:
    CurTokenLexer->Lex(Tok);
    break;
  case CLK_CachingLexer:
    CachingLex(Tok);
    break;
  case CLK_LexAfterModuleImport:
    LexAfterModuleImport(Tok);
    break;
  }
  if (Tok.is(tok::eof) && !InPredefines) {
    ReachedMainFileEOF = true;
    break;
  }
  if (UsingPCHThroughHeader && !SkippingUntilPCHThroughHeader)
    break;
  if (UsingPragmaHdrStop && !SkippingUntilPragmaHdrStop)
    break;
}
if (ReachedMainFileEOF) {
  if (UsingPCHThroughHeader)
    Diag(SourceLocation(), diag::err_pp_through_header_not_seen)
        << PPOpts->PCHThroughHeader << 1;
  else if (!PPOpts->PCHWithHdrStopCreate)
    Diag(SourceLocation(), diag::err_pp_pragma_hdrstop_not_seen);
}
664}

666void Preprocessor::replayPreambleConditionalStack() {
// Restore the conditional stack from the preamble, if there is one.
if (PreambleConditionalStack.isReplaying()) {
  assert(CurPPLexer &&((void)0)
         "CurPPLexer is null when calling replayPreambleConditionalStack.")((void)0);
  CurPPLexer->setConditionalLevels(PreambleConditionalStack.getStack());
  PreambleConditionalStack.doneReplaying();
  if (PreambleConditionalStack.reachedEOFWhileSkipping())
    SkipExcludedConditionalBlock(
        PreambleConditionalStack.SkipInfo->HashTokenLoc,
        PreambleConditionalStack.SkipInfo->IfTokenLoc,
        PreambleConditionalStack.SkipInfo->FoundNonSkipPortion,
        PreambleConditionalStack.SkipInfo->FoundElse,
        PreambleConditionalStack.SkipInfo->ElseLoc);
}
681}

683void Preprocessor::EndSourceFile() {
// Notify the client that we reached the end of the source file.
if (Callbacks)
  Callbacks->EndOfMainFile();
687}

689//===----------------------------------------------------------------------===//
690// Lexer Event Handling.
691//===----------------------------------------------------------------------===//

693/// LookUpIdentifierInfo - Given a tok::raw_identifier token, look up the
694/// identifier information for the token and install it into the token,
695/// updating the token kind accordingly.
696IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier) const {
assert(!Identifier.getRawIdentifier().empty() && "No raw identifier data!")((void)0);

// Look up this token, see if it is a macro, or if it is a language keyword.
IdentifierInfo *II;
if (!Identifier.needsCleaning() && !Identifier.hasUCN()) {
  // No cleaning needed, just use the characters from the lexed buffer.
  II = getIdentifierInfo(Identifier.getRawIdentifier());
} else {
  // Cleaning needed, alloca a buffer, clean into it, then use the buffer.
  SmallString<64> IdentifierBuffer;
  StringRef CleanedStr = getSpelling(Identifier, IdentifierBuffer);

  if (Identifier.hasUCN()) {
    SmallString<64> UCNIdentifierBuffer;
    expandUCNs(UCNIdentifierBuffer, CleanedStr);
    II = getIdentifierInfo(UCNIdentifierBuffer);
  } else {
    II = getIdentifierInfo(CleanedStr);
  }
}

// Update the token info (identifier info and appropriate token kind).
Identifier.setIdentifierInfo(II);
if (getLangOpts().MSVCCompat && II->isCPlusPlusOperatorKeyword() &&
    getSourceManager().isInSystemHeader(Identifier.getLocation()))
  Identifier.setKind(tok::identifier);
else
  Identifier.setKind(II->getTokenID());

return II;
727}

729void Preprocessor::SetPoisonReason(IdentifierInfo *II, unsigned DiagID) {
PoisonReasons[II] = DiagID;
731}

733void Preprocessor::PoisonSEHIdentifiers(bool Poison) {
assert(Ident__exception_code && Ident__exception_info)((void)0);
assert(Ident___exception_code && Ident___exception_info)((void)0);
Ident__exception_code->setIsPoisoned(Poison);
Ident___exception_code->setIsPoisoned(Poison);
Ident_GetExceptionCode->setIsPoisoned(Poison);
Ident__exception_info->setIsPoisoned(Poison);
Ident___exception_info->setIsPoisoned(Poison);
Ident_GetExceptionInfo->setIsPoisoned(Poison);
Ident__abnormal_termination->setIsPoisoned(Poison);
Ident___abnormal_termination->setIsPoisoned(Poison);
Ident_AbnormalTermination->setIsPoisoned(Poison);
745}

747void Preprocessor::HandlePoisonedIdentifier(Token & Identifier) {
assert(Identifier.getIdentifierInfo() &&((void)0)
       "Can't handle identifiers without identifier info!")((void)0);
llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =
  PoisonReasons.find(Identifier.getIdentifierInfo());
if(it == PoisonReasons.end())
  Diag(Identifier, diag::err_pp_used_poisoned_id);
else
  Diag(Identifier,it->second) << Identifier.getIdentifierInfo();
756}

758/// Returns a diagnostic message kind for reporting a future keyword as
759/// appropriate for the identifier and specified language.
760static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
                                        const LangOptions &LangOpts) {
assert(II.isFutureCompatKeyword() && "diagnostic should not be needed")((void)0);

if (LangOpts.CPlusPlus)
  return llvm::StringSwitch<diag::kind>(II.getName())
766#define CXX11_KEYWORD(NAME, FLAGS)                                             \
      .Case(#NAME, diag::warn_cxx11_keyword)
768#define CXX20_KEYWORD(NAME, FLAGS)                                             \
      .Case(#NAME, diag::warn_cxx20_keyword)
770#include "clang/Basic/TokenKinds.def"
      // char8_t is not modeled as a CXX20_KEYWORD because it's not
      // unconditionally enabled in C++20 mode. (It can be disabled
      // by -fno-char8_t.)
      .Case("char8_t", diag::warn_cxx20_keyword)
      ;

llvm_unreachable(__builtin_unreachable()
    "Keyword not known to come from a newer Standard or proposed Standard")__builtin_unreachable();
779}

781void Preprocessor::updateOutOfDateIdentifier(IdentifierInfo &II) const {
assert(II.isOutOfDate() && "not out of date")((void)0);
getExternalSource()->updateOutOfDateIdentifier(II);
784}

786/// HandleIdentifier - This callback is invoked when the lexer reads an
787/// identifier.  This callback looks up the identifier in the map and/or
788/// potentially macro expands it or turns it into a named token (like 'for').
789///
790/// Note that callers of this method are guarded by checking the
791/// IdentifierInfo's 'isHandleIdentifierCase' bit.  If this method changes, the
792/// IdentifierInfo methods that compute these properties will need to change to
793/// match.
794bool Preprocessor::HandleIdentifier(Token &Identifier) {
assert(Identifier.getIdentifierInfo() &&((void)0)
       "Can't handle identifiers without identifier info!")((void)0);

IdentifierInfo &II = *Identifier.getIdentifierInfo();

// If the information about this identifier is out of date, update it from
// the external source.
// We have to treat __VA_ARGS__ in a special way, since it gets
// serialized with isPoisoned = true, but our preprocessor may have
// unpoisoned it if we're defining a C99 macro.
if (II.isOutOfDate()) {
1
Assuming the condition is false→
2
←
Taking false branch→
  bool CurrentIsPoisoned = false;
  const bool IsSpecialVariadicMacro =
      &II == Ident__VA_ARGS__ || &II == Ident__VA_OPT__;
  if (IsSpecialVariadicMacro)
    CurrentIsPoisoned = II.isPoisoned();

  updateOutOfDateIdentifier(II);
  Identifier.setKind(II.getTokenID());

  if (IsSpecialVariadicMacro)
    II.setIsPoisoned(CurrentIsPoisoned);
}

// If this identifier was poisoned, and if it was not produced from a macro
// expansion, emit an error.
if (II.isPoisoned() && CurPPLexer) {
3
←
Assuming the condition is false→
  HandlePoisonedIdentifier(Identifier);
}

// If this is a macro to be expanded, do it.
if (MacroDefinition MD = getMacroDefinition(&II)) {
4
←
Calling 'Preprocessor::getMacroDefinition'→
  auto *MI = MD.getMacroInfo();
  assert(MI && "macro definition with no macro info?")((void)0);
  if (!DisableMacroExpansion) {
    if (!Identifier.isExpandDisabled() && MI->isEnabled()) {
      // C99 6.10.3p10: If the preprocessing token immediately after the
      // macro name isn't a '(', this macro should not be expanded.
      if (!MI->isFunctionLike() || isNextPPTokenLParen())
        return HandleMacroExpandedIdentifier(Identifier, MD);
    } else {
      // C99 6.10.3.4p2 says that a disabled macro may never again be
      // expanded, even if it's in a context where it could be expanded in the
      // future.
      Identifier.setFlag(Token::DisableExpand);
      if (MI->isObjectLike() || isNextPPTokenLParen())
        Diag(Identifier, diag::pp_disabled_macro_expansion);
    }
  }
}

// If this identifier is a keyword in a newer Standard or proposed Standard,
// produce a warning. Don't warn if we're not considering macro expansion,
// since this identifier might be the name of a macro.
// FIXME: This warning is disabled in cases where it shouldn't be, like
//   "#define constexpr constexpr", "int constexpr;"
if (II.isFutureCompatKeyword() && !DisableMacroExpansion) {
  Diag(Identifier, getFutureCompatDiagKind(II, getLangOpts()))
      << II.getName();
  // Don't diagnose this keyword again in this translation unit.
  II.setIsFutureCompatKeyword(false);
}

// If this is an extension token, diagnose its use.
// We avoid diagnosing tokens that originate from macro definitions.
// FIXME: This warning is disabled in cases where it shouldn't be,
// like "#define TY typeof", "TY(1) x".
if (II.isExtensionToken() && !DisableMacroExpansion)
  Diag(Identifier, diag::ext_token_used);

// If this is the 'import' contextual keyword following an '@', note
// that the next token indicates a module name.
//
// Note that we do not treat 'import' as a contextual
// keyword when we're in a caching lexer, because caching lexers only get
// used in contexts where import declarations are disallowed.
//
// Likewise if this is the C++ Modules TS import keyword.
if (((LastTokenWasAt && II.isModulesImport()) ||
     Identifier.is(tok::kw_import)) &&
    !InMacroArgs && !DisableMacroExpansion &&
    (getLangOpts().Modules || getLangOpts().DebuggerSupport) &&
    CurLexerKind != CLK_CachingLexer) {
  ModuleImportLoc = Identifier.getLocation();
  ModuleImportPath.clear();
  ModuleImportExpectsIdentifier = true;
  CurLexerKind = CLK_LexAfterModuleImport;
}
return true;
884}

886void Preprocessor::Lex(Token &Result) {
++LexLevel;

// We loop here until a lex function returns a token; this avoids recursion.
bool ReturnedToken;
do {
  switch (CurLexerKind) {
  case CLK_Lexer:
    ReturnedToken = CurLexer->Lex(Result);
    break;
  case CLK_TokenLexer:
    ReturnedToken = CurTokenLexer->Lex(Result);
    break;
  case CLK_CachingLexer:
    CachingLex(Result);
    ReturnedToken = true;
    break;
  case CLK_LexAfterModuleImport:
    ReturnedToken = LexAfterModuleImport(Result);
    break;
  }
} while (!ReturnedToken);

if (Result.is(tok::unknown) && TheModuleLoader.HadFatalFailure)
  return;

if (Result.is(tok::code_completion) && Result.getIdentifierInfo()) {
  // Remember the identifier before code completion token.
  setCodeCompletionIdentifierInfo(Result.getIdentifierInfo());
  setCodeCompletionTokenRange(Result.getLocation(), Result.getEndLoc());
  // Set IdenfitierInfo to null to avoid confusing code that handles both
  // identifiers and completion tokens.
  Result.setIdentifierInfo(nullptr);
}

// Update ImportSeqState to track our position within a C++20 import-seq
// if this token is being produced as a result of phase 4 of translation.
if (getLangOpts().CPlusPlusModules && LexLevel == 1 &&
    !Result.getFlag(Token::IsReinjected)) {
  switch (Result.getKind()) {
  case tok::l_paren: case tok::l_square: case tok::l_brace:
    ImportSeqState.handleOpenBracket();
    break;
  case tok::r_paren: case tok::r_square:
    ImportSeqState.handleCloseBracket();
    break;
  case tok::r_brace:
    ImportSeqState.handleCloseBrace();
    break;
  case tok::semi:
    ImportSeqState.handleSemi();
    break;
  case tok::header_name:
  case tok::annot_header_unit:
    ImportSeqState.handleHeaderName();
    break;
  case tok::kw_export:
    ImportSeqState.handleExport();
    break;
  case tok::identifier:
    if (Result.getIdentifierInfo()->isModulesImport()) {
      ImportSeqState.handleImport();
      if (ImportSeqState.afterImportSeq()) {
        ModuleImportLoc = Result.getLocation();
        ModuleImportPath.clear();
        ModuleImportExpectsIdentifier = true;
        CurLexerKind = CLK_LexAfterModuleImport;
      }
      break;
    }
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  default:
    ImportSeqState.handleMisc();
    break;
  }
}

LastTokenWasAt = Result.is(tok::at);
--LexLevel;

if ((LexLevel == 0 || PreprocessToken) &&
    !Result.getFlag(Token::IsReinjected)) {
  if (LexLevel == 0)
    ++TokenCount;
  if (OnToken)
    OnToken(Result);
}
973}

975/// Lex a header-name token (including one formed from header-name-tokens if
976/// \p AllowConcatenation is \c true).
977///
978/// \param FilenameTok Filled in with the next token. On success, this will
979///        be either a header_name token. On failure, it will be whatever other
980///        token was found instead.
981/// \param AllowMacroExpansion If \c true, allow the header name to be formed
982///        by macro expansion (concatenating tokens as necessary if the first
983///        token is a '<').
984/// \return \c true if we reached EOD or EOF while looking for a > token in
985///         a concatenated header name and diagnosed it. \c false otherwise.
986bool Preprocessor::LexHeaderName(Token &FilenameTok, bool AllowMacroExpansion) {
// Lex using header-name tokenization rules if tokens are being lexed from
// a file. Just grab a token normally if we're in a macro expansion.
if (CurPPLexer)
  CurPPLexer->LexIncludeFilename(FilenameTok);
else
  Lex(FilenameTok);

// This could be a <foo/bar.h> file coming from a macro expansion.  In this
// case, glue the tokens together into an angle_string_literal token.
SmallString<128> FilenameBuffer;
if (FilenameTok.is(tok::less) && AllowMacroExpansion) {
  bool StartOfLine = FilenameTok.isAtStartOfLine();
  bool LeadingSpace = FilenameTok.hasLeadingSpace();
  bool LeadingEmptyMacro = FilenameTok.hasLeadingEmptyMacro();

  SourceLocation Start = FilenameTok.getLocation();
  SourceLocation End;
  FilenameBuffer.push_back('<');

  // Consume tokens until we find a '>'.
  // FIXME: A header-name could be formed starting or ending with an
  // alternative token. It's not clear whether that's ill-formed in all
  // cases.
  while (FilenameTok.isNot(tok::greater)) {
    Lex(FilenameTok);
    if (FilenameTok.isOneOf(tok::eod, tok::eof)) {
      Diag(FilenameTok.getLocation(), diag::err_expected) << tok::greater;
      Diag(Start, diag::note_matching) << tok::less;
      return true;
    }

    End = FilenameTok.getLocation();

    // FIXME: Provide code completion for #includes.
    if (FilenameTok.is(tok::code_completion)) {
      setCodeCompletionReached();
      Lex(FilenameTok);
      continue;
    }

    // Append the spelling of this token to the buffer. If there was a space
    // before it, add it now.
    if (FilenameTok.hasLeadingSpace())
      FilenameBuffer.push_back(' ');

    // Get the spelling of the token, directly into FilenameBuffer if
    // possible.
    size_t PreAppendSize = FilenameBuffer.size();
    FilenameBuffer.resize(PreAppendSize + FilenameTok.getLength());

    const char *BufPtr = &FilenameBuffer[PreAppendSize];
    unsigned ActualLen = getSpelling(FilenameTok, BufPtr);

    // If the token was spelled somewhere else, copy it into FilenameBuffer.
    if (BufPtr != &FilenameBuffer[PreAppendSize])
      memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);

    // Resize FilenameBuffer to the correct size.
    if (FilenameTok.getLength() != ActualLen)
      FilenameBuffer.resize(PreAppendSize + ActualLen);
  }

  FilenameTok.startToken();
  FilenameTok.setKind(tok::header_name);
  FilenameTok.setFlagValue(Token::StartOfLine, StartOfLine);
  FilenameTok.setFlagValue(Token::LeadingSpace, LeadingSpace);
  FilenameTok.setFlagValue(Token::LeadingEmptyMacro, LeadingEmptyMacro);
  CreateString(FilenameBuffer, FilenameTok, Start, End);
} else if (FilenameTok.is(tok::string_literal) && AllowMacroExpansion) {
  // Convert a string-literal token of the form " h-char-sequence "
  // (produced by macro expansion) into a header-name token.
  //
  // The rules for header-names don't quite match the rules for
  // string-literals, but all the places where they differ result in
  // undefined behavior, so we can and do treat them the same.
  //
  // A string-literal with a prefix or suffix is not translated into a
  // header-name. This could theoretically be observable via the C++20
  // context-sensitive header-name formation rules.
  StringRef Str = getSpelling(FilenameTok, FilenameBuffer);
  if (Str.size() >= 2 && Str.front() == '"' && Str.back() == '"')
    FilenameTok.setKind(tok::header_name);
}

return false;
1072}

1074/// Collect the tokens of a C++20 pp-import-suffix.
1075void Preprocessor::CollectPpImportSuffix(SmallVectorImpl<Token> &Toks) {
// FIXME: For error recovery, consider recognizing attribute syntax here
// and terminating / diagnosing a missing semicolon if we find anything
// else? (Can we leave that to the parser?)
unsigned BracketDepth = 0;
while (true) {
  Toks.emplace_back();
  Lex(Toks.back());

  switch (Toks.back().getKind()) {
  case tok::l_paren: case tok::l_square: case tok::l_brace:
    ++BracketDepth;
    break;

  case tok::r_paren: case tok::r_square: case tok::r_brace:
    if (BracketDepth == 0)
      return;
    --BracketDepth;
    break;

  case tok::semi:
    if (BracketDepth == 0)
      return;
  break;

  case tok::eof:
    return;

  default:
    break;
  }
}
1107}


1110/// Lex a token following the 'import' contextual keyword.
1111///
1112///     pp-import: [C++20]
1113///           import header-name pp-import-suffix[opt] ;
1114///           import header-name-tokens pp-import-suffix[opt] ;
1115/// [ObjC]    @ import module-name ;
1116/// [Clang]   import module-name ;
1117///
1118///     header-name-tokens:
1119///           string-literal
1120///           < [any sequence of preprocessing-tokens other than >] >
1121///
1122///     module-name:
1123///           module-name-qualifier[opt] identifier
1124///
1125///     module-name-qualifier
1126///           module-name-qualifier[opt] identifier .
1127///
1128/// We respond to a pp-import by importing macros from the named module.
1129bool Preprocessor::LexAfterModuleImport(Token &Result) {
// Figure out what kind of lexer we actually have.
recomputeCurLexerKind();

// Lex the next token. The header-name lexing rules are used at the start of
// a pp-import.
//
// For now, we only support header-name imports in C++20 mode.
// FIXME: Should we allow this in all language modes that support an import
// declaration as an extension?
if (ModuleImportPath.empty() && getLangOpts().CPlusPlusModules) {
  if (LexHeaderName(Result))
    return true;
} else {
  Lex(Result);
}

// Allocate a holding buffer for a sequence of tokens and introduce it into
// the token stream.
auto EnterTokens = [this](ArrayRef<Token> Toks) {
  auto ToksCopy = std::make_unique<Token[]>(Toks.size());
  std::copy(Toks.begin(), Toks.end(), ToksCopy.get());
  EnterTokenStream(std::move(ToksCopy), Toks.size(),
                   /*DisableMacroExpansion*/ true, /*IsReinject*/ false);
};

// Check for a header-name.
SmallVector<Token, 32> Suffix;
if (Result.is(tok::header_name)) {
  // Enter the header-name token into the token stream; a Lex action cannot
  // both return a token and cache tokens (doing so would corrupt the token
  // cache if the call to Lex comes from CachingLex / PeekAhead).
  Suffix.push_back(Result);

  // Consume the pp-import-suffix and expand any macros in it now. We'll add
  // it back into the token stream later.
  CollectPpImportSuffix(Suffix);
  if (Suffix.back().isNot(tok::semi)) {
    // This is not a pp-import after all.
    EnterTokens(Suffix);
    return false;
  }

  // C++2a [cpp.module]p1:
  //   The ';' preprocessing-token terminating a pp-import shall not have
  //   been produced by macro replacement.
  SourceLocation SemiLoc = Suffix.back().getLocation();
  if (SemiLoc.isMacroID())
    Diag(SemiLoc, diag::err_header_import_semi_in_macro);

  // Reconstitute the import token.
  Token ImportTok;
  ImportTok.startToken();
  ImportTok.setKind(tok::kw_import);
  ImportTok.setLocation(ModuleImportLoc);
  ImportTok.setIdentifierInfo(getIdentifierInfo("import"));
  ImportTok.setLength(6);

  auto Action = HandleHeaderIncludeOrImport(
      /*HashLoc*/ SourceLocation(), ImportTok, Suffix.front(), SemiLoc);
  switch (Action.Kind) {
  case ImportAction::None:
    break;

  case ImportAction::ModuleBegin:
    // Let the parser know we're textually entering the module.
    Suffix.emplace_back();
    Suffix.back().startToken();
    Suffix.back().setKind(tok::annot_module_begin);
    Suffix.back().setLocation(SemiLoc);
    Suffix.back().setAnnotationEndLoc(SemiLoc);
    Suffix.back().setAnnotationValue(Action.ModuleForHeader);
    LLVM_FALLTHROUGH[[gnu::fallthrough]];

  case ImportAction::ModuleImport:
  case ImportAction::SkippedModuleImport:
    // We chose to import (or textually enter) the file. Convert the
    // header-name token into a header unit annotation token.
    Suffix[0].setKind(tok::annot_header_unit);
    Suffix[0].setAnnotationEndLoc(Suffix[0].getLocation());
    Suffix[0].setAnnotationValue(Action.ModuleForHeader);
    // FIXME: Call the moduleImport callback?
    break;
  case ImportAction::Failure:
    assert(TheModuleLoader.HadFatalFailure &&((void)0)
           "This should be an early exit only to a fatal error")((void)0);
    Result.setKind(tok::eof);
    CurLexer->cutOffLexing();
    EnterTokens(Suffix);
    return true;
  }

  EnterTokens(Suffix);
  return false;
}

// The token sequence
//
//   import identifier (. identifier)*
//
// indicates a module import directive. We already saw the 'import'
// contextual keyword, so now we're looking for the identifiers.
if (ModuleImportExpectsIdentifier && Result.getKind() == tok::identifier) {
  // We expected to see an identifier here, and we did; continue handling
  // identifiers.
  ModuleImportPath.push_back(std::make_pair(Result.getIdentifierInfo(),
                                            Result.getLocation()));
  ModuleImportExpectsIdentifier = false;
  CurLexerKind = CLK_LexAfterModuleImport;
  return true;
}

// If we're expecting a '.' or a ';', and we got a '.', then wait until we
// see the next identifier. (We can also see a '[[' that begins an
// attribute-specifier-seq here under the C++ Modules TS.)
if (!ModuleImportExpectsIdentifier && Result.getKind() == tok::period) {
  ModuleImportExpectsIdentifier = true;
  CurLexerKind = CLK_LexAfterModuleImport;
  return true;
}

// If we didn't recognize a module name at all, this is not a (valid) import.
if (ModuleImportPath.empty() || Result.is(tok::eof))
  return true;

// Consume the pp-import-suffix and expand any macros in it now, if we're not
// at the semicolon already.
SourceLocation SemiLoc = Result.getLocation();
if (Result.isNot(tok::semi)) {
  Suffix.push_back(Result);
  CollectPpImportSuffix(Suffix);
  if (Suffix.back().isNot(tok::semi)) {
    // This is not an import after all.
    EnterTokens(Suffix);
    return false;
  }
  SemiLoc = Suffix.back().getLocation();
}

// Under the Modules TS, the dot is just part of the module name, and not
// a real hierarchy separator. Flatten such module names now.
//
// FIXME: Is this the right level to be performing this transformation?
std::string FlatModuleName;
if (getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) {
  for (auto &Piece : ModuleImportPath) {
    if (!FlatModuleName.empty())
      FlatModuleName += ".";
    FlatModuleName += Piece.first->getName();
  }
  SourceLocation FirstPathLoc = ModuleImportPath[0].second;
  ModuleImportPath.clear();
  ModuleImportPath.push_back(
      std::make_pair(getIdentifierInfo(FlatModuleName), FirstPathLoc));
}

Module *Imported = nullptr;
if (getLangOpts().Modules) {
  Imported = TheModuleLoader.loadModule(ModuleImportLoc,
                                        ModuleImportPath,
                                        Module::Hidden,
                                        /*IsInclusionDirective=*/false);
  if (Imported)
    makeModuleVisible(Imported, SemiLoc);
}
if (Callbacks)
  Callbacks->moduleImport(ModuleImportLoc, ModuleImportPath, Imported);

if (!Suffix.empty()) {
  EnterTokens(Suffix);
  return false;
}
return true;
1302}

1304void Preprocessor::makeModuleVisible(Module *M, SourceLocation Loc) {
CurSubmoduleState->VisibleModules.setVisible(
    M, Loc, [](Module *) {},
    [&](ArrayRef<Module *> Path, Module *Conflict, StringRef Message) {
      // FIXME: Include the path in the diagnostic.
      // FIXME: Include the import location for the conflicting module.
      Diag(ModuleImportLoc, diag::warn_module_conflict)
          << Path[0]->getFullModuleName()
          << Conflict->getFullModuleName()
          << Message;
    });

// Add this module to the imports list of the currently-built submodule.
if (!BuildingSubmoduleStack.empty() && M != BuildingSubmoduleStack.back().M)
  BuildingSubmoduleStack.back().M->Imports.insert(M);
1319}

1321bool Preprocessor::FinishLexStringLiteral(Token &Result, std::string &String,
                                        const char *DiagnosticTag,
                                        bool AllowMacroExpansion) {
// We need at least one string literal.
if (Result.isNot(tok::string_literal)) {
  Diag(Result, diag::err_expected_string_literal)
    << /*Source='in...'*/0 << DiagnosticTag;
  return false;
}

// Lex string literal tokens, optionally with macro expansion.
SmallVector<Token, 4> StrToks;
do {
  StrToks.push_back(Result);

  if (Result.hasUDSuffix())
    Diag(Result, diag::err_invalid_string_udl);

  if (AllowMacroExpansion)
    Lex(Result);
  else
    LexUnexpandedToken(Result);
} while (Result.is(tok::string_literal));

// Concatenate and parse the strings.
StringLiteralParser Literal(StrToks, *this);
assert(Literal.isAscii() && "Didn't allow wide strings in")((void)0);

if (Literal.hadError)
  return false;

if (Literal.Pascal) {
  Diag(StrToks[0].getLocation(), diag::err_expected_string_literal)
    << /*Source='in...'*/0 << DiagnosticTag;
  return false;
}

String = std::string(Literal.GetString());
return true;
1360}

1362bool Preprocessor::parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value) {
assert(Tok.is(tok::numeric_constant))((void)0);
SmallString<8> IntegerBuffer;
bool NumberInvalid = false;
StringRef Spelling = getSpelling(Tok, IntegerBuffer, &NumberInvalid);
if (NumberInvalid)
  return false;
NumericLiteralParser Literal(Spelling, Tok.getLocation(), getSourceManager(),
                             getLangOpts(), getTargetInfo(),
                             getDiagnostics());
if (Literal.hadError || !Literal.isIntegerLiteral() || Literal.hasUDSuffix())
  return false;
llvm::APInt APVal(64, 0);
if (Literal.GetIntegerValue(APVal))
  return false;
Lex(Tok);
Value = APVal.getLimitedValue();
return true;
1380}

1382void Preprocessor::addCommentHandler(CommentHandler *Handler) {
assert(Handler && "NULL comment handler")((void)0);
assert(llvm::find(CommentHandlers, Handler) == CommentHandlers.end() &&((void)0)
       "Comment handler already registered")((void)0);
CommentHandlers.push_back(Handler);
1387}

1389void Preprocessor::removeCommentHandler(CommentHandler *Handler) {
std::vector<CommentHandler *>::iterator Pos =
    llvm::find(CommentHandlers, Handler);
assert(Pos != CommentHandlers.end() && "Comment handler not registered")((void)0);
CommentHandlers.erase(Pos);
1394}

1396bool Preprocessor::HandleComment(Token &result, SourceRange Comment) {
bool AnyPendingTokens = false;
for (std::vector<CommentHandler *>::iterator H = CommentHandlers.begin(),
     HEnd = CommentHandlers.end();
     H != HEnd; ++H) {
  if ((*H)->HandleComment(*this, Comment))
    AnyPendingTokens = true;
}
if (!AnyPendingTokens || getCommentRetentionState())
  return false;
Lex(result);
return true;
1408}

1410ModuleLoader::~ModuleLoader() = default;

1412CommentHandler::~CommentHandler() = default;

1414EmptylineHandler::~EmptylineHandler() = default;

1416CodeCompletionHandler::~CodeCompletionHandler() = default;

1418void Preprocessor::createPreprocessingRecord() {
if (Record)
  return;

Record = new PreprocessingRecord(getSourceManager());
addPPCallbacks(std::unique_ptr<PPCallbacks>(Record));
1424}

←

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/include/clang/Lex/Preprocessor.h

→

1//===- Preprocessor.h - C Language Family Preprocessor ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::Preprocessor interface.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_LEX_PREPROCESSOR_H
15#define LLVM_CLANG_LEX_PREPROCESSOR_H

17#include "clang/Basic/Diagnostic.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/Lexer.h"
26#include "clang/Lex/MacroInfo.h"
27#include "clang/Lex/ModuleLoader.h"
28#include "clang/Lex/ModuleMap.h"
29#include "clang/Lex/PPCallbacks.h"
30#include "clang/Lex/PreprocessorExcludedConditionalDirectiveSkipMapping.h"
31#include "clang/Lex/Token.h"
32#include "clang/Lex/TokenLexer.h"
33#include "llvm/ADT/ArrayRef.h"
34#include "llvm/ADT/DenseMap.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/FunctionExtras.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/SmallPtrSet.h"
42#include "llvm/ADT/SmallVector.h"
43#include "llvm/ADT/StringRef.h"
44#include "llvm/ADT/TinyPtrVector.h"
45#include "llvm/ADT/iterator_range.h"
46#include "llvm/Support/Allocator.h"
47#include "llvm/Support/Casting.h"
48#include "llvm/Support/Registry.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <map>
53#include <memory>
54#include <string>
55#include <utility>
56#include <vector>

58namespace llvm {

60template<unsigned InternalLen> class SmallString;

62} // namespace llvm

64namespace clang {

66class CodeCompletionHandler;
67class CommentHandler;
68class DirectoryEntry;
69class DirectoryLookup;
70class EmptylineHandler;
71class ExternalPreprocessorSource;
72class FileEntry;
73class FileManager;
74class HeaderSearch;
75class MacroArgs;
76class PragmaHandler;
77class PragmaNamespace;
78class PreprocessingRecord;
79class PreprocessorLexer;
80class PreprocessorOptions;
81class ScratchBuffer;
82class TargetInfo;

84namespace Builtin {
85class Context;
86}

88/// Stores token information for comparing actual tokens with
89/// predefined values.  Only handles simple tokens and identifiers.
90class TokenValue {
tok::TokenKind Kind;
IdentifierInfo *II;

94public:
TokenValue(tok::TokenKind Kind) : Kind(Kind), II(nullptr) {
  assert(Kind != tok::raw_identifier && "Raw identifiers are not supported.")((void)0);
  assert(Kind != tok::identifier &&((void)0)
         "Identifiers should be created by TokenValue(IdentifierInfo *)")((void)0);
  assert(!tok::isLiteral(Kind) && "Literals are not supported.")((void)0);
  assert(!tok::isAnnotation(Kind) && "Annotations are not supported.")((void)0);
}

TokenValue(IdentifierInfo *II) : Kind(tok::identifier), II(II) {}

bool operator==(const Token &Tok) const {
  return Tok.getKind() == Kind &&
      (!II || II == Tok.getIdentifierInfo());
}
109};

111/// Context in which macro name is used.
112enum MacroUse {
// other than #define or #undef
MU_Other  = 0,

// macro name specified in #define
MU_Define = 1,

// macro name specified in #undef
MU_Undef  = 2
121};

123/// Engages in a tight little dance with the lexer to efficiently
124/// preprocess tokens.
125///
126/// Lexers know only about tokens within a single source file, and don't
127/// know anything about preprocessor-level issues like the \#include stack,
128/// token expansion, etc.
129class Preprocessor {
friend class VAOptDefinitionContext;
friend class VariadicMacroScopeGuard;

llvm::unique_function<void(const clang::Token &)> OnToken;
std::shared_ptr<PreprocessorOptions> PPOpts;
DiagnosticsEngine        *Diags;
LangOptions       &LangOpts;
const TargetInfo *Target = nullptr;
const TargetInfo *AuxTarget = nullptr;
FileManager       &FileMgr;
SourceManager     &SourceMgr;
std::unique_ptr<ScratchBuffer> ScratchBuf;
HeaderSearch      &HeaderInfo;
ModuleLoader      &TheModuleLoader;

/// External source of macros.
ExternalPreprocessorSource *ExternalSource;

/// A BumpPtrAllocator object used to quickly allocate and release
/// objects internal to the Preprocessor.
llvm::BumpPtrAllocator BP;

/// Identifiers for builtin macros and other builtins.
IdentifierInfo *Ident__LINE__, *Ident__FILE__;   // __LINE__, __FILE__
IdentifierInfo *Ident__DATE__, *Ident__TIME__;   // __DATE__, __TIME__
IdentifierInfo *Ident__INCLUDE_LEVEL__;          // __INCLUDE_LEVEL__
IdentifierInfo *Ident__BASE_FILE__;              // __BASE_FILE__
IdentifierInfo *Ident__FILE_NAME__;              // __FILE_NAME__
IdentifierInfo *Ident__TIMESTAMP__;              // __TIMESTAMP__
IdentifierInfo *Ident__COUNTER__;                // __COUNTER__
IdentifierInfo *Ident_Pragma, *Ident__pragma;    // _Pragma, __pragma
IdentifierInfo *Ident__identifier;               // __identifier
IdentifierInfo *Ident__VA_ARGS__;                // __VA_ARGS__
IdentifierInfo *Ident__VA_OPT__;                 // __VA_OPT__
IdentifierInfo *Ident__has_feature;              // __has_feature
IdentifierInfo *Ident__has_extension;            // __has_extension
IdentifierInfo *Ident__has_builtin;              // __has_builtin
IdentifierInfo *Ident__has_attribute;            // __has_attribute
IdentifierInfo *Ident__has_include;              // __has_include
IdentifierInfo *Ident__has_include_next;         // __has_include_next
IdentifierInfo *Ident__has_warning;              // __has_warning
IdentifierInfo *Ident__is_identifier;            // __is_identifier
IdentifierInfo *Ident__building_module;          // __building_module
IdentifierInfo *Ident__MODULE__;                 // __MODULE__
IdentifierInfo *Ident__has_cpp_attribute;        // __has_cpp_attribute
IdentifierInfo *Ident__has_c_attribute;          // __has_c_attribute
IdentifierInfo *Ident__has_declspec;             // __has_declspec_attribute
IdentifierInfo *Ident__is_target_arch;           // __is_target_arch
IdentifierInfo *Ident__is_target_vendor;         // __is_target_vendor
IdentifierInfo *Ident__is_target_os;             // __is_target_os
IdentifierInfo *Ident__is_target_environment;    // __is_target_environment

// Weak, only valid (and set) while InMacroArgs is true.
Token* ArgMacro;

SourceLocation DATELoc, TIMELoc;

// Next __COUNTER__ value, starts at 0.
unsigned CounterValue = 0;

enum {
  /// Maximum depth of \#includes.
  MaxAllowedIncludeStackDepth = 200
};

// State that is set before the preprocessor begins.
bool KeepComments : 1;
bool KeepMacroComments : 1;
bool SuppressIncludeNotFoundError : 1;

// State that changes while the preprocessor runs:
bool InMacroArgs : 1;            // True if parsing fn macro invocation args.

/// Whether the preprocessor owns the header search object.
bool OwnsHeaderSearch : 1;

/// True if macro expansion is disabled.
bool DisableMacroExpansion : 1;

/// Temporarily disables DisableMacroExpansion (i.e. enables expansion)
/// when parsing preprocessor directives.
bool MacroExpansionInDirectivesOverride : 1;

class ResetMacroExpansionHelper;

/// Whether we have already loaded macros from the external source.
mutable bool ReadMacrosFromExternalSource : 1;

/// True if pragmas are enabled.
bool PragmasEnabled : 1;

/// True if the current build action is a preprocessing action.
bool PreprocessedOutput : 1;

/// True if we are currently preprocessing a #if or #elif directive
bool ParsingIfOrElifDirective;

/// True if we are pre-expanding macro arguments.
bool InMacroArgPreExpansion;

/// Mapping/lookup information for all identifiers in
/// the program, including program keywords.
mutable IdentifierTable Identifiers;

/// This table contains all the selectors in the program.
///
/// Unlike IdentifierTable above, this table *isn't* populated by the
/// preprocessor. It is declared/expanded here because its role/lifetime is
/// conceptually similar to the IdentifierTable. In addition, the current
/// control flow (in clang::ParseAST()), make it convenient to put here.
///
/// FIXME: Make sure the lifetime of Identifiers/Selectors *isn't* tied to
/// the lifetime of the preprocessor.
SelectorTable Selectors;

/// Information about builtins.
std::unique_ptr<Builtin::Context> BuiltinInfo;

/// Tracks all of the pragmas that the client registered
/// with this preprocessor.
std::unique_ptr<PragmaNamespace> PragmaHandlers;

/// Pragma handlers of the original source is stored here during the
/// parsing of a model file.
std::unique_ptr<PragmaNamespace> PragmaHandlersBackup;

/// Tracks all of the comment handlers that the client registered
/// with this preprocessor.
std::vector<CommentHandler *> CommentHandlers;

/// Empty line handler.
EmptylineHandler *Emptyline = nullptr;

/// True if we want to ignore EOF token and continue later on (thus
/// avoid tearing the Lexer and etc. down).
bool IncrementalProcessing = false;

267public:
/// The kind of translation unit we are processing.
const TranslationUnitKind TUKind;

271private:
/// The code-completion handler.
CodeCompletionHandler *CodeComplete = nullptr;

/// The file that we're performing code-completion for, if any.
const FileEntry *CodeCompletionFile = nullptr;

/// The offset in file for the code-completion point.
unsigned CodeCompletionOffset = 0;

/// The location for the code-completion point. This gets instantiated
/// when the CodeCompletionFile gets \#include'ed for preprocessing.
SourceLocation CodeCompletionLoc;

/// The start location for the file of the code-completion point.
///
/// This gets instantiated when the CodeCompletionFile gets \#include'ed
/// for preprocessing.
SourceLocation CodeCompletionFileLoc;

/// The source location of the \c import contextual keyword we just
/// lexed, if any.
SourceLocation ModuleImportLoc;

/// The module import path that we're currently processing.
SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> ModuleImportPath;

/// Whether the last token we lexed was an '@'.
bool LastTokenWasAt = false;

/// A position within a C++20 import-seq.
class ImportSeq {
public:
  enum State : int {
    // Positive values represent a number of unclosed brackets.
    AtTopLevel = 0,
    AfterTopLevelTokenSeq = -1,
    AfterExport = -2,
    AfterImportSeq = -3,
  };

  ImportSeq(State S) : S(S) {}

  /// Saw any kind of open bracket.
  void handleOpenBracket() {
    S = static_cast<State>(std::max<int>(S, 0) + 1);
  }
  /// Saw any kind of close bracket other than '}'.
  void handleCloseBracket() {
    S = static_cast<State>(std::max<int>(S, 1) - 1);
  }
  /// Saw a close brace.
  void handleCloseBrace() {
    handleCloseBracket();
    if (S == AtTopLevel && !AfterHeaderName)
      S = AfterTopLevelTokenSeq;
  }
  /// Saw a semicolon.
  void handleSemi() {
    if (atTopLevel()) {
      S = AfterTopLevelTokenSeq;
      AfterHeaderName = false;
    }
  }

  /// Saw an 'export' identifier.
  void handleExport() {
    if (S == AfterTopLevelTokenSeq)
      S = AfterExport;
    else if (S <= 0)
      S = AtTopLevel;
  }
  /// Saw an 'import' identifier.
  void handleImport() {
    if (S == AfterTopLevelTokenSeq || S == AfterExport)
      S = AfterImportSeq;
    else if (S <= 0)
      S = AtTopLevel;
  }

  /// Saw a 'header-name' token; do not recognize any more 'import' tokens
  /// until we reach a top-level semicolon.
  void handleHeaderName() {
    if (S == AfterImportSeq)
      AfterHeaderName = true;
    handleMisc();
  }

  /// Saw any other token.
  void handleMisc() {
    if (S <= 0)
      S = AtTopLevel;
  }

  bool atTopLevel() { return S <= 0; }
  bool afterImportSeq() { return S == AfterImportSeq; }

private:
  State S;
  /// Whether we're in the pp-import-suffix following the header-name in a
  /// pp-import. If so, a close-brace is not sufficient to end the
  /// top-level-token-seq of an import-seq.
  bool AfterHeaderName = false;
};

/// Our current position within a C++20 import-seq.
ImportSeq ImportSeqState = ImportSeq::AfterTopLevelTokenSeq;

/// Whether the module import expects an identifier next. Otherwise,
/// it expects a '.' or ';'.
bool ModuleImportExpectsIdentifier = false;

/// The identifier and source location of the currently-active
/// \#pragma clang arc_cf_code_audited begin.
std::pair<IdentifierInfo *, SourceLocation> PragmaARCCFCodeAuditedInfo;

/// The source location of the currently-active
/// \#pragma clang assume_nonnull begin.
SourceLocation PragmaAssumeNonNullLoc;

/// True if we hit the code-completion point.
bool CodeCompletionReached = false;

/// The code completion token containing the information
/// on the stem that is to be code completed.
IdentifierInfo *CodeCompletionII = nullptr;

/// Range for the code completion token.
SourceRange CodeCompletionTokenRange;

/// The directory that the main file should be considered to occupy,
/// if it does not correspond to a real file (as happens when building a
/// module).
const DirectoryEntry *MainFileDir = nullptr;

/// The number of bytes that we will initially skip when entering the
/// main file, along with a flag that indicates whether skipping this number
/// of bytes will place the lexer at the start of a line.
///
/// This is used when loading a precompiled preamble.
std::pair<int, bool> SkipMainFilePreamble;

/// Whether we hit an error due to reaching max allowed include depth. Allows
/// to avoid hitting the same error over and over again.
bool HasReachedMaxIncludeDepth = false;

/// The number of currently-active calls to Lex.
///
/// Lex is reentrant, and asking for an (end-of-phase-4) token can often
/// require asking for multiple additional tokens. This counter makes it
/// possible for Lex to detect whether it's producing a token for the end
/// of phase 4 of translation or for some other situation.
unsigned LexLevel = 0;

/// The number of (LexLevel 0) preprocessor tokens.
unsigned TokenCount = 0;

/// Preprocess every token regardless of LexLevel.
bool PreprocessToken = false;

/// The maximum number of (LexLevel 0) tokens before issuing a -Wmax-tokens
/// warning, or zero for unlimited.
unsigned MaxTokens = 0;
SourceLocation MaxTokensOverrideLoc;

436public:
struct PreambleSkipInfo {
  SourceLocation HashTokenLoc;
  SourceLocation IfTokenLoc;
  bool FoundNonSkipPortion;
  bool FoundElse;
  SourceLocation ElseLoc;

  PreambleSkipInfo(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc,
                   bool FoundNonSkipPortion, bool FoundElse,
                   SourceLocation ElseLoc)
      : HashTokenLoc(HashTokenLoc), IfTokenLoc(IfTokenLoc),
        FoundNonSkipPortion(FoundNonSkipPortion), FoundElse(FoundElse),
        ElseLoc(ElseLoc) {}
};

452private:
friend class ASTReader;
friend class MacroArgs;

class PreambleConditionalStackStore {
  enum State {
    Off = 0,
    Recording = 1,
    Replaying = 2,
  };

public:
  PreambleConditionalStackStore() = default;

  void startRecording() { ConditionalStackState = Recording; }
  void startReplaying() { ConditionalStackState = Replaying; }
  bool isRecording() const { return ConditionalStackState == Recording; }
  bool isReplaying() const { return ConditionalStackState == Replaying; }

  ArrayRef<PPConditionalInfo> getStack() const {
    return ConditionalStack;
  }

  void doneReplaying() {
    ConditionalStack.clear();
    ConditionalStackState = Off;
  }

  void setStack(ArrayRef<PPConditionalInfo> s) {
    if (!isRecording() && !isReplaying())
      return;
    ConditionalStack.clear();
    ConditionalStack.append(s.begin(), s.end());
  }

  bool hasRecordedPreamble() const { return !ConditionalStack.empty(); }

  bool reachedEOFWhileSkipping() const { return SkipInfo.hasValue(); }

  void clearSkipInfo() { SkipInfo.reset(); }

  llvm::Optional<PreambleSkipInfo> SkipInfo;

private:
  SmallVector<PPConditionalInfo, 4> ConditionalStack;
  State ConditionalStackState = Off;
} PreambleConditionalStack;

/// The current top of the stack that we're lexing from if
/// not expanding a macro and we are lexing directly from source code.
///
/// Only one of CurLexer, or CurTokenLexer will be non-null.
std::unique_ptr<Lexer> CurLexer;

/// The current top of the stack what we're lexing from
/// if not expanding a macro.
///
/// This is an alias for CurLexer.
PreprocessorLexer *CurPPLexer = nullptr;

/// Used to find the current FileEntry, if CurLexer is non-null
/// and if applicable.
///
/// This allows us to implement \#include_next and find directory-specific
/// properties.
const DirectoryLookup *CurDirLookup = nullptr;

/// The current macro we are expanding, if we are expanding a macro.
///
/// One of CurLexer and CurTokenLexer must be null.
std::unique_ptr<TokenLexer> CurTokenLexer;

/// The kind of lexer we're currently working with.
enum CurLexerKind {
  CLK_Lexer,
  CLK_TokenLexer,
  CLK_CachingLexer,
  CLK_LexAfterModuleImport
} CurLexerKind = CLK_Lexer;

/// If the current lexer is for a submodule that is being built, this
/// is that submodule.
Module *CurLexerSubmodule = nullptr;

/// Keeps track of the stack of files currently
/// \#included, and macros currently being expanded from, not counting
/// CurLexer/CurTokenLexer.
struct IncludeStackInfo {
  enum CurLexerKind           CurLexerKind;
  Module                     *TheSubmodule;
  std::unique_ptr<Lexer>      TheLexer;
  PreprocessorLexer          *ThePPLexer;
  std::unique_ptr<TokenLexer> TheTokenLexer;
  const DirectoryLookup      *TheDirLookup;

  // The following constructors are completely useless copies of the default
  // versions, only needed to pacify MSVC.
  IncludeStackInfo(enum CurLexerKind CurLexerKind, Module *TheSubmodule,
                   std::unique_ptr<Lexer> &&TheLexer,
                   PreprocessorLexer *ThePPLexer,
                   std::unique_ptr<TokenLexer> &&TheTokenLexer,
                   const DirectoryLookup *TheDirLookup)
      : CurLexerKind(std::move(CurLexerKind)),
        TheSubmodule(std::move(TheSubmodule)), TheLexer(std::move(TheLexer)),
        ThePPLexer(std::move(ThePPLexer)),
        TheTokenLexer(std::move(TheTokenLexer)),
        TheDirLookup(std::move(TheDirLookup)) {}
};
std::vector<IncludeStackInfo> IncludeMacroStack;

/// Actions invoked when some preprocessor activity is
/// encountered (e.g. a file is \#included, etc).
std::unique_ptr<PPCallbacks> Callbacks;

struct MacroExpandsInfo {
  Token Tok;
  MacroDefinition MD;
  SourceRange Range;

  MacroExpandsInfo(Token Tok, MacroDefinition MD, SourceRange Range)
      : Tok(Tok), MD(MD), Range(Range) {}
};
SmallVector<MacroExpandsInfo, 2> DelayedMacroExpandsCallbacks;

/// Information about a name that has been used to define a module macro.
struct ModuleMacroInfo {
  /// The most recent macro directive for this identifier.
  MacroDirective *MD;

  /// The active module macros for this identifier.
  llvm::TinyPtrVector<ModuleMacro *> ActiveModuleMacros;

  /// The generation number at which we last updated ActiveModuleMacros.
  /// \see Preprocessor::VisibleModules.
  unsigned ActiveModuleMacrosGeneration = 0;

  /// Whether this macro name is ambiguous.
  bool IsAmbiguous = false;

  /// The module macros that are overridden by this macro.
  llvm::TinyPtrVector<ModuleMacro *> OverriddenMacros;

  ModuleMacroInfo(MacroDirective *MD) : MD(MD) {}
};

/// The state of a macro for an identifier.
class MacroState {
  mutable llvm::PointerUnion<MacroDirective *, ModuleMacroInfo *> State;

  ModuleMacroInfo *getModuleInfo(Preprocessor &PP,
                                 const IdentifierInfo *II) const {
    if (II->isOutOfDate())
11
←
Assuming the condition is false→
12
←
Taking false branch→
      PP.updateOutOfDateIdentifier(const_cast<IdentifierInfo&>(*II));
    // FIXME: Find a spare bit on IdentifierInfo and store a
    //        HasModuleMacros flag.
    if (!II->hasMacroDefinition() ||
13
←
Assuming the condition is false→
16
←
Taking false branch→
        (!PP.getLangOpts().Modules &&
14
←
Assuming field 'Modules' is not equal to 0→
         !PP.getLangOpts().ModulesLocalVisibility) ||
        !PP.CurSubmoduleState->VisibleModules.getGeneration())
15
←
Assuming the condition is false→
      return nullptr;

    auto *Info = State.dyn_cast<ModuleMacroInfo*>();
    if (!Info16.1
'Info' is null
1
'Info' is null
1
'Info' is null
1
'Info' is null
) {
17
←
Taking true branch→
      Info = new (PP.getPreprocessorAllocator())
18
←
Calling 'operator new<llvm::MallocAllocator, 4096UL, 4096UL, 128UL>'→
          ModuleMacroInfo(State.get<MacroDirective *>());
      State = Info;
    }

    if (PP.CurSubmoduleState->VisibleModules.getGeneration() !=
        Info->ActiveModuleMacrosGeneration)
      PP.updateModuleMacroInfo(II, *Info);
    return Info;
  }

public:
  MacroState() : MacroState(nullptr) {}
  MacroState(MacroDirective *MD) : State(MD) {}

  MacroState(MacroState &&O) noexcept : State(O.State) {
    O.State = (MacroDirective *)nullptr;
  }

  MacroState &operator=(MacroState &&O) noexcept {
    auto S = O.State;
    O.State = (MacroDirective *)nullptr;
    State = S;
    return *this;
  }

  ~MacroState() {
    if (auto *Info = State.dyn_cast<ModuleMacroInfo*>())
      Info->~ModuleMacroInfo();
  }

  MacroDirective *getLatest() const {
    if (auto *Info = State.dyn_cast<ModuleMacroInfo*>())
      return Info->MD;
    return State.get<MacroDirective*>();
  }

  void setLatest(MacroDirective *MD) {
    if (auto *Info = State.dyn_cast<ModuleMacroInfo*>())
      Info->MD = MD;
    else
      State = MD;
  }

  bool isAmbiguous(Preprocessor &PP, const IdentifierInfo *II) const {
    auto *Info = getModuleInfo(PP, II);
    return Info ? Info->IsAmbiguous : false;
  }

  ArrayRef<ModuleMacro *>
  getActiveModuleMacros(Preprocessor &PP, const IdentifierInfo *II) const {
    if (auto *Info = getModuleInfo(PP, II))
10
←
Calling 'MacroState::getModuleInfo'→
      return Info->ActiveModuleMacros;
    return None;
  }

  MacroDirective::DefInfo findDirectiveAtLoc(SourceLocation Loc,
                                             SourceManager &SourceMgr) const {
    // FIXME: Incorporate module macros into the result of this.
    if (auto *Latest = getLatest())
      return Latest->findDirectiveAtLoc(Loc, SourceMgr);
    return {};
  }

  void overrideActiveModuleMacros(Preprocessor &PP, IdentifierInfo *II) {
    if (auto *Info = getModuleInfo(PP, II)) {
      Info->OverriddenMacros.insert(Info->OverriddenMacros.end(),
                                    Info->ActiveModuleMacros.begin(),
                                    Info->ActiveModuleMacros.end());
      Info->ActiveModuleMacros.clear();
      Info->IsAmbiguous = false;
    }
  }

  ArrayRef<ModuleMacro*> getOverriddenMacros() const {
    if (auto *Info = State.dyn_cast<ModuleMacroInfo*>())
      return Info->OverriddenMacros;
    return None;
  }

  void setOverriddenMacros(Preprocessor &PP,
                           ArrayRef<ModuleMacro *> Overrides) {
    auto *Info = State.dyn_cast<ModuleMacroInfo*>();
    if (!Info) {
      if (Overrides.empty())
        return;
      Info = new (PP.getPreprocessorAllocator())
          ModuleMacroInfo(State.get<MacroDirective *>());
      State = Info;
    }
    Info->OverriddenMacros.clear();
    Info->OverriddenMacros.insert(Info->OverriddenMacros.end(),
                                  Overrides.begin(), Overrides.end());
    Info->ActiveModuleMacrosGeneration = 0;
  }
};

/// For each IdentifierInfo that was associated with a macro, we
/// keep a mapping to the history of all macro definitions and #undefs in
/// the reverse order (the latest one is in the head of the list).
///
/// This mapping lives within the \p CurSubmoduleState.
using MacroMap = llvm::DenseMap<const IdentifierInfo *, MacroState>;

struct SubmoduleState;

/// Information about a submodule that we're currently building.
struct BuildingSubmoduleInfo {
  /// The module that we are building.
  Module *M;

  /// The location at which the module was included.
  SourceLocation ImportLoc;

  /// Whether we entered this submodule via a pragma.
  bool IsPragma;

  /// The previous SubmoduleState.
  SubmoduleState *OuterSubmoduleState;

  /// The number of pending module macro names when we started building this.
  unsigned OuterPendingModuleMacroNames;

  BuildingSubmoduleInfo(Module *M, SourceLocation ImportLoc, bool IsPragma,
                        SubmoduleState *OuterSubmoduleState,
                        unsigned OuterPendingModuleMacroNames)
      : M(M), ImportLoc(ImportLoc), IsPragma(IsPragma),
        OuterSubmoduleState(OuterSubmoduleState),
        OuterPendingModuleMacroNames(OuterPendingModuleMacroNames) {}
};
SmallVector<BuildingSubmoduleInfo, 8> BuildingSubmoduleStack;

/// Information about a submodule's preprocessor state.
struct SubmoduleState {
  /// The macros for the submodule.
  MacroMap Macros;

  /// The set of modules that are visible within the submodule.
  VisibleModuleSet VisibleModules;

  // FIXME: CounterValue?
  // FIXME: PragmaPushMacroInfo?
};
std::map<Module *, SubmoduleState> Submodules;

/// The preprocessor state for preprocessing outside of any submodule.
SubmoduleState NullSubmoduleState;

/// The current submodule state. Will be \p NullSubmoduleState if we're not
/// in a submodule.
SubmoduleState *CurSubmoduleState;

/// The set of known macros exported from modules.
llvm::FoldingSet<ModuleMacro> ModuleMacros;

/// The names of potential module macros that we've not yet processed.
llvm::SmallVector<const IdentifierInfo *, 32> PendingModuleMacroNames;

/// The list of module macros, for each identifier, that are not overridden by
/// any other module macro.
llvm::DenseMap<const IdentifierInfo *, llvm::TinyPtrVector<ModuleMacro *>>
    LeafModuleMacros;

/// Macros that we want to warn because they are not used at the end
/// of the translation unit.
///
/// We store just their SourceLocations instead of
/// something like MacroInfo*. The benefit of this is that when we are
/// deserializing from PCH, we don't need to deserialize identifier & macros
/// just so that we can report that they are unused, we just warn using
/// the SourceLocations of this set (that will be filled by the ASTReader).
using WarnUnusedMacroLocsTy = llvm::SmallDenseSet<SourceLocation, 32>;
WarnUnusedMacroLocsTy WarnUnusedMacroLocs;

/// A "freelist" of MacroArg objects that can be
/// reused for quick allocation.
MacroArgs *MacroArgCache = nullptr;

/// For each IdentifierInfo used in a \#pragma push_macro directive,
/// we keep a MacroInfo stack used to restore the previous macro value.
llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>
    PragmaPushMacroInfo;

// Various statistics we track for performance analysis.
unsigned NumDirectives = 0;
unsigned NumDefined = 0;
unsigned NumUndefined = 0;
unsigned NumPragma = 0;
unsigned NumIf = 0;
unsigned NumElse = 0;
unsigned NumEndif = 0;
unsigned NumEnteredSourceFiles = 0;
unsigned MaxIncludeStackDepth = 0;
unsigned NumMacroExpanded = 0;
unsigned NumFnMacroExpanded = 0;
unsigned NumBuiltinMacroExpanded = 0;
unsigned NumFastMacroExpanded = 0;
unsigned NumTokenPaste = 0;
unsigned NumFastTokenPaste = 0;
unsigned NumSkipped = 0;

/// The predefined macros that preprocessor should use from the
/// command line etc.
std::string Predefines;

/// The file ID for the preprocessor predefines.
FileID PredefinesFileID;

/// The file ID for the PCH through header.
FileID PCHThroughHeaderFileID;

/// Whether tokens are being skipped until a #pragma hdrstop is seen.
bool SkippingUntilPragmaHdrStop = false;

/// Whether tokens are being skipped until the through header is seen.
bool SkippingUntilPCHThroughHeader = false;

/// \{
/// Cache of macro expanders to reduce malloc traffic.
enum { TokenLexerCacheSize = 8 };
unsigned NumCachedTokenLexers;
std::unique_ptr<TokenLexer> TokenLexerCache[TokenLexerCacheSize];
/// \}

/// Keeps macro expanded tokens for TokenLexers.
//
/// Works like a stack; a TokenLexer adds the macro expanded tokens that is
/// going to lex in the cache and when it finishes the tokens are removed
/// from the end of the cache.
SmallVector<Token, 16> MacroExpandedTokens;
std::vector<std::pair<TokenLexer *, size_t>> MacroExpandingLexersStack;

/// A record of the macro definitions and expansions that
/// occurred during preprocessing.
///
/// This is an optional side structure that can be enabled with
/// \c createPreprocessingRecord() prior to preprocessing.
PreprocessingRecord *Record = nullptr;

/// Cached tokens state.
using CachedTokensTy = SmallVector<Token, 1>;

/// Cached tokens are stored here when we do backtracking or
/// lookahead. They are "lexed" by the CachingLex() method.
CachedTokensTy CachedTokens;

/// The position of the cached token that CachingLex() should
/// "lex" next.
///
/// If it points beyond the CachedTokens vector, it means that a normal
/// Lex() should be invoked.
CachedTokensTy::size_type CachedLexPos = 0;

/// Stack of backtrack positions, allowing nested backtracks.
///
/// The EnableBacktrackAtThisPos() method pushes a position to
/// indicate where CachedLexPos should be set when the BackTrack() method is
/// invoked (at which point the last position is popped).
std::vector<CachedTokensTy::size_type> BacktrackPositions;

struct MacroInfoChain {
  MacroInfo MI;
  MacroInfoChain *Next;
};

/// MacroInfos are managed as a chain for easy disposal.  This is the head
/// of that list.
MacroInfoChain *MIChainHead = nullptr;

void updateOutOfDateIdentifier(IdentifierInfo &II) const;

886public:
Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
             DiagnosticsEngine &diags, LangOptions &opts, SourceManager &SM,
             HeaderSearch &Headers, ModuleLoader &TheModuleLoader,
             IdentifierInfoLookup *IILookup = nullptr,
             bool OwnsHeaderSearch = false,
             TranslationUnitKind TUKind = TU_Complete);

~Preprocessor();

/// Initialize the preprocessor using information about the target.
///
/// \param Target is owned by the caller and must remain valid for the
/// lifetime of the preprocessor.
/// \param AuxTarget is owned by the caller and must remain valid for
/// the lifetime of the preprocessor.
void Initialize(const TargetInfo &Target,
                const TargetInfo *AuxTarget = nullptr);

/// Initialize the preprocessor to parse a model file
///
/// To parse model files the preprocessor of the original source is reused to
/// preserver the identifier table. However to avoid some duplicate
/// information in the preprocessor some cleanup is needed before it is used
/// to parse model files. This method does that cleanup.
void InitializeForModelFile();

/// Cleanup after model file parsing
void FinalizeForModelFile();

/// Retrieve the preprocessor options used to initialize this
/// preprocessor.
PreprocessorOptions &getPreprocessorOpts() const { return *PPOpts; }

DiagnosticsEngine &getDiagnostics() const { return *Diags; }
void setDiagnostics(DiagnosticsEngine &D) { Diags = &D; }

const LangOptions &getLangOpts() const { return LangOpts; }
const TargetInfo &getTargetInfo() const { return *Target; }
const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
FileManager &getFileManager() const { return FileMgr; }
SourceManager &getSourceManager() const { return SourceMgr; }
HeaderSearch &getHeaderSearchInfo() const { return HeaderInfo; }

IdentifierTable &getIdentifierTable() { return Identifiers; }
const IdentifierTable &getIdentifierTable() const { return Identifiers; }
SelectorTable &getSelectorTable() { return Selectors; }
Builtin::Context &getBuiltinInfo() { return *BuiltinInfo; }
llvm::BumpPtrAllocator &getPreprocessorAllocator() { return BP; }

void setExternalSource(ExternalPreprocessorSource *Source) {
  ExternalSource = Source;
}

ExternalPreprocessorSource *getExternalSource() const {
  return ExternalSource;
}

/// Retrieve the module loader associated with this preprocessor.
ModuleLoader &getModuleLoader() const { return TheModuleLoader; }

bool hadModuleLoaderFatalFailure() const {
  return TheModuleLoader.HadFatalFailure;
}

/// Retrieve the number of Directives that have been processed by the
/// Preprocessor.
unsigned getNumDirectives() const {
  return NumDirectives;
}

/// True if we are currently preprocessing a #if or #elif directive
bool isParsingIfOrElifDirective() const {
  return ParsingIfOrElifDirective;
}

/// Control whether the preprocessor retains comments in output.
void SetCommentRetentionState(bool KeepComments, bool KeepMacroComments) {
  this->KeepComments = KeepComments | KeepMacroComments;
  this->KeepMacroComments = KeepMacroComments;
}

bool getCommentRetentionState() const { return KeepComments; }

void setPragmasEnabled(bool Enabled) { PragmasEnabled = Enabled; }
bool getPragmasEnabled() const { return PragmasEnabled; }

void SetSuppressIncludeNotFoundError(bool Suppress) {
  SuppressIncludeNotFoundError = Suppress;
}

bool GetSuppressIncludeNotFoundError() {
  return SuppressIncludeNotFoundError;
}

/// Sets whether the preprocessor is responsible for producing output or if
/// it is producing tokens to be consumed by Parse and Sema.
void setPreprocessedOutput(bool IsPreprocessedOutput) {
  PreprocessedOutput = IsPreprocessedOutput;
}

/// Returns true if the preprocessor is responsible for generating output,
/// false if it is producing tokens to be consumed by Parse and Sema.
bool isPreprocessedOutput() const { return PreprocessedOutput; }

/// Return true if we are lexing directly from the specified lexer.
bool isCurrentLexer(const PreprocessorLexer *L) const {
  return CurPPLexer == L;
}

/// Return the current lexer being lexed from.
///
/// Note that this ignores any potentially active macro expansions and _Pragma
/// expansions going on at the time.
PreprocessorLexer *getCurrentLexer() const { return CurPPLexer; }

/// Return the current file lexer being lexed from.
///
/// Note that this ignores any potentially active macro expansions and _Pragma
/// expansions going on at the time.
PreprocessorLexer *getCurrentFileLexer() const;

/// Return the submodule owning the file being lexed. This may not be
/// the current module if we have changed modules since entering the file.
Module *getCurrentLexerSubmodule() const { return CurLexerSubmodule; }

/// Returns the FileID for the preprocessor predefines.
FileID getPredefinesFileID() const { return PredefinesFileID; }

/// \{
/// Accessors for preprocessor callbacks.
///
/// Note that this class takes ownership of any PPCallbacks object given to
/// it.
PPCallbacks *getPPCallbacks() const { return Callbacks.get(); }
void addPPCallbacks(std::unique_ptr<PPCallbacks> C) {
  if (Callbacks)
    C = std::make_unique<PPChainedCallbacks>(std::move(C),
                                              std::move(Callbacks));
  Callbacks = std::move(C);
}
/// \}

/// Get the number of tokens processed so far.
unsigned getTokenCount() const { return TokenCount; }

/// Get the max number of tokens before issuing a -Wmax-tokens warning.
unsigned getMaxTokens() const { return MaxTokens; }

void overrideMaxTokens(unsigned Value, SourceLocation Loc) {
  MaxTokens = Value;
  MaxTokensOverrideLoc = Loc;
};

SourceLocation getMaxTokensOverrideLoc() const { return MaxTokensOverrideLoc; }

/// Register a function that would be called on each token in the final
/// expanded token stream.
/// This also reports annotation tokens produced by the parser.
void setTokenWatcher(llvm::unique_function<void(const clang::Token &)> F) {
  OnToken = std::move(F);
}

void setPreprocessToken(bool Preprocess) { PreprocessToken = Preprocess; }

bool isMacroDefined(StringRef Id) {
  return isMacroDefined(&Identifiers.get(Id));
}
bool isMacroDefined(const IdentifierInfo *II) {
  return II->hasMacroDefinition() &&
         (!getLangOpts().Modules || (bool)getMacroDefinition(II));
}

/// Determine whether II is defined as a macro within the module M,
/// if that is a module that we've already preprocessed. Does not check for
/// macros imported into M.
bool isMacroDefinedInLocalModule(const IdentifierInfo *II, Module *M) {
  if (!II->hasMacroDefinition())
    return false;
  auto I = Submodules.find(M);
  if (I == Submodules.end())
    return false;
  auto J = I->second.Macros.find(II);
  if (J == I->second.Macros.end())
    return false;
  auto *MD = J->second.getLatest();
  return MD && MD->isDefined();
}

MacroDefinition getMacroDefinition(const IdentifierInfo *II) {
  if (!II->hasMacroDefinition())
5
←
Assuming the condition is false→
6
←
Taking false branch→
    return {};

  MacroState &S = CurSubmoduleState->Macros[II];
  auto *MD = S.getLatest();
  while (MD && isa<VisibilityMacroDirective>(MD))
7
←
Assuming 'MD' is null→
    MD = MD->getPrevious();
  return MacroDefinition(dyn_cast_or_null<DefMacroDirective>(MD),
8
←
Assuming null pointer is passed into cast→
                         S.getActiveModuleMacros(*this, II),
9
←
Calling 'MacroState::getActiveModuleMacros'→
                         S.isAmbiguous(*this, II));
}

MacroDefinition getMacroDefinitionAtLoc(const IdentifierInfo *II,
                                        SourceLocation Loc) {
  if (!II->hadMacroDefinition())
    return {};

  MacroState &S = CurSubmoduleState->Macros[II];
  MacroDirective::DefInfo DI;
  if (auto *MD = S.getLatest())
    DI = MD->findDirectiveAtLoc(Loc, getSourceManager());
  // FIXME: Compute the set of active module macros at the specified location.
  return MacroDefinition(DI.getDirective(),
                         S.getActiveModuleMacros(*this, II),
                         S.isAmbiguous(*this, II));
}

/// Given an identifier, return its latest non-imported MacroDirective
/// if it is \#define'd and not \#undef'd, or null if it isn't \#define'd.
MacroDirective *getLocalMacroDirective(const IdentifierInfo *II) const {
  if (!II->hasMacroDefinition())
    return nullptr;

  auto *MD = getLocalMacroDirectiveHistory(II);
  if (!MD || MD->getDefinition().isUndefined())
    return nullptr;

  return MD;
}

const MacroInfo *getMacroInfo(const IdentifierInfo *II) const {
  return const_cast<Preprocessor*>(this)->getMacroInfo(II);
}

MacroInfo *getMacroInfo(const IdentifierInfo *II) {
  if (!II->hasMacroDefinition())
    return nullptr;
  if (auto MD = getMacroDefinition(II))
    return MD.getMacroInfo();
  return nullptr;
}

/// Given an identifier, return the latest non-imported macro
/// directive for that identifier.
///
/// One can iterate over all previous macro directives from the most recent
/// one.
MacroDirective *getLocalMacroDirectiveHistory(const IdentifierInfo *II) const;

/// Add a directive to the macro directive history for this identifier.
void appendMacroDirective(IdentifierInfo *II, MacroDirective *MD);
DefMacroDirective *appendDefMacroDirective(IdentifierInfo *II, MacroInfo *MI,
                                           SourceLocation Loc) {
  DefMacroDirective *MD = AllocateDefMacroDirective(MI, Loc);
  appendMacroDirective(II, MD);
  return MD;
}
DefMacroDirective *appendDefMacroDirective(IdentifierInfo *II,
                                           MacroInfo *MI) {
  return appendDefMacroDirective(II, MI, MI->getDefinitionLoc());
}

/// Set a MacroDirective that was loaded from a PCH file.
void setLoadedMacroDirective(IdentifierInfo *II, MacroDirective *ED,
                             MacroDirective *MD);

/// Register an exported macro for a module and identifier.
ModuleMacro *addModuleMacro(Module *Mod, IdentifierInfo *II, MacroInfo *Macro,
                            ArrayRef<ModuleMacro *> Overrides, bool &IsNew);
ModuleMacro *getModuleMacro(Module *Mod, const IdentifierInfo *II);

/// Get the list of leaf (non-overridden) module macros for a name.
ArrayRef<ModuleMacro*> getLeafModuleMacros(const IdentifierInfo *II) const {
  if (II->isOutOfDate())
    updateOutOfDateIdentifier(const_cast<IdentifierInfo&>(*II));
  auto I = LeafModuleMacros.find(II);
  if (I != LeafModuleMacros.end())
    return I->second;
  return None;
}

/// Get the list of submodules that we're currently building.
ArrayRef<BuildingSubmoduleInfo> getBuildingSubmodules() const {
  return BuildingSubmoduleStack;
}

/// \{
/// Iterators for the macro history table. Currently defined macros have
/// IdentifierInfo::hasMacroDefinition() set and an empty
/// MacroInfo::getUndefLoc() at the head of the list.
using macro_iterator = MacroMap::const_iterator;

macro_iterator macro_begin(bool IncludeExternalMacros = true) const;
macro_iterator macro_end(bool IncludeExternalMacros = true) const;

llvm::iterator_range<macro_iterator>
macros(bool IncludeExternalMacros = true) const {
  macro_iterator begin = macro_begin(IncludeExternalMacros);
  macro_iterator end = macro_end(IncludeExternalMacros);
  return llvm::make_range(begin, end);
}

/// \}

/// Return the name of the macro defined before \p Loc that has
/// spelling \p Tokens.  If there are multiple macros with same spelling,
/// return the last one defined.
StringRef getLastMacroWithSpelling(SourceLocation Loc,
                                   ArrayRef<TokenValue> Tokens) const;

const std::string &getPredefines() const { return Predefines; }

/// Set the predefines for this Preprocessor.
///
/// These predefines are automatically injected when parsing the main file.
void setPredefines(const char *P) { Predefines = P; }
void setPredefines(StringRef P) { Predefines = std::string(P); }

/// Return information about the specified preprocessor
/// identifier token.
IdentifierInfo *getIdentifierInfo(StringRef Name) const {
  return &Identifiers.get(Name);
}

/// Add the specified pragma handler to this preprocessor.
///
/// If \p Namespace is non-null, then it is a token required to exist on the
/// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler);
void AddPragmaHandler(PragmaHandler *Handler) {
  AddPragmaHandler(StringRef(), Handler);
}

/// Remove the specific pragma handler from this preprocessor.
///
/// If \p Namespace is non-null, then it should be the namespace that
/// \p Handler was added to. It is an error to remove a handler that
/// has not been registered.
void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler);
void RemovePragmaHandler(PragmaHandler *Handler) {
  RemovePragmaHandler(StringRef(), Handler);
}

/// Install empty handlers for all pragmas (making them ignored).
void IgnorePragmas();

/// Set empty line handler.
void setEmptylineHandler(EmptylineHandler *Handler) { Emptyline = Handler; }

EmptylineHandler *getEmptylineHandler() const { return Emptyline; }

/// Add the specified comment handler to the preprocessor.
void addCommentHandler(CommentHandler *Handler);

/// Remove the specified comment handler.
///
/// It is an error to remove a handler that has not been registered.
void removeCommentHandler(CommentHandler *Handler);

/// Set the code completion handler to the given object.
void setCodeCompletionHandler(CodeCompletionHandler &Handler) {
  CodeComplete = &Handler;
}

/// Retrieve the current code-completion handler.
CodeCompletionHandler *getCodeCompletionHandler() const {
  return CodeComplete;
}

/// Clear out the code completion handler.
void clearCodeCompletionHandler() {
  CodeComplete = nullptr;
}

/// Hook used by the lexer to invoke the "included file" code
/// completion point.
void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);

/// Hook used by the lexer to invoke the "natural language" code
/// completion point.
void CodeCompleteNaturalLanguage();

/// Set the code completion token for filtering purposes.
void setCodeCompletionIdentifierInfo(IdentifierInfo *Filter) {
  CodeCompletionII = Filter;
}

/// Set the code completion token range for detecting replacement range later
/// on.
void setCodeCompletionTokenRange(const SourceLocation Start,
                                 const SourceLocation End) {
  CodeCompletionTokenRange = {Start, End};
}
SourceRange getCodeCompletionTokenRange() const {
  return CodeCompletionTokenRange;
}

/// Get the code completion token for filtering purposes.
StringRef getCodeCompletionFilter() {
  if (CodeCompletionII)
    return CodeCompletionII->getName();
  return {};
}

/// Retrieve the preprocessing record, or NULL if there is no
/// preprocessing record.
PreprocessingRecord *getPreprocessingRecord() const { return Record; }

/// Create a new preprocessing record, which will keep track of
/// all macro expansions, macro definitions, etc.
void createPreprocessingRecord();

/// Returns true if the FileEntry is the PCH through header.
bool isPCHThroughHeader(const FileEntry *FE);

/// True if creating a PCH with a through header.
bool creatingPCHWithThroughHeader();

/// True if using a PCH with a through header.
bool usingPCHWithThroughHeader();

/// True if creating a PCH with a #pragma hdrstop.
bool creatingPCHWithPragmaHdrStop();

/// True if using a PCH with a #pragma hdrstop.
bool usingPCHWithPragmaHdrStop();

/// Skip tokens until after the #include of the through header or
/// until after a #pragma hdrstop.
void SkipTokensWhileUsingPCH();

/// Process directives while skipping until the through header or
/// #pragma hdrstop is found.
void HandleSkippedDirectiveWhileUsingPCH(Token &Result,
                                         SourceLocation HashLoc);

/// Enter the specified FileID as the main source file,
/// which implicitly adds the builtin defines etc.
void EnterMainSourceFile();

/// Inform the preprocessor callbacks that processing is complete.
void EndSourceFile();

/// Add a source file to the top of the include stack and
/// start lexing tokens from it instead of the current buffer.
///
/// Emits a diagnostic, doesn't enter the file, and returns true on error.
bool EnterSourceFile(FileID FID, const DirectoryLookup *Dir,
                     SourceLocation Loc);

/// Add a Macro to the top of the include stack and start lexing
/// tokens from it instead of the current buffer.
///
/// \param Args specifies the tokens input to a function-like macro.
/// \param ILEnd specifies the location of the ')' for a function-like macro
/// or the identifier for an object-like macro.
void EnterMacro(Token &Tok, SourceLocation ILEnd, MacroInfo *Macro,
                MacroArgs *Args);

1345private:
/// Add a "macro" context to the top of the include stack,
/// which will cause the lexer to start returning the specified tokens.
///
/// If \p DisableMacroExpansion is true, tokens lexed from the token stream
/// will not be subject to further macro expansion. Otherwise, these tokens
/// will be re-macro-expanded when/if expansion is enabled.
///
/// If \p OwnsTokens is false, this method assumes that the specified stream
/// of tokens has a permanent owner somewhere, so they do not need to be
/// copied. If it is true, it assumes the array of tokens is allocated with
/// \c new[] and the Preprocessor will delete[] it.
///
/// If \p IsReinject the resulting tokens will have Token::IsReinjected flag
/// set, see the flag documentation for details.
void EnterTokenStream(const Token *Toks, unsigned NumToks,
                      bool DisableMacroExpansion, bool OwnsTokens,
                      bool IsReinject);

1364public:
void EnterTokenStream(std::unique_ptr<Token[]> Toks, unsigned NumToks,
                      bool DisableMacroExpansion, bool IsReinject) {
  EnterTokenStream(Toks.release(), NumToks, DisableMacroExpansion, true,
                   IsReinject);
}

void EnterTokenStream(ArrayRef<Token> Toks, bool DisableMacroExpansion,
                      bool IsReinject) {
  EnterTokenStream(Toks.data(), Toks.size(), DisableMacroExpansion, false,
                   IsReinject);
}

/// Pop the current lexer/macro exp off the top of the lexer stack.
///
/// This should only be used in situations where the current state of the
/// top-of-stack lexer is known.
void RemoveTopOfLexerStack();

/// From the point that this method is called, and until
/// CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor
/// keeps track of the lexed tokens so that a subsequent Backtrack() call will
/// make the Preprocessor re-lex the same tokens.
///
/// Nested backtracks are allowed, meaning that EnableBacktrackAtThisPos can
/// be called multiple times and CommitBacktrackedTokens/Backtrack calls will
/// be combined with the EnableBacktrackAtThisPos calls in reverse order.
///
/// NOTE: *DO NOT* forget to call either CommitBacktrackedTokens or Backtrack
/// at some point after EnableBacktrackAtThisPos. If you don't, caching of
/// tokens will continue indefinitely.
///
void EnableBacktrackAtThisPos();

/// Disable the last EnableBacktrackAtThisPos call.
void CommitBacktrackedTokens();

/// Make Preprocessor re-lex the tokens that were lexed since
/// EnableBacktrackAtThisPos() was previously called.
void Backtrack();

/// True if EnableBacktrackAtThisPos() was called and
/// caching of tokens is on.
bool isBacktrackEnabled() const { return !BacktrackPositions.empty(); }

/// Lex the next token for this preprocessor.
void Lex(Token &Result);

/// Lex a token, forming a header-name token if possible.
bool LexHeaderName(Token &Result, bool AllowMacroExpansion = true);

bool LexAfterModuleImport(Token &Result);
void CollectPpImportSuffix(SmallVectorImpl<Token> &Toks);

void makeModuleVisible(Module *M, SourceLocation Loc);

SourceLocation getModuleImportLoc(Module *M) const {
  return CurSubmoduleState->VisibleModules.getImportLoc(M);
}

/// Lex a string literal, which may be the concatenation of multiple
/// string literals and may even come from macro expansion.
/// \returns true on success, false if a error diagnostic has been generated.
bool LexStringLiteral(Token &Result, std::string &String,
                      const char *DiagnosticTag, bool AllowMacroExpansion) {
  if (AllowMacroExpansion)
    Lex(Result);
  else
    LexUnexpandedToken(Result);
  return FinishLexStringLiteral(Result, String, DiagnosticTag,
                                AllowMacroExpansion);
}

/// Complete the lexing of a string literal where the first token has
/// already been lexed (see LexStringLiteral).
bool FinishLexStringLiteral(Token &Result, std::string &String,
                            const char *DiagnosticTag,
                            bool AllowMacroExpansion);

/// Lex a token.  If it's a comment, keep lexing until we get
/// something not a comment.
///
/// This is useful in -E -C mode where comments would foul up preprocessor
/// directive handling.
void LexNonComment(Token &Result) {
  do
    Lex(Result);
  while (Result.getKind() == tok::comment);
}

/// Just like Lex, but disables macro expansion of identifier tokens.
void LexUnexpandedToken(Token &Result) {
  // Disable macro expansion.
  bool OldVal = DisableMacroExpansion;
  DisableMacroExpansion = true;
  // Lex the token.
  Lex(Result);

  // Reenable it.
  DisableMacroExpansion = OldVal;
}

/// Like LexNonComment, but this disables macro expansion of
/// identifier tokens.
void LexUnexpandedNonComment(Token &Result) {
  do
    LexUnexpandedToken(Result);
  while (Result.getKind() == tok::comment);
}

/// Parses a simple integer literal to get its numeric value.  Floating
/// point literals and user defined literals are rejected.  Used primarily to
/// handle pragmas that accept integer arguments.
bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value);

/// Disables macro expansion everywhere except for preprocessor directives.
void SetMacroExpansionOnlyInDirectives() {
  DisableMacroExpansion = true;
  MacroExpansionInDirectivesOverride = true;
}

/// Peeks ahead N tokens and returns that token without consuming any
/// tokens.
///
/// LookAhead(0) returns the next token that would be returned by Lex(),
/// LookAhead(1) returns the token after it, etc.  This returns normal
/// tokens after phase 5.  As such, it is equivalent to using
/// 'Lex', not 'LexUnexpandedToken'.
const Token &LookAhead(unsigned N) {
  assert(LexLevel == 0 && "cannot use lookahead while lexing")((void)0);
  if (CachedLexPos + N < CachedTokens.size())
    return CachedTokens[CachedLexPos+N];
  else
    return PeekAhead(N+1);
}

/// When backtracking is enabled and tokens are cached,
/// this allows to revert a specific number of tokens.
///
/// Note that the number of tokens being reverted should be up to the last
/// backtrack position, not more.
void RevertCachedTokens(unsigned N) {
  assert(isBacktrackEnabled() &&((void)0)
         "Should only be called when tokens are cached for backtracking")((void)0);
  assert(signed(CachedLexPos) - signed(N) >= signed(BacktrackPositions.back())((void)0)
       && "Should revert tokens up to the last backtrack position, not more")((void)0);
  assert(signed(CachedLexPos) - signed(N) >= 0 &&((void)0)
         "Corrupted backtrack positions ?")((void)0);
  CachedLexPos -= N;
}

/// Enters a token in the token stream to be lexed next.
///
/// If BackTrack() is called afterwards, the token will remain at the
/// insertion point.
/// If \p IsReinject is true, resulting token will have Token::IsReinjected
/// flag set. See the flag documentation for details.
void EnterToken(const Token &Tok, bool IsReinject) {
  if (LexLevel) {
    // It's not correct in general to enter caching lex mode while in the
    // middle of a nested lexing action.
    auto TokCopy = std::make_unique<Token[]>(1);
    TokCopy[0] = Tok;
    EnterTokenStream(std::move(TokCopy), 1, true, IsReinject);
  } else {
    EnterCachingLexMode();
    assert(IsReinject && "new tokens in the middle of cached stream")((void)0);
    CachedTokens.insert(CachedTokens.begin()+CachedLexPos, Tok);
  }
}

/// We notify the Preprocessor that if it is caching tokens (because
/// backtrack is enabled) it should replace the most recent cached tokens
/// with the given annotation token. This function has no effect if
/// backtracking is not enabled.
///
/// Note that the use of this function is just for optimization, so that the
/// cached tokens doesn't get re-parsed and re-resolved after a backtrack is
/// invoked.
void AnnotateCachedTokens(const Token &Tok) {
  assert(Tok.isAnnotation() && "Expected annotation token")((void)0);
  if (CachedLexPos != 0 && isBacktrackEnabled())
    AnnotatePreviousCachedTokens(Tok);
}

/// Get the location of the last cached token, suitable for setting the end
/// location of an annotation token.
SourceLocation getLastCachedTokenLocation() const {
  assert(CachedLexPos != 0)((void)0);
  return CachedTokens[CachedLexPos-1].getLastLoc();
}

/// Whether \p Tok is the most recent token (`CachedLexPos - 1`) in
/// CachedTokens.
bool IsPreviousCachedToken(const Token &Tok) const;

/// Replace token in `CachedLexPos - 1` in CachedTokens by the tokens
/// in \p NewToks.
///
/// Useful when a token needs to be split in smaller ones and CachedTokens
/// most recent token must to be updated to reflect that.
void ReplacePreviousCachedToken(ArrayRef<Token> NewToks);

/// Replace the last token with an annotation token.
///
/// Like AnnotateCachedTokens(), this routine replaces an
/// already-parsed (and resolved) token with an annotation
/// token. However, this routine only replaces the last token with
/// the annotation token; it does not affect any other cached
/// tokens. This function has no effect if backtracking is not
/// enabled.
void ReplaceLastTokenWithAnnotation(const Token &Tok) {
  assert(Tok.isAnnotation() && "Expected annotation token")((void)0);
  if (CachedLexPos != 0 && isBacktrackEnabled())
    CachedTokens[CachedLexPos-1] = Tok;
}

/// Enter an annotation token into the token stream.
void EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind,
                          void *AnnotationVal);

/// Determine whether it's possible for a future call to Lex to produce an
/// annotation token created by a previous call to EnterAnnotationToken.
bool mightHavePendingAnnotationTokens() {
  return CurLexerKind != CLK_Lexer;
}

/// Update the current token to represent the provided
/// identifier, in order to cache an action performed by typo correction.
void TypoCorrectToken(const Token &Tok) {
  assert(Tok.getIdentifierInfo() && "Expected identifier token")((void)0);
  if (CachedLexPos != 0 && isBacktrackEnabled())
    CachedTokens[CachedLexPos-1] = Tok;
}

/// Recompute the current lexer kind based on the CurLexer/
/// CurTokenLexer pointers.
void recomputeCurLexerKind();

/// Returns true if incremental processing is enabled
bool isIncrementalProcessingEnabled() const { return IncrementalProcessing; }

/// Enables the incremental processing
void enableIncrementalProcessing(bool value = true) {
  IncrementalProcessing = value;
}

/// Specify the point at which code-completion will be performed.
///
/// \param File the file in which code completion should occur. If
/// this file is included multiple times, code-completion will
/// perform completion the first time it is included. If NULL, this
/// function clears out the code-completion point.
///
/// \param Line the line at which code completion should occur
/// (1-based).
///
/// \param Column the column at which code completion should occur
/// (1-based).
///
/// \returns true if an error occurred, false otherwise.
bool SetCodeCompletionPoint(const FileEntry *File,
                            unsigned Line, unsigned Column);

/// Determine if we are performing code completion.
bool isCodeCompletionEnabled() const { return CodeCompletionFile != nullptr; }

/// Returns the location of the code-completion point.
///
/// Returns an invalid location if code-completion is not enabled or the file
/// containing the code-completion point has not been lexed yet.
SourceLocation getCodeCompletionLoc() const { return CodeCompletionLoc; }

/// Returns the start location of the file of code-completion point.
///
/// Returns an invalid location if code-completion is not enabled or the file
/// containing the code-completion point has not been lexed yet.
SourceLocation getCodeCompletionFileLoc() const {
  return CodeCompletionFileLoc;
}

/// Returns true if code-completion is enabled and we have hit the
/// code-completion point.
bool isCodeCompletionReached() const { return CodeCompletionReached; }

/// Note that we hit the code-completion point.
void setCodeCompletionReached() {
  assert(isCodeCompletionEnabled() && "Code-completion not enabled!")((void)0);
  CodeCompletionReached = true;
  // Silence any diagnostics that occur after we hit the code-completion.
  getDiagnostics().setSuppressAllDiagnostics(true);
}

/// The location of the currently-active \#pragma clang
/// arc_cf_code_audited begin.
///
/// Returns an invalid location if there is no such pragma active.
std::pair<IdentifierInfo *, SourceLocation>
getPragmaARCCFCodeAuditedInfo() const {
  return PragmaARCCFCodeAuditedInfo;
}

/// Set the location of the currently-active \#pragma clang
/// arc_cf_code_audited begin.  An invalid location ends the pragma.
void setPragmaARCCFCodeAuditedInfo(IdentifierInfo *Ident,
                                   SourceLocation Loc) {
  PragmaARCCFCodeAuditedInfo = {Ident, Loc};
}

/// The location of the currently-active \#pragma clang
/// assume_nonnull begin.
///
/// Returns an invalid location if there is no such pragma active.
SourceLocation getPragmaAssumeNonNullLoc() const {
  return PragmaAssumeNonNullLoc;
}

/// Set the location of the currently-active \#pragma clang
/// assume_nonnull begin.  An invalid location ends the pragma.
void setPragmaAssumeNonNullLoc(SourceLocation Loc) {
  PragmaAssumeNonNullLoc = Loc;
}

/// Set the directory in which the main file should be considered
/// to have been found, if it is not a real file.
void setMainFileDir(const DirectoryEntry *Dir) {
  MainFileDir = Dir;
}

/// Instruct the preprocessor to skip part of the main source file.
///
/// \param Bytes The number of bytes in the preamble to skip.
///
/// \param StartOfLine Whether skipping these bytes puts the lexer at the
/// start of a line.
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine) {
  SkipMainFilePreamble.first = Bytes;
  SkipMainFilePreamble.second = StartOfLine;
}

/// Forwarding function for diagnostics.  This emits a diagnostic at
/// the specified Token's location, translating the token's start
/// position in the current buffer into a SourcePosition object for rendering.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const {
  return Diags->Report(Loc, DiagID);
}

DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID) const {
  return Diags->Report(Tok.getLocation(), DiagID);
}

/// Return the 'spelling' of the token at the given
/// location; does not go up to the spelling location or down to the
/// expansion location.
///
/// \param buffer A buffer which will be used only if the token requires
///   "cleaning", e.g. if it contains trigraphs or escaped newlines
/// \param invalid If non-null, will be set \c true if an error occurs.
StringRef getSpelling(SourceLocation loc,
                      SmallVectorImpl<char> &buffer,
                      bool *invalid = nullptr) const {
  return Lexer::getSpelling(loc, buffer, SourceMgr, LangOpts, invalid);
}

/// Return the 'spelling' of the Tok token.
///
/// The spelling of a token is the characters used to represent the token in
/// the source file after trigraph expansion and escaped-newline folding.  In
/// particular, this wants to get the true, uncanonicalized, spelling of
/// things like digraphs, UCNs, etc.
///
/// \param Invalid If non-null, will be set \c true if an error occurs.
std::string getSpelling(const Token &Tok, bool *Invalid = nullptr) const {
  return Lexer::getSpelling(Tok, SourceMgr, LangOpts, Invalid);
}

/// Get the spelling of a token into a preallocated buffer, instead
/// of as an std::string.
///
/// The caller is required to allocate enough space for the token, which is
/// guaranteed to be at least Tok.getLength() bytes long. The length of the
/// actual result is returned.
///
/// Note that this method may do two possible things: it may either fill in
/// the buffer specified with characters, or it may *change the input pointer*
/// to point to a constant buffer with the data already in it (avoiding a
/// copy).  The caller is not allowed to modify the returned buffer pointer
/// if an internal buffer is returned.
unsigned getSpelling(const Token &Tok, const char *&Buffer,
                     bool *Invalid = nullptr) const {
  return Lexer::getSpelling(Tok, Buffer, SourceMgr, LangOpts, Invalid);
}

/// Get the spelling of a token into a SmallVector.
///
/// Note that the returned StringRef may not point to the
/// supplied buffer if a copy can be avoided.
StringRef getSpelling(const Token &Tok,
                      SmallVectorImpl<char> &Buffer,
                      bool *Invalid = nullptr) const;

/// Relex the token at the specified location.
/// \returns true if there was a failure, false on success.
bool getRawToken(SourceLocation Loc, Token &Result,
                 bool IgnoreWhiteSpace = false) {
  return Lexer::getRawToken(Loc, Result, SourceMgr, LangOpts, IgnoreWhiteSpace);
}

/// Given a Token \p Tok that is a numeric constant with length 1,
/// return the character.
char
getSpellingOfSingleCharacterNumericConstant(const Token &Tok,
                                            bool *Invalid = nullptr) const {
  assert(Tok.is(tok::numeric_constant) &&((void)0)
         Tok.getLength() == 1 && "Called on unsupported token")((void)0);
  assert(!Tok.needsCleaning() && "Token can't need cleaning with length 1")((void)0);

  // If the token is carrying a literal data pointer, just use it.
  if (const char *D = Tok.getLiteralData())
    return *D;

  // Otherwise, fall back on getCharacterData, which is slower, but always
  // works.
  return *SourceMgr.getCharacterData(Tok.getLocation(), Invalid);
}

/// Retrieve the name of the immediate macro expansion.
///
/// This routine starts from a source location, and finds the name of the
/// macro responsible for its immediate expansion. It looks through any
/// intervening macro argument expansions to compute this. It returns a
/// StringRef that refers to the SourceManager-owned buffer of the source
/// where that macro name is spelled. Thus, the result shouldn't out-live
/// the SourceManager.
StringRef getImmediateMacroName(SourceLocation Loc) {
  return Lexer::getImmediateMacroName(Loc, SourceMgr, getLangOpts());
}

/// Plop the specified string into a scratch buffer and set the
/// specified token's location and length to it.
///
/// If specified, the source location provides a location of the expansion
/// point of the token.
void CreateString(StringRef Str, Token &Tok,
                  SourceLocation ExpansionLocStart = SourceLocation(),
                  SourceLocation ExpansionLocEnd = SourceLocation());

/// Split the first Length characters out of the token starting at TokLoc
/// and return a location pointing to the split token. Re-lexing from the
/// split token will return the split token rather than the original.
SourceLocation SplitToken(SourceLocation TokLoc, unsigned Length);

/// Computes the source location just past the end of the
/// token at this source location.
///
/// This routine can be used to produce a source location that
/// points just past the end of the token referenced by \p Loc, and
/// is generally used when a diagnostic needs to point just after a
/// token where it expected something different that it received. If
/// the returned source location would not be meaningful (e.g., if
/// it points into a macro), this routine returns an invalid
/// source location.
///
/// \param Offset an offset from the end of the token, where the source
/// location should refer to. The default offset (0) produces a source
/// location pointing just past the end of the token; an offset of 1 produces
/// a source location pointing to the last character in the token, etc.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0) {
  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
}

/// Returns true if the given MacroID location points at the first
/// token of the macro expansion.
///
/// \param MacroBegin If non-null and function returns true, it is set to
/// begin location of the macro.
bool isAtStartOfMacroExpansion(SourceLocation loc,
                               SourceLocation *MacroBegin = nullptr) const {
  return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts,
                                          MacroBegin);
}

/// Returns true if the given MacroID location points at the last
/// token of the macro expansion.
///
/// \param MacroEnd If non-null and function returns true, it is set to
/// end location of the macro.
bool isAtEndOfMacroExpansion(SourceLocation loc,
                             SourceLocation *MacroEnd = nullptr) const {
  return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd);
}

/// Print the token to stderr, used for debugging.
void DumpToken(const Token &Tok, bool DumpFlags = false) const;
void DumpLocation(SourceLocation Loc) const;
void DumpMacro(const MacroInfo &MI) const;
void dumpMacroInfo(const IdentifierInfo *II);

/// Given a location that specifies the start of a
/// token, return a new location that specifies a character within the token.
SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart,
                                       unsigned Char) const {
  return Lexer::AdvanceToTokenCharacter(TokStart, Char, SourceMgr, LangOpts);
}

/// Increment the counters for the number of token paste operations
/// performed.
///
/// If fast was specified, this is a 'fast paste' case we handled.
void IncrementPasteCounter(bool isFast) {
  if (isFast)
    ++NumFastTokenPaste;
  else
    ++NumTokenPaste;
}

void PrintStats();

size_t getTotalMemory() const;

/// When the macro expander pastes together a comment (/##/) in Microsoft
/// mode, this method handles updating the current state, returning the
/// token on the next source line.
void HandleMicrosoftCommentPaste(Token &Tok);

//===--------------------------------------------------------------------===//
// Preprocessor callback methods.  These are invoked by a lexer as various
// directives and events are found.

/// Given a tok::raw_identifier token, look up the
/// identifier information for the token and install it into the token,
/// updating the token kind accordingly.
IdentifierInfo *LookUpIdentifierInfo(Token &Identifier) const;

1898private:
llvm::DenseMap<IdentifierInfo*,unsigned> PoisonReasons;

1901public:
/// Specifies the reason for poisoning an identifier.
///
/// If that identifier is accessed while poisoned, then this reason will be
/// used instead of the default "poisoned" diagnostic.
void SetPoisonReason(IdentifierInfo *II, unsigned DiagID);

/// Display reason for poisoned identifier.
void HandlePoisonedIdentifier(Token & Identifier);

void MaybeHandlePoisonedIdentifier(Token & Identifier) {
  if(IdentifierInfo * II = Identifier.getIdentifierInfo()) {
    if(II->isPoisoned()) {
      HandlePoisonedIdentifier(Identifier);
    }
  }
}

1919private:
/// Identifiers used for SEH handling in Borland. These are only
/// allowed in particular circumstances
// __except block
IdentifierInfo *Ident__exception_code,
               *Ident___exception_code,
               *Ident_GetExceptionCode;
// __except filter expression
IdentifierInfo *Ident__exception_info,
               *Ident___exception_info,
               *Ident_GetExceptionInfo;
// __finally
IdentifierInfo *Ident__abnormal_termination,
               *Ident___abnormal_termination,
               *Ident_AbnormalTermination;

const char *getCurLexerEndPos();
void diagnoseMissingHeaderInUmbrellaDir(const Module &Mod);

1938public:
void PoisonSEHIdentifiers(bool Poison = true); // Borland

/// Callback invoked when the lexer reads an identifier and has
/// filled in the tokens IdentifierInfo member.
///
/// This callback potentially macro expands it or turns it into a named
/// token (like 'for').
///
/// \returns true if we actually computed a token, false if we need to
/// lex again.
bool HandleIdentifier(Token &Identifier);

/// Callback invoked when the lexer hits the end of the current file.
///
/// This either returns the EOF token and returns true, or
/// pops a level off the include stack and returns false, at which point the
/// client should call lex again.
bool HandleEndOfFile(Token &Result, SourceLocation Loc,
                     bool isEndOfMacro = false);

/// Callback invoked when the current TokenLexer hits the end of its
/// token stream.
bool HandleEndOfTokenLexer(Token &Result);

/// Callback invoked when the lexer sees a # token at the start of a
/// line.
///
/// This consumes the directive, modifies the lexer/preprocessor state, and
/// advances the lexer(s) so that the next token read is the correct one.
void HandleDirective(Token &Result);

/// Ensure that the next token is a tok::eod token.
///
/// If not, emit a diagnostic and consume up until the eod.
/// If \p EnableMacros is true, then we consider macros that expand to zero
/// tokens as being ok.
///
/// \return The location of the end of the directive (the terminating
/// newline).
SourceLocation CheckEndOfDirective(const char *DirType,
                                   bool EnableMacros = false);

/// Read and discard all tokens remaining on the current line until
/// the tok::eod token is found. Returns the range of the skipped tokens.
SourceRange DiscardUntilEndOfDirective();

/// Returns true if the preprocessor has seen a use of
/// __DATE__ or __TIME__ in the file so far.
bool SawDateOrTime() const {
  return DATELoc != SourceLocation() || TIMELoc != SourceLocation();
}
unsigned getCounterValue() const { return CounterValue; }
void setCounterValue(unsigned V) { CounterValue = V; }

/// Retrieves the module that we're currently building, if any.
Module *getCurrentModule();

/// Allocate a new MacroInfo object with the provided SourceLocation.
MacroInfo *AllocateMacroInfo(SourceLocation L);

/// Turn the specified lexer token into a fully checked and spelled
/// filename, e.g. as an operand of \#include.
///
/// The caller is expected to provide a buffer that is large enough to hold
/// the spelling of the filename, but is also expected to handle the case
/// when this method decides to use a different buffer.
///
/// \returns true if the input filename was in <>'s or false if it was
/// in ""'s.
bool GetIncludeFilenameSpelling(SourceLocation Loc,StringRef &Buffer);

/// Given a "foo" or \<foo> reference, look up the indicated file.
///
/// Returns None on failure.  \p isAngled indicates whether the file
/// reference is for system \#include's or not (i.e. using <> instead of "").
Optional<FileEntryRef>
LookupFile(SourceLocation FilenameLoc, StringRef Filename, bool isAngled,
           const DirectoryLookup *FromDir, const FileEntry *FromFile,
           const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,
           SmallVectorImpl<char> *RelativePath,
           ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped,
           bool *IsFrameworkFound, bool SkipCache = false);

/// Get the DirectoryLookup structure used to find the current
/// FileEntry, if CurLexer is non-null and if applicable.
///
/// This allows us to implement \#include_next and find directory-specific
/// properties.
const DirectoryLookup *GetCurDirLookup() { return CurDirLookup; }

/// Return true if we're in the top-level file, not in a \#include.
bool isInPrimaryFile() const;

/// Lex an on-off-switch (C99 6.10.6p2) and verify that it is
/// followed by EOD.  Return true if the token is not a valid on-off-switch.
bool LexOnOffSwitch(tok::OnOffSwitch &Result);

bool CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
                    bool *ShadowFlag = nullptr);

void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma);
Module *LeaveSubmodule(bool ForPragma);

2042private:
friend void TokenLexer::ExpandFunctionArguments();

void PushIncludeMacroStack() {
  assert(CurLexerKind != CLK_CachingLexer && "cannot push a caching lexer")((void)0);
  IncludeMacroStack.emplace_back(CurLexerKind, CurLexerSubmodule,
                                 std::move(CurLexer), CurPPLexer,
                                 std::move(CurTokenLexer), CurDirLookup);
  CurPPLexer = nullptr;
}

void PopIncludeMacroStack() {
  CurLexer = std::move(IncludeMacroStack.back().TheLexer);
  CurPPLexer = IncludeMacroStack.back().ThePPLexer;
  CurTokenLexer = std::move(IncludeMacroStack.back().TheTokenLexer);
  CurDirLookup  = IncludeMacroStack.back().TheDirLookup;
  CurLexerSubmodule = IncludeMacroStack.back().TheSubmodule;
  CurLexerKind = IncludeMacroStack.back().CurLexerKind;
  IncludeMacroStack.pop_back();
}

void PropagateLineStartLeadingSpaceInfo(Token &Result);

/// Determine whether we need to create module macros for #defines in the
/// current context.
bool needModuleMacros() const;

/// Update the set of active module macros and ambiguity flag for a module
/// macro name.
void updateModuleMacroInfo(const IdentifierInfo *II, ModuleMacroInfo &Info);

DefMacroDirective *AllocateDefMacroDirective(MacroInfo *MI,
                                             SourceLocation Loc);
UndefMacroDirective *AllocateUndefMacroDirective(SourceLocation UndefLoc);
VisibilityMacroDirective *AllocateVisibilityMacroDirective(SourceLocation Loc,
                                                           bool isPublic);

/// Lex and validate a macro name, which occurs after a
/// \#define or \#undef.
///
/// \param MacroNameTok Token that represents the name defined or undefined.
/// \param IsDefineUndef Kind if preprocessor directive.
/// \param ShadowFlag Points to flag that is set if macro name shadows
///                   a keyword.
///
/// This emits a diagnostic, sets the token kind to eod,
/// and discards the rest of the macro line if the macro name is invalid.
void ReadMacroName(Token &MacroNameTok, MacroUse IsDefineUndef = MU_Other,
                   bool *ShadowFlag = nullptr);

/// ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the
/// entire line) of the macro's tokens and adds them to MacroInfo, and while
/// doing so performs certain validity checks including (but not limited to):
///   - # (stringization) is followed by a macro parameter
/// \param MacroNameTok - Token that represents the macro name
/// \param ImmediatelyAfterHeaderGuard - Macro follows an #ifdef header guard
///
///  Either returns a pointer to a MacroInfo object OR emits a diagnostic and
///  returns a nullptr if an invalid sequence of tokens is encountered.
MacroInfo *ReadOptionalMacroParameterListAndBody(
    const Token &MacroNameTok, bool ImmediatelyAfterHeaderGuard);

/// The ( starting an argument list of a macro definition has just been read.
/// Lex the rest of the parameters and the closing ), updating \p MI with
/// what we learn and saving in \p LastTok the last token read.
/// Return true if an error occurs parsing the arg list.
bool ReadMacroParameterList(MacroInfo *MI, Token& LastTok);

/// We just read a \#if or related directive and decided that the
/// subsequent tokens are in the \#if'd out portion of the
/// file.  Lex the rest of the file, until we see an \#endif.  If \p
/// FoundNonSkipPortion is true, then we have already emitted code for part of
/// this \#if directive, so \#else/\#elif blocks should never be entered. If
/// \p FoundElse is false, then \#else directives are ok, if not, then we have
/// already seen one so a \#else directive is a duplicate.  When this returns,
/// the caller can lex the first valid token.
void SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,
                                  SourceLocation IfTokenLoc,
                                  bool FoundNonSkipPortion, bool FoundElse,
                                  SourceLocation ElseLoc = SourceLocation());

/// Information about the result for evaluating an expression for a
/// preprocessor directive.
struct DirectiveEvalResult {
  /// Whether the expression was evaluated as true or not.
  bool Conditional;

  /// True if the expression contained identifiers that were undefined.
  bool IncludedUndefinedIds;

  /// The source range for the expression.
  SourceRange ExprRange;
};

/// Evaluate an integer constant expression that may occur after a
/// \#if or \#elif directive and return a \p DirectiveEvalResult object.
///
/// If the expression is equivalent to "!defined(X)" return X in IfNDefMacro.
DirectiveEvalResult EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro);

/// Install the standard preprocessor pragmas:
/// \#pragma GCC poison/system_header/dependency and \#pragma once.
void RegisterBuiltinPragmas();

/// Register builtin macros such as __LINE__ with the identifier table.
void RegisterBuiltinMacros();

/// If an identifier token is read that is to be expanded as a macro, handle
/// it and return the next token as 'Tok'.  If we lexed a token, return true;
/// otherwise the caller should lex again.
bool HandleMacroExpandedIdentifier(Token &Identifier, const MacroDefinition &MD);

/// Cache macro expanded tokens for TokenLexers.
//
/// Works like a stack; a TokenLexer adds the macro expanded tokens that is
/// going to lex in the cache and when it finishes the tokens are removed
/// from the end of the cache.
Token *cacheMacroExpandedTokens(TokenLexer *tokLexer,
                                ArrayRef<Token> tokens);

void removeCachedMacroExpandedTokensOfLastLexer();

/// Determine whether the next preprocessor token to be
/// lexed is a '('.  If so, consume the token and return true, if not, this
/// method should have no observable side-effect on the lexed tokens.
bool isNextPPTokenLParen();

/// After reading "MACRO(", this method is invoked to read all of the formal
/// arguments specified for the macro invocation.  Returns null on error.
MacroArgs *ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI,
                                     SourceLocation &MacroEnd);

/// If an identifier token is read that is to be expanded
/// as a builtin macro, handle it and return the next token as 'Tok'.
void ExpandBuiltinMacro(Token &Tok);

/// Read a \c _Pragma directive, slice it up, process it, then
/// return the first token after the directive.
/// This assumes that the \c _Pragma token has just been read into \p Tok.
void Handle_Pragma(Token &Tok);

/// Like Handle_Pragma except the pragma text is not enclosed within
/// a string literal.
void HandleMicrosoft__pragma(Token &Tok);

/// Add a lexer to the top of the include stack and
/// start lexing tokens from it instead of the current buffer.
void EnterSourceFileWithLexer(Lexer *TheLexer, const DirectoryLookup *Dir);

/// Set the FileID for the preprocessor predefines.
void setPredefinesFileID(FileID FID) {
  assert(PredefinesFileID.isInvalid() && "PredefinesFileID already set!")((void)0);
  PredefinesFileID = FID;
}

/// Set the FileID for the PCH through header.
void setPCHThroughHeaderFileID(FileID FID);

/// Returns true if we are lexing from a file and not a
/// pragma or a macro.
static bool IsFileLexer(const Lexer* L, const PreprocessorLexer* P) {
  return L ? !L->isPragmaLexer() : P != nullptr;
}

static bool IsFileLexer(const IncludeStackInfo& I) {
  return IsFileLexer(I.TheLexer.get(), I.ThePPLexer);
}

bool IsFileLexer() const {
  return IsFileLexer(CurLexer.get(), CurPPLexer);
}

//===--------------------------------------------------------------------===//
// Caching stuff.
void CachingLex(Token &Result);

bool InCachingLexMode() const {
  // If the Lexer pointers are 0 and IncludeMacroStack is empty, it means
  // that we are past EOF, not that we are in CachingLex mode.
  return !CurPPLexer && !CurTokenLexer && !IncludeMacroStack.empty();
}

void EnterCachingLexMode();
void EnterCachingLexModeUnchecked();

void ExitCachingLexMode() {
  if (InCachingLexMode())
    RemoveTopOfLexerStack();
}

const Token &PeekAhead(unsigned N);
void AnnotatePreviousCachedTokens(const Token &Tok);

//===--------------------------------------------------------------------===//
/// Handle*Directive - implement the various preprocessor directives.  These
/// should side-effect the current preprocessor object so that the next call
/// to Lex() will return the appropriate token next.
void HandleLineDirective();
void HandleDigitDirective(Token &Tok);
void HandleUserDiagnosticDirective(Token &Tok, bool isWarning);
void HandleIdentSCCSDirective(Token &Tok);
void HandleMacroPublicDirective(Token &Tok);
void HandleMacroPrivateDirective();

/// An additional notification that can be produced by a header inclusion or
/// import to tell the parser what happened.
struct ImportAction {
  enum ActionKind {
    None,
    ModuleBegin,
    ModuleImport,
    SkippedModuleImport,
    Failure,
  } Kind;
  Module *ModuleForHeader = nullptr;

  ImportAction(ActionKind AK, Module *Mod = nullptr)
      : Kind(AK), ModuleForHeader(Mod) {
    assert((AK == None || Mod || AK == Failure) &&((void)0)
           "no module for module action")((void)0);
  }
};

Optional<FileEntryRef> LookupHeaderIncludeOrImport(
    const DirectoryLookup *&CurDir, StringRef &Filename,
    SourceLocation FilenameLoc, CharSourceRange FilenameRange,
    const Token &FilenameTok, bool &IsFrameworkFound, bool IsImportDecl,
    bool &IsMapped, const DirectoryLookup *LookupFrom,
    const FileEntry *LookupFromFile, StringRef &LookupFilename,
    SmallVectorImpl<char> &RelativePath, SmallVectorImpl<char> &SearchPath,
    ModuleMap::KnownHeader &SuggestedModule, bool isAngled);

// File inclusion.
void HandleIncludeDirective(SourceLocation HashLoc, Token &Tok,
                            const DirectoryLookup *LookupFrom = nullptr,
                            const FileEntry *LookupFromFile = nullptr);
ImportAction
HandleHeaderIncludeOrImport(SourceLocation HashLoc, Token &IncludeTok,
                            Token &FilenameTok, SourceLocation EndLoc,
                            const DirectoryLookup *LookupFrom = nullptr,
                            const FileEntry *LookupFromFile = nullptr);
void HandleIncludeNextDirective(SourceLocation HashLoc, Token &Tok);
void HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &Tok);
void HandleImportDirective(SourceLocation HashLoc, Token &Tok);
void HandleMicrosoftImportDirective(Token &Tok);

2288public:
/// Check that the given module is available, producing a diagnostic if not.
/// \return \c true if the check failed (because the module is not available).
///         \c false if the module appears to be usable.
static bool checkModuleIsAvailable(const LangOptions &LangOpts,
                                   const TargetInfo &TargetInfo,
                                   DiagnosticsEngine &Diags, Module *M);

// Module inclusion testing.
/// Find the module that owns the source or header file that
/// \p Loc points to. If the location is in a file that was included
/// into a module, or is outside any module, returns nullptr.
Module *getModuleForLocation(SourceLocation Loc);

/// We want to produce a diagnostic at location IncLoc concerning an
/// unreachable effect at location MLoc (eg, where a desired entity was
/// declared or defined). Determine whether the right way to make MLoc
/// reachable is by #include, and if so, what header should be included.
///
/// This is not necessarily fast, and might load unexpected module maps, so
/// should only be called by code that intends to produce an error.
///
/// \param IncLoc The location at which the missing effect was detected.
/// \param MLoc A location within an unimported module at which the desired
///        effect occurred.
/// \return A file that can be #included to provide the desired effect. Null
///         if no such file could be determined or if a #include is not
///         appropriate (eg, if a module should be imported instead).
const FileEntry *getHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
                                                  SourceLocation MLoc);

bool isRecordingPreamble() const {
  return PreambleConditionalStack.isRecording();
}

bool hasRecordedPreamble() const {
  return PreambleConditionalStack.hasRecordedPreamble();
}

ArrayRef<PPConditionalInfo> getPreambleConditionalStack() const {
    return PreambleConditionalStack.getStack();
}

void setRecordedPreambleConditionalStack(ArrayRef<PPConditionalInfo> s) {
  PreambleConditionalStack.setStack(s);
}

void setReplayablePreambleConditionalStack(ArrayRef<PPConditionalInfo> s,
                                           llvm::Optional<PreambleSkipInfo> SkipInfo) {
  PreambleConditionalStack.startReplaying();
  PreambleConditionalStack.setStack(s);
  PreambleConditionalStack.SkipInfo = SkipInfo;
}

llvm::Optional<PreambleSkipInfo> getPreambleSkipInfo() const {
  return PreambleConditionalStack.SkipInfo;
}

2346private:
/// After processing predefined file, initialize the conditional stack from
/// the preamble.
void replayPreambleConditionalStack();

// Macro handling.
void HandleDefineDirective(Token &Tok, bool ImmediatelyAfterHeaderGuard);
void HandleUndefDirective();

// Conditional Inclusion.
void HandleIfdefDirective(Token &Result, const Token &HashToken,
                          bool isIfndef, bool ReadAnyTokensBeforeDirective);
void HandleIfDirective(Token &IfToken, const Token &HashToken,
                       bool ReadAnyTokensBeforeDirective);
void HandleEndifDirective(Token &EndifToken);
void HandleElseDirective(Token &Result, const Token &HashToken);
void HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken,
                               tok::PPKeywordKind Kind);

// Pragmas.
void HandlePragmaDirective(PragmaIntroducer Introducer);
void ResolvePragmaIncludeInstead(SourceLocation Location) const;

2369public:
void HandlePragmaOnce(Token &OnceTok);
void HandlePragmaMark(Token &MarkTok);
void HandlePragmaPoison();
void HandlePragmaSystemHeader(Token &SysHeaderTok);
void HandlePragmaIncludeInstead(Token &Tok);
void HandlePragmaDependency(Token &DependencyTok);
void HandlePragmaPushMacro(Token &Tok);
void HandlePragmaPopMacro(Token &Tok);
void HandlePragmaIncludeAlias(Token &Tok);
void HandlePragmaModuleBuild(Token &Tok);
void HandlePragmaHdrstop(Token &Tok);
IdentifierInfo *ParsePragmaPushOrPopMacro(Token &Tok);

// Return true and store the first token only if any CommentHandler
// has inserted some tokens and getCommentRetentionState() is false.
bool HandleComment(Token &result, SourceRange Comment);

/// A macro is used, update information about macros that need unused
/// warnings.
void markMacroAsUsed(MacroInfo *MI);

2391private:
Optional<unsigned>
getSkippedRangeForExcludedConditionalBlock(SourceLocation HashLoc);

/// Contains the currently active skipped range mappings for skipping excluded
/// conditional directives.
ExcludedPreprocessorDirectiveSkipMapping
    *ExcludedConditionalDirectiveSkipMappings;
2399};

2401/// Abstract base class that describes a handler that will receive
2402/// source ranges for each of the comments encountered in the source file.
2403class CommentHandler {
2404public:
virtual ~CommentHandler();

// The handler shall return true if it has pushed any tokens
// to be read using e.g. EnterToken or EnterTokenStream.
virtual bool HandleComment(Preprocessor &PP, SourceRange Comment) = 0;
2410};

2412/// Abstract base class that describes a handler that will receive
2413/// source ranges for empty lines encountered in the source file.
2414class EmptylineHandler {
2415public:
virtual ~EmptylineHandler();

// The handler handles empty lines.
virtual void HandleEmptyline(SourceRange Range) = 0;
2420};

2422/// Registry of pragma handlers added by plugins
2423using PragmaHandlerRegistry = llvm::Registry<PragmaHandler>;

2425} // namespace clang

2427#endif // LLVM_CLANG_LEX_PREPROCESSOR_H

←

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include/llvm/Support/Allocator.h

→

1//===- Allocator.h - Simple memory allocation abstraction -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms
11/// to the LLVM "Allocator" concept and is similar to MallocAllocator, but
12/// objects cannot be deallocated. Their lifetime is tied to the lifetime of the
13/// allocator.
14///
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_SUPPORT_ALLOCATOR_H
18#define LLVM_SUPPORT_ALLOCATOR_H

20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/Support/Alignment.h"
23#include "llvm/Support/AllocatorBase.h"
24#include "llvm/Support/Compiler.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/MathExtras.h"
27#include "llvm/Support/MemAlloc.h"
28#include <algorithm>
29#include <cassert>
30#include <cstddef>
31#include <cstdint>
32#include <cstdlib>
33#include <iterator>
34#include <type_traits>
35#include <utility>

37namespace llvm {

39namespace detail {

41// We call out to an external function to actually print the message as the
42// printing code uses Allocator.h in its implementation.
43void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
                              size_t TotalMemory);

46} // end namespace detail

48/// Allocate memory in an ever growing pool, as if by bump-pointer.
49///
50/// This isn't strictly a bump-pointer allocator as it uses backing slabs of
51/// memory rather than relying on a boundless contiguous heap. However, it has
52/// bump-pointer semantics in that it is a monotonically growing pool of memory
53/// where every allocation is found by merely allocating the next N bytes in
54/// the slab, or the next N bytes in the next slab.
55///
56/// Note that this also has a threshold for forcing allocations above a certain
57/// size into their own slab.
58///
59/// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
60/// object, which wraps malloc, to allocate memory, but it can be changed to
61/// use a custom allocator.
62///
63/// The GrowthDelay specifies after how many allocated slabs the allocator
64/// increases the size of the slabs.
65template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
        size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
67class BumpPtrAllocatorImpl
  : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay>>,
    private AllocatorT {
71public:
static_assert(SizeThreshold <= SlabSize,
              "The SizeThreshold must be at most the SlabSize to ensure "
              "that objects larger than a slab go into their own memory "
              "allocation.");
static_assert(GrowthDelay > 0,
              "GrowthDelay must be at least 1 which already increases the"
              "slab size after each allocated slab.");

BumpPtrAllocatorImpl() = default;

template <typename T>
BumpPtrAllocatorImpl(T &&Allocator)
    : AllocatorT(std::forward<T &&>(Allocator)) {}

// Manually implement a move constructor as we must clear the old allocator's
// slabs as a matter of correctness.
BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
    : AllocatorT(static_cast<AllocatorT &&>(Old)), CurPtr(Old.CurPtr),
      End(Old.End), Slabs(std::move(Old.Slabs)),
      CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
      BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) {
  Old.CurPtr = Old.End = nullptr;
  Old.BytesAllocated = 0;
  Old.Slabs.clear();
  Old.CustomSizedSlabs.clear();
}

~BumpPtrAllocatorImpl() {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();
}

BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();

  CurPtr = RHS.CurPtr;
  End = RHS.End;
  BytesAllocated = RHS.BytesAllocated;
  RedZoneSize = RHS.RedZoneSize;
  Slabs = std::move(RHS.Slabs);
  CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
  AllocatorT::operator=(static_cast<AllocatorT &&>(RHS));

  RHS.CurPtr = RHS.End = nullptr;
  RHS.BytesAllocated = 0;
  RHS.Slabs.clear();
  RHS.CustomSizedSlabs.clear();
  return *this;
}

/// Deallocate all but the current slab and reset the current pointer
/// to the beginning of it, freeing all memory allocated so far.
void Reset() {
  // Deallocate all but the first slab, and deallocate all custom-sized slabs.
  DeallocateCustomSizedSlabs();
  CustomSizedSlabs.clear();

  if (Slabs.empty())
    return;

  // Reset the state.
  BytesAllocated = 0;
  CurPtr = (char *)Slabs.front();
  End = CurPtr + SlabSize;

  __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
  DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
  Slabs.erase(std::next(Slabs.begin()), Slabs.end());
}

/// Allocate space at the specified alignment.
LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, Align Alignment) {
  // Keep track of how many bytes we've allocated.
  BytesAllocated += Size;

  size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment);
21
←
Calling 'offsetToAlignedAddr'→
  assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow")((void)0);

  size_t SizeToAllocate = Size;
153#if LLVM_ADDRESS_SANITIZER_BUILD0
  // Add trailing bytes as a "red zone" under ASan.
  SizeToAllocate += RedZoneSize;
156#endif

  // Check if we have enough space.
  if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
    char *AlignedPtr = CurPtr + Adjustment;
    CurPtr = AlignedPtr + SizeToAllocate;
    // Update the allocation point of this memory block in MemorySanitizer.
    // Without this, MemorySanitizer messages for values originated from here
    // will point to the allocation of the entire slab.
    __msan_allocated_memory(AlignedPtr, Size);
    // Similarly, tell ASan about this space.
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // If Size is really big, allocate a separate slab for it.
  size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
  if (PaddedSize > SizeThreshold) {
    void *NewSlab =
        AllocatorT::Allocate(PaddedSize, alignof(std::max_align_t));
    // We own the new slab and don't want anyone reading anyting other than
    // pieces returned from this method.  So poison the whole slab.
    __asan_poison_memory_region(NewSlab, PaddedSize);
    CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));

    uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
    assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize)((void)0);
    char *AlignedPtr = (char*)AlignedAddr;
    __msan_allocated_memory(AlignedPtr, Size);
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // Otherwise, start a new slab and try again.
  StartNewSlab();
  uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
  assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&((void)0)
         "Unable to allocate memory!")((void)0);
  char *AlignedPtr = (char*)AlignedAddr;
  CurPtr = AlignedPtr + SizeToAllocate;
  __msan_allocated_memory(AlignedPtr, Size);
  __asan_unpoison_memory_region(AlignedPtr, Size);
  return AlignedPtr;
}

inline LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, size_t Alignment) {
  assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.")((void)0);
  return Allocate(Size, Align(Alignment));
20
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;

// Bump pointer allocators are expected to never free their storage; and
// clients expect pointers to remain valid for non-dereferencing uses even
// after deallocation.
void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
  __asan_poison_memory_region(Ptr, Size);
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;

size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }

/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
/// The returned value is negative iff the object is inside a custom-size
/// slab.
/// Returns an empty optional if the pointer is not found in the allocator.
llvm::Optional<int64_t> identifyObject(const void *Ptr) {
  const char *P = static_cast<const char *>(Ptr);
  int64_t InSlabIdx = 0;
  for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(Slabs[Idx]);
    if (P >= S && P < S + computeSlabSize(Idx))
      return InSlabIdx + static_cast<int64_t>(P - S);
    InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx));
  }

  // Use negative index to denote custom sized slabs.
  int64_t InCustomSizedSlabIdx = -1;
  for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first);
    size_t Size = CustomSizedSlabs[Idx].second;
    if (P >= S && P < S + Size)
      return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
    InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
  }
  return None;
}

/// A wrapper around identifyObject that additionally asserts that
/// the object is indeed within the allocator.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
int64_t identifyKnownObject(const void *Ptr) {
  Optional<int64_t> Out = identifyObject(Ptr);
  assert(Out && "Wrong allocator used")((void)0);
  return *Out;
}

/// A wrapper around identifyKnownObject. Accepts type information
/// about the object and produces a smaller identifier by relying on
/// the alignment information. Note that sub-classes may have different
/// alignment, so the most base class should be passed as template parameter
/// in order to obtain correct results. For that reason automatic template
/// parameter deduction is disabled.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator. This identifier is
/// different from the ones produced by identifyObject and
/// identifyAlignedObject.
template <typename T>
int64_t identifyKnownAlignedObject(const void *Ptr) {
  int64_t Out = identifyKnownObject(Ptr);
  assert(Out % alignof(T) == 0 && "Wrong alignment information")((void)0);
  return Out / alignof(T);
}

size_t getTotalMemory() const {
  size_t TotalMemory = 0;
  for (auto I = Slabs.begin(), E = Slabs.end(); I != E; ++I)
    TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
  for (auto &PtrAndSize : CustomSizedSlabs)
    TotalMemory += PtrAndSize.second;
  return TotalMemory;
}

size_t getBytesAllocated() const { return BytesAllocated; }

void setRedZoneSize(size_t NewSize) {
  RedZoneSize = NewSize;
}

void PrintStats() const {
  detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
                                     getTotalMemory());
}

296private:
/// The current pointer into the current slab.
///
/// This points to the next free byte in the slab.
char *CurPtr = nullptr;

/// The end of the current slab.
char *End = nullptr;

/// The slabs allocated so far.
SmallVector<void *, 4> Slabs;

/// Custom-sized slabs allocated for too-large allocation requests.
SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;

/// How many bytes we've allocated.
///
/// Used so that we can compute how much space was wasted.
size_t BytesAllocated = 0;

/// The number of bytes to put between allocations when running under
/// a sanitizer.
size_t RedZoneSize = 1;

static size_t computeSlabSize(unsigned SlabIdx) {
  // Scale the actual allocated slab size based on the number of slabs
  // allocated. Every GrowthDelay slabs allocated, we double
  // the allocated size to reduce allocation frequency, but saturate at
  // multiplying the slab size by 2^30.
  return SlabSize *
         ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay));
}

/// Allocate a new slab and move the bump pointers over into the new
/// slab, modifying CurPtr and End.
void StartNewSlab() {
  size_t AllocatedSlabSize = computeSlabSize(Slabs.size());

  void *NewSlab =
      AllocatorT::Allocate(AllocatedSlabSize, alignof(std::max_align_t));
  // We own the new slab and don't want anyone reading anything other than
  // pieces returned from this method.  So poison the whole slab.
  __asan_poison_memory_region(NewSlab, AllocatedSlabSize);

  Slabs.push_back(NewSlab);
  CurPtr = (char *)(NewSlab);
  End = ((char *)NewSlab) + AllocatedSlabSize;
}

/// Deallocate a sequence of slabs.
void DeallocateSlabs(SmallVectorImpl<void *>::iterator I,
                     SmallVectorImpl<void *>::iterator E) {
  for (; I != E; ++I) {
    size_t AllocatedSlabSize =
        computeSlabSize(std::distance(Slabs.begin(), I));
    AllocatorT::Deallocate(*I, AllocatedSlabSize, alignof(std::max_align_t));
  }
}

/// Deallocate all memory for custom sized slabs.
void DeallocateCustomSizedSlabs() {
  for (auto &PtrAndSize : CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    AllocatorT::Deallocate(Ptr, Size, alignof(std::max_align_t));
  }
}

template <typename T> friend class SpecificBumpPtrAllocator;
365};

367/// The standard BumpPtrAllocator which just uses the default template
368/// parameters.
369typedef BumpPtrAllocatorImpl<> BumpPtrAllocator;

371/// A BumpPtrAllocator that allows only elements of a specific type to be
372/// allocated.
373///
374/// This allows calling the destructor in DestroyAll() and when the allocator is
375/// destroyed.
376template <typename T> class SpecificBumpPtrAllocator {
BumpPtrAllocator Allocator;

379public:
SpecificBumpPtrAllocator() {
  // Because SpecificBumpPtrAllocator walks the memory to call destructors,
  // it can't have red zones between allocations.
  Allocator.setRedZoneSize(0);
}
SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
    : Allocator(std::move(Old.Allocator)) {}
~SpecificBumpPtrAllocator() { DestroyAll(); }

SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
  Allocator = std::move(RHS.Allocator);
  return *this;
}

/// Call the destructor of each allocated object and deallocate all but the
/// current slab and reset the current pointer to the beginning of it, freeing
/// all memory allocated so far.
void DestroyAll() {
  auto DestroyElements = [](char *Begin, char *End) {
    assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()))((void)0);
    for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
      reinterpret_cast<T *>(Ptr)->~T();
  };

  for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
       ++I) {
    size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
        std::distance(Allocator.Slabs.begin(), I));
    char *Begin = (char *)alignAddr(*I, Align::Of<T>());
    char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                             : (char *)*I + AllocatedSlabSize;

    DestroyElements(Begin, End);
  }

  for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
                    (char *)Ptr + Size);
  }

  Allocator.Reset();
}

/// Allocate space for an array of objects without constructing them.
T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
427};

429} // end namespace llvm

431template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
433void *
434operator new(size_t Size,
           llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
                                      GrowthDelay> &Allocator) {
return Allocator.Allocate(Size, std::min((size_t)llvm::NextPowerOf2(Size),
19
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
                                         alignof(std::max_align_t)));
439}

441template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
443void operator delete(void *,
                   llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay> &) {
446}

448#endif // LLVM_SUPPORT_ALLOCATOR_H

←

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include/llvm/Support/Alignment.h

1//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains types to represent alignments.
10// They are instrumented to guarantee some invariants are preserved and prevent
11// invalid manipulations.
12//
13// - Align represents an alignment in bytes, it is always set and always a valid
14// power of two, its minimum value is 1 which means no alignment requirements.
15//
16// - MaybeAlign is an optional type, it may be undefined or set. When it's set
17// you can get the underlying Align type by using the getValue() method.
18//
19//===----------------------------------------------------------------------===//
20 
21#ifndef LLVM_SUPPORT_ALIGNMENT_H_
22#define LLVM_SUPPORT_ALIGNMENT_H_
23 
24#include "llvm/ADT/Optional.h"
25#include "llvm/Support/MathExtras.h"
26#include <cassert>
27#ifndef NDEBUG1
28#include <string>
29#endif // NDEBUG
30 
31namespace llvm {
32 
33#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
34  assert(decl > 0 && (#decl " should be defined"))((void)0)
35 
36/// This struct is a compact representation of a valid (non-zero power of two)
37/// alignment.
38/// It is suitable for use as static global constants.
39struct Align {
40private:
41  uint8_t ShiftValue = 0; /// The log2 of the required alignment.
42                          /// ShiftValue is less than 64 by construction.
43 
44  friend struct MaybeAlign;
45  friend unsigned Log2(Align);
46  friend bool operator==(Align Lhs, Align Rhs);
47  friend bool operator!=(Align Lhs, Align Rhs);
48  friend bool operator<=(Align Lhs, Align Rhs);
49  friend bool operator>=(Align Lhs, Align Rhs);
50  friend bool operator<(Align Lhs, Align Rhs);
51  friend bool operator>(Align Lhs, Align Rhs);
52  friend unsigned encode(struct MaybeAlign A);
53  friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
54 
55  /// A trivial type to allow construction of constexpr Align.
56  /// This is currently needed to workaround a bug in GCC 5.3 which prevents
57  /// definition of constexpr assign operators.
58  /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic
59  /// FIXME: Remove this, make all assign operators constexpr and introduce user
60  /// defined literals when we don't have to support GCC 5.3 anymore.
61  /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
62  struct LogValue {
63    uint8_t Log;
64  };
65 
66public:
67  /// Default is byte-aligned.
68  constexpr Align() = default;
69  /// Do not perform checks in case of copy/move construct/assign, because the
70  /// checks have been performed when building `Other`.
71  constexpr Align(const Align &Other) = default;
72  constexpr Align(Align &&Other) = default;
73  Align &operator=(const Align &Other) = default;
74  Align &operator=(Align &&Other) = default;
75 
76  explicit Align(uint64_t Value) {
77    assert(Value > 0 && "Value must not be 0")((void)0);
78    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2")((void)0);
79    ShiftValue = Log2_64(Value);
80    assert(ShiftValue < 64 && "Broken invariant")((void)0);
81  }
82 
83  /// This is a hole in the type system and should not be abused.
84  /// Needed to interact with C for instance.
85  uint64_t value() const { return uint64_t(1) << ShiftValue; }
26
←
The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'
86 
87  /// Allow constructions of constexpr Align.
88  template <size_t kValue> constexpr static LogValue Constant() {
89    return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
90  }
91 
92  /// Allow constructions of constexpr Align from types.
93  /// Compile time equivalent to Align(alignof(T)).
94  template <typename T> constexpr static LogValue Of() {
95    return Constant<std::alignment_of<T>::value>();
96  }
97 
98  /// Constexpr constructor from LogValue type.
99  constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
100};
101 
102/// Treats the value 0 as a 1, so Align is always at least 1.
103inline Align assumeAligned(uint64_t Value) {
104  return Value ? Align(Value) : Align();
105}
106 
107/// This struct is a compact representation of a valid (power of two) or
108/// undefined (0) alignment.
109struct MaybeAlign : public llvm::Optional<Align> {
110private:
111  using UP = llvm::Optional<Align>;
112 
113public:
114  /// Default is undefined.
115  MaybeAlign() = default;
116  /// Do not perform checks in case of copy/move construct/assign, because the
117  /// checks have been performed when building `Other`.
118  MaybeAlign(const MaybeAlign &Other) = default;
119  MaybeAlign &operator=(const MaybeAlign &Other) = default;
120  MaybeAlign(MaybeAlign &&Other) = default;
121  MaybeAlign &operator=(MaybeAlign &&Other) = default;
122 
123  /// Use llvm::Optional<Align> constructor.
124  using UP::UP;
125 
126  explicit MaybeAlign(uint64_t Value) {
127    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&((void)0)
128           "Alignment is neither 0 nor a power of 2")((void)0);
129    if (Value)
130      emplace(Value);
131  }
132 
133  /// For convenience, returns a valid alignment or 1 if undefined.
134  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
135};
136 
137/// Checks that SizeInBytes is a multiple of the alignment.
138inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
139  return SizeInBytes % Lhs.value() == 0;
140}
141 
142/// Checks that Addr is a multiple of the alignment.
143inline bool isAddrAligned(Align Lhs, const void *Addr) {
144  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
145}
146 
147/// Returns a multiple of A needed to store `Size` bytes.
148inline uint64_t alignTo(uint64_t Size, Align A) {
149  const uint64_t Value = A.value();
25
←
Calling 'Align::value'→
150  // The following line is equivalent to `(Size + Value - 1) / Value * Value`.
151 
152  // The division followed by a multiplication can be thought of as a right
153  // shift followed by a left shift which zeros out the extra bits produced in
154  // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out
155  // are just zero.
156 
157  // Most compilers can generate this code but the pattern may be missed when
158  // multiple functions gets inlined.
159  return (Size + Value - 1) & ~(Value - 1U);
160}
161 
162/// If non-zero \p Skew is specified, the return value will be a minimal integer
163/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for
164/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p
165/// Skew mod \p A'.
166///
167/// Examples:
168/// \code
169///   alignTo(5, Align(8), 7) = 7
170///   alignTo(17, Align(8), 1) = 17
171///   alignTo(~0LL, Align(8), 3) = 3
172/// \endcode
173inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) {
174  const uint64_t Value = A.value();
175  Skew %= Value;
176  return ((Size + Value - 1 - Skew) & ~(Value - 1U)) + Skew;
177}
178 
179/// Returns a multiple of A needed to store `Size` bytes.
180/// Returns `Size` if current alignment is undefined.
181inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
182  return A ? alignTo(Size, A.getValue()) : Size;
183}
184 
185/// Aligns `Addr` to `Alignment` bytes, rounding up.
186inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
187  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
188  assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=((void)0)
189             ArithAddr &&((void)0)
190         "Overflow")((void)0);
191  return alignTo(ArithAddr, Alignment);
192}
193 
194/// Returns the offset to the next integer (mod 2**64) that is greater than
195/// or equal to \p Value and is a multiple of \p Align.
196inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
197  return alignTo(Value, Alignment) - Value;
23
←
The value 255 is assigned to 'A.ShiftValue'→
24
←
Calling 'alignTo'→
198}
199 
200/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
201/// bytes, rounding up.
202inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
203  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
22
←
Calling 'offsetToAlignment'→
204}
205 
206/// Returns the log2 of the alignment.
207inline unsigned Log2(Align A) { return A.ShiftValue; }
208 
209/// Returns the alignment that satisfies both alignments.
210/// Same semantic as MinAlign.
211inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
212 
213/// Returns the alignment that satisfies both alignments.
214/// Same semantic as MinAlign.
215inline Align commonAlignment(Align A, uint64_t Offset) {
216  return Align(MinAlign(A.value(), Offset));
217}
218 
219/// Returns the alignment that satisfies both alignments.
220/// Same semantic as MinAlign.
221inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
222  return A && B ? commonAlignment(*A, *B) : A ? A : B;
223}
224 
225/// Returns the alignment that satisfies both alignments.
226/// Same semantic as MinAlign.
227inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
228  return MaybeAlign(MinAlign((*A).value(), Offset));
229}
230 
231/// Returns a representation of the alignment that encodes undefined as 0.
232inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
233 
234/// Dual operation of the encode function above.
235inline MaybeAlign decodeMaybeAlign(unsigned Value) {
236  if (Value == 0)
237    return MaybeAlign();
238  Align Out;
239  Out.ShiftValue = Value - 1;
240  return Out;
241}
242 
243/// Returns a representation of the alignment, the encoded value is positive by
244/// definition.
245inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
246 
247/// Comparisons between Align and scalars. Rhs must be positive.
248inline bool operator==(Align Lhs, uint64_t Rhs) {
249  ALIGN_CHECK_ISPOSITIVE(Rhs);
250  return Lhs.value() == Rhs;
251}
252inline bool operator!=(Align Lhs, uint64_t Rhs) {
253  ALIGN_CHECK_ISPOSITIVE(Rhs);
254  return Lhs.value() != Rhs;
255}
256inline bool operator<=(Align Lhs, uint64_t Rhs) {
257  ALIGN_CHECK_ISPOSITIVE(Rhs);
258  return Lhs.value() <= Rhs;
259}
260inline bool operator>=(Align Lhs, uint64_t Rhs) {
261  ALIGN_CHECK_ISPOSITIVE(Rhs);
262  return Lhs.value() >= Rhs;
263}
264inline bool operator<(Align Lhs, uint64_t Rhs) {
265  ALIGN_CHECK_ISPOSITIVE(Rhs);
266  return Lhs.value() < Rhs;
267}
268inline bool operator>(Align Lhs, uint64_t Rhs) {
269  ALIGN_CHECK_ISPOSITIVE(Rhs);
270  return Lhs.value() > Rhs;
271}
272 
273/// Comparisons between MaybeAlign and scalars.
274inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
275  return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
276}
277inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
278  return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
279}
280 
281/// Comparisons operators between Align.
282inline bool operator==(Align Lhs, Align Rhs) {
283  return Lhs.ShiftValue == Rhs.ShiftValue;
284}
285inline bool operator!=(Align Lhs, Align Rhs) {
286  return Lhs.ShiftValue != Rhs.ShiftValue;
287}
288inline bool operator<=(Align Lhs, Align Rhs) {
289  return Lhs.ShiftValue <= Rhs.ShiftValue;
290}
291inline bool operator>=(Align Lhs, Align Rhs) {
292  return Lhs.ShiftValue >= Rhs.ShiftValue;
293}
294inline bool operator<(Align Lhs, Align Rhs) {
295  return Lhs.ShiftValue < Rhs.ShiftValue;
296}
297inline bool operator>(Align Lhs, Align Rhs) {
298  return Lhs.ShiftValue > Rhs.ShiftValue;
299}
300 
301// Don't allow relational comparisons with MaybeAlign.
302bool operator<=(Align Lhs, MaybeAlign Rhs) = delete;
303bool operator>=(Align Lhs, MaybeAlign Rhs) = delete;
304bool operator<(Align Lhs, MaybeAlign Rhs) = delete;
305bool operator>(Align Lhs, MaybeAlign Rhs) = delete;
306 
307bool operator<=(MaybeAlign Lhs, Align Rhs) = delete;
308bool operator>=(MaybeAlign Lhs, Align Rhs) = delete;
309bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
310bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
311 
312bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
313bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
314bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
315bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
316 
317inline Align operator*(Align Lhs, uint64_t Rhs) {
318  assert(Rhs > 0 && "Rhs must be positive")((void)0);
319  return Align(Lhs.value() * Rhs);
320}
321 
322inline MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) {
323  assert(Rhs > 0 && "Rhs must be positive")((void)0);
324  return Lhs ? Lhs.getValue() * Rhs : MaybeAlign();
325}
326 
327inline Align operator/(Align Lhs, uint64_t Divisor) {
328  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
329         "Divisor must be positive and a power of 2")((void)0);
330  assert(Lhs != 1 && "Can't halve byte alignment")((void)0);
331  return Align(Lhs.value() / Divisor);
332}
333 
334inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
335  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
336         "Divisor must be positive and a power of 2")((void)0);
337  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
338}
339 
340inline Align max(MaybeAlign Lhs, Align Rhs) {
341  return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
342}
343 
344inline Align max(Align Lhs, MaybeAlign Rhs) {
345  return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
346}
347 
348#ifndef NDEBUG1
349// For usage in LLVM_DEBUG macros.
350inline std::string DebugStr(const Align &A) {
351  return std::to_string(A.value());
352}
353// For usage in LLVM_DEBUG macros.
354inline std::string DebugStr(const MaybeAlign &MA) {
355  if (MA)
356    return std::to_string(MA->value());
357  return "None";
358}
359#endif // NDEBUG
360 
361#undef ALIGN_CHECK_ISPOSITIVE
362 
363} // namespace llvm
364 
365#endif // LLVM_SUPPORT_ALIGNMENT_H_