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

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../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 SemaFixItUtils.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/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/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/libclangSema/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/libclangSema/../../../llvm/clang/lib/Sema/SemaFixItUtils.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaFixItUtils.cpp

→

1//===--- SemaFixItUtils.cpp - Sema FixIts ---------------------------------===//
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 defines helper classes for generation of Sema FixItHints.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/ASTContext.h"
14#include "clang/AST/ExprCXX.h"
15#include "clang/AST/ExprObjC.h"
16#include "clang/Lex/Preprocessor.h"
17#include "clang/Sema/Sema.h"
18#include "clang/Sema/SemaFixItUtils.h"

20using namespace clang;

22bool ConversionFixItGenerator::compareTypesSimple(CanQualType From,
                                                CanQualType To,
                                                Sema &S,
                                                SourceLocation Loc,
                                                ExprValueKind FromVK) {
if (!To.isAtLeastAsQualifiedAs(From))
  return false;

From = From.getNonReferenceType();
To = To.getNonReferenceType();

// If both are pointer types, work with the pointee types.
if (isa<PointerType>(From) && isa<PointerType>(To)) {
  From = S.Context.getCanonicalType(
      (cast<PointerType>(From))->getPointeeType());
  To = S.Context.getCanonicalType(
      (cast<PointerType>(To))->getPointeeType());
}

const CanQualType FromUnq = From.getUnqualifiedType();
const CanQualType ToUnq = To.getUnqualifiedType();

if ((FromUnq == ToUnq || (S.IsDerivedFrom(Loc, FromUnq, ToUnq)) ) &&
    To.isAtLeastAsQualifiedAs(From))
  return true;
return false;
48}

50bool ConversionFixItGenerator::tryToFixConversion(const Expr *FullExpr,
                                                const QualType FromTy,
                                                const QualType ToTy,
                                                Sema &S) {
if (!FullExpr)
  return false;

const CanQualType FromQTy = S.Context.getCanonicalType(FromTy);
const CanQualType ToQTy = S.Context.getCanonicalType(ToTy);
const SourceLocation Begin = FullExpr->getSourceRange().getBegin();
const SourceLocation End = S.getLocForEndOfToken(FullExpr->getSourceRange()
                                                 .getEnd());

// Strip the implicit casts - those are implied by the compiler, not the
// original source code.
const Expr* Expr = FullExpr->IgnoreImpCasts();

bool NeedParen = true;
if (isa<ArraySubscriptExpr>(Expr) ||
    isa<CallExpr>(Expr) ||
    isa<DeclRefExpr>(Expr) ||
    isa<CastExpr>(Expr) ||
    isa<CXXNewExpr>(Expr) ||
    isa<CXXConstructExpr>(Expr) ||
    isa<CXXDeleteExpr>(Expr) ||
    isa<CXXNoexceptExpr>(Expr) ||
    isa<CXXPseudoDestructorExpr>(Expr) ||
    isa<CXXScalarValueInitExpr>(Expr) ||
    isa<CXXThisExpr>(Expr) ||
    isa<CXXTypeidExpr>(Expr) ||
    isa<CXXUnresolvedConstructExpr>(Expr) ||
    isa<ObjCMessageExpr>(Expr) ||
    isa<ObjCPropertyRefExpr>(Expr) ||
    isa<ObjCProtocolExpr>(Expr) ||
    isa<MemberExpr>(Expr) ||
    isa<ParenExpr>(FullExpr) ||
    isa<ParenListExpr>(Expr) ||
    isa<SizeOfPackExpr>(Expr) ||
    isa<UnaryOperator>(Expr))
  NeedParen = false;

// Check if the argument needs to be dereferenced:
//   (type * -> type) or (type * -> type &).
if (const PointerType *FromPtrTy = dyn_cast<PointerType>(FromQTy)) {
  OverloadFixItKind FixKind = OFIK_Dereference;

  bool CanConvert = CompareTypes(
    S.Context.getCanonicalType(FromPtrTy->getPointeeType()), ToQTy,
                               S, Begin, VK_LValue);
  if (CanConvert) {
    // Do not suggest dereferencing a Null pointer.
    if (Expr->IgnoreParenCasts()->
        isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull))
      return false;

    if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Expr)) {
      if (UO->getOpcode() == UO_AddrOf) {
        FixKind = OFIK_RemoveTakeAddress;
        Hints.push_back(FixItHint::CreateRemoval(
                          CharSourceRange::getTokenRange(Begin, Begin)));
      }
    } else if (NeedParen) {
      Hints.push_back(FixItHint::CreateInsertion(Begin, "*("));
      Hints.push_back(FixItHint::CreateInsertion(End, ")"));
    } else {
      Hints.push_back(FixItHint::CreateInsertion(Begin, "*"));
    }

    NumConversionsFixed++;
    if (NumConversionsFixed == 1)
      Kind = FixKind;
    return true;
  }
}

// Check if the pointer to the argument needs to be passed:
//   (type -> type *) or (type & -> type *).
if (isa<PointerType>(ToQTy)) {
  bool CanConvert = false;
  OverloadFixItKind FixKind = OFIK_TakeAddress;

  // Only suggest taking address of L-values.
  if (!Expr->isLValue() || Expr->getObjectKind() != OK_Ordinary)
    return false;

  CanConvert = CompareTypes(S.Context.getPointerType(FromQTy), ToQTy, S,
                            Begin, VK_PRValue);
  if (CanConvert) {

    if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Expr)) {
      if (UO->getOpcode() == UO_Deref) {
        FixKind = OFIK_RemoveDereference;
        Hints.push_back(FixItHint::CreateRemoval(
                          CharSourceRange::getTokenRange(Begin, Begin)));
      }
    } else if (NeedParen) {
      Hints.push_back(FixItHint::CreateInsertion(Begin, "&("));
      Hints.push_back(FixItHint::CreateInsertion(End, ")"));
    } else {
      Hints.push_back(FixItHint::CreateInsertion(Begin, "&"));
    }

    NumConversionsFixed++;
    if (NumConversionsFixed == 1)
      Kind = FixKind;
    return true;
  }
}

return false;
160}

162static bool isMacroDefined(const Sema &S, SourceLocation Loc, StringRef Name) {
return (bool)S.PP.getMacroDefinitionAtLoc(&S.getASTContext().Idents.get(Name),
4
←
Calling 'Preprocessor::getMacroDefinitionAtLoc'→
                                          Loc);
165}

167static std::string getScalarZeroExpressionForType(
  const Type &T, SourceLocation Loc, const Sema &S) {
assert(T.isScalarType() && "use scalar types only")((void)0);
// Suggest "0" for non-enumeration scalar types, unless we can find a
// better initializer.
if (T.isEnumeralType())
2
←
Taking false branch→
  return std::string();
if ((T.isObjCObjectPointerType() || T.isBlockPointerType()) &&
    isMacroDefined(S, Loc, "nil"))
3
←
Calling 'isMacroDefined'→
  return "nil";
if (T.isRealFloatingType())
  return "0.0";
if (T.isBooleanType() &&
    (S.LangOpts.CPlusPlus || isMacroDefined(S, Loc, "false")))
  return "false";
if (T.isPointerType() || T.isMemberPointerType()) {
  if (S.LangOpts.CPlusPlus11)
    return "nullptr";
  if (isMacroDefined(S, Loc, "NULL"))
    return "NULL";
}
if (T.isCharType())
  return "'\\0'";
if (T.isWideCharType())
  return "L'\\0'";
if (T.isChar16Type())
  return "u'\\0'";
if (T.isChar32Type())
  return "U'\\0'";
return "0";
197}

199std::string
200Sema::getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const {
if (T->isScalarType()) {
  std::string s = getScalarZeroExpressionForType(*T, Loc, *this);
  if (!s.empty())
    s = " = " + s;
  return s;
}

const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
if (!RD || !RD->hasDefinition())
  return std::string();
if (LangOpts.CPlusPlus11 && !RD->hasUserProvidedDefaultConstructor())
  return "{}";
if (RD->isAggregate())
  return " = {}";
return std::string();
216}

218std::string
219Sema::getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const {
return getScalarZeroExpressionForType(*T, Loc, *this);
1
Calling 'getScalarZeroExpressionForType'→
221}

←

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

→

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

14#ifndef LLVM_CLANG_LEX_PREPROCESSOR_H
15#define LLVM_CLANG_LEX_PREPROCESSOR_H

17#include "clang/Basic/Diagnostic.h"
18#include "clang/Basic/IdentifierTable.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/Module.h"
22#include "clang/Basic/SourceLocation.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Basic/TokenKinds.h"
25#include "clang/Lex/Lexer.h"
26#include "clang/Lex/MacroInfo.h"
27#include "clang/Lex/ModuleLoader.h"
28#include "clang/Lex/ModuleMap.h"
29#include "clang/Lex/PPCallbacks.h"
30#include "clang/Lex/PreprocessorExcludedConditionalDirectiveSkipMapping.h"
31#include "clang/Lex/Token.h"
32#include "clang/Lex/TokenLexer.h"
33#include "llvm/ADT/ArrayRef.h"
34#include "llvm/ADT/DenseMap.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/FunctionExtras.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/SmallPtrSet.h"
42#include "llvm/ADT/SmallVector.h"
43#include "llvm/ADT/StringRef.h"
44#include "llvm/ADT/TinyPtrVector.h"
45#include "llvm/ADT/iterator_range.h"
46#include "llvm/Support/Allocator.h"
47#include "llvm/Support/Casting.h"
48#include "llvm/Support/Registry.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <map>
53#include <memory>
54#include <string>
55#include <utility>
56#include <vector>

58namespace llvm {

60template<unsigned InternalLen> class SmallString;

62} // namespace llvm

64namespace clang {

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

84namespace Builtin {
85class Context;
86}

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

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

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

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

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

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

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

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

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

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

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

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

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

SourceLocation DATELoc, TIMELoc;

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

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

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

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

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

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

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

class ResetMacroExpansionHelper;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

452private:
friend class ASTReader;
friend class MacroArgs;

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

public:
  PreambleConditionalStackStore() = default;

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

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

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

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

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

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

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

  llvm::Optional<PreambleSkipInfo> SkipInfo;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

struct SubmoduleState;

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

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

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

  /// The previous SubmoduleState.
  SubmoduleState *OuterSubmoduleState;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void updateOutOfDateIdentifier(IdentifierInfo &II) const;

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

~Preprocessor();

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

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

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

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

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

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

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

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

ExternalPreprocessorSource *getExternalSource() const {
  return ExternalSource;
}

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

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

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

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

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

bool getCommentRetentionState() const { return KeepComments; }

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

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

bool GetSuppressIncludeNotFoundError() {
  return SuppressIncludeNotFoundError;
}

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

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

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

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

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

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

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

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

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

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

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

SourceLocation getMaxTokensOverrideLoc() const { return MaxTokensOverrideLoc; }

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

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

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

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

MacroDefinition getMacroDefinition(const IdentifierInfo *II) {
  if (!II->hasMacroDefinition())
    return {};

  MacroState &S = CurSubmoduleState->Macros[II];
  auto *MD = S.getLatest();
  while (MD && isa<VisibilityMacroDirective>(MD))
    MD = MD->getPrevious();
  return MacroDefinition(dyn_cast_or_null<DefMacroDirective>(MD),
                         S.getActiveModuleMacros(*this, II),
                         S.isAmbiguous(*this, II));
}

MacroDefinition getMacroDefinitionAtLoc(const IdentifierInfo *II,
                                        SourceLocation Loc) {
  if (!II->hadMacroDefinition())
5
←
Assuming the condition is false→
6
←
Taking false branch→
    return {};

  MacroState &S = CurSubmoduleState->Macros[II];
  MacroDirective::DefInfo DI;
  if (auto *MD = S.getLatest())
7
←
Assuming 'MD' is null→
8
←
Taking false branch→
    DI = MD->findDirectiveAtLoc(Loc, getSourceManager());
  // FIXME: Compute the set of active module macros at the specified location.
  return MacroDefinition(DI.getDirective(),
                         S.getActiveModuleMacros(*this, II),
9
←
Calling 'MacroState::getActiveModuleMacros'→
                         S.isAmbiguous(*this, II));
}

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

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

  return MD;
}

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

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

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

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

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

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

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

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

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

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

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

/// \}

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

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

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

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

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

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

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

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

EmptylineHandler *getEmptylineHandler() const { return Emptyline; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void makeModuleVisible(Module *M, SourceLocation Loc);

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

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

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

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

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

  // Reenable it.
  DisableMacroExpansion = OldVal;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void PrintStats();

size_t getTotalMemory() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void PropagateLineStartLeadingSpaceInfo(Token &Result);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void removeCachedMacroExpandedTokensOfLastLexer();

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

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

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

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

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

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

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

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

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

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

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

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

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

void EnterCachingLexMode();
void EnterCachingLexModeUnchecked();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2425} // namespace clang

2427#endif // LLVM_CLANG_LEX_PREPROCESSOR_H

←

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

→

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

17#ifndef LLVM_SUPPORT_ALLOCATOR_H
18#define LLVM_SUPPORT_ALLOCATOR_H

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

37namespace llvm {

39namespace detail {

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

46} // end namespace detail

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

BumpPtrAllocatorImpl() = default;

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

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

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

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

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

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

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

  if (Slabs.empty())
    return;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

size_t getBytesAllocated() const { return BytesAllocated; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    DestroyElements(Begin, End);
  }

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

  Allocator.Reset();
}

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

429} // end namespace llvm

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

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

448#endif // LLVM_SUPPORT_ALLOCATOR_H

←

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

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