//===- SourceManager.cpp - Track and cache source files -------------------===// // // 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 // //===----------------------------------------------------------------------===// // // This file implements the SourceManager interface. // //===----------------------------------------------------------------------===// #include "clang/Basic/SourceManager.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManagerInternals.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Capacity.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Endian.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include <algorithm> #include <cassert> #include <cstddef> #include <cstdint> #include <memory> #include <optional> #include <tuple> #include <utility> #include <vector> usingnamespaceclang; usingnamespaceSrcMgr; MemoryBuffer; #define DEBUG_TYPE … // Reaching a limit of 2^31 results in a hard error. This metric allows to track // if particular invocation of the compiler is close to it. STATISTIC(MaxUsedSLocBytes, "Maximum number of bytes used by source locations " "(both loaded and local)."); //===----------------------------------------------------------------------===// // SourceManager Helper Classes //===----------------------------------------------------------------------===// /// getSizeBytesMapped - Returns the number of bytes actually mapped for this /// ContentCache. This can be 0 if the MemBuffer was not actually expanded. unsigned ContentCache::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 ContentCache::getMemoryBufferKind() const { … } /// getSize - 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, that /// file is not lazily brought in from disk to satisfy this query. unsigned ContentCache::getSize() const { … } const char *ContentCache::getInvalidBOM(StringRef BufStr) { … } std::optional<llvm::MemoryBufferRef> ContentCache::getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM, SourceLocation Loc) const { … } unsigned LineTableInfo::getLineTableFilenameID(StringRef Name) { … } /// Add a line note to the line table that indicates that there is a \#line or /// GNU line marker at the specified FID/Offset location which changes the /// presumed location to LineNo/FilenameID. If EntryExit is 0, then this doesn't /// change the presumed \#include stack. If it is 1, this is a file entry, if /// it is 2 then this is a file exit. FileKind specifies whether this is a /// system header or extern C system header. void LineTableInfo::AddLineNote(FileID FID, unsigned Offset, unsigned LineNo, int FilenameID, unsigned EntryExit, SrcMgr::CharacteristicKind FileKind) { … } /// FindNearestLineEntry - Find the line entry nearest to FID that is before /// it. If there is no line entry before Offset in FID, return null. const LineEntry *LineTableInfo::FindNearestLineEntry(FileID FID, unsigned Offset) { … } /// Add a new line entry that has already been encoded into /// the internal representation of the line table. void LineTableInfo::AddEntry(FileID FID, const std::vector<LineEntry> &Entries) { … } /// getLineTableFilenameID - Return the uniqued ID for the specified filename. unsigned SourceManager::getLineTableFilenameID(StringRef Name) { … } /// AddLineNote - Add a line note to the line table for the FileID and offset /// specified by Loc. If FilenameID is -1, it is considered to be /// unspecified. void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind) { … } LineTableInfo &SourceManager::getLineTable() { … } //===----------------------------------------------------------------------===// // Private 'Create' methods. //===----------------------------------------------------------------------===// SourceManager::SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr, bool UserFilesAreVolatile) : … { … } SourceManager::~SourceManager() { … } void SourceManager::clearIDTables() { … } bool SourceManager::isMainFile(const FileEntry &SourceFile) { … } void SourceManager::initializeForReplay(const SourceManager &Old) { … } ContentCache &SourceManager::getOrCreateContentCache(FileEntryRef FileEnt, bool isSystemFile) { … } /// Create a new ContentCache for the specified memory buffer. /// This does no caching. ContentCache &SourceManager::createMemBufferContentCache( std::unique_ptr<llvm::MemoryBuffer> Buffer) { … } const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index, bool *Invalid) const { … } SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index, bool *Invalid) { … } std::pair<int, SourceLocation::UIntTy> SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries, SourceLocation::UIntTy TotalSize) { … } /// As part of recovering from missing or changed content, produce a /// fake, non-empty buffer. llvm::MemoryBufferRef SourceManager::getFakeBufferForRecovery() const { … } /// As part of recovering from missing or changed content, produce a /// fake content cache. SrcMgr::ContentCache &SourceManager::getFakeContentCacheForRecovery() const { … } /// Returns the previous in-order FileID or an invalid FileID if there /// is no previous one. FileID SourceManager::getPreviousFileID(FileID FID) const { … } /// Returns the next in-order FileID or an invalid FileID if there is /// no next one. FileID SourceManager::getNextFileID(FileID FID) const { … } //===----------------------------------------------------------------------===// // Methods to create new FileID's and macro expansions. //===----------------------------------------------------------------------===// /// Create a new FileID that represents the specified file /// being \#included from the specified IncludePosition. FileID SourceManager::createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID, SourceLocation::UIntTy LoadedOffset) { … } /// 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 SourceManager::createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer, SrcMgr::CharacteristicKind FileCharacter, int LoadedID, SourceLocation::UIntTy LoadedOffset, SourceLocation IncludeLoc) { … } /// Create a new FileID that represents the specified memory buffer. /// /// This does not take ownership of the MemoryBuffer. The memory buffer must /// outlive the SourceManager. FileID SourceManager::createFileID(const llvm::MemoryBufferRef &Buffer, SrcMgr::CharacteristicKind FileCharacter, int LoadedID, SourceLocation::UIntTy LoadedOffset, SourceLocation IncludeLoc) { … } /// Get the FileID for \p SourceFile if it exists. Otherwise, create a /// new FileID for the \p SourceFile. FileID SourceManager::getOrCreateFileID(FileEntryRef SourceFile, SrcMgr::CharacteristicKind FileCharacter) { … } /// 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::createFileIDImpl(ContentCache &File, StringRef Filename, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID, SourceLocation::UIntTy LoadedOffset) { … } SourceLocation SourceManager::createMacroArgExpansionLoc( SourceLocation SpellingLoc, SourceLocation ExpansionLoc, unsigned Length) { … } SourceLocation SourceManager::createExpansionLoc( SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned Length, bool ExpansionIsTokenRange, int LoadedID, SourceLocation::UIntTy LoadedOffset) { … } SourceLocation SourceManager::createTokenSplitLoc(SourceLocation Spelling, SourceLocation TokenStart, SourceLocation TokenEnd) { … } SourceLocation SourceManager::createExpansionLocImpl(const ExpansionInfo &Info, unsigned Length, int LoadedID, SourceLocation::UIntTy LoadedOffset) { … } std::optional<llvm::MemoryBufferRef> SourceManager::getMemoryBufferForFileOrNone(FileEntryRef File) { … } void SourceManager::overrideFileContents( FileEntryRef SourceFile, std::unique_ptr<llvm::MemoryBuffer> Buffer) { … } void SourceManager::overrideFileContents(const FileEntry *SourceFile, FileEntryRef NewFile) { … } OptionalFileEntryRef SourceManager::bypassFileContentsOverride(FileEntryRef File) { … } void SourceManager::setFileIsTransient(FileEntryRef File) { … } std::optional<StringRef> SourceManager::getNonBuiltinFilenameForID(FileID FID) const { … } StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const { … } std::optional<StringRef> SourceManager::getBufferDataIfLoaded(FileID FID) const { … } std::optional<StringRef> SourceManager::getBufferDataOrNone(FileID FID) const { … } //===----------------------------------------------------------------------===// // SourceLocation manipulation methods. //===----------------------------------------------------------------------===// /// Return the FileID for a SourceLocation. /// /// This is the cache-miss path of getFileID. Not as hot as that function, but /// still very important. It is responsible for finding the entry in the /// SLocEntry tables that contains the specified location. FileID SourceManager::getFileIDSlow(SourceLocation::UIntTy SLocOffset) const { … } /// Return the FileID for a SourceLocation with a low offset. /// /// This function knows that the SourceLocation is in a local buffer, not a /// loaded one. FileID SourceManager::getFileIDLocal(SourceLocation::UIntTy SLocOffset) const { … } /// Return the FileID for a SourceLocation with a high offset. /// /// This function knows that the SourceLocation is in a loaded buffer, not a /// local one. FileID SourceManager::getFileIDLoaded(SourceLocation::UIntTy SLocOffset) const { … } SourceLocation SourceManager:: getExpansionLocSlowCase(SourceLocation Loc) const { … } SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const { … } SourceLocation SourceManager::getFileLocSlowCase(SourceLocation Loc) const { … } std::pair<FileID, unsigned> SourceManager::getDecomposedExpansionLocSlowCase( const SrcMgr::SLocEntry *E) const { … } std::pair<FileID, unsigned> SourceManager::getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E, unsigned Offset) const { … } /// getImmediateSpellingLoc - Given a SourceLocation object, return the /// spelling location referenced by the ID. This is the first level down /// towards the place where the characters that make up the lexed token can be /// found. This should not generally be used by clients. SourceLocation SourceManager::getImmediateSpellingLoc(SourceLocation Loc) const{ … } /// Return the filename of the file containing a SourceLocation. StringRef SourceManager::getFilename(SourceLocation SpellingLoc) const { … } /// getImmediateExpansionRange - Loc is required to be an expansion location. /// Return the start/end of the expansion information. CharSourceRange SourceManager::getImmediateExpansionRange(SourceLocation Loc) const { … } SourceLocation SourceManager::getTopMacroCallerLoc(SourceLocation Loc) const { … } /// getExpansionRange - Given a SourceLocation object, return the range of /// tokens covered by the expansion in the ultimate file. CharSourceRange SourceManager::getExpansionRange(SourceLocation Loc) const { … } bool SourceManager::isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc) const { … } bool SourceManager::isMacroBodyExpansion(SourceLocation Loc) const { … } bool SourceManager::isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin) const { … } bool SourceManager::isAtEndOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroEnd) const { … } //===----------------------------------------------------------------------===// // Queries about the code at a SourceLocation. //===----------------------------------------------------------------------===// /// getCharacterData - Return a pointer to the start of the specified location /// in the appropriate MemoryBuffer. const char *SourceManager::getCharacterData(SourceLocation SL, bool *Invalid) 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 { … } // isInvalid - Return the result of calling loc.isInvalid(), and // if Invalid is not null, set its value to same. template<typename LocType> static bool isInvalid(LocType Loc, bool *Invalid) { … } unsigned SourceManager::getSpellingColumnNumber(SourceLocation Loc, bool *Invalid) const { … } unsigned SourceManager::getExpansionColumnNumber(SourceLocation Loc, bool *Invalid) const { … } unsigned SourceManager::getPresumedColumnNumber(SourceLocation Loc, bool *Invalid) const { … } // Check if mutli-byte word x has bytes between m and n, included. This may also // catch bytes equal to n + 1. // The returned value holds a 0x80 at each byte position that holds a match. // see http://graphics.stanford.edu/~seander/bithacks.html#HasBetweenInWord template <class T> static constexpr inline T likelyhasbetween(T x, unsigned char m, unsigned char n) { … } LineOffsetMapping LineOffsetMapping::get(llvm::MemoryBufferRef Buffer, llvm::BumpPtrAllocator &Alloc) { … } LineOffsetMapping::LineOffsetMapping(ArrayRef<unsigned> LineOffsets, llvm::BumpPtrAllocator &Alloc) : … { … } /// getLineNumber - Given a SourceLocation, return the spelling line number /// for the position indicated. This requires building and caching a table of /// line offsets for the MemoryBuffer, so this is not cheap: use only when /// about to emit a diagnostic. unsigned SourceManager::getLineNumber(FileID FID, unsigned FilePos, bool *Invalid) const { … } unsigned SourceManager::getSpellingLineNumber(SourceLocation Loc, bool *Invalid) const { … } unsigned SourceManager::getExpansionLineNumber(SourceLocation Loc, bool *Invalid) const { … } unsigned SourceManager::getPresumedLineNumber(SourceLocation Loc, bool *Invalid) const { … } /// getFileCharacteristic - return the file characteristic of the specified /// source location, indicating whether this is a normal file, a system /// header, or an "implicit extern C" system header. /// /// This state can be modified with flags on GNU linemarker directives like: /// # 4 "foo.h" 3 /// which changes all source locations in the current file after that to be /// considered to be from a system header. SrcMgr::CharacteristicKind SourceManager::getFileCharacteristic(SourceLocation Loc) const { … } /// Return the filename or buffer identifier of the buffer the location is in. /// Note that this name does not respect \#line directives. Use getPresumedLoc /// for normal clients. StringRef SourceManager::getBufferName(SourceLocation Loc, bool *Invalid) const { … } /// 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 { … } /// Returns whether the PresumedLoc for a given SourceLocation is /// in the main file. /// /// This computes the "presumed" location for a SourceLocation, then checks /// whether it came from a file other than the main file. This is different /// from isWrittenInMainFile() because it takes line marker directives into /// account. bool SourceManager::isInMainFile(SourceLocation Loc) const { … } /// The size of the SLocEntry that \p FID represents. unsigned SourceManager::getFileIDSize(FileID FID) const { … } //===----------------------------------------------------------------------===// // Other miscellaneous methods. //===----------------------------------------------------------------------===// /// 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 { … } /// 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 { … } /// Get the source location in \arg FID for the given line:col. /// Returns null location if \arg FID is not a file SLocEntry. SourceLocation SourceManager::translateLineCol(FileID FID, unsigned Line, unsigned Col) const { … } /// 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() void SourceManager::computeMacroArgsCache(MacroArgsMap &MacroArgsCache, FileID FID) const { … } void SourceManager::associateFileChunkWithMacroArgExp( MacroArgsMap &MacroArgsCache, FileID FID, SourceLocation SpellLoc, SourceLocation ExpansionLoc, unsigned ExpansionLength) const { … } void SourceManager::updateSlocUsageStats() const { … } /// If \arg Loc points inside a function macro argument, the returned /// location will be the macro location in which the argument was expanded. /// If a macro argument is used multiple times, the expanded location will /// be at the first expansion of the argument. /// e.g. /// MY_MACRO(foo); /// ^ /// Passing a file location pointing at 'foo', will yield a macro location /// where 'foo' was expanded into. SourceLocation SourceManager::getMacroArgExpandedLocation(SourceLocation Loc) const { … } std::pair<FileID, unsigned> SourceManager::getDecomposedIncludedLoc(FileID FID) const { … } FileID SourceManager::getUniqueLoadedASTFileID(SourceLocation Loc) const { … } bool SourceManager::isInTheSameTranslationUnitImpl( const std::pair<FileID, unsigned> &LOffs, const std::pair<FileID, unsigned> &ROffs) const { … } /// Given a decomposed source location, move it up the include/expansion stack /// to the parent source location within the same translation unit. If this is /// possible, return the decomposed version of the parent in Loc and return /// false. If Loc is a top-level entry, return true and don't modify it. static bool MoveUpTranslationUnitIncludeHierarchy(std::pair<FileID, unsigned> &Loc, const SourceManager &SM) { … } /// Return the cache entry for comparing the given file IDs /// for isBeforeInTranslationUnit. InBeforeInTUCacheEntry &SourceManager::getInBeforeInTUCache(FileID LFID, FileID RFID) const { … } /// Determines the order of 2 source locations in the translation unit. /// /// \returns true if LHS source location comes before RHS, false otherwise. bool SourceManager::isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const { … } std::pair<bool, bool> SourceManager::isInTheSameTranslationUnit( std::pair<FileID, unsigned> &LOffs, std::pair<FileID, unsigned> &ROffs) const { … } void SourceManager::PrintStats() const { … } LLVM_DUMP_METHOD void SourceManager::dump() const { … } void SourceManager::noteSLocAddressSpaceUsage( DiagnosticsEngine &Diag, std::optional<unsigned> MaxNotes) const { … } ExternalSLocEntrySource::~ExternalSLocEntrySource() = default; /// Return the amount of memory used by memory buffers, breaking down /// by heap-backed versus mmap'ed memory. SourceManager::MemoryBufferSizes SourceManager::getMemoryBufferSizes() const { … } size_t SourceManager::getDataStructureSizes() const { … } SourceManagerForFile::SourceManagerForFile(StringRef FileName, StringRef Content) { … }
Codebase Browser
llvm