Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SourceManager_8cpp_source.html below:

clang: lib/Basic/SourceManager.cpp Source File

;

SrcMgr;

llvm::MemoryBuffer;

(MaxUsedSLocBytes,

);

Buffer ? Buffer->getBufferSize() : 0;

(Buffer ==

) {

assert(0 &&

);

llvm::MemoryBuffer::MemoryBuffer_Malloc;

Buffer->getBufferKind();

Buffer ? (

)Buffer->getBufferSize()

*InvalidBOM =

llvm::StringSwitch<const char *>(BufStr)

.StartsWith(llvm::StringLiteral::withInnerNUL(

),

.StartsWith(llvm::StringLiteral::withInnerNUL(

),

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

.StartsWith(

,

)

std::optional<llvm::MemoryBufferRef>

Buffer->getMemBufferRef();

(!BufferOrError) {

.Report(

, diag::err_cannot_open_file)

Buffer = std::move(*BufferOrError);

(Buffer->getBufferSize() >= std::numeric_limits<unsigned>::max()) {

StringRef BufStr = Buffer->getBuffer();

.Report(

, diag::err_unsupported_bom)

Buffer->getMemBufferRef();

IterBool = FilenameIDs.try_emplace(Name, FilenamesByID.size());

FilenamesByID.push_back(&*IterBool.first);

IterBool.first->second;

FilenameID,

EntryExit,

std::vector<LineEntry> &Entries = LineEntries[FID];

assert((Entries.empty() || Entries.back().FileOffset < Offset) &&

);

IncludeOffset = 0;

(EntryExit == 1) {

IncludeOffset = Offset-1;

*PrevEntry = Entries.empty() ? nullptr : &Entries.back();

(EntryExit == 2) {

assert(PrevEntry && PrevEntry->IncludeOffset &&

PrevEntry = FindNearestLineEntry(FID, PrevEntry->IncludeOffset);

IncludeOffset = PrevEntry->IncludeOffset;

(FilenameID == -1) {

FilenameID = PrevEntry->FilenameID;

Entries.push_back(

(Offset, LineNo, FilenameID, FileKind,

std::vector<LineEntry> &Entries = LineEntries[FID];

assert(!Entries.empty() &&

);

(Entries.back().FileOffset <= Offset)

&Entries.back();

std::vector<LineEntry>::const_iterator I = llvm::upper_bound(Entries, Offset);

(I == Entries.begin())

std::vector<LineEntry> &Entries) {

LineEntries[FID] = Entries;

getLineTable().getLineTableFilenameID(Name);

FilenameID,

IsFileEntry,

std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(

);

(void) getLineTable();

EntryExit = 0;

LineTable->AddLineNote(LocInfo.first, LocInfo.second, LineNo, FilenameID,

EntryExit, FileKind);

UserFilesAreVolatile)

:

(

), FileMgr(FileMgr), UserFilesAreVolatile(UserFilesAreVolatile) {

(

i = 0, e = MemBufferInfos.size(); i != e; ++i) {

(MemBufferInfos[i]) {

MemBufferInfos[i]->~ContentCache();

ContentCacheAlloc.Deallocate(MemBufferInfos[i]);

(

I = FileInfos.begin(),

= FileInfos.end(); I !=

; ++I) {

I->second->~ContentCache();

ContentCacheAlloc.Deallocate(I->second);

LocalSLocEntryTable.clear();

LoadedSLocEntryTable.clear();

SLocEntryLoaded.clear();

SLocEntryOffsetLoaded.clear();

LastLineNoFileIDQuery =

();

LastLineNoContentCache =

;

LastFileIDLookup =

();

IncludedLocMap.clear();

CurrentLoadedOffset = MaxLoadedOffset;

assert(MainFileID.

() &&

);

FE->getUID() == SourceFile.

();

assert(MainFileID.

() &&

);

Clone->ContentsEntry =

->ContentsEntry;

Clone->BufferOverridden =

->BufferOverridden;

Clone->IsFileVolatile =

->IsFileVolatile;

Clone->IsTransient =

->IsTransient;

Clone->setUnownedBuffer(

->getBufferIfLoaded());

(

I = 0, N = Old.LoadedSLocEntryTable.size(); I != N; ++I)

(!Old.SLocEntryLoaded[I])

Old.loadSLocEntry(I,

);

(

&

: Old.FileInfos) {

Slot = CloneContentCache(

.second);

(OverriddenFilesInfo) {

overI = OverriddenFilesInfo->OverriddenFiles.find(FileEnt);

(overI == OverriddenFilesInfo->OverriddenFiles.end())

(Entry)

(OverridenFilesKeepOriginalName ? FileEnt

&SourceManager::createMemBufferContentCache(

std::unique_ptr<llvm::MemoryBuffer> Buffer) {

MemBufferInfos.push_back(Entry);

assert(!SLocEntryLoaded[Index]);

(ExternalSLocEntries->

(-(

(Index) + 2))) {

(!SLocEntryLoaded[Index]) {

(!FakeSLocEntryForRecovery)

FakeSLocEntryForRecovery = std::make_unique<SLocEntry>(

(

*FakeSLocEntryForRecovery;

LoadedSLocEntryTable[Index];

std::pair<int, SourceLocation::UIntTy>

assert(ExternalSLocEntries &&

);

(CurrentLoadedOffset < TotalSize ||

CurrentLoadedOffset - TotalSize < NextLocalOffset) {

std::make_pair(0, 0);

LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);

SLocEntryLoaded.resize(LoadedSLocEntryTable.size());

SLocEntryOffsetLoaded.resize(LoadedSLocEntryTable.size());

CurrentLoadedOffset -= TotalSize;

updateSlocUsageStats();

BaseID = -

(LoadedSLocEntryTable.size()) - 1;

LoadedSLocEntryAllocBegin.push_back(FileID::get(BaseID));

std::make_pair(BaseID, CurrentLoadedOffset);

llvm::MemoryBufferRef SourceManager::getFakeBufferForRecovery()

{

(!FakeBufferForRecovery)

FakeBufferForRecovery =

llvm::MemoryBuffer::getMemBuffer(

);

*FakeBufferForRecovery;

(!FakeContentCacheForRecovery) {

FakeContentCacheForRecovery = std::make_unique<SrcMgr::ContentCache>();

FakeContentCacheForRecovery->setUnownedBuffer(getFakeBufferForRecovery());

*FakeContentCacheForRecovery;

SourceManager::getPreviousFileID(

FID)

{

}

(

(-(ID-1) - 2) >= LoadedSLocEntryTable.size()) {

FileID::get(ID-1);

}

(ID+1 >= -1) {

FileID::get(ID+1);

createFileIDImpl(IR, SourceFile.

(), IncludePos, FileCharacter,

LoadedID, LoadedOffset);

StringRef Name = Buffer->getBufferIdentifier();

createFileIDImpl(createMemBufferContentCache(std::move(Buffer)), Name,

IncludeLoc, FileCharacter, LoadedID, LoadedOffset);

(llvm::MemoryBuffer::getMemBuffer(Buffer), FileCharacter,

LoadedID, LoadedOffset, IncludeLoc);

llvm::ErrorOr<bool> NeedConversion =

llvm::needzOSConversion(

.str().c_str());

NeedConversion && *NeedConversion;

assert(LoadedID != -1 &&

);

Index =

(-LoadedID) - 2;

assert(Index < LoadedSLocEntryTable.size() &&

);

assert(!SLocEntryLoaded[Index] &&

);

SLocEntryLoaded[Index] = SLocEntryOffsetLoaded[Index] =

;

FileID::get(LoadedID);

FileSize =

.getSize();

(NeedConversion) {

(std::optional<llvm::MemoryBufferRef> Buffer =

BufSize = Buffer->getBufferSize();

(BufSize > FileSize) {

(

.ContentsEntry.has_value())

.ContentsEntry->updateFileEntryBufferSize(BufSize);

(!(NextLocalOffset + FileSize + 1 > NextLocalOffset &&

NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset)) {

Diag.

(IncludePos, diag::err_sloc_space_too_large);

LocalSLocEntryTable.push_back(

NextLocalOffset += FileSize + 1;

updateSlocUsageStats();

FID = FileID::get(LocalSLocEntryTable.size()-1);

LastFileIDLookup = FID;

createExpansionLocImpl(Info, Length);

ExpansionIsTokenRange,

LoadedID,

SpellingLoc, ExpansionLocStart, ExpansionLocEnd, ExpansionIsTokenRange);

createExpansionLocImpl(Info, Length, LoadedID, LoadedOffset);

);

createExpansionLocImpl(

TokenEnd.getOffset() - TokenStart.getOffset());

SourceManager::createExpansionLocImpl(

&Info,

Length,

LoadedID,

assert(LoadedID != -1 &&

);

Index =

(-LoadedID) - 2;

assert(Index < LoadedSLocEntryTable.size() &&

);

assert(!SLocEntryLoaded[Index] &&

);

LoadedSLocEntryTable[Index] =

(LoadedOffset, Info);

SLocEntryLoaded[Index] = SLocEntryOffsetLoaded[Index] =

;

SourceLocation::getMacroLoc(LoadedOffset);

LocalSLocEntryTable.push_back(

(NextLocalOffset, Info));

(NextLocalOffset + Length + 1 <= NextLocalOffset ||

NextLocalOffset + Length + 1 > CurrentLoadedOffset) {

Diag.

(diag::err_sloc_space_too_large);

llvm::report_fatal_error(

);

NextLocalOffset += Length + 1;

updateSlocUsageStats();

SourceLocation::getMacroLoc(NextLocalOffset - (Length + 1));

std::optional<llvm::MemoryBufferRef>

SourceFile, std::unique_ptr<llvm::MemoryBuffer> Buffer) {

getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);

);

assert(FileInfos.find_as(SourceFile) == FileInfos.end() &&

);

Pair = getOverriddenFilesInfo().OverriddenFiles.insert(

std::make_pair(SourceFile, NewFile));

Pair.first->second = NewFile;

(void)getOrCreateContentCache(*BypassFile);

std::optional<StringRef>

(Entry->getFile().getContentCache().

)

Entry->getFile().getName();

B ? *B :

;

std::optional<StringRef>

B->getBuffer();

FileID::get(0);

(SLocOffset < NextLocalOffset)

getFileIDLocal(SLocOffset);

getFileIDLoaded(SLocOffset);

assert(SLocOffset < NextLocalOffset &&

);

LessIndex = 0;

GreaterIndex = LocalSLocEntryTable.size();

(LastFileIDLookup.ID >= 0) {

(LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset)

LessIndex = LastFileIDLookup.ID;

GreaterIndex = LastFileIDLookup.ID;

NumProbes = 0;

assert(GreaterIndex < LocalSLocEntryTable.size());

(LocalSLocEntryTable[GreaterIndex].getOffset() <= SLocOffset) {

Res = FileID::get(

(GreaterIndex));

LastFileIDLookup = Res;

NumLinearScans += NumProbes+1;

(++NumProbes == 8)

MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;

(MidOffset > SLocOffset) {

GreaterIndex = MiddleIndex;

(MiddleIndex + 1 == LocalSLocEntryTable.size() ||

Res = FileID::get(MiddleIndex);

LastFileIDLookup = Res;

NumBinaryProbes += NumProbes;

LessIndex = MiddleIndex;

(SLocOffset < CurrentLoadedOffset) {

assert(0 &&

);

FileID::get(ExternalSLocEntries->

(SLocOffset));

std::pair<FileID, unsigned>

SourceManager::getDecomposedExpansionLocSlowCase(

=

->getExpansion().getExpansionLocStart();

Offset =

.getOffset()-

->getOffset();

std::make_pair(FID, Offset);

std::pair<FileID, unsigned>

Offset)

{

=

->getExpansion().getSpellingLoc();

Offset =

.getOffset()-

->getOffset();

std::make_pair(FID, Offset);

assert(

.

() &&

);

(DecompLoc.second > 0)

PrevFID = getPreviousFileID(DecompLoc.first);

*MacroBegin = ExpLoc;

NextFID = getNextFileID(FID);

CharDataInvalid =

;

(CharDataInvalid || !Entry.

()) {

;

std::optional<llvm::MemoryBufferRef> Buffer =

Buffer ? Buffer->getBufferStart() + LocInfo.second

:

;

(FilePos > MemBuf->getBufferSize()) {

*Buf = MemBuf->getBufferStart();

(LastLineNoFileIDQuery == FID && LastLineNoContentCache->

&&

LastLineNoResult < LastLineNoContentCache->SourceLineCache.

()) {

*SourceLineCache =

LineStart = SourceLineCache[LastLineNoResult - 1];

LineEnd = SourceLineCache[LastLineNoResult];

(FilePos >= LineStart && FilePos < LineEnd) {

(FilePos + 1 == LineEnd && FilePos > LineStart) {

(Buf[FilePos - 1] ==

|| Buf[FilePos - 1] ==

)

FilePos - LineStart + 1;

LineStart = FilePos;

(LineStart && Buf[LineStart-1] !=

&& Buf[LineStart-1] !=

)

FilePos-LineStart+1;

<

LocType>

((x - ~

(0) / 255 * (n + 1)) & ~x &

((x & ~

(0) / 255 * 127) +

(~

(0) / 255 * (127 - (m - 1))))) &

~static_cast<T>(0) / 255 * 128;

llvm::BumpPtrAllocator &Alloc) {

LineOffsets.push_back(0);

*Start = (

*)Buffer.getBufferStart();

*End = (

*)Buffer.getBufferEnd();

*Buf = Start;

((

)(End - Start) >

(Word)) {

Word = llvm::support::endian::read64(Buf, llvm::endianness::little);

Buf +=

(Word);

N = llvm::countr_zero(Mask) - 7;

Byte = Word;

(*Buf ==

) {

LineOffsets.push_back(Buf - Start);

}

(Buf < End -

(Word) - 1);

(*Buf ==

) {

LineOffsets.push_back(Buf - Start + 1);

}

(*Buf ==

) {

(Buf + 1 < End && Buf[1] ==

) {

LineOffsets.push_back(Buf - Start + 1);

llvm::BumpPtrAllocator &Alloc)

: Storage(Alloc.Allocate<

>(LineOffsets.size() + 1)) {

Storage[0] = LineOffsets.size();

std::copy(LineOffsets.begin(), LineOffsets.end(), Storage + 1);

(LastLineNoFileIDQuery == FID)

Content = LastLineNoContentCache;

MyInvalid =

;

&Entry = getSLocEntry(FID, &MyInvalid);

(MyInvalid || !Entry.

()) {

std::optional<llvm::MemoryBufferRef> Buffer =

*SourceLineCacheStart = SourceLineCache;

QueriedFilePos = FilePos+1;

(LastLineNoFileIDQuery == FID) {

(QueriedFilePos >= LastLineNoFilePos) {

SourceLineCache = SourceLineCache+LastLineNoResult-1;

(SourceLineCache+5 < SourceLineCacheEnd) {

(SourceLineCache[5] > QueriedFilePos)

SourceLineCacheEnd = SourceLineCache+5;

(SourceLineCache+10 < SourceLineCacheEnd) {

(SourceLineCache[10] > QueriedFilePos)

SourceLineCacheEnd = SourceLineCache+10;

(SourceLineCache+20 < SourceLineCacheEnd) {

(SourceLineCache[20] > QueriedFilePos)

SourceLineCacheEnd = SourceLineCache+20;

(LastLineNoResult < Content->SourceLineCache.size())

SourceLineCacheEnd = SourceLineCache+LastLineNoResult+1;

*Pos =

std::lower_bound(SourceLineCache, SourceLineCacheEnd, QueriedFilePos);

LineNo = Pos-SourceLineCacheStart;

LastLineNoFileIDQuery = FID;

LastLineNoContentCache = Content;

LastLineNoFilePos = QueriedFilePos;

LastLineNoResult = LineNo;

std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(

);

getLineNumber(LocInfo.first, LocInfo.second);

std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(

);

getLineNumber(LocInfo.first, LocInfo.second);

assert(

.

() &&

);

std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(

);

*SEntry = getSLocEntryForFile(LocInfo.first);

assert(LineTable &&

);

LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second);

B = getBufferOrNone(getFileID(

));

B ? B->getBufferIdentifier() :

;

UseLineDirectives)

{

std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(

);

FID = LocInfo.first;

(

Buffer =

->getBufferOrNone(

, getFileManager()))

= Buffer->getBufferIdentifier();

LineNo = getLineNumber(LocInfo.first, LocInfo.second, &

);

ColNo = getColumnNumber(LocInfo.first, LocInfo.second, &

);

assert(LineTable &&

);

LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second)) {

(Entry->FilenameID != -1) {

= LineTable->getFilename(Entry->FilenameID);

FID = FileID::get(0);

MarkerLineNo = getLineNumber(LocInfo.first, Entry->FileOffset);

LineNo = Entry->LineNo + (LineNo-MarkerLineNo-1);

(Entry->IncludeOffset) {

IncludeLoc = getLocForStartOfFile(LocInfo.first);

std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(

);

*Entry = getSLocEntryForFile(LocInfo.first);

LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second))

(Entry->IncludeOffset)

((ID > 0 &&

(ID+1) == local_sloc_entry_size()))

NextOffset = getNextLocalOffset();

(ID+1 == -1)

NextOffset = MaxLoadedOffset;

NextOffset = getSLocEntry(FileID::get(ID+1)).getOffset();

NextOffset - Entry.

() - 1;

Col)

{

assert(SourceFile &&

);

assert(

&& Col &&

);

FirstFID = translateFile(SourceFile);

translateLineCol(FirstFID,

, Col);

assert(SourceFile &&

);

(MainFileID.isValid()) {

(MainSLoc.

()) {

(

I = 0, N = local_sloc_entry_size(); I != N; ++I) {

&SLoc = getLocalSLocEntry(I);

FileID::get(I);

(

I = 0, N = loaded_sloc_entry_size(); I != N; ++I) {

&SLoc = getLoadedSLocEntry(I);

FileID::get(-

(I) - 2);

Col)

{

assert(

&& Col &&

);

(

== 1 && Col == 1)

std::optional<llvm::MemoryBufferRef> Buffer =

Size = Buffer->getBufferSize();

*Buf = Buffer->getBufferStart() + FilePos;

BufLength = Buffer->getBufferSize() - FilePos;

(i < BufLength-1 && i < Col-1 && Buf[i] !=

&& Buf[i] !=

)

SourceManager::computeMacroArgsCache(MacroArgsMap &MacroArgsCache,

(

(ID) >= local_sloc_entry_size())

}

(ID == -1) {

IncludedInFID =

(IncludeLoc.

() && isInFileID(IncludeLoc, FID)) ||

(FID == MainFileID && Entry.

().

() ==

);

(IncludedInFID) {

(Entry.

().NumCreatedFIDs)

ID += Entry.

().NumCreatedFIDs - 1

;

associateFileChunkWithMacroArgExp(MacroArgsCache, FID,

SourceLocation::getMacroLoc(Entry.

()),

getFileIDSize(FileID::get(ID)));

SourceManager::associateFileChunkWithMacroArgExp(

MacroArgsMap &MacroArgsCache,

ExpansionLength)

{

SpellRelativeOffs;

std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);

&Entry = getSLocEntry(SpellFID);

SpellFIDSize = getFileIDSize(SpellFID);

CurrSpellLength;

(SpellFIDEndOffs < SpellEndOffs)

CurrSpellLength = SpellFIDSize - SpellRelativeOffs;

CurrSpellLength = ExpansionLength;

associateFileChunkWithMacroArgExp(MacroArgsCache, FID,

ExpansionLoc, CurrSpellLength);

(SpellFIDEndOffs >= SpellEndOffs)

= SpellFIDSize - SpellRelativeOffs + 1;

SpellRelativeOffs = 0;

(!isInFileID(SpellLoc, FID, &BeginOffs))

EndOffs = BeginOffs + ExpansionLength;

MacroArgsMap::iterator I = MacroArgsCache.upper_bound(EndOffs);

MacroArgsCache[BeginOffs] = ExpansionLoc;

MacroArgsCache[EndOffs] = EndOffsMappedLoc;

SourceManager::updateSlocUsageStats()

{

NextLocalOffset + (MaxLoadedOffset - CurrentLoadedOffset);

MaxUsedSLocBytes.updateMax(UsedBytes);

std::tie(FID, Offset) = getDecomposedLoc(

);

std::unique_ptr<MacroArgsMap> &MacroArgsCache = MacroArgsCacheMap[FID];

(!MacroArgsCache) {

MacroArgsCache = std::make_unique<MacroArgsMap>();

computeMacroArgsCache(*MacroArgsCache, FID);

assert(!MacroArgsCache->empty());

MacroArgsMap::iterator I = MacroArgsCache->upper_bound(Offset);

(I == MacroArgsCache->begin())

(MacroArgExpandedLoc.

())

std::pair<FileID, unsigned>

std::make_pair(

(), 0);

DecompTy = std::pair<FileID, unsigned>;

InsertOp = IncludedLocMap.try_emplace(FID);

DecompTy &DecompLoc = InsertOp.first->second;

(!InsertOp.second)

DecompLoc = getDecomposedLoc(UpperLoc);

assert(isLoadedSourceLocation(

) &&

);

[FID, Ignore] = getDecomposedLoc(

);

llvm::lower_bound(LoadedSLocEntryAllocBegin, FID, std::greater<FileID>{});

);

std::pair<FileID, unsigned> &LOffs,

std::pair<FileID, unsigned> &ROffs)

{

(isLoadedFileID(LOffs.first) != isLoadedFileID(ROffs.first))

(isLoadedFileID(LOffs.first) && isLoadedFileID(ROffs.first)) {

FindSLocEntryAlloc = [

](

FID) {

llvm::lower_bound(LoadedSLocEntryAllocBegin, FID,

std::greater<FileID>{});

(FindSLocEntryAlloc(LOffs.first) != FindSLocEntryAlloc(ROffs.first))

std::pair<FileID, unsigned> UpperLoc =

.getDecomposedIncludedLoc(

.first);

(UpperLoc.first.isInvalid() ||

!

.isInTheSameTranslationUnitImpl(UpperLoc,

))

{ MagicCacheSize = 300 };

IsBeforeInTUCacheKey Key(LFID, RFID);

(IBTUCache.size() < MagicCacheSize)

IBTUCache.try_emplace(Key, LFID, RFID).first->second;

InBeforeInTUCache::iterator I = IBTUCache.find(Key);

(I != IBTUCache.end())

IBTUCacheOverflow.setQueryFIDs(LFID, RFID);

IBTUCacheOverflow;

assert(LHS.

() && RHS.

() &&

);

std::pair<FileID, unsigned> LOffs = getDecomposedLoc(LHS);

std::pair<FileID, unsigned> ROffs = getDecomposedLoc(RHS);

(LOffs.first.isInvalid() || ROffs.first.isInvalid())

LOffs.first.isInvalid() && !ROffs.first.isInvalid();

std::pair<bool, bool> InSameTU = isInTheSameTranslationUnit(LOffs, ROffs);

InSameTU.second;

LOffs.first < ROffs.first;

std::pair<FileID, unsigned> &LOffs,

std::pair<FileID, unsigned> &ROffs)

{

(!isInTheSameTranslationUnitImpl(LOffs, ROffs))

std::make_pair(

,

);

(LOffs.first == ROffs.first)

std::make_pair(

, LOffs.second < ROffs.second);

getInBeforeInTUCache(LOffs.first, ROffs.first);

std::make_pair(

, IsBeforeInTUCache.

(LOffs.second, ROffs.second));

std::pair<FileID, unsigned> DecomposedLoc;

llvm::SmallDenseMap<FileID, Entry, 16> LChain;

LChain.try_emplace(LOffs.first, Entry{LOffs, LChild});

(LOffs.first == ROffs.first)

LChild = LOffs.first;

LIt = LChain.find(ROffs.first);

(LIt != LChain.end()) {

LOffs = LIt->second.DecomposedLoc;

LChild = LIt->second.ChildFID;

LChildID = LChild.ID;

RChildID = RChild.ID;

assert(((LOffs.second != ROffs.second) ||

(LChildID == 0 || RChildID == 0) ||

isInSameSLocAddrSpace(getComposedLoc(LChild, 0),

getComposedLoc(RChild, 0),

)) &&

);

IsBeforeInTUCache.

(LOffs.first, LOffs.second, ROffs.second,

LChildID < RChildID);

std::make_pair(

, IsBeforeInTUCache.

(LOffs.second, ROffs.second));

RChild = ROffs.first;

StringRef LB = getBufferOrFake(LOffs.first).getBufferIdentifier();

StringRef RB = getBufferOrFake(ROffs.first).getBufferIdentifier();

LIsBuiltins = LB ==

;

RIsBuiltins = RB ==

;

(LIsBuiltins || RIsBuiltins) {

(LIsBuiltins != RIsBuiltins)

std::make_pair(

, LIsBuiltins);

std::make_pair(

, LOffs.first < ROffs.first);

LIsAsm = LB ==

;

RIsAsm = RB ==

;

(LIsAsm || RIsAsm) {

(LIsAsm != RIsAsm)

std::make_pair(

, RIsAsm);

assert(LOffs.first == ROffs.first);

std::make_pair(

,

);

LIsScratch = LB ==

;

RIsScratch = RB ==

;

(LIsScratch || RIsScratch) {

(LIsScratch != RIsScratch)

std::make_pair(

, LIsScratch);

std::make_pair(

, LOffs.second < ROffs.second);

llvm_unreachable(

);

llvm::errs() <<

;

llvm::errs() << FileInfos.size() <<

<< MemBufferInfos.size()

<<

;

llvm::errs() << LocalSLocEntryTable.size() <<

<< llvm::capacity_in_bytes(LocalSLocEntryTable)

<<

<< NextLocalOffset

<<

;

llvm::errs() << LoadedSLocEntryTable.size()

<<

<< llvm::capacity_in_bytes(LoadedSLocEntryTable)

<<

<< MaxLoadedOffset - CurrentLoadedOffset

<<

;

NumLineNumsComputed = 0;

NumFileBytesMapped = 0;

NumLineNumsComputed +=

(I->second->SourceLineCache);

NumFileBytesMapped += I->second->getSizeBytesMapped();

NumMacroArgsComputed = MacroArgsCacheMap.size();

llvm::errs() << NumFileBytesMapped <<

<< NumLineNumsComputed <<

<< NumMacroArgsComputed <<

;

llvm::errs() <<

<< NumLinearScans <<

<< NumBinaryProbes <<

;

llvm::raw_ostream &out = llvm::errs();

std::optional<SourceLocation::UIntTy> NextStart) {

out <<

<< ID <<

<< (Entry.isFile() ?

:

)

<<

<< Entry.getOffset() <<

;

out << *NextStart <<

;

(Entry.isFile()) {

&FI = Entry.getFile();

(FI.NumCreatedFIDs)

out <<

<< ID <<

<<

(ID + FI.NumCreatedFIDs)

(FI.getIncludeLoc().isValid())

out <<

<< FI.getIncludeLoc().getOffset() <<

;

&CC = FI.getContentCache();

out <<

<< (CC.OrigEntry ? CC.OrigEntry->getName() :

)

(CC.BufferOverridden)

out <<

;

(CC.ContentsEntry != CC.OrigEntry) {

out <<

<< (CC.ContentsEntry ? CC.ContentsEntry->getName() :

)

&EI = Entry.getExpansion();

out <<

<< EI.getSpellingLoc().getOffset() <<

;

out <<

<< (EI.isMacroArgExpansion() ?

:

)

<<

<< EI.getExpansionLocStart().getOffset() <<

<< EI.getExpansionLocEnd().getOffset() <<

;

(

ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs; ++ID) {

DumpSLocEntry(ID, LocalSLocEntryTable[ID],

ID == NumIDs - 1 ? NextLocalOffset

: LocalSLocEntryTable[ID + 1].getOffset());

std::optional<SourceLocation::UIntTy> NextStart;

(

Index = 0; Index != LoadedSLocEntryTable.size(); ++Index) {

ID = -(

)Index - 2;

(SLocEntryLoaded[Index]) {

DumpSLocEntry(ID, LoadedSLocEntryTable[Index], NextStart);

NextStart = LoadedSLocEntryTable[Index].getOffset();

NextStart = std::nullopt;

Inclusions = 0;

uint64_t DirectSize = 0;

uint64_t TotalSize = 0;

UsageMap = llvm::MapVector<const FileEntry*, Info>;

uint64_t CountedSize = 0;

AddUsageForFileID = [&](

ID) {

Size = getFileIDSize(ID) + 1;

FileLocID = getFileID(FileStart);

*Entry = getFileEntryForID(FileLocID);

Info &EntryInfo = Usage[Entry];

(EntryInfo.Loc.isInvalid())

EntryInfo.Loc = FileStart;

(ID == FileLocID) {

++EntryInfo.Inclusions;

EntryInfo.DirectSize += Size;

EntryInfo.TotalSize += Size;

CountedSize += Size;

(

Index = 0; Index != LoadedSLocEntryTable.size(); ++Index) {

AddUsageForFileID(FileID::get(-2 - Index));

(

Index = 0; Index != LocalSLocEntryTable.size(); ++Index) {

AddUsageForFileID(FileID::get(Index));

SortedUsage = Usage.takeVector();

Cmp = [](

UsageMap::value_type &A,

UsageMap::value_type &B) {

A.second.TotalSize > B.second.TotalSize ||

(A.second.TotalSize == B.second.TotalSize &&

A.second.Loc < B.second.Loc);

SortedEnd = SortedUsage.end();

(MaxNotes && SortedUsage.size() > *MaxNotes) {

SortedEnd = SortedUsage.begin() + *MaxNotes;

std::nth_element(SortedUsage.begin(), SortedEnd, SortedUsage.end(), Cmp);

std::sort(SortedUsage.begin(), SortedEnd, Cmp);

uint64_t LocalUsage = NextLocalOffset;

uint64_t LoadedUsage = MaxLoadedOffset - CurrentLoadedOffset;

UsagePercent =

(100.0 *

(LocalUsage + LoadedUsage) /

.Report(diag::note_total_sloc_usage)

<< LocalUsage << LoadedUsage << (LocalUsage + LoadedUsage)

uint64_t ReportedSize = 0;

llvm::make_range(SortedUsage.begin(), SortedEnd)) {

.Report(

.Loc, diag::note_file_sloc_usage)

ReportedSize +=

.TotalSize;

(ReportedSize != CountedSize) {

.Report(diag::note_file_misc_sloc_usage)

<< (SortedUsage.end() - SortedEnd) << CountedSize - ReportedSize;

malloc_bytes = 0;

mmap_bytes = 0;

(

i = 0, e = MemBufferInfos.size(); i != e; ++i)

(

sized_mapped = MemBufferInfos[i]->getSizeBytesMapped())

(MemBufferInfos[i]->getMemoryBufferKind()) {

llvm::MemoryBuffer::MemoryBuffer_MMap:

mmap_bytes += sized_mapped;

llvm::MemoryBuffer::MemoryBuffer_Malloc:

malloc_bytes += sized_mapped;

size = llvm::capacity_in_bytes(MemBufferInfos) +

llvm::capacity_in_bytes(LocalSLocEntryTable) +

llvm::capacity_in_bytes(LoadedSLocEntryTable) +

llvm::capacity_in_bytes(SLocEntryLoaded) +

llvm::capacity_in_bytes(FileInfos);

(OverriddenFilesInfo)

size += llvm::capacity_in_bytes(OverriddenFilesInfo->OverriddenFiles);

StringRef Content) {

llvm::vfs::InMemoryFileSystem);

InMemoryFileSystem->addFile(

llvm::MemoryBuffer::getMemBuffer(Content,

,

Diagnostics = std::make_unique<DiagnosticsEngine>(

SourceMgr = std::make_unique<SourceManager>(*Diagnostics, *FileMgr);

assert(ID.isValid());

SourceMgr->setMainFileID(ID);

Defines the Diagnostic-related interfaces.

Defines the clang::FileManager interface and associated types.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

static ParseState advance(ParseState S, size_t N)

Defines the clang::SourceLocation class and associated facilities.

Defines implementation details of the clang::SourceManager class.

static constexpr T likelyhasbetween(T x, unsigned char m, unsigned char n)

static bool MoveUpTranslationUnitIncludeHierarchy(std::pair< FileID, unsigned > &Loc, const SourceManager &SM)

Given a decomposed source location, move it up the include/expansion stack to the parent source locat...

static bool isInvalid(LocType Loc, bool *Invalid)

STATISTIC(MaxUsedSLocBytes, "Maximum number of bytes used by source locations " "(both loaded and local).")

bool needConversion(StringRef Filename)

Helper function to determine if an input file requires conversion.

Defines the SourceManager interface.

Represents a character-granular source range.

void setEnd(SourceLocation e)

bool isTokenRange() const

Return true if the end of this range specifies the start of the last token.

void setBegin(SourceLocation b)

SourceLocation getEnd() const

SourceLocation getBegin() const

void setTokenRange(bool TR)

Used for handling and querying diagnostic IDs.

Options for controlling the compiler diagnostics engine.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

void setSourceManager(SourceManager *SrcMgr)

virtual int getSLocEntryID(SourceLocation::UIntTy SLocOffset)=0

Get the index ID for the loaded SourceLocation offset.

virtual ~ExternalSLocEntrySource()

virtual bool ReadSLocEntry(int ID)=0

Read the source location entry with index ID, which will always be less than -1.

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

StringRef getName() const

The name of this FileEntry.

Cached information about one file (either on disk or in the virtual file system).

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true, std::optional< int64_t > MaybeLimit=std::nullopt, bool IsText=true)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

OptionalFileEntryRef getBypassFile(FileEntryRef VFE)

Retrieve a FileEntry that bypasses VFE, which is expected to be a virtual file entry,...

Keeps track of options that affect how file operations are performed.

Holds the cache used by isBeforeInTranslationUnit.

void setCommonLoc(FileID commonFID, unsigned lCommonOffset, unsigned rCommonOffset, bool LParentBeforeRParent)

bool getCachedResult(unsigned LOffset, unsigned ROffset) const

If the cache is valid, compute the result given the specified offsets in the LHS/RHS FileID's.

bool isCacheValid() const

Return true if the currently cached values match up with the specified LHS/RHS query.

Used to hold and unique data used to represent #line information.

const LineEntry * FindNearestLineEntry(FileID FID, unsigned Offset)

Find the line entry nearest to FID that is before it.

unsigned getLineTableFilenameID(StringRef Str)

void AddEntry(FileID FID, const std::vector< LineEntry > &Entries)

Add a new line entry that has already been encoded into the internal representation of the line table...

void AddLineNote(FileID FID, unsigned Offset, unsigned LineNo, int FilenameID, unsigned EntryExit, SrcMgr::CharacteristicKind FileKind)

Add a line note to the line table that indicates that there is a #line or GNU line marker at the spec...

Represents an unpacked "presumed" location which can be presented to the user.

unsigned getColumn() const

Return the presumed column number of this location.

unsigned getLine() const

Return the presumed line number of this location.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

SourceManagerForFile(StringRef FileName, StringRef Content)

Creates SourceManager and necessary dependencies (e.g.

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

std::optional< StringRef > getNonBuiltinFilenameForID(FileID FID) const

Returns the filename for the provided FileID, unless it's a built-in buffer that's not represented by...

bool isMacroBodyExpansion(SourceLocation Loc) const

Tests whether the given source location represents the expansion of a macro body.

unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

bool isAtEndOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroEnd=nullptr) const

Returns true if the given MacroID location points at the character end of the immediate macro expansi...

unsigned getColumnNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const

Return the column # for the specified file position.

void noteSLocAddressSpaceUsage(DiagnosticsEngine &Diag, std::optional< unsigned > MaxNotes=32) const

bool isInMainFile(SourceLocation Loc) const

Returns whether the PresumedLoc for a given SourceLocation is in the main file.

void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)

Add a line note to the line table for the FileID and offset specified by Loc.

SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr, bool UserFilesAreVolatile=false)

SourceLocation createTokenSplitLoc(SourceLocation SpellingLoc, SourceLocation TokenStart, SourceLocation TokenEnd)

Return a new SourceLocation that encodes that the token starting at TokenStart ends prematurely at To...

PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const

Returns the "presumed" location of a SourceLocation specifies.

MemoryBufferSizes getMemoryBufferSizes() const

Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...

void setFileIsTransient(FileEntryRef SourceFile)

Specify that a file is transient.

bool isFileOverridden(const FileEntry *File) const

Returns true if the file contents have been overridden.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

SourceLocation translateLineCol(FileID FID, unsigned Line, unsigned Col) const

Get the source location in FID for the given line:col.

StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const

Return the filename or buffer identifier of the buffer the location is in.

SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const

std::optional< StringRef > getBufferDataOrNone(FileID FID) const

Return a StringRef to the source buffer data for the specified FileID, returning std::nullopt if inva...

unsigned getExpansionColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const

FileID translateFile(const FileEntry *SourceFile) const

Get the FileID for the given file.

StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const

Return a StringRef to the source buffer data for the specified FileID.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

void PrintStats() const

Print statistics to stderr.

FileID getUniqueLoadedASTFileID(SourceLocation Loc) const

bool isMainFile(const FileEntry &SourceFile)

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

size_t getDataStructureSizes() const

Return the amount of memory used for various side tables and data structures in the SourceManager.

bool isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc=nullptr) const

Tests whether the given source location represents a macro argument's expansion into the function-lik...

bool isInTheSameTranslationUnitImpl(const std::pair< FileID, unsigned > &LOffs, const std::pair< FileID, unsigned > &ROffs) const

Determines whether the two decomposed source location is in the same TU.

const SrcMgr::SLocEntry & getLocalSLocEntry(unsigned Index) const

Get a local SLocEntry. This is exposed for indexing.

OptionalFileEntryRef bypassFileContentsOverride(FileEntryRef File)

Bypass the overridden contents of a file.

FileManager & getFileManager() const

unsigned local_sloc_entry_size() const

Get the number of local SLocEntries we have.

std::optional< StringRef > getBufferDataIfLoaded(FileID FID) const

Return a StringRef to the source buffer data for the specified FileID, returning std::nullopt if it's...

const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const

Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.

std::pair< int, SourceLocation::UIntTy > AllocateLoadedSLocEntries(unsigned NumSLocEntries, SourceLocation::UIntTy TotalSize)

Allocate a number of loaded SLocEntries, which will be actually loaded on demand from the external so...

void overrideFileContents(FileEntryRef SourceFile, const llvm::MemoryBufferRef &Buffer)

Override the contents of the given source file by providing an already-allocated buffer.

unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const

unsigned getFileIDSize(FileID FID) const

The size of the SLocEntry that FID represents.

unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const

Given a SourceLocation, return the spelling line number for the position indicated.

std::pair< bool, bool > isInTheSameTranslationUnit(std::pair< FileID, unsigned > &LOffs, std::pair< FileID, unsigned > &ROffs) const

Determines whether the two decomposed source location is in the same translation unit.

llvm::DenseMap< FileEntryRef, SrcMgr::ContentCache * >::const_iterator fileinfo_iterator

CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const

Return the start/end of the expansion information for an expansion location.

unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const

CharSourceRange getExpansionRange(SourceLocation Loc) const

Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...

bool isInFileID(SourceLocation Loc, FileID FID, unsigned *RelativeOffset=nullptr) const

Given a specific FileID, returns true if Loc is inside that FileID chunk and sets relative offset (of...

unsigned getLineTableFilenameID(StringRef Str)

Return the uniqued ID for the specified filename.

std::pair< FileID, unsigned > getDecomposedExpansionLoc(SourceLocation Loc) const

Decompose the specified location into a raw FileID + Offset pair.

unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const

void initializeForReplay(const SourceManager &Old)

Initialize this source manager suitably to replay the compilation described by Old.

FileID getOrCreateFileID(FileEntryRef SourceFile, SrcMgr::CharacteristicKind FileCharacter)

Get the FileID for SourceFile if it exists.

SourceLocation translateFileLineCol(const FileEntry *SourceFile, unsigned Line, unsigned Col) const

Get the source location for the given file:line:col triplet.

std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const

Decompose the specified location into a raw FileID + Offset pair.

const FileEntry * getFileEntryForID(FileID FID) const

Returns the FileEntry record for the provided FileID.

std::pair< FileID, unsigned > getDecomposedSpellingLoc(SourceLocation Loc) const

Decompose the specified location into a raw FileID + Offset pair.

bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const

Returns true if the given MacroID location points at the beginning of the immediate macro expansion.

SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const

Return the file characteristic of the specified source location, indicating whether this is a normal ...

SourceLocation createExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned Length, bool ExpansionIsTokenRange=true, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Creates an expansion SLocEntry for a macro use.

unsigned getPresumedColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const

std::pair< FileID, unsigned > getDecomposedIncludedLoc(FileID FID) const

Returns the "included/expanded in" decomposed location of the given FileID.

StringRef getFilename(SourceLocation SpellingLoc) const

Return the filename of the file containing a SourceLocation.

SourceLocation getMacroArgExpandedLocation(SourceLocation Loc) const

If Loc points inside a function macro argument, the returned location will be the macro location in w...

bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const

Determines the order of 2 source locations in the translation unit.

std::optional< llvm::MemoryBufferRef > getBufferOrNone(FileID FID, SourceLocation Loc=SourceLocation()) const

Return the buffer for the specified FileID.

LineTableInfo & getLineTable()

Retrieve the stored line table.

SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const

Given a SourceLocation object, return the spelling location referenced by the ID.

std::optional< llvm::MemoryBufferRef > getMemoryBufferForFileOrNone(FileEntryRef File)

Retrieve the memory buffer associated with the given file.

const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const

SourceLocation createMacroArgExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLoc, unsigned Length)

Creates an expansion SLocEntry for the substitution of an argument into a function-like macro's body.

A trivial tuple used to represent a source range.

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

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

Set the buffer.

std::optional< StringRef > getBufferDataIfLoaded() const

Return a StringRef to the source buffer data, only if it has already been loaded.

OptionalFileEntryRef ContentsEntry

References the file which the contents were actually loaded from.

unsigned getSizeBytesMapped() const

Returns the number of bytes actually mapped for this ContentCache.

unsigned IsTransient

True if this file may be transient, that is, if it might not exist at some later point in time when t...

unsigned getSize() const

Returns the size of the content encapsulated by this ContentCache.

llvm::MemoryBuffer::BufferKind getMemoryBufferKind() const

Returns the kind of memory used to back the memory buffer for this content cache.

unsigned IsFileVolatile

True if this content cache was initially created for a source file considered to be volatile (likely ...

LineOffsetMapping SourceLineCache

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

std::optional< llvm::MemoryBufferRef > getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM, SourceLocation Loc=SourceLocation()) const

Returns the memory buffer for the associated content.

static const char * getInvalidBOM(StringRef BufStr)

unsigned BufferOverridden

Indicates whether the buffer itself was provided to override the actual file contents.

OptionalFileEntryRef OrigEntry

Reference to the file entry representing this ContentCache.

Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...

SourceLocation getExpansionLocStart() const

static ExpansionInfo create(SourceLocation SpellingLoc, SourceLocation Start, SourceLocation End, bool ExpansionIsTokenRange=true)

Return a ExpansionInfo for an expansion.

bool isMacroBodyExpansion() const

SourceLocation getSpellingLoc() const

CharSourceRange getExpansionLocRange() const

bool isMacroArgExpansion() const

static ExpansionInfo createForMacroArg(SourceLocation SpellingLoc, SourceLocation ExpansionLoc)

Return a special ExpansionInfo for the expansion of a macro argument into a function-like macro's bod...

static ExpansionInfo createForTokenSplit(SourceLocation SpellingLoc, SourceLocation Start, SourceLocation End)

Return a special ExpansionInfo representing a token that ends prematurely.

SourceLocation getExpansionLocEnd() const

Information about a FileID, basically just the logical file that it represents and include stack info...

const ContentCache & getContentCache() const

CharacteristicKind getFileCharacteristic() const

Return whether this is a system header or not.

static FileInfo get(SourceLocation IL, ContentCache &Con, CharacteristicKind FileCharacter, StringRef Filename)

Return a FileInfo object.

bool hasLineDirectives() const

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

void setHasLineDirectives()

Set the flag that indicates that this FileID has line table entries associated with it.

SourceLocation getIncludeLoc() const

StringRef getName() const

Returns the name of the file that was used when the file was loaded from the underlying file system.

Mapping of line offsets into a source file.

const unsigned * begin() const

LineOffsetMapping()=default

const unsigned * end() const

static LineOffsetMapping get(llvm::MemoryBufferRef Buffer, llvm::BumpPtrAllocator &Alloc)

This is a discriminated union of FileInfo and ExpansionInfo.

SourceLocation::UIntTy getOffset() const

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

const FileInfo & getFile() const

const ExpansionInfo & getExpansion() const

CharacteristicKind

Indicates whether a file or directory holds normal user code, system code, or system code which is im...

bool isSystem(CharacteristicKind CK)

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

The JSON file list parser is used to communicate input to InstallAPI.

const FunctionProtoType * T

SrcMgr::CharacteristicKind FileKind

Set the 0 if no flags, 1 if a system header,.

static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4