Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- SourceManager.h - Track and cache source files -----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

/// \file

/// Defines the SourceManager interface.

///

/// There are three different types of locations in a %file: a spelling

/// location, an expansion location, and a presumed location.

///

/// Given an example of:

/// \code

/// #define min(x, y) x < y ? x : y

/// \endcode

///

/// and then later on a use of min:

/// \code

/// #line 17

/// return min(a, b);

/// \endcode

///

/// The expansion location is the line in the source code where the macro

/// was expanded (the return statement), the spelling location is the

/// location in the source where the macro was originally defined,

/// and the presumed location is where the line directive states that

/// the line is 17, or any other line.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_BASIC_SOURCEMANAGER_H

#define LLVM_CLANG_BASIC_SOURCEMANAGER_H

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/FileEntry.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/SourceLocation.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/BitVector.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/MemoryBuffer.h"

#include <cassert>

#include <cstddef>

#include <map>

#include <memory>

#include <optional>

#include <string>

#include <utility>

#include <vector>

namespace clang {

class ASTReader;

class ASTWriter;

class FileManager;

class LineTableInfo;

class SourceManager;

/// Public enums and private classes that are part of the

/// SourceManager implementation.

namespace SrcMgr {

/// Indicates whether a file or directory holds normal user code,

/// system code, or system code which is implicitly 'extern "C"' in C++ mode.

///

/// Entire directories can be tagged with this (this is maintained by

/// DirectoryLookup and friends) as can specific FileInfos when a \#pragma

/// system_header is seen or in various other cases.

///

enum CharacteristicKind {

  C_User,

  C_System,

  C_ExternCSystem,

  C_User_ModuleMap,

  C_System_ModuleMap

};

/// Determine whether a file / directory characteristic is for system code.

inline bool isSystem(CharacteristicKind CK) {

  return CK != C_User && CK != C_User_ModuleMap;

}

/// Determine whether a file characteristic is for a module map.

inline bool isModuleMap(CharacteristicKind CK) {

  return CK == C_User_ModuleMap || CK == C_System_ModuleMap;

}

/// Mapping of line offsets into a source file. This does not own the storage

/// for the line numbers.

class LineOffsetMapping {

public:

  explicit operator bool() const { return Storage; }

  unsigned size() const {

    assert(Storage);

    return Storage[0];

  }

  ArrayRef<unsigned> getLines() const {

    assert(Storage);

    return ArrayRef<unsigned>(Storage + 1, Storage + 1 + size());

  }

  const unsigned *begin() const { return getLines().begin(); }

  const unsigned *end() const { return getLines().end(); }

  const unsigned &operator[](int I) const { return getLines()[I]; }

  static LineOffsetMapping get(llvm::MemoryBufferRef Buffer,

                               llvm::BumpPtrAllocator &Alloc);

  LineOffsetMapping() = default;

  LineOffsetMapping(ArrayRef<unsigned> LineOffsets,

                    llvm::BumpPtrAllocator &Alloc);

private:

  /// First element is the size, followed by elements at off-by-one indexes.

  unsigned *Storage = nullptr;

};

/// One instance of this struct is kept for every file loaded or used.

///

/// This object owns the MemoryBuffer object.

class alignas(8) ContentCache {

  /// The actual buffer containing the characters from the input

  /// file.

  mutable std::unique_ptr<llvm::MemoryBuffer> Buffer;

public:

  /// Reference to the file entry representing this ContentCache.

  ///

  /// This reference does not own the FileEntry object.

  ///

  /// It is possible for this to be NULL if the ContentCache encapsulates

  /// an imaginary text buffer.

  ///

  /// FIXME: Make non-optional using a virtual file as needed, remove \c

  /// Filename and use \c OrigEntry.getNameAsRequested() instead.

  OptionalFileEntryRefDegradesToFileEntryPtr OrigEntry;

  /// References the file which the contents were actually loaded from.

  ///

  /// Can be different from 'Entry' if we overridden the contents of one file

  /// with the contents of another file.

  const FileEntry *ContentsEntry;

  /// The filename that is used to access OrigEntry.

  ///

  /// FIXME: Remove this once OrigEntry is a FileEntryRef with a stable name.

  StringRef Filename;

  /// A bump pointer allocated array of offsets for each source line.

  ///

  /// This is lazily computed.  The lines are owned by the SourceManager

  /// BumpPointerAllocator object.

  mutable LineOffsetMapping SourceLineCache;

  /// Indicates whether the buffer itself was provided to override

  /// the actual file contents.

  ///

  /// When true, the original entry may be a virtual file that does not

  /// exist.

  unsigned BufferOverridden : 1;

  /// True if this content cache was initially created for a source file

  /// considered to be volatile (likely to change between stat and open).

  unsigned IsFileVolatile : 1;

  /// True if this file may be transient, that is, if it might not

  /// exist at some later point in time when this content entry is used,

  /// after serialization and deserialization.

  unsigned IsTransient : 1;

  mutable unsigned IsBufferInvalid : 1;

  ContentCache()

      : OrigEntry(std::nullopt), ContentsEntry(nullptr),

        BufferOverridden(false), IsFileVolatile(false), IsTransient(false),

        IsBufferInvalid(false) {}

  ContentCache(FileEntryRef Ent) : ContentCache(Ent, Ent) {}

  ContentCache(FileEntryRef Ent, const FileEntry *contentEnt)

      : OrigEntry(Ent), ContentsEntry(contentEnt), BufferOverridden(false),

        IsFileVolatile(false), IsTransient(false), IsBufferInvalid(false) {}

  /// The copy ctor does not allow copies where source object has either

  /// a non-NULL Buffer or SourceLineCache.  Ownership of allocated memory

  /// is not transferred, so this is a logical error.

  ContentCache(const ContentCache &RHS)

      : BufferOverridden(false), IsFileVolatile(false), IsTransient(false),

        IsBufferInvalid(false) {

    OrigEntry = RHS.OrigEntry;

    ContentsEntry = RHS.ContentsEntry;

    assert(!RHS.Buffer && !RHS.SourceLineCache &&

           "Passed ContentCache object cannot own a buffer.");

  }

  ContentCache &operator=(const ContentCache &RHS) = delete;

  /// Returns the memory buffer for the associated content.

  ///

  /// \param Diag Object through which diagnostics will be emitted if the

  ///   buffer cannot be retrieved.

  ///

  /// \param Loc If specified, is the location that invalid file diagnostics

  ///   will be emitted at.

  std::optional<llvm::MemoryBufferRef>

  getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM,

                  SourceLocation Loc = SourceLocation()) const;

  /// Returns the size of the content encapsulated by this

  /// ContentCache.

  ///

  /// This can be the size of the source file or the size of an

  /// arbitrary scratch buffer.  If the ContentCache encapsulates a source

  /// file this size is retrieved from the file's FileEntry.

  unsigned getSize() const;

  /// Returns the number of bytes actually mapped for this

  /// ContentCache.

  ///

  /// This can be 0 if the MemBuffer was not actually expanded.

  unsigned getSizeBytesMapped() const;

  /// Returns the kind of memory used to back the memory buffer for

  /// this content cache.  This is used for performance analysis.

  llvm::MemoryBuffer::BufferKind getMemoryBufferKind() const;

  /// Return the buffer, only if it has been loaded.

  std::optional<llvm::MemoryBufferRef> getBufferIfLoaded() const {

    if (Buffer)

      return Buffer->getMemBufferRef();

    return std::nullopt;

  }

  /// Return a StringRef to the source buffer data, only if it has already

  /// been loaded.

  std::optional<StringRef> getBufferDataIfLoaded() const {

    if (Buffer)

      return Buffer->getBuffer();

    return std::nullopt;

  }

  /// Set the buffer.

  void setBuffer(std::unique_ptr<llvm::MemoryBuffer> B) {

    IsBufferInvalid = false;

    Buffer = std::move(B);

  }

  /// Set the buffer to one that's not owned (or to nullptr).

  ///

  /// \pre Buffer cannot already be set.

  void setUnownedBuffer(std::optional<llvm::MemoryBufferRef> B) {

    assert(!Buffer && "Expected to be called right after construction");

    if (B)

      setBuffer(llvm::MemoryBuffer::getMemBuffer(*B));

  }

  // If BufStr has an invalid BOM, returns the BOM name; otherwise, returns

  // nullptr

  static const char *getInvalidBOM(StringRef BufStr);

};

// Assert that the \c ContentCache objects will always be 8-byte aligned so

// that we can pack 3 bits of integer into pointers to such objects.

static_assert(alignof(ContentCache) >= 8,

              "ContentCache must be 8-byte aligned.");

/// Information about a FileID, basically just the logical file

/// that it represents and include stack information.

///

/// Each FileInfo has include stack information, indicating where it came

/// from. This information encodes the \#include chain that a token was

/// expanded from. The main include file has an invalid IncludeLoc.

///

/// FileInfo should not grow larger than ExpansionInfo. Doing so will

/// cause memory to bloat in compilations with many unloaded macro

/// expansions, since the two data structurs are stored in a union in

/// SLocEntry. Extra fields should instead go in "ContentCache *", which

/// stores file contents and other bits on the side.

///

class FileInfo {

  friend class clang::SourceManager;

  friend class clang::ASTWriter;

  friend class clang::ASTReader;

  /// The location of the \#include that brought in this file.

  ///

  /// This is an invalid SLOC for the main file (top of the \#include chain).

  SourceLocation IncludeLoc;

  /// Number of FileIDs (files and macros) that were created during

  /// preprocessing of this \#include, including this SLocEntry.

  ///

  /// Zero means the preprocessor didn't provide such info for this SLocEntry.

  unsigned NumCreatedFIDs : 31;

  /// Whether this FileInfo has any \#line directives.

  unsigned HasLineDirectives : 1;

  /// The content cache and the characteristic of the file.

  llvm::PointerIntPair<const ContentCache *, 3, CharacteristicKind>

      ContentAndKind;

public:

  /// Return a FileInfo object.

  static FileInfo get(SourceLocation IL, ContentCache &Con,

                      CharacteristicKind FileCharacter, StringRef Filename) {

    FileInfo X;

    X.IncludeLoc = IL;

    X.NumCreatedFIDs = 0;

    X.HasLineDirectives = false;

    X.ContentAndKind.setPointer(&Con);

    X.ContentAndKind.setInt(FileCharacter);

    Con.Filename = Filename;

    return X;

  }

  SourceLocation getIncludeLoc() const {

    return IncludeLoc;

  }

  const ContentCache &getContentCache() const {

    return *ContentAndKind.getPointer();

  }

  /// Return whether this is a system header or not.

  CharacteristicKind getFileCharacteristic() const {

    return ContentAndKind.getInt();

  }

  /// Return true if this FileID has \#line directives in it.

  bool hasLineDirectives() const { return HasLineDirectives; }

  /// Set the flag that indicates that this FileID has

  /// line table entries associated with it.

  void setHasLineDirectives() { HasLineDirectives = true; }

  /// Returns the name of the file that was used when the file was loaded from

  /// the underlying file system.

  StringRef getName() const { return getContentCache().Filename; }

};

/// Each ExpansionInfo encodes the expansion location - where

/// the token was ultimately expanded, and the SpellingLoc - where the actual

/// character data for the token came from.

class ExpansionInfo {

  // Really these are all SourceLocations.

  /// Where the spelling for the token can be found.

  SourceLocation SpellingLoc;

  /// In a macro expansion, ExpansionLocStart and ExpansionLocEnd

  /// indicate the start and end of the expansion. In object-like macros,

  /// they will be the same. In a function-like macro expansion, the start

  /// will be the identifier and the end will be the ')'. Finally, in

  /// macro-argument instantiations, the end will be 'SourceLocation()', an

  /// invalid location.

  SourceLocation ExpansionLocStart, ExpansionLocEnd;

  /// Whether the expansion range is a token range.

  bool ExpansionIsTokenRange;

public:

  SourceLocation getSpellingLoc() const {

    return SpellingLoc.isInvalid() ? getExpansionLocStart() : SpellingLoc;

  }

  SourceLocation getExpansionLocStart() const {

    return ExpansionLocStart;

  }

  SourceLocation getExpansionLocEnd() const {

    return ExpansionLocEnd.isInvalid() ? getExpansionLocStart()

                                       : ExpansionLocEnd;

  }

  bool isExpansionTokenRange() const { return ExpansionIsTokenRange; }

  CharSourceRange getExpansionLocRange() const {

    return CharSourceRange(

        SourceRange(getExpansionLocStart(), getExpansionLocEnd()),

        isExpansionTokenRange());

  }

  bool isMacroArgExpansion() const {

    // Note that this needs to return false for default constructed objects.

    return getExpansionLocStart().isValid() && ExpansionLocEnd.isInvalid();

  }

  bool isMacroBodyExpansion() const {

    return getExpansionLocStart().isValid() && ExpansionLocEnd.isValid();

  }

  bool isFunctionMacroExpansion() const {

    return getExpansionLocStart().isValid() &&

           getExpansionLocStart() != getExpansionLocEnd();

  }

  /// Return a ExpansionInfo for an expansion.

  ///

  /// Start and End specify the expansion range (where the macro is

  /// expanded), and SpellingLoc specifies the spelling location (where

  /// the characters from the token come from). All three can refer to

  /// normal File SLocs or expansion locations.

  static ExpansionInfo create(SourceLocation SpellingLoc, SourceLocation Start,

                              SourceLocation End,

                              bool ExpansionIsTokenRange = true) {

    ExpansionInfo X;

    X.SpellingLoc = SpellingLoc;

    X.ExpansionLocStart = Start;

    X.ExpansionLocEnd = End;

    X.ExpansionIsTokenRange = ExpansionIsTokenRange;

    return X;

  }

  /// Return a special ExpansionInfo for the expansion of

  /// a macro argument into a function-like macro's body.

  ///

  /// ExpansionLoc specifies the expansion location (where the macro is

  /// expanded). This doesn't need to be a range because a macro is always

  /// expanded at a macro parameter reference, and macro parameters are

  /// always exactly one token. SpellingLoc specifies the spelling location

  /// (where the characters from the token come from). ExpansionLoc and

  /// SpellingLoc can both refer to normal File SLocs or expansion locations.

  ///

  /// Given the code:

  /// \code

  ///   #define F(x) f(x)

  ///   F(42);

  /// \endcode

  ///

  /// When expanding '\c F(42)', the '\c x' would call this with an

  /// SpellingLoc pointing at '\c 42' and an ExpansionLoc pointing at its

  /// location in the definition of '\c F'.

  static ExpansionInfo createForMacroArg(SourceLocation SpellingLoc,

                                         SourceLocation ExpansionLoc) {

    // We store an intentionally invalid source location for the end of the

    // expansion range to mark that this is a macro argument location rather

    // than a normal one.

    return create(SpellingLoc, ExpansionLoc, SourceLocation());

  }

  /// Return a special ExpansionInfo representing a token that ends

  /// prematurely. This is used to model a '>>' token that has been split

  /// into '>' tokens and similar cases. Unlike for the other forms of

  /// expansion, the expansion range in this case is a character range, not

  /// a token range.

  static ExpansionInfo createForTokenSplit(SourceLocation SpellingLoc,

                                           SourceLocation Start,

                                           SourceLocation End) {

    return create(SpellingLoc, Start, End, false);

  }

};

// Assert that the \c FileInfo objects are no bigger than \c ExpansionInfo

// objects. This controls the size of \c SLocEntry, of which we have one for

// each macro expansion. The number of (unloaded) macro expansions can be

// very large. Any other fields needed in FileInfo should go in ContentCache.

static_assert(sizeof(FileInfo) <= sizeof(ExpansionInfo),

              "FileInfo must be no larger than ExpansionInfo.");

/// This is a discriminated union of FileInfo and ExpansionInfo.

///

/// SourceManager keeps an array of these objects, and they are uniquely

/// identified by the FileID datatype.

class SLocEntry {

  static constexpr int OffsetBits = 8 * sizeof(SourceLocation::UIntTy) - 1;

  SourceLocation::UIntTy Offset : OffsetBits;

  SourceLocation::UIntTy IsExpansion : 1;

  union {

    FileInfo File;

    ExpansionInfo Expansion;

  };

public:

  SLocEntry() : Offset(), IsExpansion(), File() {}

  SourceLocation::UIntTy getOffset() const { return Offset; }

  bool isExpansion() const { return IsExpansion; }

  bool isFile() const { return !isExpansion(); }

  const FileInfo &getFile() const {

    assert(isFile() && "Not a file SLocEntry!");

    return File;

  }

  const ExpansionInfo &getExpansion() const {

    assert(isExpansion() && "Not a macro expansion SLocEntry!");

    return Expansion;

  }

  static SLocEntry get(SourceLocation::UIntTy Offset, const FileInfo &FI) {

    assert(!(Offset & (1ULL << OffsetBits)) && "Offset is too large");

    SLocEntry E;

    E.Offset = Offset;

    E.IsExpansion = false;

    E.File = FI;

    return E;

  }

  static SLocEntry get(SourceLocation::UIntTy Offset,

                       const ExpansionInfo &Expansion) {

    assert(!(Offset & (1ULL << OffsetBits)) && "Offset is too large");

    SLocEntry E;

    E.Offset = Offset;

    E.IsExpansion = true;

    new (&E.Expansion) ExpansionInfo(Expansion);

    return E;

  }

};

} // namespace SrcMgr

/// External source of source location entries.

class ExternalSLocEntrySource {

public:

  virtual ~ExternalSLocEntrySource();

  /// Read the source location entry with index ID, which will always be

  /// less than -1.

  ///

  /// \returns true if an error occurred that prevented the source-location

  /// entry from being loaded.

  virtual bool ReadSLocEntry(int ID) = 0;

  /// Retrieve the module import location and name for the given ID, if

  /// in fact it was loaded from a module (rather than, say, a precompiled

  /// header).

  virtual std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) = 0;

};

/// Holds the cache used by isBeforeInTranslationUnit.

///

/// The cache structure is complex enough to be worth breaking out of

/// SourceManager.

class InBeforeInTUCacheEntry {

  /// The FileID's of the cached query.

  ///

  /// If these match up with a subsequent query, the result can be reused.

  FileID LQueryFID, RQueryFID;

  /// The relative order of FileIDs that the CommonFID *immediately* includes.

  ///

  /// This is used to compare macro expansion locations.

  bool LChildBeforeRChild;

  /// The file found in common between the two \#include traces, i.e.,

  /// the nearest common ancestor of the \#include tree.

  FileID CommonFID;

  /// The offset of the previous query in CommonFID.

  ///

  /// Usually, this represents the location of the \#include for QueryFID, but

  /// if LQueryFID is a parent of RQueryFID (or vice versa) then these can be a

  /// random token in the parent.

  unsigned LCommonOffset, RCommonOffset;

public:

  InBeforeInTUCacheEntry() = default;

  InBeforeInTUCacheEntry(FileID L, FileID R) : LQueryFID(L), RQueryFID(R) {

    assert(L != R);

  }

  /// Return true if the currently cached values match up with

  /// the specified LHS/RHS query.

  ///

  /// If not, we can't use the cache.

  bool isCacheValid() const {

    return CommonFID.isValid();

  }

  /// If the cache is valid, compute the result given the

  /// specified offsets in the LHS/RHS FileID's.

  bool getCachedResult(unsigned LOffset, unsigned ROffset) const {

    // If one of the query files is the common file, use the offset.  Otherwise,

    // use the #include loc in the common file.

    if (LQueryFID != CommonFID) LOffset = LCommonOffset;

    if (RQueryFID != CommonFID) ROffset = RCommonOffset;

    // It is common for multiple macro expansions to be "included" from the same

    // location (expansion location), in which case use the order of the FileIDs

    // to determine which came first. This will also take care the case where

    // one of the locations points at the inclusion/expansion point of the other

    // in which case its FileID will come before the other.

    if (LOffset == ROffset)

      return LChildBeforeRChild;

    return LOffset < ROffset;

  }

  /// Set up a new query.

  /// If it matches the old query, we can keep the cached answer.

  void setQueryFIDs(FileID LHS, FileID RHS) {

    assert(LHS != RHS);

    if (LQueryFID != LHS || RQueryFID != RHS) {

      LQueryFID = LHS;

      RQueryFID = RHS;

      CommonFID = FileID();

    }

  }

  void setCommonLoc(FileID commonFID, unsigned lCommonOffset,

                    unsigned rCommonOffset, bool LParentBeforeRParent) {

    CommonFID = commonFID;

    LCommonOffset = lCommonOffset;

    RCommonOffset = rCommonOffset;

    LChildBeforeRChild = LParentBeforeRParent;

  }

};

/// The stack used when building modules on demand, which is used

/// to provide a link between the source managers of the different compiler

/// instances.

using ModuleBuildStack = ArrayRef<std::pair<std::string, FullSourceLoc>>;

/// This class handles loading and caching of source files into memory.

///

/// This object owns the MemoryBuffer objects for all of the loaded

/// files and assigns unique FileID's for each unique \#include chain.

///

/// The SourceManager can be queried for information about SourceLocation

/// objects, turning them into either spelling or expansion locations. Spelling

/// locations represent where the bytes corresponding to a token came from and

/// expansion locations represent where the location is in the user's view. In

/// the case of a macro expansion, for example, the spelling location indicates

/// where the expanded token came from and the expansion location specifies

/// where it was expanded.

class SourceManager : public RefCountedBase<SourceManager> {

  /// DiagnosticsEngine object.

  DiagnosticsEngine &Diag;

  FileManager &FileMgr;

  mutable llvm::BumpPtrAllocator ContentCacheAlloc;

  /// Memoized information about all of the files tracked by this

  /// SourceManager.

  ///

  /// This map allows us to merge ContentCache entries based

  /// on their FileEntry*.  All ContentCache objects will thus have unique,

  /// non-null, FileEntry pointers.

  llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*> FileInfos;

  /// True if the ContentCache for files that are overridden by other

  /// files, should report the original file name. Defaults to true.

  bool OverridenFilesKeepOriginalName = true;

  /// True if non-system source files should be treated as volatile

  /// (likely to change while trying to use them). Defaults to false.

  bool UserFilesAreVolatile;

  /// True if all files read during this compilation should be treated

  /// as transient (may not be present in later compilations using a module

  /// file created from this compilation). Defaults to false.

  bool FilesAreTransient = false;

  struct OverriddenFilesInfoTy {

    /// Files that have been overridden with the contents from another

    /// file.

    llvm::DenseMap<const FileEntry *, FileEntryRef> OverriddenFiles;

    /// Files that were overridden with a memory buffer.

    llvm::DenseSet<const FileEntry *> OverriddenFilesWithBuffer;

  };

  /// Lazily create the object keeping overridden files info, since

  /// it is uncommonly used.

  std::unique_ptr<OverriddenFilesInfoTy> OverriddenFilesInfo;

  OverriddenFilesInfoTy &getOverriddenFilesInfo() {

    if (!OverriddenFilesInfo)

      OverriddenFilesInfo.reset(new OverriddenFilesInfoTy);

    return *OverriddenFilesInfo;

  }

  /// Information about various memory buffers that we have read in.

  ///

  /// All FileEntry* within the stored ContentCache objects are NULL,

  /// as they do not refer to a file.

  std::vector<SrcMgr::ContentCache*> MemBufferInfos;

  /// The table of SLocEntries that are local to this module.

  ///

  /// Positive FileIDs are indexes into this table. Entry 0 indicates an invalid

  /// expansion.

  SmallVector<SrcMgr::SLocEntry, 0> LocalSLocEntryTable;

  /// The table of SLocEntries that are loaded from other modules.

  ///

  /// Negative FileIDs are indexes into this table. To get from ID to an index,

  /// use (-ID - 2).

  SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable;

  /// The starting offset of the next local SLocEntry.

  ///

  /// This is LocalSLocEntryTable.back().Offset + the size of that entry.

  SourceLocation::UIntTy NextLocalOffset;

  /// The starting offset of the latest batch of loaded SLocEntries.

  ///

  /// This is LoadedSLocEntryTable.back().Offset, except that that entry might

  /// not have been loaded, so that value would be unknown.

  SourceLocation::UIntTy CurrentLoadedOffset;

  /// The highest possible offset is 2^31-1 (2^63-1 for 64-bit source

  /// locations), so CurrentLoadedOffset starts at 2^31 (2^63 resp.).

  static const SourceLocation::UIntTy MaxLoadedOffset =

      1ULL << (8 * sizeof(SourceLocation::UIntTy) - 1);

  /// A bitmap that indicates whether the entries of LoadedSLocEntryTable

  /// have already been loaded from the external source.

  ///

  /// Same indexing as LoadedSLocEntryTable.

  llvm::BitVector SLocEntryLoaded;

  /// An external source for source location entries.

  ExternalSLocEntrySource *ExternalSLocEntries = nullptr;

  /// A one-entry cache to speed up getFileID.

  ///

  /// LastFileIDLookup records the last FileID looked up or created, because it

  /// is very common to look up many tokens from the same file.

  mutable FileID LastFileIDLookup;

  /// Holds information for \#line directives.

  ///

  /// This is referenced by indices from SLocEntryTable.

  std::unique_ptr<LineTableInfo> LineTable;

  /// These ivars serve as a cache used in the getLineNumber

  /// method which is used to speedup getLineNumber calls to nearby locations.

  mutable FileID LastLineNoFileIDQuery;

  mutable const SrcMgr::ContentCache *LastLineNoContentCache;

  mutable unsigned LastLineNoFilePos;

  mutable unsigned LastLineNoResult;

  /// The file ID for the main source file of the translation unit.

  FileID MainFileID;

  /// The file ID for the precompiled preamble there is one.

  FileID PreambleFileID;

  // Statistics for -print-stats.

  mutable unsigned NumLinearScans = 0;

  mutable unsigned NumBinaryProbes = 0;

  /// Associates a FileID with its "included/expanded in" decomposed

  /// location.

  ///

  /// Used to cache results from and speed-up \c getDecomposedIncludedLoc

  /// function.

  mutable llvm::DenseMap<FileID, std::pair<FileID, unsigned>> IncludedLocMap;

  /// The key value into the IsBeforeInTUCache table.

  using IsBeforeInTUCacheKey = std::pair<FileID, FileID>;

  /// The IsBeforeInTranslationUnitCache is a mapping from FileID pairs

  /// to cache results.

  using InBeforeInTUCache =

      llvm::DenseMap<IsBeforeInTUCacheKey, InBeforeInTUCacheEntry>;

  /// Cache results for the isBeforeInTranslationUnit method.

  mutable InBeforeInTUCache IBTUCache;

  mutable InBeforeInTUCacheEntry IBTUCacheOverflow;

  /// Return the cache entry for comparing the given file IDs

  /// for isBeforeInTranslationUnit.

  InBeforeInTUCacheEntry &getInBeforeInTUCache(FileID LFID, FileID RFID) const;

  // Cache for the "fake" buffer used for error-recovery purposes.

  mutable std::unique_ptr<llvm::MemoryBuffer> FakeBufferForRecovery;

  mutable std::unique_ptr<SrcMgr::ContentCache> FakeContentCacheForRecovery;

  mutable std::unique_ptr<SrcMgr::SLocEntry> FakeSLocEntryForRecovery;

  /// Lazily computed map of macro argument chunks to their expanded

  /// source location.

  using MacroArgsMap = std::map<unsigned, SourceLocation>;

  mutable llvm::DenseMap<FileID, std::unique_ptr<MacroArgsMap>>

      MacroArgsCacheMap;

  /// The stack of modules being built, which is used to detect

  /// cycles in the module dependency graph as modules are being built, as

  /// well as to describe why we're rebuilding a particular module.

  ///

  /// There is no way to set this value from the command line. If we ever need

  /// to do so (e.g., if on-demand module construction moves out-of-process),

  /// we can add a cc1-level option to do so.

  SmallVector<std::pair<std::string, FullSourceLoc>, 2> StoredModuleBuildStack;

public:

  SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr,

                bool UserFilesAreVolatile = false);

  explicit SourceManager(const SourceManager &) = delete;

  SourceManager &operator=(const SourceManager &) = delete;

  ~SourceManager();

  void clearIDTables();

  /// Initialize this source manager suitably to replay the compilation

  /// described by \p Old. Requires that \p Old outlive \p *this.

  void initializeForReplay(const SourceManager &Old);

  DiagnosticsEngine &getDiagnostics() const { return Diag; }

  FileManager &getFileManager() const { return FileMgr; }

  /// Set true if the SourceManager should report the original file name

  /// for contents of files that were overridden by other files. Defaults to

  /// true.

  void setOverridenFilesKeepOriginalName(bool value) {

    OverridenFilesKeepOriginalName = value;

  }

  /// True if non-system source files should be treated as volatile

  /// (likely to change while trying to use them).

  bool userFilesAreVolatile() const { return UserFilesAreVolatile; }

  /// Retrieve the module build stack.

  ModuleBuildStack getModuleBuildStack() const {

    return StoredModuleBuildStack;

  }

  /// Set the module build stack.

  void setModuleBuildStack(ModuleBuildStack stack) {

    StoredModuleBuildStack.clear();

    StoredModuleBuildStack.append(stack.begin(), stack.end());

  }

  /// Push an entry to the module build stack.

  void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc) {

    StoredModuleBuildStack.push_back(std::make_pair(moduleName.str(),importLoc));

  }

  //===--------------------------------------------------------------------===//

  // MainFileID creation and querying methods.

  //===--------------------------------------------------------------------===//

  /// Returns the FileID of the main source file.

  FileID getMainFileID() const { return MainFileID; }

  /// Set the file ID for the main source file.

  void setMainFileID(FileID FID) {

    MainFileID = FID;

  }

  /// Returns true when the given FileEntry corresponds to the main file.

  ///

  /// The main file should be set prior to calling this function.

  bool isMainFile(const FileEntry &SourceFile);

  /// Set the file ID for the precompiled preamble.

  void setPreambleFileID(FileID Preamble) {