[clang] [clang][modules] Remove preloaded SLocEntries from PCM files (PR #66962)
Jan Svoboda via cfe-commits
cfe-commits at lists.llvm.org
Wed Oct 4 10:52:09 PDT 2023
https://github.com/jansvoboda11 updated https://github.com/llvm/llvm-project/pull/66962
>From 61e8961cde95e9e8ce8cea3efd6aa52273f430e9 Mon Sep 17 00:00:00 2001
From: Jan Svoboda <jan_svoboda at apple.com>
Date: Wed, 20 Sep 2023 16:50:48 -0700
Subject: [PATCH 1/5] [clang][modules] Remove preloaded SLocEntries from PCM
files
This commit removes the list of SLocEntry offsets to preload eagerly from PCM files. Commit introducing this functionality (258ae54a) doesn't clarify why this would be more performant than the lazy approach used regularly.
Currently, the only SLocEntry the reader is supposed to preload is the predefines buffer, but in my experience, it's not actually referenced in most modules, so the time spent deserializing its SLocEntry is wasted. This is especially noticeable in the dependency scanner, where this change brings 4.56% speedup on my benchmark.
---
.../include/clang/Serialization/ASTBitCodes.h | 10 ++------
.../include/clang/Serialization/ModuleFile.h | 3 ---
clang/lib/Serialization/ASTReader.cpp | 23 -------------------
clang/lib/Serialization/ASTWriter.cpp | 8 -------
4 files changed, 2 insertions(+), 42 deletions(-)
diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h
index 9e115f2a5cce3f9..85f49e21b2e2ec1 100644
--- a/clang/include/clang/Serialization/ASTBitCodes.h
+++ b/clang/include/clang/Serialization/ASTBitCodes.h
@@ -51,7 +51,7 @@ const unsigned VERSION_MAJOR = 29;
/// for the previous version could still support reading the new
/// version by ignoring new kinds of subblocks), this number
/// should be increased.
-const unsigned VERSION_MINOR = 0;
+const unsigned VERSION_MINOR = 1;
/// An ID number that refers to an identifier in an AST file.
///
@@ -524,13 +524,7 @@ enum ASTRecordTypes {
/// of source-location information.
SOURCE_LOCATION_OFFSETS = 14,
- /// Record code for the set of source location entries
- /// that need to be preloaded by the AST reader.
- ///
- /// This set contains the source location entry for the
- /// predefines buffer and for any file entries that need to be
- /// preloaded.
- SOURCE_LOCATION_PRELOADS = 15,
+ // ID 15 used to be for source location entry preloads.
/// Record code for the set of ext_vector type names.
EXT_VECTOR_DECLS = 16,
diff --git a/clang/include/clang/Serialization/ModuleFile.h b/clang/include/clang/Serialization/ModuleFile.h
index 0af5cae6aebc375..48be8676cc26a4c 100644
--- a/clang/include/clang/Serialization/ModuleFile.h
+++ b/clang/include/clang/Serialization/ModuleFile.h
@@ -292,9 +292,6 @@ class ModuleFile {
/// AST file.
const uint32_t *SLocEntryOffsets = nullptr;
- /// SLocEntries that we're going to preload.
- SmallVector<uint64_t, 4> PreloadSLocEntries;
-
/// Remapping table for source locations in this module.
ContinuousRangeMap<SourceLocation::UIntTy, SourceLocation::IntTy, 2>
SLocRemap;
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 0952244d037a77c..e796617455ac390 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -3226,7 +3226,6 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
case SOURCE_LOCATION_OFFSETS:
case MODULE_OFFSET_MAP:
case SOURCE_MANAGER_LINE_TABLE:
- case SOURCE_LOCATION_PRELOADS:
case PPD_ENTITIES_OFFSETS:
case HEADER_SEARCH_TABLE:
case IMPORTED_MODULES:
@@ -3576,18 +3575,6 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
ParseLineTable(F, Record);
break;
- case SOURCE_LOCATION_PRELOADS: {
- // Need to transform from the local view (1-based IDs) to the global view,
- // which is based off F.SLocEntryBaseID.
- if (!F.PreloadSLocEntries.empty())
- return llvm::createStringError(
- std::errc::illegal_byte_sequence,
- "Multiple SOURCE_LOCATION_PRELOADS records in AST file");
-
- F.PreloadSLocEntries.swap(Record);
- break;
- }
-
case EXT_VECTOR_DECLS:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
@@ -4417,16 +4404,6 @@ ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName, ModuleKind Type,
for (ImportedModule &M : Loaded) {
ModuleFile &F = *M.Mod;
- // Preload SLocEntries.
- for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
- int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
- // Load it through the SourceManager and don't call ReadSLocEntry()
- // directly because the entry may have already been loaded in which case
- // calling ReadSLocEntry() directly would trigger an assertion in
- // SourceManager.
- SourceMgr.getLoadedSLocEntryByID(Index);
- }
-
// Map the original source file ID into the ID space of the current
// compilation.
if (F.OriginalSourceFileID.isValid())
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index 65bee806d2c5571..3392243d7ac4ba7 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -838,7 +838,6 @@ void ASTWriter::WriteBlockInfoBlock() {
RECORD(METHOD_POOL);
RECORD(PP_COUNTER_VALUE);
RECORD(SOURCE_LOCATION_OFFSETS);
- RECORD(SOURCE_LOCATION_PRELOADS);
RECORD(EXT_VECTOR_DECLS);
RECORD(UNUSED_FILESCOPED_DECLS);
RECORD(PPD_ENTITIES_OFFSETS);
@@ -2137,7 +2136,6 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
// entry, which is always the same dummy entry.
std::vector<uint32_t> SLocEntryOffsets;
uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
- RecordData PreloadSLocs;
SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
I != N; ++I) {
@@ -2213,9 +2211,6 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
StringRef(Name.data(), Name.size() + 1));
EmitBlob = true;
-
- if (Name == "<built-in>")
- PreloadSLocs.push_back(SLocEntryOffsets.size());
}
if (EmitBlob) {
@@ -2277,9 +2272,6 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record,
bytes(SLocEntryOffsets));
}
- // Write the source location entry preloads array, telling the AST
- // reader which source locations entries it should load eagerly.
- Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
// Write the line table. It depends on remapping working, so it must come
// after the source location offsets.
>From 8f035aab2abab7cbc49a84207c279b7ea1239ec8 Mon Sep 17 00:00:00 2001
From: Jan Svoboda <jan_svoboda at apple.com>
Date: Mon, 2 Oct 2023 14:44:39 -0700
Subject: [PATCH 2/5] [clang] Clarify FileID comparison
---
clang/lib/Basic/SourceManager.cpp | 39 ++++++++++++++++---------------
1 file changed, 20 insertions(+), 19 deletions(-)
diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp
index 0521ac7b30339ab..baaf57f2c8d851d 100644
--- a/clang/lib/Basic/SourceManager.cpp
+++ b/clang/lib/Basic/SourceManager.cpp
@@ -2100,48 +2100,49 @@ std::pair<bool, bool> SourceManager::isInTheSameTranslationUnit(
// A location within a FileID on the path up from LOffs to the main file.
struct Entry {
- unsigned Offset;
- FileID ParentFID; // Used for breaking ties.
+ std::pair<FileID, unsigned> DecomposedLoc; // FileID redundant, but clearer.
+ FileID ChildFID; // Used for breaking ties. Invalid for the initial loc.
};
llvm::SmallDenseMap<FileID, Entry, 16> LChain;
- FileID Parent;
+ FileID LChild;
do {
- LChain.try_emplace(LOffs.first, Entry{LOffs.second, Parent});
+ LChain.try_emplace(LOffs.first, Entry{LOffs, LChild});
// We catch the case where LOffs is in a file included by ROffs and
// quit early. The other way round unfortunately remains suboptimal.
if (LOffs.first == ROffs.first)
break;
- Parent = LOffs.first;
+ LChild = LOffs.first;
} while (!MoveUpIncludeHierarchy(LOffs, *this));
- Parent = FileID();
+ FileID RChild;
do {
- auto I = LChain.find(ROffs.first);
- if (I != LChain.end()) {
+ auto LIt = LChain.find(ROffs.first);
+ if (LIt != LChain.end()) {
// Compare the locations within the common file and cache them.
- LOffs.first = I->first;
- LOffs.second = I->second.Offset;
- // The relative order of LParent and RParent is a tiebreaker when
+ LOffs = LIt->second.DecomposedLoc;
+ LChild = LIt->second.ChildFID;
+ // The relative order of LChild and RChild is a tiebreaker when
// - locs expand to the same location (occurs in macro arg expansion)
// - one loc is a parent of the other (we consider the parent as "first")
- // For the parent to be first, the invalid file ID must compare smaller.
+ // For the parent entry to be first, its invalid child file ID must
+ // compare smaller to the valid child file ID of the other entry.
// However loaded FileIDs are <0, so we perform *unsigned* comparison!
// This changes the relative order of local vs loaded FileIDs, but it
// doesn't matter as these are never mixed in macro expansion.
- unsigned LParent = I->second.ParentFID.ID;
- unsigned RParent = Parent.ID;
+ unsigned LChildID = LChild.ID;
+ unsigned RChildID = RChild.ID;
assert(((LOffs.second != ROffs.second) ||
- (LParent == 0 || RParent == 0) ||
- isInSameSLocAddrSpace(getComposedLoc(I->second.ParentFID, 0),
- getComposedLoc(Parent, 0), nullptr)) &&
+ (LChildID == 0 || RChildID == 0) ||
+ isInSameSLocAddrSpace(getComposedLoc(LChild, 0),
+ getComposedLoc(RChild, 0), nullptr)) &&
"Mixed local/loaded FileIDs with same include location?");
IsBeforeInTUCache.setCommonLoc(LOffs.first, LOffs.second, ROffs.second,
- LParent < RParent);
+ LChildID < RChildID);
return std::make_pair(
true, IsBeforeInTUCache.getCachedResult(LOffs.second, ROffs.second));
}
- Parent = ROffs.first;
+ RChild = ROffs.first;
} while (!MoveUpIncludeHierarchy(ROffs, *this));
// If we found no match, we're not in the same TU.
>From af8b797aba43684323d4f063515c26e0186f3a8a Mon Sep 17 00:00:00 2001
From: Jan Svoboda <jan_svoboda at apple.com>
Date: Mon, 25 Sep 2023 12:51:15 -0700
Subject: [PATCH 3/5] [clang] Cut off IncludeLoc walk on TU boundary, return
early
---
clang/include/clang/Basic/SourceManager.h | 9 ++
clang/lib/Basic/SourceManager.cpp | 130 ++++++++++++++--------
2 files changed, 90 insertions(+), 49 deletions(-)
diff --git a/clang/include/clang/Basic/SourceManager.h b/clang/include/clang/Basic/SourceManager.h
index 2f846502d6f3327..255b9d8fb37b394 100644
--- a/clang/include/clang/Basic/SourceManager.h
+++ b/clang/include/clang/Basic/SourceManager.h
@@ -701,6 +701,10 @@ class SourceManager : public RefCountedBase<SourceManager> {
/// use (-ID - 2).
SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable;
+ /// For each allocation in LoadedSLocEntryTable, we keep the new size. This
+ /// can be used to determine whether two FileIDs come from the same AST file.
+ SmallVector<size_t, 0> LoadedSLocEntryTableSegments;
+
/// The starting offset of the next local SLocEntry.
///
/// This is LocalSLocEntryTable.back().Offset + the size of that entry.
@@ -1649,6 +1653,11 @@ class SourceManager : public RefCountedBase<SourceManager> {
isInTheSameTranslationUnit(std::pair<FileID, unsigned> &LOffs,
std::pair<FileID, unsigned> &ROffs) const;
+ /// Determines whether the two decomposed source location is in the same TU.
+ bool isInTheSameTranslationUnitImpl(
+ const std::pair<FileID, unsigned> &LOffs,
+ const std::pair<FileID, unsigned> &ROffs) const;
+
/// Determines the order of 2 source locations in the "source location
/// address space".
bool isBeforeInSLocAddrSpace(SourceLocation LHS, SourceLocation RHS) const {
diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp
index baaf57f2c8d851d..e07167b7f2e0213 100644
--- a/clang/lib/Basic/SourceManager.cpp
+++ b/clang/lib/Basic/SourceManager.cpp
@@ -458,11 +458,14 @@ SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries,
CurrentLoadedOffset - TotalSize < NextLocalOffset) {
return std::make_pair(0, 0);
}
- LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);
- SLocEntryLoaded.resize(LoadedSLocEntryTable.size());
+
+ unsigned NewTableSize = LoadedSLocEntryTable.size() + NumSLocEntries;
+ LoadedSLocEntryTableSegments.push_back(NewTableSize);
+ LoadedSLocEntryTable.resize(NewTableSize);
+ SLocEntryLoaded.resize(NewTableSize);
+
CurrentLoadedOffset -= TotalSize;
- int ID = LoadedSLocEntryTable.size();
- return std::make_pair(-ID - 1, CurrentLoadedOffset);
+ return std::make_pair(-NewTableSize - 1, CurrentLoadedOffset);
}
/// As part of recovering from missing or changed content, produce a
@@ -1976,14 +1979,36 @@ SourceManager::getDecomposedIncludedLoc(FileID FID) const {
return DecompLoc;
}
+bool SourceManager::isInTheSameTranslationUnitImpl(
+ const std::pair<FileID, unsigned> &LOffs,
+ const std::pair<FileID, unsigned> &ROffs) const {
+ // If one is local while the other is loaded.
+ if (isLoadedFileID(LOffs.first) != isLoadedFileID(ROffs.first))
+ return false;
+
+ // If both are loaded from different AST files.
+ if (isLoadedFileID(LOffs.first) && isLoadedFileID(ROffs.first)) {
+ auto FindTableSegment = [this](FileID FID) {
+ return llvm::upper_bound(LoadedSLocEntryTableSegments, -FID.ID - 2);
+ };
+
+ if (FindTableSegment(LOffs.first) != FindTableSegment(ROffs.first))
+ return false;
+ }
+
+ return true;
+}
+
/// Given a decomposed source location, move it up the include/expansion stack
-/// to the parent source location. If this is possible, return the decomposed
-/// version of the parent in Loc and return false. If Loc is the top-level
-/// entry, return true and don't modify it.
-static bool MoveUpIncludeHierarchy(std::pair<FileID, unsigned> &Loc,
- const SourceManager &SM) {
+/// 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) {
std::pair<FileID, unsigned> UpperLoc = SM.getDecomposedIncludedLoc(Loc.first);
- if (UpperLoc.first.isInvalid())
+ if (UpperLoc.first.isInvalid() ||
+ !SM.isInTheSameTranslationUnitImpl(UpperLoc, Loc))
return true; // We reached the top.
Loc = UpperLoc;
@@ -2039,45 +2064,18 @@ bool SourceManager::isBeforeInTranslationUnit(SourceLocation LHS,
std::pair<bool, bool> InSameTU = isInTheSameTranslationUnit(LOffs, ROffs);
if (InSameTU.first)
return InSameTU.second;
-
- // If we arrived here, the location is either in a built-ins buffer or
- // associated with global inline asm. PR5662 and PR22576 are examples.
-
- StringRef LB = getBufferOrFake(LOffs.first).getBufferIdentifier();
- StringRef RB = getBufferOrFake(ROffs.first).getBufferIdentifier();
- bool LIsBuiltins = LB == "<built-in>";
- bool RIsBuiltins = RB == "<built-in>";
- // Sort built-in before non-built-in.
- if (LIsBuiltins || RIsBuiltins) {
- if (LIsBuiltins != RIsBuiltins)
- return LIsBuiltins;
- // Both are in built-in buffers, but from different files. We just claim that
- // lower IDs come first.
- return LOffs.first < ROffs.first;
- }
- bool LIsAsm = LB == "<inline asm>";
- bool RIsAsm = RB == "<inline asm>";
- // Sort assembler after built-ins, but before the rest.
- if (LIsAsm || RIsAsm) {
- if (LIsAsm != RIsAsm)
- return RIsAsm;
- assert(LOffs.first == ROffs.first);
- return false;
- }
- bool LIsScratch = LB == "<scratch space>";
- bool RIsScratch = RB == "<scratch space>";
- // Sort scratch after inline asm, but before the rest.
- if (LIsScratch || RIsScratch) {
- if (LIsScratch != RIsScratch)
- return LIsScratch;
- return LOffs.second < ROffs.second;
- }
- llvm_unreachable("Unsortable locations found");
+ // TODO: This should be unreachable, but some clients are calling this
+ // function before making sure LHS and RHS are in the same TU.
+ return LOffs.first < ROffs.first;
}
std::pair<bool, bool> SourceManager::isInTheSameTranslationUnit(
std::pair<FileID, unsigned> &LOffs,
std::pair<FileID, unsigned> &ROffs) const {
+ // If the source locations are not in the same TU, return early.
+ if (!isInTheSameTranslationUnitImpl(LOffs, ROffs))
+ return std::make_pair(false, false);
+
// If the source locations are in the same file, just compare offsets.
if (LOffs.first == ROffs.first)
return std::make_pair(true, LOffs.second < ROffs.second);
@@ -2113,7 +2111,7 @@ std::pair<bool, bool> SourceManager::isInTheSameTranslationUnit(
if (LOffs.first == ROffs.first)
break;
LChild = LOffs.first;
- } while (!MoveUpIncludeHierarchy(LOffs, *this));
+ } while (!MoveUpTranslationUnitIncludeHierarchy(LOffs, *this));
FileID RChild;
do {
@@ -2143,11 +2141,45 @@ std::pair<bool, bool> SourceManager::isInTheSameTranslationUnit(
true, IsBeforeInTUCache.getCachedResult(LOffs.second, ROffs.second));
}
RChild = ROffs.first;
- } while (!MoveUpIncludeHierarchy(ROffs, *this));
+ } while (!MoveUpTranslationUnitIncludeHierarchy(ROffs, *this));
+
+ // If we found no match, the location is either in a built-ins buffer or
+ // associated with global inline asm. PR5662 and PR22576 are examples.
+
+ StringRef LB = getBufferOrFake(LOffs.first).getBufferIdentifier();
+ StringRef RB = getBufferOrFake(ROffs.first).getBufferIdentifier();
- // If we found no match, we're not in the same TU.
- // We don't cache this, but it is rare.
- return std::make_pair(false, false);
+ bool LIsBuiltins = LB == "<built-in>";
+ bool RIsBuiltins = RB == "<built-in>";
+ // Sort built-in before non-built-in.
+ if (LIsBuiltins || RIsBuiltins) {
+ if (LIsBuiltins != RIsBuiltins)
+ return std::make_pair(true, LIsBuiltins);
+ // Both are in built-in buffers, but from different files. We just claim
+ // that lower IDs come first.
+ return std::make_pair(true, LOffs.first < ROffs.first);
+ }
+
+ bool LIsAsm = LB == "<inline asm>";
+ bool RIsAsm = RB == "<inline asm>";
+ // Sort assembler after built-ins, but before the rest.
+ if (LIsAsm || RIsAsm) {
+ if (LIsAsm != RIsAsm)
+ return std::make_pair(true, RIsAsm);
+ assert(LOffs.first == ROffs.first);
+ return std::make_pair(true, false);
+ }
+
+ bool LIsScratch = LB == "<scratch space>";
+ bool RIsScratch = RB == "<scratch space>";
+ // Sort scratch after inline asm, but before the rest.
+ if (LIsScratch || RIsScratch) {
+ if (LIsScratch != RIsScratch)
+ return std::make_pair(true, LIsScratch);
+ return std::make_pair(true, LOffs.second < ROffs.second);
+ }
+
+ llvm_unreachable("Unsortable locations found");
}
void SourceManager::PrintStats() const {
>From a527cb317e3cead0345cc9428b20ce08da64ec16 Mon Sep 17 00:00:00 2001
From: Jan Svoboda <jan_svoboda at apple.com>
Date: Wed, 4 Oct 2023 10:39:35 -0700
Subject: [PATCH 4/5] Use FileID instead of size_t
---
clang/include/clang/Basic/SourceManager.h | 7 ++++---
clang/lib/Basic/SourceManager.cpp | 22 +++++++++++-----------
2 files changed, 15 insertions(+), 14 deletions(-)
diff --git a/clang/include/clang/Basic/SourceManager.h b/clang/include/clang/Basic/SourceManager.h
index 255b9d8fb37b394..5494d3f67a6c481 100644
--- a/clang/include/clang/Basic/SourceManager.h
+++ b/clang/include/clang/Basic/SourceManager.h
@@ -701,9 +701,10 @@ class SourceManager : public RefCountedBase<SourceManager> {
/// use (-ID - 2).
SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable;
- /// For each allocation in LoadedSLocEntryTable, we keep the new size. This
- /// can be used to determine whether two FileIDs come from the same AST file.
- SmallVector<size_t, 0> LoadedSLocEntryTableSegments;
+ /// For each allocation in LoadedSLocEntryTable, we keep the first FileID.
+ /// We assume exactly one allocation per AST file, and use that to determine
+ /// whether two FileIDs come from the same AST file.
+ SmallVector<FileID, 0> LoadedSLocEntryAllocBegin;
/// The starting offset of the next local SLocEntry.
///
diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp
index e07167b7f2e0213..af46ccb6009e6f5 100644
--- a/clang/lib/Basic/SourceManager.cpp
+++ b/clang/lib/Basic/SourceManager.cpp
@@ -458,14 +458,12 @@ SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries,
CurrentLoadedOffset - TotalSize < NextLocalOffset) {
return std::make_pair(0, 0);
}
-
- unsigned NewTableSize = LoadedSLocEntryTable.size() + NumSLocEntries;
- LoadedSLocEntryTableSegments.push_back(NewTableSize);
- LoadedSLocEntryTable.resize(NewTableSize);
- SLocEntryLoaded.resize(NewTableSize);
-
+ LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);
+ SLocEntryLoaded.resize(LoadedSLocEntryTable.size());
CurrentLoadedOffset -= TotalSize;
- return std::make_pair(-NewTableSize - 1, CurrentLoadedOffset);
+ int ID = LoadedSLocEntryTable.size();
+ LoadedSLocEntryAllocBegin.push_back(FileID::get(-ID - 2));
+ return std::make_pair(-ID - 1, CurrentLoadedOffset);
}
/// As part of recovering from missing or changed content, produce a
@@ -1986,13 +1984,15 @@ bool SourceManager::isInTheSameTranslationUnitImpl(
if (isLoadedFileID(LOffs.first) != isLoadedFileID(ROffs.first))
return false;
- // If both are loaded from different AST files.
if (isLoadedFileID(LOffs.first) && isLoadedFileID(ROffs.first)) {
- auto FindTableSegment = [this](FileID FID) {
- return llvm::upper_bound(LoadedSLocEntryTableSegments, -FID.ID - 2);
+ auto FindSLocEntryAlloc = [this](FileID FID) {
+ // FileIDs are negative, we store the beginning of each allocation (the
+ // lowest FileID), later allocations have lower FileIDs.
+ return llvm::upper_bound(LoadedSLocEntryAllocBegin, FID, std::greater{});
};
- if (FindTableSegment(LOffs.first) != FindTableSegment(ROffs.first))
+ // If both are loaded from different AST files.
+ if (FindSLocEntryAlloc(LOffs.first) != FindSLocEntryAlloc(ROffs.first))
return false;
}
>From bff3feb796869287c5e140ae6274704e04185d1a Mon Sep 17 00:00:00 2001
From: Jan Svoboda <jan_svoboda at apple.com>
Date: Wed, 4 Oct 2023 10:51:44 -0700
Subject: [PATCH 5/5] Tweak comment
---
clang/lib/Basic/SourceManager.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp
index af46ccb6009e6f5..a2d8aeace0d85c8 100644
--- a/clang/lib/Basic/SourceManager.cpp
+++ b/clang/lib/Basic/SourceManager.cpp
@@ -1986,8 +1986,8 @@ bool SourceManager::isInTheSameTranslationUnitImpl(
if (isLoadedFileID(LOffs.first) && isLoadedFileID(ROffs.first)) {
auto FindSLocEntryAlloc = [this](FileID FID) {
- // FileIDs are negative, we store the beginning of each allocation (the
- // lowest FileID), later allocations have lower FileIDs.
+ // Loaded FileIDs are negative, we store the lowest FileID from each
+ // allocation, later allocations have lower FileIDs.
return llvm::upper_bound(LoadedSLocEntryAllocBegin, FID, std::greater{});
};
More information about the cfe-commits
mailing list