class FileInfo
{
    /// \brief The location of the #include that brought in this file.
    ///
    /// This is an invalid SLOC for the main file (top of the #include chain).
    unsigned IncludeLoc;  // Really a SourceLocation

    /// \brief 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;

    /// \brief Contains the ContentCache* and the bits indicating the
    /// characteristic of the file and whether it has #line info, all
    /// bitmangled together.
    uintptr_t Data;
}

static FileInfo get(SourceLocation IL, const ContentCache *Con,
    CharacteristicKind FileCharacter)
{
    FileInfo X;
    X.IncludeLoc = IL.getRawEncoding();
    X.NumCreatedFIDs = 0;
    X.Data = (uintptr_t)Con;
    assert((X.Data & 7) == 0 && "ContentCache pointer insufficiently aligned");
    assert((unsigned)FileCharacter < 4 && "invalid file character");
    X.Data |= (unsigned)FileCharacter;
    return X;
}

enum CharacteristicKind
{
    C_User, C_System, C_ExternCSystem
};

class LLVM_ALIGNAS(8) ContentCache
{
    enum CCFlags
    {
        /// \brief Whether the buffer is invalid.
        InvalidFlag = 0x01,
        /// \brief Whether the buffer should not be freed on destruction.
        DoNotFreeFlag = 0x02
    };

    /// \brief The actual buffer containing the characters from the input
    /// file.
    ///
    /// This is owned by the ContentCache object.  The bits indicate
    /// whether the buffer is invalid.
    mutable llvm::PointerIntPair<llvm::MemoryBuffer *, 2> Buffer;

public:
    unsigned NumLines : 31;
    const FileEntry *OrigEntry;
    const FileEntry *ContentsEntry;
    unsigned *SourceLineCache;
    unsigned BufferOverridden : 1;
    unsigned IsSystemFile : 1;
}

llvm::MemoryBuffer *SourceManager::getMemoryBufferForFile(const FileEntry *File,
    bool *Invalid)
{
    const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
    assert(IR && "getOrCreateContentCache() cannot return NULL");
    return IR->getBuffer(Diag, *this, SourceLocation(), Invalid);
}

llvm::MemoryBuffer *ContentCache::getBuffer(DiagnosticsEngine &Diag,
    const SourceManager &SM,
    SourceLocation Loc,
    bool *Invalid) const

// Lazily create the Buffer for ContentCaches that wrap files.  If we already
// computed it, just return what we have.
if (Buffer.getPointer() || !ContentsEntry)
{
    if (Invalid)
        *Invalid = isBufferInvalid();

    return Buffer.getPointer();
}

bool isVolatile = SM.userFilesAreVolatile() && !IsSystemFile;
auto BufferOrError =
    SM.getFileManager().getBufferForFile(ContentsEntry, isVolatile);

if (!BufferOrError)
{
    StringRef FillStr("<<<MISSING SOURCE FILE>>>\n");
    Buffer.setPointer(MemoryBuffer::getNewUninitMemBuffer(
        ContentsEntry->getSize(), "<invalid>").release());
    char *Ptr = const_cast<char*>(Buffer.getPointer()->getBufferStart());
    for (unsigned i = 0, e = ContentsEntry->getSize(); i != e; ++i)
        Ptr[i] = FillStr[i % FillStr.size()];

    if (Diag.isDiagnosticInFlight())
        Diag.SetDelayedDiagnostic(diag::err_cannot_open_file,
            ContentsEntry->getName(),
            BufferOrError.getError().message());
    else
        Diag.Report(Loc, diag::err_cannot_open_file)
        << ContentsEntry->getName() << BufferOrError.getError().message();

    Buffer.setInt(Buffer.getInt() | InvalidFlag);

    if (Invalid) *Invalid = true;
    return Buffer.getPointer();
}

// If the buffer is valid, check to see if it has a UTF Byte Order Mark
// (BOM).  We only support UTF-8 with and without a BOM right now.  See
// http://en.wikipedia.org/wiki/Byte_order_mark for more information.
StringRef BufStr = Buffer.getPointer()->getBuffer();
const char *InvalidBOM = llvm::StringSwitch<const char *>(BufStr)
    .StartsWith("\xFE\xFF", "UTF-16 (BE)")
    .StartsWith("\xFF\xFE", "UTF-16 (LE)")
    .StartsWith("\x00\x00\xFE\xFF", "UTF-32 (BE)")
    .StartsWith("\xFF\xFE\x00\x00", "UTF-32 (LE)")
    .StartsWith("\x2B\x2F\x76", "UTF-7")
    .StartsWith("\xF7\x64\x4C", "UTF-1")
    .StartsWith("\xDD\x73\x66\x73", "UTF-EBCDIC")
    .StartsWith("\x0E\xFE\xFF", "SDSU")
    .StartsWith("\xFB\xEE\x28", "BOCU-1")
    .StartsWith("\x84\x31\x95\x33", "GB-18030")
    .Default(nullptr);

void SourceManager::overrideFileContents(const FileEntry *SourceFile,
    llvm::MemoryBuffer *Buffer,
    bool DoNotFree)
{
    const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
    assert(IR && "getOrCreateContentCache() cannot return NULL");

    const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(Buffer, DoNotFree);
    const_cast<SrcMgr::ContentCache *>(IR)->BufferOverridden = true;

    getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
}

void SourceManager::overrideFileContents(const FileEntry *SourceFile,
    const FileEntry *NewFile)
{
    assert(SourceFile->getSize() == NewFile->getSize() &&
        "Different sizes, use the FileManager to create a virtual file with "
        "the correct size");
    assert(FileInfos.count(SourceFile) == 0 &&
        "This function should be called at the initialization stage, before "
        "any parsing occurs.");
    getOverriddenFilesInfo().OverriddenFiles[SourceFile] = NewFile;
}

void SourceManager::disableFileContentsOverride(const FileEntry *File)
{
    if (!isFileOverridden(File))
        return;

    const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
    const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(nullptr);
    const_cast<SrcMgr::ContentCache *>(IR)->ContentsEntry = IR->OrigEntry;

    assert(OverriddenFilesInfo);
    OverriddenFilesInfo->OverriddenFiles.erase(File);
    OverriddenFilesInfo->OverriddenFilesWithBuffer.erase(File);
}

#define min(x,y) (x)>(y)?(y):(x)

void main(int argc,char**argv){

#line 4
int a=min(2,4)
}

class SourceLocation
{
    unsigned ID;
    enum : unsigned
    {
        MacroIDBit = 1U << 31
    };
}

SourceLocation() : ID(0) {}
//默认无效Location
bool isFileID() const { return (ID & MacroIDBit) == 0; }
bool isMacroID() const { return (ID & MacroIDBit) != 0; }

/// \brief Return true if this is a valid SourceLocation object.
///
/// Invalid SourceLocations are often used when events have no corresponding
/// location in the source (e.g. a diagnostic is required for a command line
/// option).
bool isValid() const { return ID != 0; }
bool isInvalid() const { return ID == 0; }

/// \brief Return the offset into the manager's global input view.
unsigned getOffset() const
{
    return ID & ~MacroIDBit;
}

static SourceLocation getFileLoc(unsigned ID)
{
    assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
    SourceLocation L;
    L.ID = ID;
    return L;
}

static SourceLocation getMacroLoc(unsigned ID)
{
    assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
    SourceLocation L;
    L.ID = MacroIDBit | ID;
    return L;
}

class SourceRange
{
    SourceLocation B;
    SourceLocation E;
}

class CharSourceRange
{
    SourceRange Range;
    bool IsTokenRange;
}

class FullSourceLoc : public SourceLocation
{
    const SourceManager *SrcMgr;
}

FileID getFileID() const;

FullSourceLoc getExpansionLoc() const;
FullSourceLoc getSpellingLoc() const;

unsigned getExpansionLineNumber(bool *Invalid = nullptr) const;
unsigned getExpansionColumnNumber(bool *Invalid = nullptr) const;

unsigned getSpellingLineNumber(bool *Invalid = nullptr) const;
unsigned getSpellingColumnNumber(bool *Invalid = nullptr) const;

const char *getCharacterData(bool *Invalid = nullptr) const;

class PresumedLoc
{
    const char *Filename;
    unsigned Line, Col;
    SourceLocation IncludeLoc;
}

PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
    bool UseLineDirectives) const

struct LineEntry
{
    /// \brief The offset in this file that the line entry occurs at.
    unsigned FileOffset;

    /// \brief The presumed line number of this line entry: #line 4.
    unsigned LineNo;

    /// \brief The ID of the filename identified by this line entry:
    /// #line 4 "foo.c".  This is -1 if not specified.
    int FilenameID;

    /// \brief Set the 0 if no flags, 1 if a system header,
    SrcMgr::CharacteristicKind FileKind;

    /// \brief The offset of the virtual include stack location,
    /// which is manipulated by GNU linemarker directives.
    ///
    /// If this is 0 then there is no virtual #includer.
    //都是GNU自己做得死
    unsigned IncludeOffset;
}

/// \brief Used to hold and unique data used to represent #line information.
class LineTableInfo
{
    /// \brief Map used to assign unique IDs to filenames in #line directives. 
    ///
    /// This allows us to unique the filenames that
    /// frequently reoccur and reference them with indices.  FilenameIDs holds
    /// the mapping from string -> ID, and FilenamesByID holds the mapping of ID
    /// to string.
    llvm::StringMap<unsigned, llvm::BumpPtrAllocator> FilenameIDs;
    std::vector<llvm::StringMapEntry<unsigned>*> FilenamesByID;

    /// \brief Map from FileIDs to a list of line entries (sorted by the offset
    /// at which they occur in the file).
    std::map<FileID, std::vector<LineEntry> > LineEntries;
}

const LineEntry *LineTableInfo::FindNearestLineEntry(FileID FID,
    unsigned Offset)
{
    const std::vector<LineEntry> &Entries = LineEntries[FID];
    assert(!Entries.empty() && "No #line entries for this FID after all!");

    // It is very common for the query to be after the last #line, check this
    // first.
    if (Entries.back().FileOffset <= Offset)
        return &Entries.back();

    // Do a binary search to find the maximal element that is still before Offset.
    std::vector<LineEntry>::const_iterator I =
        std::upper_bound(Entries.begin(), Entries.end(), Offset);
    if (I == Entries.begin()) return nullptr;
    return &*--I;
}

class ExpansionInfo
{
    // Really these are all SourceLocations.
    /// \brief Where the spelling for the token can be found.
    unsigned 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.
    unsigned ExpansionLocStart, ExpansionLocEnd;
}

static ExpansionInfo create(SourceLocation SpellingLoc,
    SourceLocation Start, SourceLocation End)
{
    ExpansionInfo X;
    X.SpellingLoc = SpellingLoc.getRawEncoding();
    X.ExpansionLocStart = Start.getRawEncoding();
    X.ExpansionLocEnd = End.getRawEncoding();
    return X;
}

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 ion rather than
    // a normal one.
    return create(SpellingLoc, ExpansionLoc, SourceLocation());
}

class SLocEntry
{
    unsigned Offset;   // low bit is set for expansion info.
    union
    {
        FileInfo File;
        ExpansionInfo Expansion;
    };
}

unsigned getOffset() const { return Offset >> 1; }
bool isExpansion() const { return Offset & 1; }
bool isFile() const { return !isExpansion(); }

static SLocEntry get(unsigned Offset, const FileInfo &FI)
{
    SLocEntry E;
    E.Offset = Offset << 1;
    E.File = FI;
    return E;
}

static SLocEntry get(unsigned Offset, const ExpansionInfo &Expansion)
{
    SLocEntry E;
    E.Offset = (Offset << 1) | 1;
    E.Expansion = Expansion;
    return E;
}

class SourceManager : public RefCountedBase<SourceManager>

DiagnosticsEngine &Diag;

FileManager &FileMgr;

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

struct OverriddenFilesInfoTy
{
    /// \brief Files that have been overridden with the contents from another
    /// file.
    llvm::DenseMap<const FileEntry *, const FileEntry *> OverriddenFiles;
    /// \brief Files that were overridden with a memory buffer.
    llvm::DenseSet<const FileEntry *> OverriddenFilesWithBuffer;
};

/// \brief 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;
}

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

// Cache for the "fake" buffer used for error-recovery purposes.
mutable std::unique_ptr<llvm::MemoryBuffer> FakeBufferForRecovery;

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

/// \brief 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;

/// \brief 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).
mutable SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable;

/// \brief A bitmap that indicates whether the entries of LoadedSLocEntryTable
/// have already been loaded from the external source.
///
/// Same indexing as LoadedSLocEntryTable.
std::vector<bool> SLocEntryLoaded;

/// \brief Holds information for #line directives.
///
/// This is referenced by indices from SLocEntryTable.
LineTableInfo *LineTable;

/// \brief Lazily computed map of macro argument chunks to their expanded
/// source location.
typedef std::map<unsigned, SourceLocation> MacroArgsMap;

mutable llvm::DenseMap<FileID, MacroArgsMap *> MacroArgsCacheMap;

/// \brief The file ID for the main source file of the translation unit.
FileID MainFileID;

/// \brief The file ID for the precompiled preamble there is one.
FileID PreambleFileID;

/// \brief 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;

void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
{
    StoredModuleBuildStack.push_back(std::make_pair(moduleName.str(), importLoc));
}

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
FileManager::getBufferForFile(const FileEntry *Entry, bool isVolatile,
    bool ShouldCloseOpenFile)
{
    uint64_t FileSize = Entry->getSize();
    // If there's a high enough chance that the file have changed since we
    // got its size, force a stat before opening it.
    if (isVolatile)
        FileSize = -1;

    const char *Filename = Entry->getName();
    // If the file is already open, use the open file descriptor.
    if (Entry->File)
    {
        auto Result =
            Entry->File->getBuffer(Filename, FileSize,
                /*RequiresNullTerminator=*/true, isVolatile);
        // FIXME: we need a set of APIs that can make guarantees about whether a
        // FileEntry is open or not.
        if (ShouldCloseOpenFile)
            Entry->closeFile();
        return Result;
    }

    // Otherwise, open the file.

    if (FileSystemOpts.WorkingDir.empty())
        return FS->getBufferForFile(Filename, FileSize,
            /*RequiresNullTerminator=*/true, isVolatile);

    SmallString<128> FilePath(Entry->getName());
    FixupRelativePath(FilePath);
    return FS->getBufferForFile(FilePath, FileSize,
        /*RequiresNullTerminator=*/true, isVolatile);
}

/// getOrCreateContentCache - Create or return a cached ContentCache for the
/// specified file.
const ContentCache *
SourceManager::getOrCreateContentCache(const FileEntry *FileEnt,
    bool isSystemFile)
{
    assert(FileEnt && "Didn't specify a file entry to use?");

    // Do we already have information about this file?
    ContentCache *&Entry = FileInfos[FileEnt];
    if (Entry) return Entry;

    // Nope, create a new Cache entry.
    Entry = ContentCacheAlloc.Allocate<ContentCache>();

    if (OverriddenFilesInfo)
    {
        // If the file contents are overridden with contents from another file,
        // pass that file to ContentCache.
        llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
            overI = OverriddenFilesInfo->OverriddenFiles.find(FileEnt);
        if (overI == OverriddenFilesInfo->OverriddenFiles.end())
            new (Entry) ContentCache(FileEnt);
        else
            new (Entry) ContentCache(OverridenFilesKeepOriginalName ? FileEnt
                : overI->second,
                overI->second);
    }
    else
    {
        new (Entry) ContentCache(FileEnt);
    }

    Entry->IsSystemFile = isSystemFile;

    return Entry;
}

/// \brief Create a new FileID that represents the specified file
/// being #included from the specified IncludePosition.
///
/// This translates NULL into standard input.
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos,
    SrcMgr::CharacteristicKind FileCharacter,
    int LoadedID = 0, unsigned LoadedOffset = 0)
{
    const SrcMgr::ContentCache *
        IR = getOrCreateContentCache(SourceFile,
            /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
    assert(IR && "getOrCreateContentCache() cannot return NULL");
    return createFileID(IR, IncludePos, FileCharacter, LoadedID, LoadedOffset);
}

/// \brief Create a new FileID that represents the specified memory buffer.
///
/// This does no caching of the buffer and takes ownership of the
/// MemoryBuffer, so only pass a MemoryBuffer to this once.
FileID createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
    SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
    int LoadedID = 0, unsigned LoadedOffset = 0,
    SourceLocation IncludeLoc = SourceLocation())
{
    return createFileID(createMemBufferContentCache(std::move(Buffer)),
        IncludeLoc, FileCharacter, LoadedID, LoadedOffset);
}

/// createFileID - Create a new FileID for the specified ContentCache and
/// include position.  This works regardless of whether the ContentCache
/// corresponds to a file or some other input source.
FileID SourceManager::createFileID(const ContentCache *File,
    SourceLocation IncludePos,
    SrcMgr::CharacteristicKind FileCharacter,
    int LoadedID, unsigned LoadedOffset)

assert(LoadedID != -1 && "Loading sentinel FileID");
unsigned Index = unsigned(-LoadedID) - 2;
assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
assert(!SLocEntryLoaded[Index] && "FileID already loaded");
LoadedSLocEntryTable[Index] = SLocEntry::get(LoadedOffset,
    FileInfo::get(IncludePos, File, FileCharacter));
SLocEntryLoaded[Index] = true;
return FileID::get(LoadedID);

LocalSLocEntryTable.push_back(SLocEntry::get(NextLocalOffset,
    FileInfo::get(IncludePos, File,
        FileCharacter)));
unsigned FileSize = File->getSize();
assert(NextLocalOffset + FileSize + 1 > NextLocalOffset &&
    NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset &&
    "Ran out of source locations!");
// We do a +1 here because we want a SourceLocation that means "the end of the
// file", e.g. for the "no newline at the end of the file" diagnostic.
NextLocalOffset += FileSize + 1;

// Set LastFileIDLookup to the newly created file.  The next getFileID call is
// almost guaranteed to be from that file.
FileID FID = FileID::get(LocalSLocEntryTable.size() - 1);
return LastFileIDLookup = FID;

static LLVM_ATTRIBUTE_NOINLINE void
ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI,
    llvm::BumpPtrAllocator &Alloc,
    const SourceManager &SM, bool &Invalid);

#ifdef __SSE2__
#include <emmintrin.h>
#endif

__m128i CRs = _mm_set1_epi8('\r');
__m128i LFs = _mm_set1_epi8('\n');
while (NextBuf + 16 <= End)
{
    const __m128i Chunk = *(const __m128i*)NextBuf;
    __m128i Cmp = _mm_or_si128(_mm_cmpeq_epi8(Chunk, CRs),
        _mm_cmpeq_epi8(Chunk, LFs));
    unsigned Mask = _mm_movemask_epi8(Cmp);

    // If we found a newline, adjust the pointer and jump to the handling code.
    if (Mask != 0)
    {
        NextBuf += llvm::countTrailingZeros(Mask);
        goto FoundSpecialChar;
    }
    NextBuf += 16;
}

SourceLocation
SourceManager::createMacroArgExpansionLoc(SourceLocation SpellingLoc,
    SourceLocation ExpansionLoc,
    unsigned TokLength)
{
    ExpansionInfo Info = ExpansionInfo::createForMacroArg(SpellingLoc,
        ExpansionLoc);
    return createExpansionLocImpl(Info, TokLength);
}

SourceLocation
SourceManager::createExpansionLoc(SourceLocation SpellingLoc,
    SourceLocation ExpansionLocStart,
    SourceLocation ExpansionLocEnd,
    unsigned TokLength,
    int LoadedID,
    unsigned LoadedOffset)
{
    ExpansionInfo Info = ExpansionInfo::create(SpellingLoc, ExpansionLocStart,
        ExpansionLocEnd);
    return createExpansionLocImpl(Info, TokLength, LoadedID, LoadedOffset);
}

/// \brief Return a new SourceLocation that encodes the fact
/// that a token from SpellingLoc should actually be referenced from
/// ExpansionLoc.
SourceLocation createExpansionLoc(SourceLocation Loc,
    SourceLocation ExpansionLocStart,
    SourceLocation ExpansionLocEnd,
    unsigned TokLength,
    int LoadedID = 0,
    unsigned LoadedOffset = 0);

if (LoadedID < 0)
{
    assert(LoadedID != -1 && "Loading sentinel FileID");
    unsigned Index = unsigned(-LoadedID) - 2;
    assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
    assert(!SLocEntryLoaded[Index] && "FileID already loaded");
    LoadedSLocEntryTable[Index] = SLocEntry::get(LoadedOffset, Info);
    SLocEntryLoaded[Index] = true;
    return SourceLocation::getMacroLoc(LoadedOffset);
}

LocalSLocEntryTable.push_back(SLocEntry::get(NextLocalOffset, Info));
assert(NextLocalOffset + TokLength + 1 > NextLocalOffset &&
    NextLocalOffset + TokLength + 1 <= CurrentLoadedOffset &&
    "Ran out of source locations!");
// See createFileID for that +1.
NextLocalOffset += TokLength + 1;
return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));

/// \brief Compute a map of macro argument chunks to their expanded source
/// location. Chunks that are not part of a macro argument will map to an
/// invalid source location. e.g. if a file contains one macro argument at
/// offset 100 with length 10, this is how the map will be formed:
///     0   -> SourceLocation()
///     100 -> Expanded macro arg location
///     110 -> SourceLocation()

int ID = FID.ID;
while (1)
{
    ++ID;
    // Stop if there are no more FileIDs to check.
    if (ID > 0)
    {
        if (unsigned(ID) >= local_sloc_entry_size())
            return;
    }
    else if (ID == -1)
    {
        return;
    }

    bool Invalid = false;
    const SrcMgr::SLocEntry &Entry = getSLocEntryByID(ID, &Invalid);
    if (Invalid)
        return;
    if (Entry.isFile())
    {
        SourceLocation IncludeLoc = Entry.getFile().getIncludeLoc();
        if (IncludeLoc.isInvalid())
            continue;
        if (!isInFileID(IncludeLoc, FID))
            return; // No more files/macros that may be "contained" in this file.

  // Skip the files/macros of the #include'd file, we only care about macros
  // that lexed macro arguments from our file.
        if (Entry.getFile().NumCreatedFIDs)
            ID += Entry.getFile().NumCreatedFIDs - 1/*because of next ++ID*/;
        continue;
    }

    const ExpansionInfo &ExpInfo = Entry.getExpansion();

    if (ExpInfo.getExpansionLocStart().isFileID())
    {
        if (!isInFileID(ExpInfo.getExpansionLocStart(), FID))
            return; // No more files/macros that may be "contained" in this file.
    }

    if (!ExpInfo.isMacroArgExpansion())
        continue;

    associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
        ExpInfo.getSpellingLoc(),
        SourceLocation::getMacroLoc(Entry.getOffset()),
        getFileIDSize(FileID::get(ID)));
}

if (!SpellLoc.isFileID())
{
    unsigned SpellBeginOffs = SpellLoc.getOffset();
    unsigned SpellEndOffs = SpellBeginOffs + ExpansionLength;

    // The spelling range for this macro argument expansion can span multiple
    // consecutive FileID entries. Go through each entry contained in the
    // spelling range and if one is itself a macro argument expansion, recurse
    // and associate the file chunk that it represents.

    FileID SpellFID; // Current FileID in the spelling range.
    unsigned SpellRelativeOffs;
    std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);
    while (1)
    {
        const SLocEntry &Entry = getSLocEntry(SpellFID);
        unsigned SpellFIDBeginOffs = Entry.getOffset();
        unsigned SpellFIDSize = getFileIDSize(SpellFID);
        unsigned SpellFIDEndOffs = SpellFIDBeginOffs + SpellFIDSize;
        const ExpansionInfo &Info = Entry.getExpansion();
        if (Info.isMacroArgExpansion())
        {
            unsigned CurrSpellLength;
            if (SpellFIDEndOffs < SpellEndOffs)
                CurrSpellLength = SpellFIDSize - SpellRelativeOffs;
            else
                CurrSpellLength = ExpansionLength;
            associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
                Info.getSpellingLoc().getLocWithOffset(SpellRelativeOffs),
                ExpansionLoc, CurrSpellLength);
        }

        if (SpellFIDEndOffs >= SpellEndOffs)
            return; // we covered all FileID entries in the spelling range.

  // Move to the next FileID entry in the spelling range.
        unsigned advance = SpellFIDSize - SpellRelativeOffs + 1;
        ExpansionLoc = ExpansionLoc.getLocWithOffset(advance);
        ExpansionLength -= advance;
        ++SpellFID.ID;
        SpellRelativeOffs = 0;
    }

}

/// \brief 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;
/// \brief 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 SrcMgr::ContentCache *LastLineNoContentCache;
mutable unsigned LastLineNoFilePos;
mutable unsigned LastLineNoResult;
// Statistics for -print-stats.
mutable unsigned NumLinearScans, NumBinaryProbes;

/// \brief 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;

assert(NextLocalOffset + FileSize + 1 > NextLocalOffset &&
    NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset &&
    "Ran out of source locations!");

FileID SourceManager::getFileIDSlow(unsigned SLocOffset) const
{
    if (!SLocOffset)
        return FileID::get(0);

    // Now it is time to search for the correct file. See where the SLocOffset
    // sits in the global view and consult local or loaded buffers for it.
    if (SLocOffset < NextLocalOffset)
        return getFileIDLocal(SLocOffset);
    return getFileIDLoaded(SLocOffset);
}

const SrcMgr::SLocEntry *I;

if (LastFileIDLookup.ID < 0 ||
    LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset)
{
    // Neither loc prunes our search.
    I = LocalSLocEntryTable.end();
}
else
{
    // Perhaps it is near the file point.
    I = LocalSLocEntryTable.begin() + LastFileIDLookup.ID;
}

// Find the FileID that contains this.  "I" is an iterator that points to a
// FileID whose offset is known to be larger than SLocOffset.
unsigned NumProbes = 0;
while (1)
{
    --I;
    if (I->getOffset() <= SLocOffset)
    {
        FileID Res = FileID::get(int(I - LocalSLocEntryTable.begin()));

        // If this isn't an expansion, remember it.  We have good locality across
        // FileID lookups.
        if (!I->isExpansion())
            LastFileIDLookup = Res;
        NumLinearScans += NumProbes + 1;
        return Res;
    }
    if (++NumProbes == 8)
        break;
}

// Convert "I" back into an index.  We know that it is an entry whose index is
// larger than the offset we are looking for.
unsigned GreaterIndex = I - LocalSLocEntryTable.begin();
// LessIndex - This is the lower bound of the range that we're searching.
// We know that the offset corresponding to the FileID is is less than
// SLocOffset.

unsigned LessIndex = 0;
NumProbes = 0;
while (1)
{
    bool Invalid = false;
    unsigned MiddleIndex = (GreaterIndex - LessIndex) / 2 + LessIndex;
    unsigned MidOffset = getLocalSLocEntry(MiddleIndex, &Invalid).getOffset();
    if (Invalid)
        return FileID::get(0);

    ++NumProbes;

    // If the offset of the midpoint is too large, chop the high side of the
    // range to the midpoint.
    if (MidOffset > SLocOffset)
    {
        GreaterIndex = MiddleIndex;
        continue;
    }

    // If the middle index contains the value, succeed and return.
    // FIXME: This could be made faster by using a function that's aware of
    // being in the local area.
    if (isOffsetInFileID(FileID::get(MiddleIndex), SLocOffset))
    {
        FileID Res = FileID::get(MiddleIndex);

        // If this isn't a macro expansion, remember it.  We have good locality
        // across FileID lookups.
        if (!LocalSLocEntryTable[MiddleIndex].isExpansion())
            LastFileIDLookup = Res;
        NumBinaryProbes += NumProbes;
        return Res;
    }

    // Otherwise, move the low-side up to the middle index.
    LessIndex = MiddleIndex;
}

// Sanity checking, otherwise a bug may lead to hanging in release build.
if (SLocOffset < CurrentLoadedOffset)
{
    assert(0 && "Invalid SLocOffset or bad function choice");
    return FileID();
}

// Essentially the same as the local case, but the loaded array is sorted
// in the other direction.

// First do a linear scan from the last lookup position, if possible.
unsigned I;
int LastID = LastFileIDLookup.ID;
if (LastID >= 0 || getLoadedSLocEntryByID(LastID).getOffset() < SLocOffset)
    I = 0;
else
    I = (-LastID - 2) + 1;

unsigned NumProbes;
for (NumProbes = 0; NumProbes < 8; ++NumProbes, ++I)
{
    // Make sure the entry is loaded!
    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(I);
    if (E.getOffset() <= SLocOffset)
    {
        FileID Res = FileID::get(-int(I) - 2);

        if (!E.isExpansion())
            LastFileIDLookup = Res;
        NumLinearScans += NumProbes + 1;
        return Res;
    }
}

// Linear scan failed. Do the binary search. Note the reverse sorting of the
// table: GreaterIndex is the one where the offset is greater, which is
// actually a lower index!
unsigned GreaterIndex = I;
unsigned LessIndex = LoadedSLocEntryTable.size();
NumProbes = 0;
while (1)
{
    ++NumProbes;
    unsigned MiddleIndex = (LessIndex - GreaterIndex) / 2 + GreaterIndex;
    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(MiddleIndex);
    if (E.getOffset() == 0)
        return FileID(); // invalid entry.

    ++NumProbes;

    if (E.getOffset() > SLocOffset)
    {
        // Sanity checking, otherwise a bug may lead to hanging in release build.
        if (GreaterIndex == MiddleIndex)
        {
            assert(0 && "binary search missed the entry");
            return FileID();
        }
        GreaterIndex = MiddleIndex;
        continue;
    }

    if (isOffsetInFileID(FileID::get(-int(MiddleIndex) - 2), SLocOffset))
    {
        FileID Res = FileID::get(-int(MiddleIndex) - 2);
        if (!E.isExpansion())
            LastFileIDLookup = Res;
        NumBinaryProbes += NumProbes;
        return Res;
    }

    // Sanity checking, otherwise a bug may lead to hanging in release build.
    if (LessIndex == MiddleIndex)
    {
        assert(0 && "binary search missed the entry");
        return FileID();
    }
    LessIndex = MiddleIndex;
}

/// This is a very hot method that is used for all SourceManager queries
/// that start with a SourceLocation object.  It is responsible for finding
/// the entry in SLocEntryTable which contains the specified location.
///
FileID getFileID(SourceLocation SpellingLoc) const
{
    unsigned SLocOffset = SpellingLoc.getOffset();

    // If our one-entry cache covers this offset, just return it.
    if (isOffsetInFileID(LastFileIDLookup, SLocOffset))
        return LastFileIDLookup;

    return getFileIDSlow(SLocOffset);
}

/// \brief Decompose the specified location into a raw FileID + Offset pair.
///
/// The first element is the FileID, the second is the offset from the
/// start of the buffer of the location.
std::pair<FileID, unsigned> getDecomposedLoc(SourceLocation Loc) const
{
    FileID FID = getFileID(Loc);
    bool Invalid = false;
    const SrcMgr::SLocEntry &E = getSLocEntry(FID, &Invalid);
    if (Invalid)
        return std::make_pair(FileID(), 0);
    return std::make_pair(FID, Loc.getOffset() - E.getOffset());
}

/// \brief Get the FileID for the given file.
///
/// If the source file is included multiple times, the FileID will be the
/// first inclusion.
FileID SourceManager::translateFile(const FileEntry *SourceFile) const

FileID FirstFID;

// First, check the main file ID, since it is common to look for a
// location in the main file.
Optional<llvm::sys::fs::UniqueID> SourceFileUID;
Optional<StringRef> SourceFileName;
if (MainFileID.isValid())
{
    bool Invalid = false;
    const SLocEntry &MainSLoc = getSLocEntry(MainFileID, &Invalid);
    if (Invalid)
        return FileID();

    if (MainSLoc.isFile())
    {
        const ContentCache *MainContentCache
            = MainSLoc.getFile().getContentCache();
        if (!MainContentCache)
        {
            // Can't do anything
        }
        else if (MainContentCache->OrigEntry == SourceFile)
        {
            FirstFID = MainFileID;
        }
        else
        {
            // Fall back: check whether we have the same base name and inode
            // as the main file.
            //此处省略很多字
        }
    }
}

const FileEntry *MainFile = MainContentCache->OrigEntry;
SourceFileName = llvm::sys::path::filename(SourceFile->getName());
if (*SourceFileName == llvm::sys::path::filename(MainFile->getName()))
{
    SourceFileUID = getActualFileUID(SourceFile);
    if (SourceFileUID)
    {
        if (Optional<llvm::sys::fs::UniqueID> MainFileUID =
            getActualFileUID(MainFile))
        {
            if (*SourceFileUID == *MainFileUID)
            {
                FirstFID = MainFileID;
                SourceFile = MainFile;
            }
        }
    }
}

// The location we're looking for isn't in the main file; look
// through all of the local source locations.
for (unsigned I = 0, N = local_sloc_entry_size(); I != N; ++I)
{
    bool Invalid = false;
    const SLocEntry &SLoc = getLocalSLocEntry(I, &Invalid);
    if (Invalid)
        return FileID();

    if (SLoc.isFile() &&
        SLoc.getFile().getContentCache() &&
        SLoc.getFile().getContentCache()->OrigEntry == SourceFile)
    {
        FirstFID = FileID::get(I);
        break;
    }
}

for (unsigned I = 0, N = loaded_sloc_entry_size(); I != N; ++I)
{
    const SLocEntry &SLoc = getLoadedSLocEntry(I);
    if (SLoc.isFile() &&
        SLoc.getFile().getContentCache() &&
        SLoc.getFile().getContentCache()->OrigEntry == SourceFile)
    {
        FirstFID = FileID::get(-int(I) - 2);
        break;
    }
}

/// \brief Given a SourceLocation object \p Loc, return the expansion
/// location referenced by the ID.
SourceLocation getExpansionLoc(SourceLocation Loc) const
{
    // Handle the non-mapped case inline, defer to out of line code to handle
    // expansions.
    if (Loc.isFileID()) return Loc;
    return getExpansionLocSlowCase(Loc);
}
SourceLocation SourceManager::
getExpansionLocSlowCase(SourceLocation Loc) const
{
    do
    {
        // Note: If Loc indicates an offset into a token that came from a macro
        // expansion (e.g. the 5th character of the token) we do not want to add
        // this offset when going to the expansion location.  The expansion
        // location is the macro invocation, which the offset has nothing to do
        // with.  This is unlike when we get the spelling loc, because the offset
        // directly correspond to the token whose spelling we're inspecting.
        Loc = getSLocEntry(getFileID(Loc)).getExpansion().getExpansionLocStart();
    }
    while (!Loc.isFileID());

    return Loc;
}

SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const
{
    do
    {
        std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
        Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
        Loc = Loc.getLocWithOffset(LocInfo.second);
    }
    while (!Loc.isFileID());
    return Loc;
}

/// \brief Decompose the specified location into a raw FileID + Offset pair.
///
/// The first element is the FileID, the second is the offset from the
/// start of the buffer of the location.
std::pair<FileID, unsigned> getDecomposedLoc(SourceLocation Loc) const
{
    FileID FID = getFileID(Loc);
    bool Invalid = false;
    const SrcMgr::SLocEntry &E = getSLocEntry(FID, &Invalid);
    if (Invalid)
        return std::make_pair(FileID(), 0);
    return std::make_pair(FID, Loc.getOffset() - E.getOffset());
}

/// \brief Return the start/end of the expansion information for an
/// expansion location.
///
/// \pre \p Loc is required to be an expansion location.
std::pair<SourceLocation, SourceLocation>
getImmediateExpansionRange(SourceLocation Loc) const;
/// \brief Given a SourceLocation object, return the range of
/// tokens covered by the expansion in the ultimate file.
std::pair<SourceLocation, SourceLocation>
    getExpansionRange(SourceLocation Loc) const;

/// getImmediateExpansionRange - Loc is required to be an expansion location.
/// Return the start/end of the expansion information.
std::pair<SourceLocation, SourceLocation>
SourceManager::getImmediateExpansionRange(SourceLocation Loc) const
{
    assert(Loc.isMacroID() && "Not a macro expansion loc!");
    const ExpansionInfo &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
    return Expansion.getExpansionLocRange();
}

/// getExpansionRange - Given a SourceLocation object, return the range of
/// tokens covered by the expansion in the ultimate file.
std::pair<SourceLocation, SourceLocation>
SourceManager::getExpansionRange(SourceLocation Loc) const
{
    if (Loc.isFileID()) return std::make_pair(Loc, Loc);

    std::pair<SourceLocation, SourceLocation> Res =
        getImmediateExpansionRange(Loc);

    // Fully resolve the start and end locations to their ultimate expansion
    // points.
    while (!Res.first.isFileID())
        Res.first = getImmediateExpansionRange(Res.first).first;
    while (!Res.second.isFileID())
        Res.second = getImmediateExpansionRange(Res.second).second;
}

/// The key value into the IsBeforeInTUCache table.
typedef std::pair<FileID, FileID> IsBeforeInTUCacheKey;

/// The IsBeforeInTranslationUnitCache is a mapping from FileID pairs
/// to cache results.
typedef llvm::DenseMap<IsBeforeInTUCacheKey, InBeforeInTUCacheEntry>
    InBeforeInTUCache;

/// 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;

/// getColumnNumber - Return the column # for the specified file position.
/// this is significantly cheaper to compute than the line number.
unsigned SourceManager::getColumnNumber(FileID FID, unsigned FilePos,
    bool *Invalid) const

bool MyInvalid = false;
llvm::MemoryBuffer *MemBuf = getBuffer(FID, &MyInvalid);
if (Invalid)
    *Invalid = MyInvalid;

if (MyInvalid)
    return 1;

// It is okay to request a position just past the end of the buffer.
if (FilePos > MemBuf->getBufferSize())
{
    if (Invalid)
        *Invalid = true;
    return 1;
}

// See if we just calculated the line number for this FilePos and can use
// that to lookup the start of the line instead of searching for it.
if (LastLineNoFileIDQuery == FID &&
    LastLineNoContentCache->SourceLineCache != nullptr &&
    LastLineNoResult < LastLineNoContentCache->NumLines)
{
    unsigned *SourceLineCache = LastLineNoContentCache->SourceLineCache;
    unsigned LineStart = SourceLineCache[LastLineNoResult - 1];
    unsigned LineEnd = SourceLineCache[LastLineNoResult];
    if (FilePos >= LineStart && FilePos < LineEnd)
        return FilePos - LineStart + 1;
}

const char *Buf = MemBuf->getBufferStart();
unsigned LineStart = FilePos;
while (LineStart && Buf[LineStart - 1] != '\n' && Buf[LineStart - 1] != '\r')
    --LineStart;
return FilePos - LineStart + 1;

unsigned SourceManager::getLineNumber(FileID FID, unsigned FilePos,
    bool *Invalid) const

ContentCache *Content;
if (LastLineNoFileIDQuery == FID)
    Content = LastLineNoContentCache;
else
{
    bool MyInvalid = false;
    const SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
    if (MyInvalid || !Entry.isFile())
    {
        if (Invalid)
            *Invalid = true;
        return 1;
    }

    Content = const_cast<ContentCache*>(Entry.getFile().getContentCache());
}

// If this is the first use of line information for this buffer, compute the
/// SourceLineCache for it on demand.
if (!Content->SourceLineCache)
{
    bool MyInvalid = false;
    ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
    if (Invalid)
        *Invalid = MyInvalid;
    if (MyInvalid)
        return 1;
}
else if (Invalid)
    *Invalid = false;

if (LastLineNoFileIDQuery == FID)
{
    if (QueriedFilePos >= LastLineNoFilePos)
    {
        // FIXME: Potential overflow?
        SourceLineCache = SourceLineCache + LastLineNoResult - 1;

        // The query is likely to be nearby the previous one.  Here we check to
        // see if it is within 5, 10 or 20 lines.  It can be far away in cases
        // where big comment blocks and vertical whitespace eat up lines but
        // contribute no tokens.
        if (SourceLineCache + 5 < SourceLineCacheEnd)
        {
            if (SourceLineCache[5] > QueriedFilePos)
                SourceLineCacheEnd = SourceLineCache + 5;
            else if (SourceLineCache + 10 < SourceLineCacheEnd)
            {
                if (SourceLineCache[10] > QueriedFilePos)
                    SourceLineCacheEnd = SourceLineCache + 10;
                else if (SourceLineCache + 20 < SourceLineCacheEnd)
                {
                    if (SourceLineCache[20] > QueriedFilePos)
                        SourceLineCacheEnd = SourceLineCache + 20;
                }
            }
        }
    }
    else
    {
        if (LastLineNoResult < Content->NumLines)
            SourceLineCacheEnd = SourceLineCache + LastLineNoResult + 1;
    }
}

unsigned *Pos
    = std::lower_bound(SourceLineCache, SourceLineCacheEnd, QueriedFilePos);
unsigned LineNo = Pos - SourceLineCacheStart;

LastLineNoFileIDQuery = FID;
LastLineNoContentCache = Content;
LastLineNoFilePos = QueriedFilePos;
LastLineNoResult = LineNo;
return LineNo;

unsigned SourceManager::getSpellingLineNumber(SourceLocation Loc,
    bool *Invalid) const
{
    if (isInvalid(Loc, Invalid)) return 0;
    std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc);
    return getLineNumber(LocInfo.first, LocInfo.second);
}
unsigned SourceManager::getExpansionLineNumber(SourceLocation Loc,
    bool *Invalid) const
{
    if (isInvalid(Loc, Invalid)) return 0;
    std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
    return getLineNumber(LocInfo.first, LocInfo.second);
}

unsigned SourceManager::getPresumedLineNumber(SourceLocation Loc,
    bool *Invalid) const
{
    if (isInvalid(Loc, Invalid)) return 0;
    return getPresumedLoc(Loc).getLine();
}

/// getPresumedLoc - This method returns the "presumed" location of a
/// SourceLocation specifies.  A "presumed location" can be modified by #line
/// or GNU line marker directives.  This provides a view on the data that a
/// user should see in diagnostics, for example.
///
/// Note that a presumed location is always given as the expansion point of an
/// expansion location, not at the spelling location.
PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
    bool UseLineDirectives) const

if (Loc.isInvalid()) return PresumedLoc();

// Presumed locations are always for expansion points.
std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);

bool Invalid = false;
const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
if (Invalid || !Entry.isFile())
    return PresumedLoc();

const SrcMgr::FileInfo &FI = Entry.getFile();
const SrcMgr::ContentCache *C = FI.getContentCache();
// To get the source name, first consult the FileEntry (if one exists)
// before the MemBuffer as this will avoid unnecessarily paging in the
// MemBuffer.
const char *Filename;
if (C->OrigEntry)
    Filename = C->OrigEntry->getName();
else
    Filename = C->getBuffer(Diag, *this)->getBufferIdentifier();

unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second, &Invalid);
if (Invalid)
    return PresumedLoc();
unsigned ColNo = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
if (Invalid)
    return PresumedLoc();

// If we have #line directives in this file, update and overwrite the physical
// location info if appropriate.
if (UseLineDirectives && FI.hasLineDirectives())
{
    assert(LineTable && "Can't have linetable entries without a LineTable!");
    // See if there is a #line directive before this.  If so, get it.
    if (const LineEntry *Entry =
        LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second))
    {
        // If the LineEntry indicates a filename, use it.
        if (Entry->FilenameID != -1)
            Filename = LineTable->getFilename(Entry->FilenameID);

        // Use the line number specified by the LineEntry.  This line number may
        // be multiple lines down from the line entry.  Add the difference in
        // physical line numbers from the query point and the line marker to the
        // total.
        unsigned MarkerLineNo = getLineNumber(LocInfo.first, Entry->FileOffset);
        LineNo = Entry->LineNo + (LineNo - MarkerLineNo - 1);

        // Note that column numbers are not molested by line markers.

        // Handle virtual #include manipulation.
        if (Entry->IncludeOffset)
        {
            IncludeLoc = getLocForStartOfFile(LocInfo.first);
            IncludeLoc = IncludeLoc.getLocWithOffset(Entry->IncludeOffset);
        }
    }
}

return PresumedLoc(Filename, LineNo, ColNo, IncludeLoc);

/// \brief Get the source location for the given file:line:col triplet.
///
/// If the source file is included multiple times, the source location will
/// be based upon an arbitrary inclusion.
SourceLocation SourceManager::translateFileLineCol(const FileEntry *SourceFile,
    unsigned Line,
    unsigned Col) const
{
    assert(SourceFile && "Null source file!");
    assert(Line && Col && "Line and column should start from 1!");

    FileID FirstFID = translateFile(SourceFile);
    return translateLineCol(FirstFID, Line, Col);
}

// If this is the first use of line information for this buffer, compute the
// SourceLineCache for it on demand.
if (!Content->SourceLineCache)
{
    bool MyInvalid = false;
    ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
    if (MyInvalid)
        return SourceLocation();
}

if (Line > Content->NumLines)
{
    unsigned Size = Content->getBuffer(Diag, *this)->getBufferSize();
    if (Size > 0)
        --Size;
    return FileLoc.getLocWithOffset(Size);
}

llvm::MemoryBuffer *Buffer = Content->getBuffer(Diag, *this);
unsigned FilePos = Content->SourceLineCache[Line - 1];
const char *Buf = Buffer->getBufferStart() + FilePos;
unsigned BufLength = Buffer->getBufferSize() - FilePos;
if (BufLength == 0)
    return FileLoc.getLocWithOffset(FilePos);

unsigned i = 0;

// Check that the given column is valid.
while (i < BufLength - 1 && i < Col - 1 && Buf[i] != '\n' && Buf[i] != '\r')
    ++i;
return FileLoc.getLocWithOffset(FilePos + i);