/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 PPDirectives.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/PPDirectives.cpp

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

→

1//===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//
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/// Implements # directive processing for the Preprocessor.
11///
12//===----------------------------------------------------------------------===//

14#include "clang/Basic/CharInfo.h"
15#include "clang/Basic/FileManager.h"
16#include "clang/Basic/IdentifierTable.h"
17#include "clang/Basic/LangOptions.h"
18#include "clang/Basic/Module.h"
19#include "clang/Basic/SourceLocation.h"
20#include "clang/Basic/SourceManager.h"
21#include "clang/Basic/TokenKinds.h"
22#include "clang/Lex/CodeCompletionHandler.h"
23#include "clang/Lex/HeaderSearch.h"
24#include "clang/Lex/LexDiagnostic.h"
25#include "clang/Lex/LiteralSupport.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/Pragma.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Lex/PreprocessorOptions.h"
33#include "clang/Lex/Token.h"
34#include "clang/Lex/VariadicMacroSupport.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/ScopeExit.h"
37#include "llvm/ADT/SmallString.h"
38#include "llvm/ADT/SmallVector.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/StringSwitch.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/Support/AlignOf.h"
43#include "llvm/Support/ErrorHandling.h"
44#include "llvm/Support/Path.h"
45#include <algorithm>
46#include <cassert>
47#include <cstring>
48#include <new>
49#include <string>
50#include <utility>

52using namespace clang;

54//===----------------------------------------------------------------------===//
55// Utility Methods for Preprocessor Directive Handling.
56//===----------------------------------------------------------------------===//

58MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};
17
←
Calling 'operator new<llvm::MallocAllocator, 4096UL, 4096UL, 128UL>'→
MIChainHead = MIChain;
return &MIChain->MI;
62}

64DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
                                                         SourceLocation Loc) {
return new (BP) DefMacroDirective(MI, Loc);
67}

69UndefMacroDirective *
70Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
return new (BP) UndefMacroDirective(UndefLoc);
72}

74VisibilityMacroDirective *
75Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
                                             bool isPublic) {
return new (BP) VisibilityMacroDirective(Loc, isPublic);
78}

80/// Read and discard all tokens remaining on the current line until
81/// the tok::eod token is found.
82SourceRange Preprocessor::DiscardUntilEndOfDirective() {
Token Tmp;
SourceRange Res;

LexUnexpandedToken(Tmp);
Res.setBegin(Tmp.getLocation());
while (Tmp.isNot(tok::eod)) {
  assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens")((void)0);
  LexUnexpandedToken(Tmp);
}
Res.setEnd(Tmp.getLocation());
return Res;
94}

96/// Enumerates possible cases of #define/#undef a reserved identifier.
97enum MacroDiag {
MD_NoWarn,        //> Not a reserved identifier
MD_KeywordDef,    //> Macro hides keyword, enabled by default
MD_ReservedMacro  //> #define of #undef reserved id, disabled by default
101};

103/// Enumerates possible %select values for the pp_err_elif_after_else and
104/// pp_err_elif_without_if diagnostics.
105enum PPElifDiag {
PED_Elif,
PED_Elifdef,
PED_Elifndef
109};

111// The -fmodule-name option tells the compiler to textually include headers in
112// the specified module, meaning clang won't build the specified module. This is
113// useful in a number of situations, for instance, when building a library that
114// vends a module map, one might want to avoid hitting intermediate build
115// products containing the the module map or avoid finding the system installed
116// modulemap for that library.
117static bool isForModuleBuilding(Module *M, StringRef CurrentModule,
                              StringRef ModuleName) {
StringRef TopLevelName = M->getTopLevelModuleName();

// When building framework Foo, we wanna make sure that Foo *and* Foo_Private
// are textually included and no modules are built for both.
if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName &&
    !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private"))
  TopLevelName = TopLevelName.drop_back(8);

return TopLevelName == CurrentModule;
128}

130static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
const LangOptions &Lang = PP.getLangOpts();
if (II->isReserved(Lang) != ReservedIdentifierStatus::NotReserved) {
  // list from:
  // - https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html
  // - https://docs.microsoft.com/en-us/cpp/c-runtime-library/security-features-in-the-crt?view=msvc-160
  // - man 7 feature_test_macros
  // The list must be sorted for correct binary search.
  static constexpr StringRef ReservedMacro[] = {
      "_ATFILE_SOURCE",
      "_BSD_SOURCE",
      "_CRT_NONSTDC_NO_WARNINGS",
      "_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES",
      "_CRT_SECURE_NO_WARNINGS",
      "_FILE_OFFSET_BITS",
      "_FORTIFY_SOURCE",
      "_GLIBCXX_ASSERTIONS",
      "_GLIBCXX_CONCEPT_CHECKS",
      "_GLIBCXX_DEBUG",
      "_GLIBCXX_DEBUG_PEDANTIC",
      "_GLIBCXX_PARALLEL",
      "_GLIBCXX_PARALLEL_ASSERTIONS",
      "_GLIBCXX_SANITIZE_VECTOR",
      "_GLIBCXX_USE_CXX11_ABI",
      "_GLIBCXX_USE_DEPRECATED",
      "_GNU_SOURCE",
      "_ISOC11_SOURCE",
      "_ISOC95_SOURCE",
      "_ISOC99_SOURCE",
      "_LARGEFILE64_SOURCE",
      "_POSIX_C_SOURCE",
      "_REENTRANT",
      "_SVID_SOURCE",
      "_THREAD_SAFE",
      "_XOPEN_SOURCE",
      "_XOPEN_SOURCE_EXTENDED",
      "__STDCPP_WANT_MATH_SPEC_FUNCS__",
      "__STDC_FORMAT_MACROS",
  };
  if (std::binary_search(std::begin(ReservedMacro), std::end(ReservedMacro),
                         II->getName()))
    return MD_NoWarn;

  return MD_ReservedMacro;
}
StringRef Text = II->getName();
if (II->isKeyword(Lang))
  return MD_KeywordDef;
if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
  return MD_KeywordDef;
return MD_NoWarn;
181}

183static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
const LangOptions &Lang = PP.getLangOpts();
// Do not warn on keyword undef.  It is generally harmless and widely used.
if (II->isReserved(Lang) != ReservedIdentifierStatus::NotReserved)
  return MD_ReservedMacro;
return MD_NoWarn;
189}

191// Return true if we want to issue a diagnostic by default if we
192// encounter this name in a #include with the wrong case. For now,
193// this includes the standard C and C++ headers, Posix headers,
194// and Boost headers. Improper case for these #includes is a
195// potential portability issue.
196static bool warnByDefaultOnWrongCase(StringRef Include) {
// If the first component of the path is "boost", treat this like a standard header
// for the purposes of diagnostics.
if (::llvm::sys::path::begin(Include)->equals_insensitive("boost"))
  return true;

// "condition_variable" is the longest standard header name at 18 characters.
// If the include file name is longer than that, it can't be a standard header.
static const size_t MaxStdHeaderNameLen = 18u;
if (Include.size() > MaxStdHeaderNameLen)
  return false;

// Lowercase and normalize the search string.
SmallString<32> LowerInclude{Include};
for (char &Ch : LowerInclude) {
  // In the ASCII range?
  if (static_cast<unsigned char>(Ch) > 0x7f)
    return false; // Can't be a standard header
  // ASCII lowercase:
  if (Ch >= 'A' && Ch <= 'Z')
    Ch += 'a' - 'A';
  // Normalize path separators for comparison purposes.
  else if (::llvm::sys::path::is_separator(Ch))
    Ch = '/';
}

// The standard C/C++ and Posix headers
return llvm::StringSwitch<bool>(LowerInclude)
  // C library headers
  .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
  .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
  .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
  .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
  .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
  .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)

  // C++ headers for C library facilities
  .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
  .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
  .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
  .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
  .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
  .Case("cwctype", true)

  // C++ library headers
  .Cases("algorithm", "fstream", "list", "regex", "thread", true)
  .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
  .Cases("atomic", "future", "map", "set", "type_traits", true)
  .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
  .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
  .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
  .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
  .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
  .Cases("deque", "istream", "queue", "string", "valarray", true)
  .Cases("exception", "iterator", "random", "strstream", "vector", true)
  .Cases("forward_list", "limits", "ratio", "system_error", true)

  // POSIX headers (which aren't also C headers)
  .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
  .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
  .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
  .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
  .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
  .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
  .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
  .Cases("sys/resource.h", "sys/select.h",  "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
  .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
  .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
  .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
  .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
  .Default(false);
267}

269bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
                                bool *ShadowFlag) {
// Missing macro name?
if (MacroNameTok.is(tok::eod))
  return Diag(MacroNameTok, diag::err_pp_missing_macro_name);

IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
if (!II)
  return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);

if (II->isCPlusPlusOperatorKeyword()) {
  // C++ 2.5p2: Alternative tokens behave the same as its primary token
  // except for their spellings.
  Diag(MacroNameTok, getLangOpts().MicrosoftExt
                         ? diag::ext_pp_operator_used_as_macro_name
                         : diag::err_pp_operator_used_as_macro_name)
      << II << MacroNameTok.getKind();
  // Allow #defining |and| and friends for Microsoft compatibility or
  // recovery when legacy C headers are included in C++.
}

if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
  // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
  return Diag(MacroNameTok, diag::err_defined_macro_name);
}

if (isDefineUndef == MU_Undef) {
  auto *MI = getMacroInfo(II);
  if (MI && MI->isBuiltinMacro()) {
    // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
    // and C++ [cpp.predefined]p4], but allow it as an extension.
    Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
  }
}

// If defining/undefining reserved identifier or a keyword, we need to issue
// a warning.
SourceLocation MacroNameLoc = MacroNameTok.getLocation();
if (ShadowFlag)
  *ShadowFlag = false;
if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
    (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
  MacroDiag D = MD_NoWarn;
  if (isDefineUndef == MU_Define) {
    D = shouldWarnOnMacroDef(*this, II);
  }
  else if (isDefineUndef == MU_Undef)
    D = shouldWarnOnMacroUndef(*this, II);
  if (D == MD_KeywordDef) {
    // We do not want to warn on some patterns widely used in configuration
    // scripts.  This requires analyzing next tokens, so do not issue warnings
    // now, only inform caller.
    if (ShadowFlag)
      *ShadowFlag = true;
  }
  if (D == MD_ReservedMacro)
    Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
}

// Okay, we got a good identifier.
return false;
330}

332/// Lex and validate a macro name, which occurs after a
333/// \#define or \#undef.
334///
335/// This sets the token kind to eod and discards the rest of the macro line if
336/// the macro name is invalid.
337///
338/// \param MacroNameTok Token that is expected to be a macro name.
339/// \param isDefineUndef Context in which macro is used.
340/// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
341void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
                               bool *ShadowFlag) {
// Read the token, don't allow macro expansion on it.
LexUnexpandedToken(MacroNameTok);

if (MacroNameTok.is(tok::code_completion)) {
  if (CodeComplete)
    CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
  setCodeCompletionReached();
  LexUnexpandedToken(MacroNameTok);
}

if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
  return;

// Invalid macro name, read and discard the rest of the line and set the
// token kind to tok::eod if necessary.
if (MacroNameTok.isNot(tok::eod)) {
  MacroNameTok.setKind(tok::eod);
  DiscardUntilEndOfDirective();
}
362}

364/// Ensure that the next token is a tok::eod token.
365///
366/// If not, emit a diagnostic and consume up until the eod.  If EnableMacros is
367/// true, then we consider macros that expand to zero tokens as being ok.
368///
369/// Returns the location of the end of the directive.
370SourceLocation Preprocessor::CheckEndOfDirective(const char *DirType,
                                               bool EnableMacros) {
Token Tmp;
// Lex unexpanded tokens for most directives: macros might expand to zero
// tokens, causing us to miss diagnosing invalid lines.  Some directives (like
// #line) allow empty macros.
if (EnableMacros)
  Lex(Tmp);
else
  LexUnexpandedToken(Tmp);

// There should be no tokens after the directive, but we allow them as an
// extension.
while (Tmp.is(tok::comment))  // Skip comments in -C mode.
  LexUnexpandedToken(Tmp);

if (Tmp.is(tok::eod))
  return Tmp.getLocation();

// Add a fixit in GNU/C99/C++ mode.  Don't offer a fixit for strict-C89,
// or if this is a macro-style preprocessing directive, because it is more
// trouble than it is worth to insert /**/ and check that there is no /**/
// in the range also.
FixItHint Hint;
if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
    !CurTokenLexer)
  Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
return DiscardUntilEndOfDirective().getEnd();
399}

401Optional<unsigned> Preprocessor::getSkippedRangeForExcludedConditionalBlock(
  SourceLocation HashLoc) {
if (!ExcludedConditionalDirectiveSkipMappings)
  return None;
if (!HashLoc.isFileID())
  return None;

std::pair<FileID, unsigned> HashFileOffset =
    SourceMgr.getDecomposedLoc(HashLoc);
Optional<llvm::MemoryBufferRef> Buf =
    SourceMgr.getBufferOrNone(HashFileOffset.first);
if (!Buf)
  return None;
auto It =
    ExcludedConditionalDirectiveSkipMappings->find(Buf->getBufferStart());
if (It == ExcludedConditionalDirectiveSkipMappings->end())
  return None;

const PreprocessorSkippedRangeMapping &SkippedRanges = *It->getSecond();
// Check if the offset of '#' is mapped in the skipped ranges.
auto MappingIt = SkippedRanges.find(HashFileOffset.second);
if (MappingIt == SkippedRanges.end())
  return None;

unsigned BytesToSkip = MappingIt->getSecond();
unsigned CurLexerBufferOffset = CurLexer->getCurrentBufferOffset();
assert(CurLexerBufferOffset >= HashFileOffset.second &&((void)0)
       "lexer is before the hash?")((void)0);
// Take into account the fact that the lexer has already advanced, so the
// number of bytes to skip must be adjusted.
unsigned LengthDiff = CurLexerBufferOffset - HashFileOffset.second;
assert(BytesToSkip >= LengthDiff && "lexer is after the skipped range?")((void)0);
return BytesToSkip - LengthDiff;
434}

436/// SkipExcludedConditionalBlock - We just read a \#if or related directive and
437/// decided that the subsequent tokens are in the \#if'd out portion of the
438/// file.  Lex the rest of the file, until we see an \#endif.  If
439/// FoundNonSkipPortion is true, then we have already emitted code for part of
440/// this \#if directive, so \#else/\#elif blocks should never be entered.
441/// If ElseOk is true, then \#else directives are ok, if not, then we have
442/// already seen one so a \#else directive is a duplicate.  When this returns,
443/// the caller can lex the first valid token.
444void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,
                                              SourceLocation IfTokenLoc,
                                              bool FoundNonSkipPortion,
                                              bool FoundElse,
                                              SourceLocation ElseLoc) {
++NumSkipped;
assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?")((void)0);

if (PreambleConditionalStack.reachedEOFWhileSkipping())
  PreambleConditionalStack.clearSkipInfo();
else
  CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false,
                                   FoundNonSkipPortion, FoundElse);

// Enter raw mode to disable identifier lookup (and thus macro expansion),
// disabling warnings, etc.
CurPPLexer->LexingRawMode = true;
Token Tok;
if (auto SkipLength =
        getSkippedRangeForExcludedConditionalBlock(HashTokenLoc)) {
  // Skip to the next '#endif' / '#else' / '#elif'.
  CurLexer->skipOver(*SkipLength);
}
SourceLocation endLoc;
while (true) {
  CurLexer->Lex(Tok);

  if (Tok.is(tok::code_completion)) {
    setCodeCompletionReached();
    if (CodeComplete)
      CodeComplete->CodeCompleteInConditionalExclusion();
    continue;
  }

  // If this is the end of the buffer, we have an error.
  if (Tok.is(tok::eof)) {
    // We don't emit errors for unterminated conditionals here,
    // Lexer::LexEndOfFile can do that properly.
    // Just return and let the caller lex after this #include.
    if (PreambleConditionalStack.isRecording())
      PreambleConditionalStack.SkipInfo.emplace(
          HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc);
    break;
  }

  // If this token is not a preprocessor directive, just skip it.
  if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
    continue;

  // We just parsed a # character at the start of a line, so we're in
  // directive mode.  Tell the lexer this so any newlines we see will be
  // converted into an EOD token (this terminates the macro).
  CurPPLexer->ParsingPreprocessorDirective = true;
  if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);


  // Read the next token, the directive flavor.
  LexUnexpandedToken(Tok);

  // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
  // something bogus), skip it.
  if (Tok.isNot(tok::raw_identifier)) {
    CurPPLexer->ParsingPreprocessorDirective = false;
    // Restore comment saving mode.
    if (CurLexer) CurLexer->resetExtendedTokenMode();
    continue;
  }

  // If the first letter isn't i or e, it isn't intesting to us.  We know that
  // this is safe in the face of spelling differences, because there is no way
  // to spell an i/e in a strange way that is another letter.  Skipping this
  // allows us to avoid looking up the identifier info for #define/#undef and
  // other common directives.
  StringRef RI = Tok.getRawIdentifier();

  char FirstChar = RI[0];
  if (FirstChar >= 'a' && FirstChar <= 'z' &&
      FirstChar != 'i' && FirstChar != 'e') {
    CurPPLexer->ParsingPreprocessorDirective = false;
    // Restore comment saving mode.
    if (CurLexer) CurLexer->resetExtendedTokenMode();
    continue;
  }

  // Get the identifier name without trigraphs or embedded newlines.  Note
  // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
  // when skipping.
  char DirectiveBuf[20];
  StringRef Directive;
  if (!Tok.needsCleaning() && RI.size() < 20) {
    Directive = RI;
  } else {
    std::string DirectiveStr = getSpelling(Tok);
    size_t IdLen = DirectiveStr.size();
    if (IdLen >= 20) {
      CurPPLexer->ParsingPreprocessorDirective = false;
      // Restore comment saving mode.
      if (CurLexer) CurLexer->resetExtendedTokenMode();
      continue;
    }
    memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
    Directive = StringRef(DirectiveBuf, IdLen);
  }

  if (Directive.startswith("if")) {
    StringRef Sub = Directive.substr(2);
    if (Sub.empty() ||   // "if"
        Sub == "def" ||   // "ifdef"
        Sub == "ndef") {  // "ifndef"
      // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
      // bother parsing the condition.
      DiscardUntilEndOfDirective();
      CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
                                     /*foundnonskip*/false,
                                     /*foundelse*/false);
    }
  } else if (Directive[0] == 'e') {
    StringRef Sub = Directive.substr(1);
    if (Sub == "ndif") {  // "endif"
      PPConditionalInfo CondInfo;
      CondInfo.WasSkipping = true; // Silence bogus warning.
      bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
      (void)InCond;  // Silence warning in no-asserts mode.
      assert(!InCond && "Can't be skipping if not in a conditional!")((void)0);

      // If we popped the outermost skipping block, we're done skipping!
      if (!CondInfo.WasSkipping) {
        // Restore the value of LexingRawMode so that trailing comments
        // are handled correctly, if we've reached the outermost block.
        CurPPLexer->LexingRawMode = false;
        endLoc = CheckEndOfDirective("endif");
        CurPPLexer->LexingRawMode = true;
        if (Callbacks)
          Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
        break;
      } else {
        DiscardUntilEndOfDirective();
      }
    } else if (Sub == "lse") { // "else".
      // #else directive in a skipping conditional.  If not in some other
      // skipping conditional, and if #else hasn't already been seen, enter it
      // as a non-skipping conditional.
      PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();

      // If this is a #else with a #else before it, report the error.
      if (CondInfo.FoundElse)
        Diag(Tok, diag::pp_err_else_after_else);

      // Note that we've seen a #else in this conditional.
      CondInfo.FoundElse = true;

      // If the conditional is at the top level, and the #if block wasn't
      // entered, enter the #else block now.
      if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
        CondInfo.FoundNonSkip = true;
        // Restore the value of LexingRawMode so that trailing comments
        // are handled correctly.
        CurPPLexer->LexingRawMode = false;
        endLoc = CheckEndOfDirective("else");
        CurPPLexer->LexingRawMode = true;
        if (Callbacks)
          Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
        break;
      } else {
        DiscardUntilEndOfDirective();  // C99 6.10p4.
      }
    } else if (Sub == "lif") {  // "elif".
      PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();

      // If this is a #elif with a #else before it, report the error.
      if (CondInfo.FoundElse)
        Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;

      // If this is in a skipping block or if we're already handled this #if
      // block, don't bother parsing the condition.
      if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
        DiscardUntilEndOfDirective();
      } else {
        // Restore the value of LexingRawMode so that identifiers are
        // looked up, etc, inside the #elif expression.
        assert(CurPPLexer->LexingRawMode && "We have to be skipping here!")((void)0);
        CurPPLexer->LexingRawMode = false;
        IdentifierInfo *IfNDefMacro = nullptr;
        DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
        // Stop if Lexer became invalid after hitting code completion token.
        if (!CurPPLexer)
          return;
        const bool CondValue = DER.Conditional;
        CurPPLexer->LexingRawMode = true;
        if (Callbacks) {
          Callbacks->Elif(
              Tok.getLocation(), DER.ExprRange,
              (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False),
              CondInfo.IfLoc);
        }
        // If this condition is true, enter it!
        if (CondValue) {
          CondInfo.FoundNonSkip = true;
          break;
        }
      }
    } else if (Sub == "lifdef" ||  // "elifdef"
               Sub == "lifndef") { // "elifndef"
      bool IsElifDef = Sub == "lifdef";
      PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
      Token DirectiveToken = Tok;

      // If this is a #elif with a #else before it, report the error.
      if (CondInfo.FoundElse)
        Diag(Tok, diag::pp_err_elif_after_else)
            << (IsElifDef ? PED_Elifdef : PED_Elifndef);

      // If this is in a skipping block or if we're already handled this #if
      // block, don't bother parsing the condition.
      if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
        DiscardUntilEndOfDirective();
      } else {
        // Restore the value of LexingRawMode so that identifiers are
        // looked up, etc, inside the #elif[n]def expression.
        assert(CurPPLexer->LexingRawMode && "We have to be skipping here!")((void)0);
        CurPPLexer->LexingRawMode = false;
        Token MacroNameTok;
        ReadMacroName(MacroNameTok);
        CurPPLexer->LexingRawMode = true;

        // If the macro name token is tok::eod, there was an error that was
        // already reported.
        if (MacroNameTok.is(tok::eod)) {
          // Skip code until we get to #endif.  This helps with recovery by
          // not emitting an error when the #endif is reached.
          continue;
        }

        CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");

        IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
        auto MD = getMacroDefinition(MII);
        MacroInfo *MI = MD.getMacroInfo();

        if (Callbacks) {
          if (IsElifDef) {
            Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,
                               MD);
          } else {
            Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,
                                MD);
          }
        }
        // If this condition is true, enter it!
        if (static_cast<bool>(MI) == IsElifDef) {
          CondInfo.FoundNonSkip = true;
          break;
        }
      }
    }
  }

  CurPPLexer->ParsingPreprocessorDirective = false;
  // Restore comment saving mode.
  if (CurLexer) CurLexer->resetExtendedTokenMode();
}

// Finally, if we are out of the conditional (saw an #endif or ran off the end
// of the file, just stop skipping and return to lexing whatever came after
// the #if block.
CurPPLexer->LexingRawMode = false;

// The last skipped range isn't actually skipped yet if it's truncated
// by the end of the preamble; we'll resume parsing after the preamble.
if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble()))
  Callbacks->SourceRangeSkipped(
      SourceRange(HashTokenLoc, endLoc.isValid()
                                    ? endLoc
                                    : CurPPLexer->getSourceLocation()),
      Tok.getLocation());
719}

721Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
if (!SourceMgr.isInMainFile(Loc)) {
  // Try to determine the module of the include directive.
  // FIXME: Look into directly passing the FileEntry from LookupFile instead.
  FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
  if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
    // The include comes from an included file.
    return HeaderInfo.getModuleMap()
        .findModuleForHeader(EntryOfIncl)
        .getModule();
  }
}

// This is either in the main file or not in a file at all. It belongs
// to the current module, if there is one.
return getLangOpts().CurrentModule.empty()
           ? nullptr
           : HeaderInfo.lookupModule(getLangOpts().CurrentModule);
739}

741const FileEntry *
742Preprocessor::getHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
                                             SourceLocation Loc) {
Module *IncM = getModuleForLocation(IncLoc);

// Walk up through the include stack, looking through textual headers of M
// until we hit a non-textual header that we can #include. (We assume textual
// headers of a module with non-textual headers aren't meant to be used to
// import entities from the module.)
auto &SM = getSourceManager();
while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
  auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
  auto *FE = SM.getFileEntryForID(ID);
  if (!FE)
    break;

  // We want to find all possible modules that might contain this header, so
  // search all enclosing directories for module maps and load them.
  HeaderInfo.hasModuleMap(FE->getName(), /*Root*/ nullptr,
                          SourceMgr.isInSystemHeader(Loc));

  bool InPrivateHeader = false;
  for (auto Header : HeaderInfo.findAllModulesForHeader(FE)) {
    if (!Header.isAccessibleFrom(IncM)) {
      // It's in a private header; we can't #include it.
      // FIXME: If there's a public header in some module that re-exports it,
      // then we could suggest including that, but it's not clear that's the
      // expected way to make this entity visible.
      InPrivateHeader = true;
      continue;
    }

    // We'll suggest including textual headers below if they're
    // include-guarded.
    if (Header.getRole() & ModuleMap::TextualHeader)
      continue;

    // If we have a module import syntax, we shouldn't include a header to
    // make a particular module visible. Let the caller know they should
    // suggest an import instead.
    if (getLangOpts().ObjC || getLangOpts().CPlusPlusModules ||
        getLangOpts().ModulesTS)
      return nullptr;

    // If this is an accessible, non-textual header of M's top-level module
    // that transitively includes the given location and makes the
    // corresponding module visible, this is the thing to #include.
    return FE;
  }

  // FIXME: If we're bailing out due to a private header, we shouldn't suggest
  // an import either.
  if (InPrivateHeader)
    return nullptr;

  // If the header is includable and has an include guard, assume the
  // intended way to expose its contents is by #include, not by importing a
  // module that transitively includes it.
  if (getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE))
    return FE;

  Loc = SM.getIncludeLoc(ID);
}

return nullptr;
806}

808Optional<FileEntryRef> Preprocessor::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) {
Module *RequestingModule = getModuleForLocation(FilenameLoc);
bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);

// If the header lookup mechanism may be relative to the current inclusion
// stack, record the parent #includes.
SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
    Includers;
bool BuildSystemModule = false;
if (!FromDir && !FromFile) {
  FileID FID = getCurrentFileLexer()->getFileID();
  const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);

  // If there is no file entry associated with this file, it must be the
  // predefines buffer or the module includes buffer. Any other file is not
  // lexed with a normal lexer, so it won't be scanned for preprocessor
  // directives.
  //
  // If we have the predefines buffer, resolve #include references (which come
  // from the -include command line argument) from the current working
  // directory instead of relative to the main file.
  //
  // If we have the module includes buffer, resolve #include references (which
  // come from header declarations in the module map) relative to the module
  // map file.
  if (!FileEnt) {
    if (FID == SourceMgr.getMainFileID() && MainFileDir) {
      Includers.push_back(std::make_pair(nullptr, MainFileDir));
      BuildSystemModule = getCurrentModule()->IsSystem;
    } else if ((FileEnt =
                  SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
      Includers.push_back(std::make_pair(FileEnt, *FileMgr.getDirectory(".")));
  } else {
    Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
  }

  // MSVC searches the current include stack from top to bottom for
  // headers included by quoted include directives.
  // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
  if (LangOpts.MSVCCompat && !isAngled) {
    for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
      if (IsFileLexer(ISEntry))
        if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
          Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
    }
  }
}

CurDir = CurDirLookup;

if (FromFile) {
  // We're supposed to start looking from after a particular file. Search
  // the include path until we find that file or run out of files.
  const DirectoryLookup *TmpCurDir = CurDir;
  const DirectoryLookup *TmpFromDir = nullptr;
  while (Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
             Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
             Includers, SearchPath, RelativePath, RequestingModule,
             SuggestedModule, /*IsMapped=*/nullptr,
             /*IsFrameworkFound=*/nullptr, SkipCache)) {
    // Keep looking as if this file did a #include_next.
    TmpFromDir = TmpCurDir;
    ++TmpFromDir;
    if (&FE->getFileEntry() == FromFile) {
      // Found it.
      FromDir = TmpFromDir;
      CurDir = TmpCurDir;
      break;
    }
  }
}

// Do a standard file entry lookup.
Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
    Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
    RelativePath, RequestingModule, SuggestedModule, IsMapped,
    IsFrameworkFound, SkipCache, BuildSystemModule);
if (FE) {
  if (SuggestedModule && !LangOpts.AsmPreprocessor)
    HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
        RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
        Filename, &FE->getFileEntry());
  return FE;
}

const FileEntry *CurFileEnt;
// Otherwise, see if this is a subframework header.  If so, this is relative
// to one of the headers on the #include stack.  Walk the list of the current
// headers on the #include stack and pass them to HeaderInfo.
if (IsFileLexer()) {
  if ((CurFileEnt = CurPPLexer->getFileEntry())) {
    if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(
            Filename, CurFileEnt, SearchPath, RelativePath, RequestingModule,
            SuggestedModule)) {
      if (SuggestedModule && !LangOpts.AsmPreprocessor)
        HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
            RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
            Filename, &FE->getFileEntry());
      return FE;
    }
  }
}

for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
  if (IsFileLexer(ISEntry)) {
    if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
      if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(
              Filename, CurFileEnt, SearchPath, RelativePath,
              RequestingModule, SuggestedModule)) {
        if (SuggestedModule && !LangOpts.AsmPreprocessor)
          HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
              RequestingModule, RequestingModuleIsModuleInterface,
              FilenameLoc, Filename, &FE->getFileEntry());
        return FE;
      }
    }
  }
}

// Otherwise, we really couldn't find the file.
return None;
935}

937//===----------------------------------------------------------------------===//
938// Preprocessor Directive Handling.
939//===----------------------------------------------------------------------===//

941class Preprocessor::ResetMacroExpansionHelper {
942public:
ResetMacroExpansionHelper(Preprocessor *pp)
  : PP(pp), save(pp->DisableMacroExpansion) {
  if (pp->MacroExpansionInDirectivesOverride)
    pp->DisableMacroExpansion = false;
}

~ResetMacroExpansionHelper() {
  PP->DisableMacroExpansion = save;
}

953private:
Preprocessor *PP;
bool save;
956};

958/// Process a directive while looking for the through header or a #pragma
959/// hdrstop. The following directives are handled:
960/// #include (to check if it is the through header)
961/// #define (to warn about macros that don't match the PCH)
962/// #pragma (to check for pragma hdrstop).
963/// All other directives are completely discarded.
964void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result,
                                                     SourceLocation HashLoc) {
if (const IdentifierInfo *II = Result.getIdentifierInfo()) {
8
←
Assuming 'II' is non-null→
9
←
Taking true branch→
  if (II->getPPKeywordID() == tok::pp_define) {
10
←
Assuming the condition is true→
11
←
Taking true branch→
    return HandleDefineDirective(Result,
12
←
Calling 'Preprocessor::HandleDefineDirective'→
                                 /*ImmediatelyAfterHeaderGuard=*/false);
  }
  if (SkippingUntilPCHThroughHeader &&
      II->getPPKeywordID() == tok::pp_include) {
    return HandleIncludeDirective(HashLoc, Result);
  }
  if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {
    Lex(Result);
    auto *II = Result.getIdentifierInfo();
    if (II && II->getName() == "hdrstop")
      return HandlePragmaHdrstop(Result);
  }
}
DiscardUntilEndOfDirective();
983}

985/// HandleDirective - This callback is invoked when the lexer sees a # token
986/// at the start of a line.  This consumes the directive, modifies the
987/// lexer/preprocessor state, and advances the lexer(s) so that the next token
988/// read is the correct one.
989void Preprocessor::HandleDirective(Token &Result) {
// FIXME: Traditional: # with whitespace before it not recognized by K&R?

// We just parsed a # character at the start of a line, so we're in directive
// mode.  Tell the lexer this so any newlines we see will be converted into an
// EOD token (which terminates the directive).
CurPPLexer->ParsingPreprocessorDirective = true;
if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
1
Taking false branch→

bool ImmediatelyAfterTopLevelIfndef =
    CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();

++NumDirectives;

// We are about to read a token.  For the multiple-include optimization FA to
// work, we have to remember if we had read any tokens *before* this
// pp-directive.
bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();

// Save the '#' token in case we need to return it later.
Token SavedHash = Result;

// Read the next token, the directive flavor.  This isn't expanded due to
// C99 6.10.3p8.
LexUnexpandedToken(Result);

// C99 6.10.3p11: Is this preprocessor directive in macro invocation?  e.g.:
//   #define A(x) #x
//   A(abc
//     #warning blah
//   def)
// If so, the user is relying on undefined behavior, emit a diagnostic. Do
// not support this for #include-like directives, since that can result in
// terrible diagnostics, and does not work in GCC.
if (InMacroArgs) {
2
←
Assuming field 'InMacroArgs' is false→
3
←
Taking false branch→
  if (IdentifierInfo *II = Result.getIdentifierInfo()) {
    switch (II->getPPKeywordID()) {
    case tok::pp_include:
    case tok::pp_import:
    case tok::pp_include_next:
    case tok::pp___include_macros:
    case tok::pp_pragma:
      Diag(Result, diag::err_embedded_directive) << II->getName();
      Diag(*ArgMacro, diag::note_macro_expansion_here)
          << ArgMacro->getIdentifierInfo();
      DiscardUntilEndOfDirective();
      return;
    default:
      break;
    }
  }
  Diag(Result, diag::ext_embedded_directive);
}

// Temporarily enable macro expansion if set so
// and reset to previous state when returning from this function.
ResetMacroExpansionHelper helper(this);

if (SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop)
4
←
Assuming field 'SkippingUntilPCHThroughHeader' is false→
5
←
Assuming field 'SkippingUntilPragmaHdrStop' is true→
6
←
Taking true branch→
  return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation());
7
←
Calling 'Preprocessor::HandleSkippedDirectiveWhileUsingPCH'→

switch (Result.getKind()) {
case tok::eod:
  return;   // null directive.
case tok::code_completion:
  setCodeCompletionReached();
  if (CodeComplete)
    CodeComplete->CodeCompleteDirective(
                                  CurPPLexer->getConditionalStackDepth() > 0);
  return;
case tok::numeric_constant:  // # 7  GNU line marker directive.
  if (getLangOpts().AsmPreprocessor)
    break;  // # 4 is not a preprocessor directive in .S files.
  return HandleDigitDirective(Result);
default:
  IdentifierInfo *II = Result.getIdentifierInfo();
  if (!II) break; // Not an identifier.

  // Ask what the preprocessor keyword ID is.
  switch (II->getPPKeywordID()) {
  default: break;
  // C99 6.10.1 - Conditional Inclusion.
  case tok::pp_if:
    return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective);
  case tok::pp_ifdef:
    return HandleIfdefDirective(Result, SavedHash, false,
                                true /*not valid for miopt*/);
  case tok::pp_ifndef:
    return HandleIfdefDirective(Result, SavedHash, true,
                                ReadAnyTokensBeforeDirective);
  case tok::pp_elif:
  case tok::pp_elifdef:
  case tok::pp_elifndef:
    return HandleElifFamilyDirective(Result, SavedHash, II->getPPKeywordID());

  case tok::pp_else:
    return HandleElseDirective(Result, SavedHash);
  case tok::pp_endif:
    return HandleEndifDirective(Result);

  // C99 6.10.2 - Source File Inclusion.
  case tok::pp_include:
    // Handle #include.
    return HandleIncludeDirective(SavedHash.getLocation(), Result);
  case tok::pp___include_macros:
    // Handle -imacros.
    return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);

  // C99 6.10.3 - Macro Replacement.
  case tok::pp_define:
    return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
  case tok::pp_undef:
    return HandleUndefDirective();

  // C99 6.10.4 - Line Control.
  case tok::pp_line:
    return HandleLineDirective();

  // C99 6.10.5 - Error Directive.
  case tok::pp_error:
    return HandleUserDiagnosticDirective(Result, false);

  // C99 6.10.6 - Pragma Directive.
  case tok::pp_pragma:
    return HandlePragmaDirective({PIK_HashPragma, SavedHash.getLocation()});

  // GNU Extensions.
  case tok::pp_import:
    return HandleImportDirective(SavedHash.getLocation(), Result);
  case tok::pp_include_next:
    return HandleIncludeNextDirective(SavedHash.getLocation(), Result);

  case tok::pp_warning:
    Diag(Result, diag::ext_pp_warning_directive);
    return HandleUserDiagnosticDirective(Result, true);
  case tok::pp_ident:
    return HandleIdentSCCSDirective(Result);
  case tok::pp_sccs:
    return HandleIdentSCCSDirective(Result);
  case tok::pp_assert:
    //isExtension = true;  // FIXME: implement #assert
    break;
  case tok::pp_unassert:
    //isExtension = true;  // FIXME: implement #unassert
    break;

  case tok::pp___public_macro:
    if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
      return HandleMacroPublicDirective(Result);
    break;

  case tok::pp___private_macro:
    if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
      return HandleMacroPrivateDirective();
    break;
  }
  break;
}

// If this is a .S file, treat unknown # directives as non-preprocessor
// directives.  This is important because # may be a comment or introduce
// various pseudo-ops.  Just return the # token and push back the following
// token to be lexed next time.
if (getLangOpts().AsmPreprocessor) {
  auto Toks = std::make_unique<Token[]>(2);
  // Return the # and the token after it.
  Toks[0] = SavedHash;
  Toks[1] = Result;

  // If the second token is a hashhash token, then we need to translate it to
  // unknown so the token lexer doesn't try to perform token pasting.
  if (Result.is(tok::hashhash))
    Toks[1].setKind(tok::unknown);

  // Enter this token stream so that we re-lex the tokens.  Make sure to
  // enable macro expansion, in case the token after the # is an identifier
  // that is expanded.
  EnterTokenStream(std::move(Toks), 2, false, /*IsReinject*/false);
  return;
}

// If we reached here, the preprocessing token is not valid!
Diag(Result, diag::err_pp_invalid_directive);

// Read the rest of the PP line.
DiscardUntilEndOfDirective();

// Okay, we're done parsing the directive.
1178}

1180/// GetLineValue - Convert a numeric token into an unsigned value, emitting
1181/// Diagnostic DiagID if it is invalid, and returning the value in Val.
1182static bool GetLineValue(Token &DigitTok, unsigned &Val,
                       unsigned DiagID, Preprocessor &PP,
                       bool IsGNULineDirective=false) {
if (DigitTok.isNot(tok::numeric_constant)) {
  PP.Diag(DigitTok, DiagID);

  if (DigitTok.isNot(tok::eod))
    PP.DiscardUntilEndOfDirective();
  return true;
}

SmallString<64> IntegerBuffer;
IntegerBuffer.resize(DigitTok.getLength());
const char *DigitTokBegin = &IntegerBuffer[0];
bool Invalid = false;
unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
if (Invalid)
  return true;

// Verify that we have a simple digit-sequence, and compute the value.  This
// is always a simple digit string computed in decimal, so we do this manually
// here.
Val = 0;
for (unsigned i = 0; i != ActualLength; ++i) {
  // C++1y [lex.fcon]p1:
  //   Optional separating single quotes in a digit-sequence are ignored
  if (DigitTokBegin[i] == '\'')
    continue;

  if (!isDigit(DigitTokBegin[i])) {
    PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
            diag::err_pp_line_digit_sequence) << IsGNULineDirective;
    PP.DiscardUntilEndOfDirective();
    return true;
  }

  unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
  if (NextVal < Val) { // overflow.
    PP.Diag(DigitTok, DiagID);
    PP.DiscardUntilEndOfDirective();
    return true;
  }
  Val = NextVal;
}

if (DigitTokBegin[0] == '0' && Val)
  PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
    << IsGNULineDirective;

return false;
1232}

1234/// Handle a \#line directive: C99 6.10.4.
1235///
1236/// The two acceptable forms are:
1237/// \verbatim
1238///   # line digit-sequence
1239///   # line digit-sequence "s-char-sequence"
1240/// \endverbatim
1241void Preprocessor::HandleLineDirective() {
// Read the line # and string argument.  Per C99 6.10.4p5, these tokens are
// expanded.
Token DigitTok;
Lex(DigitTok);

// Validate the number and convert it to an unsigned.
unsigned LineNo;
if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
  return;

if (LineNo == 0)
  Diag(DigitTok, diag::ext_pp_line_zero);

// Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
// number greater than 2147483647".  C90 requires that the line # be <= 32767.
unsigned LineLimit = 32768U;
if (LangOpts.C99 || LangOpts.CPlusPlus11)
  LineLimit = 2147483648U;
if (LineNo >= LineLimit)
  Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
  Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);

int FilenameID = -1;
Token StrTok;
Lex(StrTok);

// If the StrTok is "eod", then it wasn't present.  Otherwise, it must be a
// string followed by eod.
if (StrTok.is(tok::eod))
  ; // ok
else if (StrTok.isNot(tok::string_literal)) {
  Diag(StrTok, diag::err_pp_line_invalid_filename);
  DiscardUntilEndOfDirective();
  return;
} else if (StrTok.hasUDSuffix()) {
  Diag(StrTok, diag::err_invalid_string_udl);
  DiscardUntilEndOfDirective();
  return;
} else {
  // Parse and validate the string, converting it into a unique ID.
  StringLiteralParser Literal(StrTok, *this);
  assert(Literal.isAscii() && "Didn't allow wide strings in")((void)0);
  if (Literal.hadError) {
    DiscardUntilEndOfDirective();
    return;
  }
  if (Literal.Pascal) {
    Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
    DiscardUntilEndOfDirective();
    return;
  }
  FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());

  // Verify that there is nothing after the string, other than EOD.  Because
  // of C99 6.10.4p5, macros that expand to empty tokens are ok.
  CheckEndOfDirective("line", true);
}

// Take the file kind of the file containing the #line directive. #line
// directives are often used for generated sources from the same codebase, so
// the new file should generally be classified the same way as the current
// file. This is visible in GCC's pre-processed output, which rewrites #line
// to GNU line markers.
SrcMgr::CharacteristicKind FileKind =
    SourceMgr.getFileCharacteristic(DigitTok.getLocation());

SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,
                      false, FileKind);

if (Callbacks)
  Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
                         PPCallbacks::RenameFile, FileKind);
1315}

1317/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1318/// marker directive.
1319static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
                              SrcMgr::CharacteristicKind &FileKind,
                              Preprocessor &PP) {
unsigned FlagVal;
Token FlagTok;
PP.Lex(FlagTok);
if (FlagTok.is(tok::eod)) return false;
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
  return true;

if (FlagVal == 1) {
  IsFileEntry = true;

  PP.Lex(FlagTok);
  if (FlagTok.is(tok::eod)) return false;
  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
    return true;
} else if (FlagVal == 2) {
  IsFileExit = true;

  SourceManager &SM = PP.getSourceManager();
  // If we are leaving the current presumed file, check to make sure the
  // presumed include stack isn't empty!
  FileID CurFileID =
    SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
  PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
  if (PLoc.isInvalid())
    return true;

  // If there is no include loc (main file) or if the include loc is in a
  // different physical file, then we aren't in a "1" line marker flag region.
  SourceLocation IncLoc = PLoc.getIncludeLoc();
  if (IncLoc.isInvalid() ||
      SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
    PP.DiscardUntilEndOfDirective();
    return true;
  }

  PP.Lex(FlagTok);
  if (FlagTok.is(tok::eod)) return false;
  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
    return true;
}

// We must have 3 if there are still flags.
if (FlagVal != 3) {
  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
  PP.DiscardUntilEndOfDirective();
  return true;
}

FileKind = SrcMgr::C_System;

PP.Lex(FlagTok);
if (FlagTok.is(tok::eod)) return false;
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
  return true;

// We must have 4 if there is yet another flag.
if (FlagVal != 4) {
  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
  PP.DiscardUntilEndOfDirective();
  return true;
}

FileKind = SrcMgr::C_ExternCSystem;

PP.Lex(FlagTok);
if (FlagTok.is(tok::eod)) return false;

// There are no more valid flags here.
PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
PP.DiscardUntilEndOfDirective();
return true;
1394}

1396/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1397/// one of the following forms:
1398///
1399///     # 42
1400///     # 42 "file" ('1' | '2')?
1401///     # 42 "file" ('1' | '2')? '3' '4'?
1402///
1403void Preprocessor::HandleDigitDirective(Token &DigitTok) {
// Validate the number and convert it to an unsigned.  GNU does not have a
// line # limit other than it fit in 32-bits.
unsigned LineNo;
if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
                 *this, true))
  return;

Token StrTok;
Lex(StrTok);

bool IsFileEntry = false, IsFileExit = false;
int FilenameID = -1;
SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;

// If the StrTok is "eod", then it wasn't present.  Otherwise, it must be a
// string followed by eod.
if (StrTok.is(tok::eod)) {
  // Treat this like "#line NN", which doesn't change file characteristics.
  FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());
} else if (StrTok.isNot(tok::string_literal)) {
  Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
  DiscardUntilEndOfDirective();
  return;
} else if (StrTok.hasUDSuffix()) {
  Diag(StrTok, diag::err_invalid_string_udl);
  DiscardUntilEndOfDirective();
  return;
} else {
  // Parse and validate the string, converting it into a unique ID.
  StringLiteralParser Literal(StrTok, *this);
  assert(Literal.isAscii() && "Didn't allow wide strings in")((void)0);
  if (Literal.hadError) {
    DiscardUntilEndOfDirective();
    return;
  }
  if (Literal.Pascal) {
    Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
    DiscardUntilEndOfDirective();
    return;
  }
  FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());

  // If a filename was present, read any flags that are present.
  if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))
    return;
}

// Create a line note with this information.
SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,
                      IsFileExit, FileKind);

// If the preprocessor has callbacks installed, notify them of the #line
// change.  This is used so that the line marker comes out in -E mode for
// example.
if (Callbacks) {
  PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
  if (IsFileEntry)
    Reason = PPCallbacks::EnterFile;
  else if (IsFileExit)
    Reason = PPCallbacks::ExitFile;

  Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
}
1467}

1469/// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1470///
1471void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
                                               bool isWarning) {
// Read the rest of the line raw.  We do this because we don't want macros
// to be expanded and we don't require that the tokens be valid preprocessing
// tokens.  For example, this is allowed: "#warning `   'foo".  GCC does
// collapse multiple consecutive white space between tokens, but this isn't
// specified by the standard.
SmallString<128> Message;
CurLexer->ReadToEndOfLine(&Message);

// Find the first non-whitespace character, so that we can make the
// diagnostic more succinct.
StringRef Msg = Message.str().ltrim(' ');

if (isWarning)
  Diag(Tok, diag::pp_hash_warning) << Msg;
else
  Diag(Tok, diag::err_pp_hash_error) << Msg;
1489}

1491/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1492///
1493void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
// Yes, this directive is an extension.
Diag(Tok, diag::ext_pp_ident_directive);

// Read the string argument.
Token StrTok;
Lex(StrTok);

// If the token kind isn't a string, it's a malformed directive.
if (StrTok.isNot(tok::string_literal) &&
    StrTok.isNot(tok::wide_string_literal)) {
  Diag(StrTok, diag::err_pp_malformed_ident);
  if (StrTok.isNot(tok::eod))
    DiscardUntilEndOfDirective();
  return;
}

if (StrTok.hasUDSuffix()) {
  Diag(StrTok, diag::err_invalid_string_udl);
  DiscardUntilEndOfDirective();
  return;
}

// Verify that there is nothing after the string, other than EOD.
CheckEndOfDirective("ident");

if (Callbacks) {
  bool Invalid = false;
  std::string Str = getSpelling(StrTok, &Invalid);
  if (!Invalid)
    Callbacks->Ident(Tok.getLocation(), Str);
}
1525}

1527/// Handle a #public directive.
1528void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
Token MacroNameTok;
ReadMacroName(MacroNameTok, MU_Undef);

// Error reading macro name?  If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
  return;

// Check to see if this is the last token on the #__public_macro line.
CheckEndOfDirective("__public_macro");

IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
// Okay, we finally have a valid identifier to undef.
MacroDirective *MD = getLocalMacroDirective(II);

// If the macro is not defined, this is an error.
if (!MD) {
  Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
  return;
}

// Note that this macro has now been exported.
appendMacroDirective(II, AllocateVisibilityMacroDirective(
                              MacroNameTok.getLocation(), /*isPublic=*/true));
1552}

1554/// Handle a #private directive.
1555void Preprocessor::HandleMacroPrivateDirective() {
Token MacroNameTok;
ReadMacroName(MacroNameTok, MU_Undef);

// Error reading macro name?  If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
  return;

// Check to see if this is the last token on the #__private_macro line.
CheckEndOfDirective("__private_macro");

IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
// Okay, we finally have a valid identifier to undef.
MacroDirective *MD = getLocalMacroDirective(II);

// If the macro is not defined, this is an error.
if (!MD) {
  Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
  return;
}

// Note that this macro has now been marked private.
appendMacroDirective(II, AllocateVisibilityMacroDirective(
                             MacroNameTok.getLocation(), /*isPublic=*/false));
1579}

1581//===----------------------------------------------------------------------===//
1582// Preprocessor Include Directive Handling.
1583//===----------------------------------------------------------------------===//

1585/// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1586/// checked and spelled filename, e.g. as an operand of \#include. This returns
1587/// true if the input filename was in <>'s or false if it were in ""'s.  The
1588/// caller is expected to provide a buffer that is large enough to hold the
1589/// spelling of the filename, but is also expected to handle the case when
1590/// this method decides to use a different buffer.
1591bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
                                            StringRef &Buffer) {
// Get the text form of the filename.
assert(!Buffer.empty() && "Can't have tokens with empty spellings!")((void)0);

// FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and
// C++20 [lex.header]/2:
//
// If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then
//   in C: behavior is undefined
//   in C++: program is conditionally-supported with implementation-defined
//           semantics

// Make sure the filename is <x> or "x".
bool isAngled;
if (Buffer[0] == '<') {
  if (Buffer.back() != '>') {
    Diag(Loc, diag::err_pp_expects_filename);
    Buffer = StringRef();
    return true;
  }
  isAngled = true;
} else if (Buffer[0] == '"') {
  if (Buffer.back() != '"') {
    Diag(Loc, diag::err_pp_expects_filename);
    Buffer = StringRef();
    return true;
  }
  isAngled = false;
} else {
  Diag(Loc, diag::err_pp_expects_filename);
  Buffer = StringRef();
  return true;
}

// Diagnose #include "" as invalid.
if (Buffer.size() <= 2) {
  Diag(Loc, diag::err_pp_empty_filename);
  Buffer = StringRef();
  return true;
}

// Skip the brackets.
Buffer = Buffer.substr(1, Buffer.size()-2);
return isAngled;
1636}

1638/// Push a token onto the token stream containing an annotation.
1639void Preprocessor::EnterAnnotationToken(SourceRange Range,
                                      tok::TokenKind Kind,
                                      void *AnnotationVal) {
// FIXME: Produce this as the current token directly, rather than
// allocating a new token for it.
auto Tok = std::make_unique<Token[]>(1);
Tok[0].startToken();
Tok[0].setKind(Kind);
Tok[0].setLocation(Range.getBegin());
Tok[0].setAnnotationEndLoc(Range.getEnd());
Tok[0].setAnnotationValue(AnnotationVal);
EnterTokenStream(std::move(Tok), 1, true, /*IsReinject*/ false);
1651}

1653/// Produce a diagnostic informing the user that a #include or similar
1654/// was implicitly treated as a module import.
1655static void diagnoseAutoModuleImport(
  Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
  ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
  SourceLocation PathEnd) {
StringRef ImportKeyword;
if (PP.getLangOpts().ObjC)
  ImportKeyword = "@import";
else if (PP.getLangOpts().ModulesTS || PP.getLangOpts().CPlusPlusModules)
  ImportKeyword = "import";
else
  return; // no import syntax available

SmallString<128> PathString;
for (size_t I = 0, N = Path.size(); I != N; ++I) {
  if (I)
    PathString += '.';
  PathString += Path[I].first->getName();
}
int IncludeKind = 0;

switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
case tok::pp_include:
  IncludeKind = 0;
  break;

case tok::pp_import:
  IncludeKind = 1;
  break;

case tok::pp_include_next:
  IncludeKind = 2;
  break;

case tok::pp___include_macros:
  IncludeKind = 3;
  break;

default:
  llvm_unreachable("unknown include directive kind")__builtin_unreachable();
}

CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
                             /*IsTokenRange=*/false);
PP.Diag(HashLoc, diag::warn_auto_module_import)
    << IncludeKind << PathString
    << FixItHint::CreateReplacement(
           ReplaceRange, (ImportKeyword + " " + PathString + ";").str());
1702}

1704// Given a vector of path components and a string containing the real
1705// path to the file, build a properly-cased replacement in the vector,
1706// and return true if the replacement should be suggested.
1707static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
                          StringRef RealPathName) {
auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
int Cnt = 0;
bool SuggestReplacement = false;
// Below is a best-effort to handle ".." in paths. It is admittedly
// not 100% correct in the presence of symlinks.
for (auto &Component : llvm::reverse(Components)) {
  if ("." == Component) {
  } else if (".." == Component) {
    ++Cnt;
  } else if (Cnt) {
    --Cnt;
  } else if (RealPathComponentIter != RealPathComponentEnd) {
    if (Component != *RealPathComponentIter) {
      // If these path components differ by more than just case, then we
      // may be looking at symlinked paths. Bail on this diagnostic to avoid
      // noisy false positives.
      SuggestReplacement =
          RealPathComponentIter->equals_insensitive(Component);
      if (!SuggestReplacement)
        break;
      Component = *RealPathComponentIter;
    }
    ++RealPathComponentIter;
  }
}
return SuggestReplacement;
1736}

1738bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts,
                                        const TargetInfo &TargetInfo,
                                        DiagnosticsEngine &Diags, Module *M) {
Module::Requirement Requirement;
Module::UnresolvedHeaderDirective MissingHeader;
Module *ShadowingModule = nullptr;
if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader,
                   ShadowingModule))
  return false;

if (MissingHeader.FileNameLoc.isValid()) {
  Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
      << MissingHeader.IsUmbrella << MissingHeader.FileName;
} else if (ShadowingModule) {
  Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name;
  Diags.Report(ShadowingModule->DefinitionLoc,
               diag::note_previous_definition);
} else {
  // FIXME: Track the location at which the requirement was specified, and
  // use it here.
  Diags.Report(M->DefinitionLoc, diag::err_module_unavailable)
      << M->getFullModuleName() << Requirement.second << Requirement.first;
}
return true;
1762}

1764/// HandleIncludeDirective - The "\#include" tokens have just been read, read
1765/// the file to be included from the lexer, then include it!  This is a common
1766/// routine with functionality shared between \#include, \#include_next and
1767/// \#import.  LookupFrom is set when this is a \#include_next directive, it
1768/// specifies the file to start searching from.
1769void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
                                        Token &IncludeTok,
                                        const DirectoryLookup *LookupFrom,
                                        const FileEntry *LookupFromFile) {
Token FilenameTok;
if (LexHeaderName(FilenameTok))
  return;

if (FilenameTok.isNot(tok::header_name)) {
  Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
  if (FilenameTok.isNot(tok::eod))
    DiscardUntilEndOfDirective();
  return;
}

// Verify that there is nothing after the filename, other than EOD.  Note
// that we allow macros that expand to nothing after the filename, because
// this falls into the category of "#include pp-tokens new-line" specified
// in C99 6.10.2p4.
SourceLocation EndLoc =
    CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);

auto Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok,
                                          EndLoc, LookupFrom, LookupFromFile);
switch (Action.Kind) {
case ImportAction::None:
case ImportAction::SkippedModuleImport:
  break;
case ImportAction::ModuleBegin:
  EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
                       tok::annot_module_begin, Action.ModuleForHeader);
  break;
case ImportAction::ModuleImport:
  EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
                       tok::annot_module_include, Action.ModuleForHeader);
  break;
case ImportAction::Failure:
  assert(TheModuleLoader.HadFatalFailure &&((void)0)
         "This should be an early exit only to a fatal error")((void)0);
  TheModuleLoader.HadFatalFailure = true;
  IncludeTok.setKind(tok::eof);
  CurLexer->cutOffLexing();
  return;
}
1813}

1815Optional<FileEntryRef> Preprocessor::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) {
Optional<FileEntryRef> File = LookupFile(
    FilenameLoc, LookupFilename,
    isAngled, LookupFrom, LookupFromFile, CurDir,
    Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
    &SuggestedModule, &IsMapped, &IsFrameworkFound);
if (File)
  return File;

if (Callbacks) {
  // Give the clients a chance to recover.
  SmallString<128> RecoveryPath;
  if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
    if (auto DE = FileMgr.getOptionalDirectoryRef(RecoveryPath)) {
      // Add the recovery path to the list of search paths.
      DirectoryLookup DL(*DE, SrcMgr::C_User, false);
      HeaderInfo.AddSearchPath(DL, isAngled);

      // Try the lookup again, skipping the cache.
      Optional<FileEntryRef> File = LookupFile(
          FilenameLoc,
          LookupFilename, isAngled,
          LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
          &SuggestedModule, &IsMapped, /*IsFrameworkFound=*/nullptr,
          /*SkipCache*/ true);
      if (File)
        return File;
    }
  }
}

if (SuppressIncludeNotFoundError)
  return None;

// If the file could not be located and it was included via angle
// brackets, we can attempt a lookup as though it were a quoted path to
// provide the user with a possible fixit.
if (isAngled) {
  Optional<FileEntryRef> File = LookupFile(
      FilenameLoc, LookupFilename,
      false, LookupFrom, LookupFromFile, CurDir,
      Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
      &SuggestedModule, &IsMapped,
      /*IsFrameworkFound=*/nullptr);
  if (File) {
    Diag(FilenameTok, diag::err_pp_file_not_found_angled_include_not_fatal)
        << Filename << IsImportDecl
        << FixItHint::CreateReplacement(FilenameRange,
                                        "\"" + Filename.str() + "\"");
    return File;
  }
}

// Check for likely typos due to leading or trailing non-isAlphanumeric
// characters
StringRef OriginalFilename = Filename;
if (LangOpts.SpellChecking) {
  // A heuristic to correct a typo file name by removing leading and
  // trailing non-isAlphanumeric characters.
  auto CorrectTypoFilename = [](llvm::StringRef Filename) {
    Filename = Filename.drop_until(isAlphanumeric);
    while (!Filename.empty() && !isAlphanumeric(Filename.back())) {
      Filename = Filename.drop_back();
    }
    return Filename;
  };
  StringRef TypoCorrectionName = CorrectTypoFilename(Filename);
  StringRef TypoCorrectionLookupName = CorrectTypoFilename(LookupFilename);

  Optional<FileEntryRef> File = LookupFile(
      FilenameLoc, TypoCorrectionLookupName, isAngled, LookupFrom, LookupFromFile,
      CurDir, Callbacks ? &SearchPath : nullptr,
      Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped,
      /*IsFrameworkFound=*/nullptr);
  if (File) {
    auto Hint =
        isAngled ? FixItHint::CreateReplacement(
                       FilenameRange, "<" + TypoCorrectionName.str() + ">")
                 : FixItHint::CreateReplacement(
                       FilenameRange, "\"" + TypoCorrectionName.str() + "\"");
    Diag(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal)
        << OriginalFilename << TypoCorrectionName << Hint;
    // We found the file, so set the Filename to the name after typo
    // correction.
    Filename = TypoCorrectionName;
    LookupFilename = TypoCorrectionLookupName;
    return File;
  }
}

// If the file is still not found, just go with the vanilla diagnostic
assert(!File.hasValue() && "expected missing file")((void)0);
Diag(FilenameTok, diag::err_pp_file_not_found)
    << OriginalFilename << FilenameRange;
if (IsFrameworkFound) {
  size_t SlashPos = OriginalFilename.find('/');
  assert(SlashPos != StringRef::npos &&((void)0)
         "Include with framework name should have '/' in the filename")((void)0);
  StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);
  FrameworkCacheEntry &CacheEntry =
      HeaderInfo.LookupFrameworkCache(FrameworkName);
  assert(CacheEntry.Directory && "Found framework should be in cache")((void)0);
  Diag(FilenameTok, diag::note_pp_framework_without_header)
      << OriginalFilename.substr(SlashPos + 1) << FrameworkName
      << CacheEntry.Directory->getName();
}

return None;
1930}

1932/// Handle either a #include-like directive or an import declaration that names
1933/// a header file.
1934///
1935/// \param HashLoc The location of the '#' token for an include, or
1936///        SourceLocation() for an import declaration.
1937/// \param IncludeTok The include / include_next / import token.
1938/// \param FilenameTok The header-name token.
1939/// \param EndLoc The location at which any imported macros become visible.
1940/// \param LookupFrom For #include_next, the starting directory for the
1941///        directory lookup.
1942/// \param LookupFromFile For #include_next, the starting file for the directory
1943///        lookup.
1944Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
  SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok,
  SourceLocation EndLoc, const DirectoryLookup *LookupFrom,
  const FileEntry *LookupFromFile) {
SmallString<128> FilenameBuffer;
StringRef Filename = getSpelling(FilenameTok, FilenameBuffer);
SourceLocation CharEnd = FilenameTok.getEndLoc();

CharSourceRange FilenameRange
  = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
StringRef OriginalFilename = Filename;
bool isAngled =
  GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);

// If GetIncludeFilenameSpelling set the start ptr to null, there was an
// error.
if (Filename.empty())
  return {ImportAction::None};

bool IsImportDecl = HashLoc.isInvalid();
SourceLocation StartLoc = IsImportDecl ? IncludeTok.getLocation() : HashLoc;

// Complain about attempts to #include files in an audit pragma.
if (PragmaARCCFCodeAuditedInfo.second.isValid()) {
  Diag(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl;
  Diag(PragmaARCCFCodeAuditedInfo.second, diag::note_pragma_entered_here);

  // Immediately leave the pragma.
  PragmaARCCFCodeAuditedInfo = {nullptr, SourceLocation()};
}

// Complain about attempts to #include files in an assume-nonnull pragma.
if (PragmaAssumeNonNullLoc.isValid()) {
  Diag(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl;
  Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);

  // Immediately leave the pragma.
  PragmaAssumeNonNullLoc = SourceLocation();
}

if (HeaderInfo.HasIncludeAliasMap()) {
  // Map the filename with the brackets still attached.  If the name doesn't
  // map to anything, fall back on the filename we've already gotten the
  // spelling for.
  StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
  if (!NewName.empty())
    Filename = NewName;
}

// Search include directories.
bool IsMapped = false;
bool IsFrameworkFound = false;
const DirectoryLookup *CurDir;
SmallString<1024> SearchPath;
SmallString<1024> RelativePath;
// We get the raw path only if we have 'Callbacks' to which we later pass
// the path.
ModuleMap::KnownHeader SuggestedModule;
SourceLocation FilenameLoc = FilenameTok.getLocation();
StringRef LookupFilename = Filename;

2005#ifdef _WIN32
llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::windows;
2007#else
// Normalize slashes when compiling with -fms-extensions on non-Windows. This
// is unnecessary on Windows since the filesystem there handles backslashes.
SmallString<128> NormalizedPath;
llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::posix;
if (LangOpts.MicrosoftExt) {
  NormalizedPath = Filename.str();
  llvm::sys::path::native(NormalizedPath);
  LookupFilename = NormalizedPath;
  BackslashStyle = llvm::sys::path::Style::windows;
}
2018#endif

Optional<FileEntryRef> File = LookupHeaderIncludeOrImport(
    CurDir, Filename, FilenameLoc, FilenameRange, FilenameTok,
    IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile,
    LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled);

// Record the header's filename for later use.
if (File)
  CurLexer->addInclude(OriginalFilename, File->getFileEntry(), FilenameLoc);

if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) {
  if (File && isPCHThroughHeader(&File->getFileEntry()))
    SkippingUntilPCHThroughHeader = false;
  return {ImportAction::None};
}

// Should we enter the source file? Set to Skip if either the source file is
// known to have no effect beyond its effect on module visibility -- that is,
// if it's got an include guard that is already defined, set to Import if it
// is a modular header we've already built and should import.
enum { Enter, Import, Skip, IncludeLimitReached } Action = Enter;

if (PPOpts->SingleFileParseMode)
  Action = IncludeLimitReached;

// If we've reached the max allowed include depth, it is usually due to an
// include cycle. Don't enter already processed files again as it can lead to
// reaching the max allowed include depth again.
if (Action == Enter && HasReachedMaxIncludeDepth && File &&
    HeaderInfo.getFileInfo(&File->getFileEntry()).NumIncludes)
  Action = IncludeLimitReached;

// Determine whether we should try to import the module for this #include, if
// there is one. Don't do so if precompiled module support is disabled or we
// are processing this module textually (because we're building the module).
if (Action == Enter && File && SuggestedModule && getLangOpts().Modules &&
    !isForModuleBuilding(SuggestedModule.getModule(),
                         getLangOpts().CurrentModule,
                         getLangOpts().ModuleName)) {
  // If this include corresponds to a module but that module is
  // unavailable, diagnose the situation and bail out.
  // FIXME: Remove this; loadModule does the same check (but produces
  // slightly worse diagnostics).
  if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(),
                             SuggestedModule.getModule())) {
    Diag(FilenameTok.getLocation(),
         diag::note_implicit_top_level_module_import_here)
        << SuggestedModule.getModule()->getTopLevelModuleName();
    return {ImportAction::None};
  }

  // Compute the module access path corresponding to this module.
  // FIXME: Should we have a second loadModule() overload to avoid this
  // extra lookup step?
  SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
  for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
    Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
                                  FilenameTok.getLocation()));
  std::reverse(Path.begin(), Path.end());

  // Warn that we're replacing the include/import with a module import.
  if (!IsImportDecl)
    diagnoseAutoModuleImport(*this, StartLoc, IncludeTok, Path, CharEnd);

  // Load the module to import its macros. We'll make the declarations
  // visible when the parser gets here.
  // FIXME: Pass SuggestedModule in here rather than converting it to a path
  // and making the module loader convert it back again.
  ModuleLoadResult Imported = TheModuleLoader.loadModule(
      IncludeTok.getLocation(), Path, Module::Hidden,
      /*IsInclusionDirective=*/true);
  assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&((void)0)
         "the imported module is different than the suggested one")((void)0);

  if (Imported) {
    Action = Import;
  } else if (Imported.isMissingExpected()) {
    // We failed to find a submodule that we assumed would exist (because it
    // was in the directory of an umbrella header, for instance), but no
    // actual module containing it exists (because the umbrella header is
    // incomplete).  Treat this as a textual inclusion.
    SuggestedModule = ModuleMap::KnownHeader();
  } else if (Imported.isConfigMismatch()) {
    // On a configuration mismatch, enter the header textually. We still know
    // that it's part of the corresponding module.
  } else {
    // We hit an error processing the import. Bail out.
    if (hadModuleLoaderFatalFailure()) {
      // With a fatal failure in the module loader, we abort parsing.
      Token &Result = IncludeTok;
      assert(CurLexer && "#include but no current lexer set!")((void)0);
      Result.startToken();
      CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
      CurLexer->cutOffLexing();
    }
    return {ImportAction::None};
  }
}

// The #included file will be considered to be a system header if either it is
// in a system include directory, or if the #includer is a system include
// header.
SrcMgr::CharacteristicKind FileCharacter =
    SourceMgr.getFileCharacteristic(FilenameTok.getLocation());
if (File)
  FileCharacter = std::max(HeaderInfo.getFileDirFlavor(&File->getFileEntry()),
                           FileCharacter);

// If this is a '#import' or an import-declaration, don't re-enter the file.
//
// FIXME: If we have a suggested module for a '#include', and we've already
// visited this file, don't bother entering it again. We know it has no
// further effect.
bool EnterOnce =
    IsImportDecl ||
    IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import;

// Ask HeaderInfo if we should enter this #include file.  If not, #including
// this file will have no effect.
if (Action == Enter && File &&
    !HeaderInfo.ShouldEnterIncludeFile(*this, &File->getFileEntry(),
                                       EnterOnce, getLangOpts().Modules,
                                       SuggestedModule.getModule())) {
  // Even if we've already preprocessed this header once and know that we
  // don't need to see its contents again, we still need to import it if it's
  // modular because we might not have imported it from this submodule before.
  //
  // FIXME: We don't do this when compiling a PCH because the AST
  // serialization layer can't cope with it. This means we get local
  // submodule visibility semantics wrong in that case.
  Action = (SuggestedModule && !getLangOpts().CompilingPCH) ? Import : Skip;
}

// Check for circular inclusion of the main file.
// We can't generate a consistent preamble with regard to the conditional
// stack if the main file is included again as due to the preamble bounds
// some directives (e.g. #endif of a header guard) will never be seen.
// Since this will lead to confusing errors, avoid the inclusion.
if (Action == Enter && File && PreambleConditionalStack.isRecording() &&
    SourceMgr.isMainFile(File->getFileEntry())) {
  Diag(FilenameTok.getLocation(),
       diag::err_pp_including_mainfile_in_preamble);
  return {ImportAction::None};
}

if (Callbacks && !IsImportDecl) {
  // Notify the callback object that we've seen an inclusion directive.
  // FIXME: Use a different callback for a pp-import?
  Callbacks->InclusionDirective(
      HashLoc, IncludeTok, LookupFilename, isAngled, FilenameRange,
      File ? &File->getFileEntry() : nullptr, SearchPath, RelativePath,
      Action == Import ? SuggestedModule.getModule() : nullptr,
      FileCharacter);
  if (Action == Skip && File)
    Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
}

if (!File)
  return {ImportAction::None};

// If this is a C++20 pp-import declaration, diagnose if we didn't find any
// module corresponding to the named header.
if (IsImportDecl && !SuggestedModule) {
  Diag(FilenameTok, diag::err_header_import_not_header_unit)
    << OriginalFilename << File->getName();
  return {ImportAction::None};
}

// Issue a diagnostic if the name of the file on disk has a different case
// than the one we're about to open.
const bool CheckIncludePathPortability =
    !IsMapped && !File->getFileEntry().tryGetRealPathName().empty();

if (CheckIncludePathPortability) {
  StringRef Name = LookupFilename;
  StringRef NameWithoriginalSlashes = Filename;
2195#if defined(_WIN32)
  // Skip UNC prefix if present. (tryGetRealPathName() always
  // returns a path with the prefix skipped.)
  bool NameWasUNC = Name.consume_front("\\\\?\\");
  NameWithoriginalSlashes.consume_front("\\\\?\\");
2200#endif
  StringRef RealPathName = File->getFileEntry().tryGetRealPathName();
  SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
                                        llvm::sys::path::end(Name));
2204#if defined(_WIN32)
  // -Wnonportable-include-path is designed to diagnose includes using
  // case even on systems with a case-insensitive file system.
  // On Windows, RealPathName always starts with an upper-case drive
  // letter for absolute paths, but Name might start with either
  // case depending on if `cd c:\foo` or `cd C:\foo` was used in the shell.
  // ("foo" will always have on-disk case, no matter which case was
  // used in the cd command). To not emit this warning solely for
  // the drive letter, whose case is dependent on if `cd` is used
  // with upper- or lower-case drive letters, always consider the
  // given drive letter case as correct for the purpose of this warning.
  SmallString<128> FixedDriveRealPath;
  if (llvm::sys::path::is_absolute(Name) &&
      llvm::sys::path::is_absolute(RealPathName) &&
      toLowercase(Name[0]) == toLowercase(RealPathName[0]) &&
      isLowercase(Name[0]) != isLowercase(RealPathName[0])) {
    assert(Components.size() >= 3 && "should have drive, backslash, name")((void)0);
    assert(Components[0].size() == 2 && "should start with drive")((void)0);
    assert(Components[0][1] == ':' && "should have colon")((void)0);
    FixedDriveRealPath = (Name.substr(0, 1) + RealPathName.substr(1)).str();
    RealPathName = FixedDriveRealPath;
  }
2226#endif

  if (trySimplifyPath(Components, RealPathName)) {
    SmallString<128> Path;
    Path.reserve(Name.size()+2);
    Path.push_back(isAngled ? '<' : '"');

    const auto IsSep = [BackslashStyle](char c) {
      return llvm::sys::path::is_separator(c, BackslashStyle);
    };

    for (auto Component : Components) {
      // On POSIX, Components will contain a single '/' as first element
      // exactly if Name is an absolute path.
      // On Windows, it will contain "C:" followed by '\' for absolute paths.
      // The drive letter is optional for absolute paths on Windows, but
      // clang currently cannot process absolute paths in #include lines that
      // don't have a drive.
      // If the first entry in Components is a directory separator,
      // then the code at the bottom of this loop that keeps the original
      // directory separator style copies it. If the second entry is
      // a directory separator (the C:\ case), then that separator already
      // got copied when the C: was processed and we want to skip that entry.
      if (!(Component.size() == 1 && IsSep(Component[0])))
        Path.append(Component);
      else if (!Path.empty())
        continue;

      // Append the separator(s) the user used, or the close quote
      if (Path.size() > NameWithoriginalSlashes.size()) {
        Path.push_back(isAngled ? '>' : '"');
        continue;
      }
      assert(IsSep(NameWithoriginalSlashes[Path.size()-1]))((void)0);
      do
        Path.push_back(NameWithoriginalSlashes[Path.size()-1]);
      while (Path.size() <= NameWithoriginalSlashes.size() &&
             IsSep(NameWithoriginalSlashes[Path.size()-1]));
    }

2266#if defined(_WIN32)
    // Restore UNC prefix if it was there.
    if (NameWasUNC)
      Path = (Path.substr(0, 1) + "\\\\?\\" + Path.substr(1)).str();
2270#endif

    // For user files and known standard headers, issue a diagnostic.
    // For other system headers, don't. They can be controlled separately.
    auto DiagId =
        (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name))
            ? diag::pp_nonportable_path
            : diag::pp_nonportable_system_path;
    Diag(FilenameTok, DiagId) << Path <<
      FixItHint::CreateReplacement(FilenameRange, Path);
  }
}

switch (Action) {
case Skip:
  // If we don't need to enter the file, stop now.
  if (Module *M = SuggestedModule.getModule())
    return {ImportAction::SkippedModuleImport, M};
  return {ImportAction::None};

case IncludeLimitReached:
  // If we reached our include limit and don't want to enter any more files,
  // don't go any further.
  return {ImportAction::None};

case Import: {
  // If this is a module import, make it visible if needed.
  Module *M = SuggestedModule.getModule();
  assert(M && "no module to import")((void)0);

  makeModuleVisible(M, EndLoc);

  if (IncludeTok.getIdentifierInfo()->getPPKeywordID() ==
      tok::pp___include_macros)
    return {ImportAction::None};

  return {ImportAction::ModuleImport, M};
}

case Enter:
  break;
}

// Check that we don't have infinite #include recursion.
if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
  Diag(FilenameTok, diag::err_pp_include_too_deep);
  HasReachedMaxIncludeDepth = true;
  return {ImportAction::None};
}

// Look up the file, create a File ID for it.
SourceLocation IncludePos = FilenameTok.getLocation();
// If the filename string was the result of macro expansions, set the include
// position on the file where it will be included and after the expansions.
if (IncludePos.isMacroID())
  IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd();
FileID FID = SourceMgr.createFileID(*File, IncludePos, FileCharacter);
if (!FID.isValid()) {
  TheModuleLoader.HadFatalFailure = true;
  return ImportAction::Failure;
}

// If all is good, enter the new file!
if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
  return {ImportAction::None};

// Determine if we're switching to building a new submodule, and which one.
if (auto *M = SuggestedModule.getModule()) {
  if (M->getTopLevelModule()->ShadowingModule) {
    // We are building a submodule that belongs to a shadowed module. This
    // means we find header files in the shadowed module.
    Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule)
      << M->getFullModuleName();
    Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc,
         diag::note_previous_definition);
    return {ImportAction::None};
  }
  // When building a pch, -fmodule-name tells the compiler to textually
  // include headers in the specified module. We are not building the
  // specified module.
  //
  // FIXME: This is the wrong way to handle this. We should produce a PCH
  // that behaves the same as the header would behave in a compilation using
  // that PCH, which means we should enter the submodule. We need to teach
  // the AST serialization layer to deal with the resulting AST.
  if (getLangOpts().CompilingPCH &&
      isForModuleBuilding(M, getLangOpts().CurrentModule,
                          getLangOpts().ModuleName))
    return {ImportAction::None};

  assert(!CurLexerSubmodule && "should not have marked this as a module yet")((void)0);
  CurLexerSubmodule = M;

  // Let the macro handling code know that any future macros are within
  // the new submodule.
  EnterSubmodule(M, EndLoc, /*ForPragma*/false);

  // Let the parser know that any future declarations are within the new
  // submodule.
  // FIXME: There's no point doing this if we're handling a #__include_macros
  // directive.
  return {ImportAction::ModuleBegin, M};
}

assert(!IsImportDecl && "failed to diagnose missing module for import decl")((void)0);
return {ImportAction::None};
2376}

2378/// HandleIncludeNextDirective - Implements \#include_next.
2379///
2380void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
                                            Token &IncludeNextTok) {
Diag(IncludeNextTok, diag::ext_pp_include_next_directive);

// #include_next is like #include, except that we start searching after
// the current found directory.  If we can't do this, issue a
// diagnostic.
const DirectoryLookup *Lookup = CurDirLookup;
const FileEntry *LookupFromFile = nullptr;
if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
  // If the main file is a header, then it's either for PCH/AST generation,
  // or libclang opened it. Either way, handle it as a normal include below
  // and do not complain about include_next.
} else if (isInPrimaryFile()) {
  Lookup = nullptr;
  Diag(IncludeNextTok, diag::pp_include_next_in_primary);
} else if (CurLexerSubmodule) {
  // Start looking up in the directory *after* the one in which the current
  // file would be found, if any.
  assert(CurPPLexer && "#include_next directive in macro?")((void)0);
  LookupFromFile = CurPPLexer->getFileEntry();
  Lookup = nullptr;
} else if (!Lookup) {
  // The current file was not found by walking the include path. Either it
  // is the primary file (handled above), or it was found by absolute path,
  // or it was found relative to such a file.
  // FIXME: Track enough information so we know which case we're in.
  Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
} else {
  // Start looking up in the next directory.
  ++Lookup;
}

return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
                              LookupFromFile);
2415}

2417/// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2418void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
// The Microsoft #import directive takes a type library and generates header
// files from it, and includes those.  This is beyond the scope of what clang
// does, so we ignore it and error out.  However, #import can optionally have
// trailing attributes that span multiple lines.  We're going to eat those
// so we can continue processing from there.
Diag(Tok, diag::err_pp_import_directive_ms );

// Read tokens until we get to the end of the directive.  Note that the
// directive can be split over multiple lines using the backslash character.
DiscardUntilEndOfDirective();
2429}

2431/// HandleImportDirective - Implements \#import.
2432///
2433void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
                                       Token &ImportTok) {
if (!LangOpts.ObjC) {  // #import is standard for ObjC.
  if (LangOpts.MSVCCompat)
    return HandleMicrosoftImportDirective(ImportTok);
  Diag(ImportTok, diag::ext_pp_import_directive);
}
return HandleIncludeDirective(HashLoc, ImportTok);
2441}

2443/// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2444/// pseudo directive in the predefines buffer.  This handles it by sucking all
2445/// tokens through the preprocessor and discarding them (only keeping the side
2446/// effects on the preprocessor).
2447void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
                                              Token &IncludeMacrosTok) {
// This directive should only occur in the predefines buffer.  If not, emit an
// error and reject it.
SourceLocation Loc = IncludeMacrosTok.getLocation();
if (SourceMgr.getBufferName(Loc) != "<built-in>") {
  Diag(IncludeMacrosTok.getLocation(),
       diag::pp_include_macros_out_of_predefines);
  DiscardUntilEndOfDirective();
  return;
}

// Treat this as a normal #include for checking purposes.  If this is
// successful, it will push a new lexer onto the include stack.
HandleIncludeDirective(HashLoc, IncludeMacrosTok);

Token TmpTok;
do {
  Lex(TmpTok);
  assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!")((void)0);
} while (TmpTok.isNot(tok::hashhash));
2468}

2470//===----------------------------------------------------------------------===//
2471// Preprocessor Macro Directive Handling.
2472//===----------------------------------------------------------------------===//

2474/// ReadMacroParameterList - The ( starting a parameter list of a macro
2475/// definition has just been read.  Lex the rest of the parameters and the
2476/// closing ), updating MI with what we learn.  Return true if an error occurs
2477/// parsing the param list.
2478bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {
SmallVector<IdentifierInfo*, 32> Parameters;

while (true) {
  LexUnexpandedToken(Tok);
  switch (Tok.getKind()) {
  case tok::r_paren:
    // Found the end of the parameter list.
    if (Parameters.empty())  // #define FOO()
      return false;
    // Otherwise we have #define FOO(A,)
    Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
    return true;
  case tok::ellipsis:  // #define X(... -> C99 varargs
    if (!LangOpts.C99)
      Diag(Tok, LangOpts.CPlusPlus11 ?
           diag::warn_cxx98_compat_variadic_macro :
           diag::ext_variadic_macro);

    // OpenCL v1.2 s6.9.e: variadic macros are not supported.
    if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus) {
      Diag(Tok, diag::ext_pp_opencl_variadic_macros);
    }

    // Lex the token after the identifier.
    LexUnexpandedToken(Tok);
    if (Tok.isNot(tok::r_paren)) {
      Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
      return true;
    }
    // Add the __VA_ARGS__ identifier as a parameter.
    Parameters.push_back(Ident__VA_ARGS__);
    MI->setIsC99Varargs();
    MI->setParameterList(Parameters, BP);
    return false;
  case tok::eod:  // #define X(
    Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
    return true;
  default:
    // Handle keywords and identifiers here to accept things like
    // #define Foo(for) for.
    IdentifierInfo *II = Tok.getIdentifierInfo();
    if (!II) {
      // #define X(1
      Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
      return true;
    }

    // If this is already used as a parameter, it is used multiple times (e.g.
    // #define X(A,A.
    if (llvm::find(Parameters, II) != Parameters.end()) { // C99 6.10.3p6
      Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
      return true;
    }

    // Add the parameter to the macro info.
    Parameters.push_back(II);

    // Lex the token after the identifier.
    LexUnexpandedToken(Tok);

    switch (Tok.getKind()) {
    default:          // #define X(A B
      Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
      return true;
    case tok::r_paren: // #define X(A)
      MI->setParameterList(Parameters, BP);
      return false;
    case tok::comma:  // #define X(A,
      break;
    case tok::ellipsis:  // #define X(A... -> GCC extension
      // Diagnose extension.
      Diag(Tok, diag::ext_named_variadic_macro);

      // Lex the token after the identifier.
      LexUnexpandedToken(Tok);
      if (Tok.isNot(tok::r_paren)) {
        Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
        return true;
      }

      MI->setIsGNUVarargs();
      MI->setParameterList(Parameters, BP);
      return false;
    }
  }
}
2565}

2567static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
                                 const LangOptions &LOptions) {
if (MI->getNumTokens() == 1) {
  const Token &Value = MI->getReplacementToken(0);

  // Macro that is identity, like '#define inline inline' is a valid pattern.
  if (MacroName.getKind() == Value.getKind())
    return true;

  // Macro that maps a keyword to the same keyword decorated with leading/
  // trailing underscores is a valid pattern:
  //    #define inline __inline
  //    #define inline __inline__
  //    #define inline _inline (in MS compatibility mode)
  StringRef MacroText = MacroName.getIdentifierInfo()->getName();
  if (IdentifierInfo *II = Value.getIdentifierInfo()) {
    if (!II->isKeyword(LOptions))
      return false;
    StringRef ValueText = II->getName();
    StringRef TrimmedValue = ValueText;
    if (!ValueText.startswith("__")) {
      if (ValueText.startswith("_"))
        TrimmedValue = TrimmedValue.drop_front(1);
      else
        return false;
    } else {
      TrimmedValue = TrimmedValue.drop_front(2);
      if (TrimmedValue.endswith("__"))
        TrimmedValue = TrimmedValue.drop_back(2);
    }
    return TrimmedValue.equals(MacroText);
  } else {
    return false;
  }
}

// #define inline
return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
                         tok::kw_const) &&
       MI->getNumTokens() == 0;
2607}

2609// ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the
2610// entire line) of the macro's tokens and adds them to MacroInfo, and while
2611// doing so performs certain validity checks including (but not limited to):
2612//   - # (stringization) is followed by a macro parameter
2613//
2614//  Returns a nullptr if an invalid sequence of tokens is encountered or returns
2615//  a pointer to a MacroInfo object.

2617MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(
  const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {

Token LastTok = MacroNameTok;
// Create the new macro.
MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation());
16
←
Calling 'Preprocessor::AllocateMacroInfo'→

Token Tok;
LexUnexpandedToken(Tok);

// Ensure we consume the rest of the macro body if errors occur.
auto _ = llvm::make_scope_exit([&]() {
  // The flag indicates if we are still waiting for 'eod'.
  if (CurLexer->ParsingPreprocessorDirective)
    DiscardUntilEndOfDirective();
});

// Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk
// within their appropriate context.
VariadicMacroScopeGuard VariadicMacroScopeGuard(*this);

// If this is a function-like macro definition, parse the argument list,
// marking each of the identifiers as being used as macro arguments.  Also,
// check other constraints on the first token of the macro body.
if (Tok.is(tok::eod)) {
  if (ImmediatelyAfterHeaderGuard) {
    // Save this macro information since it may part of a header guard.
    CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
                                      MacroNameTok.getLocation());
  }
  // If there is no body to this macro, we have no special handling here.
} else if (Tok.hasLeadingSpace()) {
  // This is a normal token with leading space.  Clear the leading space
  // marker on the first token to get proper expansion.
  Tok.clearFlag(Token::LeadingSpace);
} else if (Tok.is(tok::l_paren)) {
  // This is a function-like macro definition.  Read the argument list.
  MI->setIsFunctionLike();
  if (ReadMacroParameterList(MI, LastTok))
    return nullptr;

  // If this is a definition of an ISO C/C++ variadic function-like macro (not
  // using the GNU named varargs extension) inform our variadic scope guard
  // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__)
  // allowed only within the definition of a variadic macro.

  if (MI->isC99Varargs()) {
    VariadicMacroScopeGuard.enterScope();
  }

  // Read the first token after the arg list for down below.
  LexUnexpandedToken(Tok);
} else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
  // C99 requires whitespace between the macro definition and the body.  Emit
  // a diagnostic for something like "#define X+".
  Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
} else {
  // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
  // first character of a replacement list is not a character required by
  // subclause 5.2.1, then there shall be white-space separation between the
  // identifier and the replacement list.".  5.2.1 lists this set:
  //   "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
  // is irrelevant here.
  bool isInvalid = false;
  if (Tok.is(tok::at)) // @ is not in the list above.
    isInvalid = true;
  else if (Tok.is(tok::unknown)) {
    // If we have an unknown token, it is something strange like "`".  Since
    // all of valid characters would have lexed into a single character
    // token of some sort, we know this is not a valid case.
    isInvalid = true;
  }
  if (isInvalid)
    Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
  else
    Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
}

if (!Tok.is(tok::eod))
  LastTok = Tok;

// Read the rest of the macro body.
if (MI->isObjectLike()) {
  // Object-like macros are very simple, just read their body.
  while (Tok.isNot(tok::eod)) {
    LastTok = Tok;
    MI->AddTokenToBody(Tok);
    // Get the next token of the macro.
    LexUnexpandedToken(Tok);
  }
} else {
  // Otherwise, read the body of a function-like macro.  While we are at it,
  // check C99 6.10.3.2p1: ensure that # operators are followed by macro
  // parameters in function-like macro expansions.

  VAOptDefinitionContext VAOCtx(*this);

  while (Tok.isNot(tok::eod)) {
    LastTok = Tok;

    if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
      MI->AddTokenToBody(Tok);

      if (VAOCtx.isVAOptToken(Tok)) {
        // If we're already within a VAOPT, emit an error.
        if (VAOCtx.isInVAOpt()) {
          Diag(Tok, diag::err_pp_vaopt_nested_use);
          return nullptr;
        }
        // Ensure VAOPT is followed by a '(' .
        LexUnexpandedToken(Tok);
        if (Tok.isNot(tok::l_paren)) {
          Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use);
          return nullptr;
        }
        MI->AddTokenToBody(Tok);
        VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation());
        LexUnexpandedToken(Tok);
        if (Tok.is(tok::hashhash)) {
          Diag(Tok, diag::err_vaopt_paste_at_start);
          return nullptr;
        }
        continue;
      } else if (VAOCtx.isInVAOpt()) {
        if (Tok.is(tok::r_paren)) {
          if (VAOCtx.sawClosingParen()) {
            const unsigned NumTokens = MI->getNumTokens();
            assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( "((void)0)
                                     "and a subsequent tok::r_paren")((void)0);
            if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) {
              Diag(Tok, diag::err_vaopt_paste_at_end);
              return nullptr;
            }
          }
        } else if (Tok.is(tok::l_paren)) {
          VAOCtx.sawOpeningParen(Tok.getLocation());
        }
      }
      // Get the next token of the macro.
      LexUnexpandedToken(Tok);
      continue;
    }

    // If we're in -traditional mode, then we should ignore stringification
    // and token pasting. Mark the tokens as unknown so as not to confuse
    // things.
    if (getLangOpts().TraditionalCPP) {
      Tok.setKind(tok::unknown);
      MI->AddTokenToBody(Tok);

      // Get the next token of the macro.
      LexUnexpandedToken(Tok);
      continue;
    }

    if (Tok.is(tok::hashhash)) {
      // If we see token pasting, check if it looks like the gcc comma
      // pasting extension.  We'll use this information to suppress
      // diagnostics later on.

      // Get the next token of the macro.
      LexUnexpandedToken(Tok);

      if (Tok.is(tok::eod)) {
        MI->AddTokenToBody(LastTok);
        break;
      }

      unsigned NumTokens = MI->getNumTokens();
      if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
          MI->getReplacementToken(NumTokens-1).is(tok::comma))
        MI->setHasCommaPasting();

      // Things look ok, add the '##' token to the macro.
      MI->AddTokenToBody(LastTok);
      continue;
    }

    // Our Token is a stringization operator.
    // Get the next token of the macro.
    LexUnexpandedToken(Tok);

    // Check for a valid macro arg identifier or __VA_OPT__.
    if (!VAOCtx.isVAOptToken(Tok) &&
        (Tok.getIdentifierInfo() == nullptr ||
         MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) {

      // If this is assembler-with-cpp mode, we accept random gibberish after
      // the '#' because '#' is often a comment character.  However, change
      // the kind of the token to tok::unknown so that the preprocessor isn't
      // confused.
      if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
        LastTok.setKind(tok::unknown);
        MI->AddTokenToBody(LastTok);
        continue;
      } else {
        Diag(Tok, diag::err_pp_stringize_not_parameter)
          << LastTok.is(tok::hashat);
        return nullptr;
      }
    }

    // Things look ok, add the '#' and param name tokens to the macro.
    MI->AddTokenToBody(LastTok);

    // If the token following '#' is VAOPT, let the next iteration handle it
    // and check it for correctness, otherwise add the token and prime the
    // loop with the next one.
    if (!VAOCtx.isVAOptToken(Tok)) {
      MI->AddTokenToBody(Tok);
      LastTok = Tok;

      // Get the next token of the macro.
      LexUnexpandedToken(Tok);
    }
  }
  if (VAOCtx.isInVAOpt()) {
    assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive")((void)0);
    Diag(Tok, diag::err_pp_expected_after)
      << LastTok.getKind() << tok::r_paren;
    Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren;
    return nullptr;
  }
}
MI->setDefinitionEndLoc(LastTok.getLocation());
return MI;
2843}
2844/// HandleDefineDirective - Implements \#define.  This consumes the entire macro
2845/// line then lets the caller lex the next real token.
2846void Preprocessor::HandleDefineDirective(
  Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {
++NumDefined;

Token MacroNameTok;
bool MacroShadowsKeyword;
ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);

// Error reading macro name?  If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
13
←
Taking false branch→
  return;

// If we are supposed to keep comments in #defines, reenable comment saving
// mode.
if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
14
←
Taking false branch→

MacroInfo *const MI = ReadOptionalMacroParameterListAndBody(
15
←
Calling 'Preprocessor::ReadOptionalMacroParameterListAndBody'→
    MacroNameTok, ImmediatelyAfterHeaderGuard);

if (!MI) return;

if (MacroShadowsKeyword &&
    !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
  Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
}
// Check that there is no paste (##) operator at the beginning or end of the
// replacement list.
unsigned NumTokens = MI->getNumTokens();
if (NumTokens != 0) {
  if (MI->getReplacementToken(0).is(tok::hashhash)) {
    Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
    return;
  }
  if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
    Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
    return;
  }
}

// When skipping just warn about macros that do not match.
if (SkippingUntilPCHThroughHeader) {
  const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo());
  if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this,
                           /*Syntactic=*/LangOpts.MicrosoftExt))
    Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch)
        << MacroNameTok.getIdentifierInfo();
  // Issue the diagnostic but allow the change if msvc extensions are enabled
  if (!LangOpts.MicrosoftExt)
    return;
}

// Finally, if this identifier already had a macro defined for it, verify that
// the macro bodies are identical, and issue diagnostics if they are not.
if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
  // In Objective-C, ignore attempts to directly redefine the builtin
  // definitions of the ownership qualifiers.  It's still possible to
  // #undef them.
  auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
    return II->isStr("__strong") ||
           II->isStr("__weak") ||
           II->isStr("__unsafe_unretained") ||
           II->isStr("__autoreleasing");
  };
 if (getLangOpts().ObjC &&
      SourceMgr.getFileID(OtherMI->getDefinitionLoc())
        == getPredefinesFileID() &&
      isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
    // Warn if it changes the tokens.
    if ((!getDiagnostics().getSuppressSystemWarnings() ||
         !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
        !MI->isIdenticalTo(*OtherMI, *this,
                           /*Syntactic=*/LangOpts.MicrosoftExt)) {
      Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
    }
    assert(!OtherMI->isWarnIfUnused())((void)0);
    return;
  }

  // It is very common for system headers to have tons of macro redefinitions
  // and for warnings to be disabled in system headers.  If this is the case,
  // then don't bother calling MacroInfo::isIdenticalTo.
  if (!getDiagnostics().getSuppressSystemWarnings() ||
      !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
    if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
      Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);

    // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
    // C++ [cpp.predefined]p4, but allow it as an extension.
    if (OtherMI->isBuiltinMacro())
      Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
    // Macros must be identical.  This means all tokens and whitespace
    // separation must be the same.  C99 6.10.3p2.
    else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
             !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
      Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
        << MacroNameTok.getIdentifierInfo();
      Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
    }
  }
  if (OtherMI->isWarnIfUnused())
    WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
}

DefMacroDirective *MD =
    appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);

assert(!MI->isUsed())((void)0);
// If we need warning for not using the macro, add its location in the
// warn-because-unused-macro set. If it gets used it will be removed from set.
if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
    !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc()) &&
    !MacroExpansionInDirectivesOverride &&
    getSourceManager().getFileID(MI->getDefinitionLoc()) !=
        getPredefinesFileID()) {
  MI->setIsWarnIfUnused(true);
  WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
}

// If the callbacks want to know, tell them about the macro definition.
if (Callbacks)
  Callbacks->MacroDefined(MacroNameTok, MD);

// If we're in MS compatibility mode and the macro being defined is the
// assert macro, implicitly add a macro definition for static_assert to work
// around their broken assert.h header file in C. Only do so if there isn't
// already a static_assert macro defined.
if (!getLangOpts().CPlusPlus && getLangOpts().MSVCCompat &&
    MacroNameTok.getIdentifierInfo()->isStr("assert") &&
    !isMacroDefined("static_assert")) {
  MacroInfo *MI = AllocateMacroInfo(SourceLocation());

  Token Tok;
  Tok.startToken();
  Tok.setKind(tok::kw__Static_assert);
  Tok.setIdentifierInfo(getIdentifierInfo("_Static_assert"));
  MI->AddTokenToBody(Tok);
  (void)appendDefMacroDirective(getIdentifierInfo("static_assert"), MI);
}
2984}

2986/// HandleUndefDirective - Implements \#undef.
2987///
2988void Preprocessor::HandleUndefDirective() {
++NumUndefined;

Token MacroNameTok;
ReadMacroName(MacroNameTok, MU_Undef);

// Error reading macro name?  If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
  return;

// Check to see if this is the last token on the #undef line.
CheckEndOfDirective("undef");

// Okay, we have a valid identifier to undef.
auto *II = MacroNameTok.getIdentifierInfo();
auto MD = getMacroDefinition(II);
UndefMacroDirective *Undef = nullptr;

// If the macro is not defined, this is a noop undef.
if (const MacroInfo *MI = MD.getMacroInfo()) {
  if (!MI->isUsed() && MI->isWarnIfUnused())
    Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);

  if (MI->isWarnIfUnused())
    WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());

  Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
}

// If the callbacks want to know, tell them about the macro #undef.
// Note: no matter if the macro was defined or not.
if (Callbacks)
  Callbacks->MacroUndefined(MacroNameTok, MD, Undef);

if (Undef)
  appendMacroDirective(II, Undef);
3024}

3026//===----------------------------------------------------------------------===//
3027// Preprocessor Conditional Directive Handling.
3028//===----------------------------------------------------------------------===//

3030/// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive.  isIfndef
3031/// is true when this is a \#ifndef directive.  ReadAnyTokensBeforeDirective is
3032/// true if any tokens have been returned or pp-directives activated before this
3033/// \#ifndef has been lexed.
3034///
3035void Preprocessor::HandleIfdefDirective(Token &Result,
                                      const Token &HashToken,
                                      bool isIfndef,
                                      bool ReadAnyTokensBeforeDirective) {
++NumIf;
Token DirectiveTok = Result;

Token MacroNameTok;
ReadMacroName(MacroNameTok);

// Error reading macro name?  If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod)) {
  // Skip code until we get to #endif.  This helps with recovery by not
  // emitting an error when the #endif is reached.
  SkipExcludedConditionalBlock(HashToken.getLocation(),
                               DirectiveTok.getLocation(),
                               /*Foundnonskip*/ false, /*FoundElse*/ false);
  return;
}

// Check to see if this is the last token on the #if[n]def line.
CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");

IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
auto MD = getMacroDefinition(MII);
MacroInfo *MI = MD.getMacroInfo();

if (CurPPLexer->getConditionalStackDepth() == 0) {
  // If the start of a top-level #ifdef and if the macro is not defined,
  // inform MIOpt that this might be the start of a proper include guard.
  // Otherwise it is some other form of unknown conditional which we can't
  // handle.
  if (!ReadAnyTokensBeforeDirective && !MI) {
    assert(isIfndef && "#ifdef shouldn't reach here")((void)0);
    CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
  } else
    CurPPLexer->MIOpt.EnterTopLevelConditional();
}

// If there is a macro, process it.
if (MI)  // Mark it used.
  markMacroAsUsed(MI);

if (Callbacks) {
  if (isIfndef)
    Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
  else
    Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
}

bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
  getSourceManager().isInMainFile(DirectiveTok.getLocation());

// Should we include the stuff contained by this directive?
if (PPOpts->SingleFileParseMode && !MI) {
  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
  // the directive blocks.
  CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
                                   /*wasskip*/false, /*foundnonskip*/false,
                                   /*foundelse*/false);
} else if (!MI == isIfndef || RetainExcludedCB) {
  // Yes, remember that we are inside a conditional, then lex the next token.
  CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
                                   /*wasskip*/false, /*foundnonskip*/true,
                                   /*foundelse*/false);
} else {
  // No, skip the contents of this block.
  SkipExcludedConditionalBlock(HashToken.getLocation(),
                               DirectiveTok.getLocation(),
                               /*Foundnonskip*/ false,
                               /*FoundElse*/ false);
}
3107}

3109/// HandleIfDirective - Implements the \#if directive.
3110///
3111void Preprocessor::HandleIfDirective(Token &IfToken,
                                   const Token &HashToken,
                                   bool ReadAnyTokensBeforeDirective) {
++NumIf;

// Parse and evaluate the conditional expression.
IdentifierInfo *IfNDefMacro = nullptr;
const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
const bool ConditionalTrue = DER.Conditional;
// Lexer might become invalid if we hit code completion point while evaluating
// expression.
if (!CurPPLexer)
  return;

// If this condition is equivalent to #ifndef X, and if this is the first
// directive seen, handle it for the multiple-include optimization.
if (CurPPLexer->getConditionalStackDepth() == 0) {
  if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
    // FIXME: Pass in the location of the macro name, not the 'if' token.
    CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
  else
    CurPPLexer->MIOpt.EnterTopLevelConditional();
}

if (Callbacks)
  Callbacks->If(
      IfToken.getLocation(), DER.ExprRange,
      (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));

bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
  getSourceManager().isInMainFile(IfToken.getLocation());

// Should we include the stuff contained by this directive?
if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
  // the directive blocks.
  CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
                                   /*foundnonskip*/false, /*foundelse*/false);
} else if (ConditionalTrue || RetainExcludedCB) {
  // Yes, remember that we are inside a conditional, then lex the next token.
  CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
                                 /*foundnonskip*/true, /*foundelse*/false);
} else {
  // No, skip the contents of this block.
  SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(),
                               /*Foundnonskip*/ false,
                               /*FoundElse*/ false);
}
3159}

3161/// HandleEndifDirective - Implements the \#endif directive.
3162///
3163void Preprocessor::HandleEndifDirective(Token &EndifToken) {
++NumEndif;

// Check that this is the whole directive.
CheckEndOfDirective("endif");

PPConditionalInfo CondInfo;
if (CurPPLexer->popConditionalLevel(CondInfo)) {
  // No conditionals on the stack: this is an #endif without an #if.
  Diag(EndifToken, diag::err_pp_endif_without_if);
  return;
}

// If this the end of a top-level #endif, inform MIOpt.
if (CurPPLexer->getConditionalStackDepth() == 0)
  CurPPLexer->MIOpt.ExitTopLevelConditional();

assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&((void)0)
       "This code should only be reachable in the non-skipping case!")((void)0);

if (Callbacks)
  Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
3185}

3187/// HandleElseDirective - Implements the \#else directive.
3188///
3189void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {
++NumElse;

// #else directive in a non-skipping conditional... start skipping.
CheckEndOfDirective("else");

PPConditionalInfo CI;
if (CurPPLexer->popConditionalLevel(CI)) {
  Diag(Result, diag::pp_err_else_without_if);
  return;
}

// If this is a top-level #else, inform the MIOpt.
if (CurPPLexer->getConditionalStackDepth() == 0)
  CurPPLexer->MIOpt.EnterTopLevelConditional();

// If this is a #else with a #else before it, report the error.
if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);

if (Callbacks)
  Callbacks->Else(Result.getLocation(), CI.IfLoc);

bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
  getSourceManager().isInMainFile(Result.getLocation());

if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
  // the directive blocks.
  CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,
                                   /*foundnonskip*/false, /*foundelse*/true);
  return;
}

// Finally, skip the rest of the contents of this block.
SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc,
                             /*Foundnonskip*/ true,
                             /*FoundElse*/ true, Result.getLocation());
3226}

3228/// Implements the \#elif, \#elifdef, and \#elifndef directives.
3229void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,
                                           const Token &HashToken,
                                           tok::PPKeywordKind Kind) {
PPElifDiag DirKind = Kind == tok::pp_elif      ? PED_Elif
                     : Kind == tok::pp_elifdef ? PED_Elifdef
                                               : PED_Elifndef;
++NumElse;

// #elif directive in a non-skipping conditional... start skipping.
// We don't care what the condition is, because we will always skip it (since
// the block immediately before it was included).
SourceRange ConditionRange = DiscardUntilEndOfDirective();

PPConditionalInfo CI;
if (CurPPLexer->popConditionalLevel(CI)) {
  Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind;
  return;
}

// If this is a top-level #elif, inform the MIOpt.
if (CurPPLexer->getConditionalStackDepth() == 0)
  CurPPLexer->MIOpt.EnterTopLevelConditional();

// If this is a #elif with a #else before it, report the error.
if (CI.FoundElse)
  Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind;

if (Callbacks) {
  switch (Kind) {
  case tok::pp_elif:
    Callbacks->Elif(ElifToken.getLocation(), ConditionRange,
                    PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
    break;
  case tok::pp_elifdef:
    Callbacks->Elifdef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
    break;
  case tok::pp_elifndef:
    Callbacks->Elifndef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
    break;
  default:
    assert(false && "unexpected directive kind")((void)0);
    break;
  }
}

bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
  getSourceManager().isInMainFile(ElifToken.getLocation());

if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
  // the directive blocks.
  CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,
                                   /*foundnonskip*/false, /*foundelse*/false);
  return;
}

// Finally, skip the rest of the contents of this block.
SkipExcludedConditionalBlock(
    HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true,
    /*FoundElse*/ CI.FoundElse, ElifToken.getLocation());
3289}

←

/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);
20
←
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));
19
←
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),
18
←
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; }
25
←
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();
24
←
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;
22
←
The value 255 is assigned to 'A.ShiftValue'→
23
←
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);
21
←
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_