[clang] 0fe78c4 - [NFC] [Serialization] Some Code Cleanups for Name lookup table things
Chuanqi Xu via cfe-commits
cfe-commits at lists.llvm.org
Thu Jun 19 02:56:52 PDT 2025
Author: Chuanqi Xu
Date: 2025-06-19T17:54:07+08:00
New Revision: 0fe78c4a290517925acc03d59f235926f440f155
URL: https://github.com/llvm/llvm-project/commit/0fe78c4a290517925acc03d59f235926f440f155
DIFF: https://github.com/llvm/llvm-project/commit/0fe78c4a290517925acc03d59f235926f440f155.diff
LOG: [NFC] [Serialization] Some Code Cleanups for Name lookup table things
Added:
Modified:
clang/include/clang/Serialization/ASTReader.h
clang/include/clang/Serialization/ASTRecordWriter.h
clang/include/clang/Serialization/ASTWriter.h
clang/lib/Serialization/ASTReader.cpp
clang/lib/Serialization/ASTReaderDecl.cpp
clang/lib/Serialization/ASTWriter.cpp
clang/lib/Serialization/ASTWriterDecl.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h
index ba676fd8698ea..866986dcbf76e 100644
--- a/clang/include/clang/Serialization/ASTReader.h
+++ b/clang/include/clang/Serialization/ASTReader.h
@@ -373,6 +373,25 @@ struct LazySpecializationInfoLookupTable;
} // namespace serialization
+struct VisibleLookupBlockOffsets {
+ uint64_t VisibleOffset = 0;
+ uint64_t ModuleLocalOffset = 0;
+ uint64_t TULocalOffset = 0;
+
+ operator bool() const {
+ return VisibleOffset || ModuleLocalOffset || // ModuleUnitLocalOffset ||
+ TULocalOffset;
+ }
+};
+
+struct LookupBlockOffsets : VisibleLookupBlockOffsets {
+ uint64_t LexicalOffset = 0;
+
+ operator bool() const {
+ return VisibleLookupBlockOffsets::operator bool() || LexicalOffset;
+ }
+};
+
/// Reads an AST files chain containing the contents of a translation
/// unit.
///
@@ -535,13 +554,6 @@ class ASTReader
/// in the chain.
DeclUpdateOffsetsMap DeclUpdateOffsets;
- struct LookupBlockOffsets {
- uint64_t LexicalOffset;
- uint64_t VisibleOffset;
- uint64_t ModuleLocalOffset;
- uint64_t TULocalOffset;
- };
-
using DelayedNamespaceOffsetMapTy =
llvm::DenseMap<GlobalDeclID, LookupBlockOffsets>;
diff --git a/clang/include/clang/Serialization/ASTRecordWriter.h b/clang/include/clang/Serialization/ASTRecordWriter.h
index 07f7e8d919d8b..ad1ec2673812b 100644
--- a/clang/include/clang/Serialization/ASTRecordWriter.h
+++ b/clang/include/clang/Serialization/ASTRecordWriter.h
@@ -115,6 +115,13 @@ class ASTRecordWriter
Record->push_back(BitOffset);
}
+ void AddLookupOffsets(const LookupBlockOffsets &Offsets) {
+ AddOffset(Offsets.LexicalOffset);
+ AddOffset(Offsets.VisibleOffset);
+ AddOffset(Offsets.ModuleLocalOffset);
+ AddOffset(Offsets.TULocalOffset);
+ }
+
/// Add the given statement or expression to the queue of
/// statements to emit.
///
diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h
index 0f49646f3f022..97679ace8b610 100644
--- a/clang/include/clang/Serialization/ASTWriter.h
+++ b/clang/include/clang/Serialization/ASTWriter.h
@@ -75,6 +75,9 @@ class StoredDeclsList;
class SwitchCase;
class Token;
+struct VisibleLookupBlockOffsets;
+struct LookupBlockOffsets;
+
namespace serialization {
enum class DeclUpdateKind;
} // namespace serialization
@@ -606,9 +609,7 @@ class ASTWriter : public ASTDeserializationListener,
uint64_t WriteDeclContextLexicalBlock(ASTContext &Context,
const DeclContext *DC);
void WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC,
- uint64_t &VisibleBlockOffset,
- uint64_t &ModuleLocalBlockOffset,
- uint64_t &TULocalBlockOffset);
+ VisibleLookupBlockOffsets &Offsets);
void WriteTypeDeclOffsets();
void WriteFileDeclIDsMap();
void WriteComments(ASTContext &Context);
@@ -777,6 +778,9 @@ class ASTWriter : public ASTDeserializationListener,
return (I == DeclIDs.end() || I->second >= clang::NUM_PREDEF_DECL_IDS);
};
+ void AddLookupOffsets(const LookupBlockOffsets &Offsets,
+ RecordDataImpl &Record);
+
/// Emit a reference to a declaration.
void AddDeclRef(const Decl *D, RecordDataImpl &Record);
// Emit a reference to a declaration if the declaration was emitted.
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index acda5a7c879dd..a3fbc3d25acab 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -4097,8 +4097,8 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
uint64_t TULocalOffset =
TULocalLocalOffset ? BaseOffset + TULocalLocalOffset : 0;
- DelayedNamespaceOffsetMap[ID] = {LexicalOffset, VisibleOffset,
- ModuleLocalOffset, TULocalOffset};
+ DelayedNamespaceOffsetMap[ID] = {
+ {VisibleOffset, TULocalOffset, ModuleLocalOffset}, LexicalOffset};
assert(!GetExistingDecl(ID) &&
"We shouldn't load the namespace in the front of delayed "
@@ -8544,17 +8544,21 @@ bool ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
SmallVector<NamedDecl *, 64> Decls;
llvm::SmallPtrSet<NamedDecl *, 8> Found;
+ auto Find = [&, this](auto &&Table, auto &&Key) {
+ for (GlobalDeclID ID : Table.find(Key)) {
+ NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
+ if (ND->getDeclName() == Name && Found.insert(ND).second)
+ Decls.push_back(ND);
+ }
+ };
+
Deserializing LookupResults(this);
// FIXME: Clear the redundancy with templated lambda in C++20 when that's
// available.
if (auto It = Lookups.find(DC); It != Lookups.end()) {
++NumVisibleDeclContextsRead;
- for (GlobalDeclID ID : It->second.Table.find(Name)) {
- NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
- if (ND->getDeclName() == Name && Found.insert(ND).second)
- Decls.push_back(ND);
- }
+ Find(It->second.Table, Name);
}
if (auto *NamedModule =
@@ -8562,21 +8566,13 @@ bool ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
: nullptr) {
if (auto It = ModuleLocalLookups.find(DC); It != ModuleLocalLookups.end()) {
++NumModuleLocalVisibleDeclContexts;
- for (GlobalDeclID ID : It->second.Table.find({Name, NamedModule})) {
- NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
- if (ND->getDeclName() == Name && Found.insert(ND).second)
- Decls.push_back(ND);
- }
+ Find(It->second.Table, std::make_pair(Name, NamedModule));
}
}
if (auto It = TULocalLookups.find(DC); It != TULocalLookups.end()) {
++NumTULocalVisibleDeclContexts;
- for (GlobalDeclID ID : It->second.Table.find(Name)) {
- NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
- if (ND->getDeclName() == Name && Found.insert(ND).second)
- Decls.push_back(ND);
- }
+ Find(It->second.Table, Name);
}
SetExternalVisibleDeclsForName(DC, Name, Decls);
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index a1368a48351c6..259c772e42225 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -414,9 +414,7 @@ class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
void VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D);
void VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D);
- void VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
- uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset,
- uint64_t &TULocalOffset);
+ void VisitDeclContext(DeclContext *DC, LookupBlockOffsets &Offsets);
template <typename T>
RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
@@ -1875,12 +1873,8 @@ void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
VisitNamedDecl(D);
- uint64_t LexicalOffset = 0;
- uint64_t VisibleOffset = 0;
- uint64_t ModuleLocalOffset = 0;
- uint64_t TULocalOffset = 0;
- VisitDeclContext(D, LexicalOffset, VisibleOffset, ModuleLocalOffset,
- TULocalOffset);
+ LookupBlockOffsets Offsets;
+ VisitDeclContext(D, Offsets);
D->IsCBuffer = Record.readBool();
D->KwLoc = readSourceLocation();
D->LBraceLoc = readSourceLocation();
@@ -2794,14 +2788,12 @@ void ASTDeclReader::VisitLifetimeExtendedTemporaryDecl(
mergeMergeable(D);
}
-void ASTDeclReader::VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
- uint64_t &VisibleOffset,
- uint64_t &ModuleLocalOffset,
- uint64_t &TULocalOffset) {
- LexicalOffset = ReadLocalOffset();
- VisibleOffset = ReadLocalOffset();
- ModuleLocalOffset = ReadLocalOffset();
- TULocalOffset = ReadLocalOffset();
+void ASTDeclReader::VisitDeclContext(DeclContext *DC,
+ LookupBlockOffsets &Offsets) {
+ Offsets.LexicalOffset = ReadLocalOffset();
+ Offsets.VisibleOffset = ReadLocalOffset();
+ Offsets.ModuleLocalOffset = ReadLocalOffset();
+ Offsets.TULocalOffset = ReadLocalOffset();
}
template <typename T>
@@ -4249,42 +4241,37 @@ Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
// If this declaration is also a declaration context, get the
// offsets for its tables of lexical and visible declarations.
if (auto *DC = dyn_cast<DeclContext>(D)) {
- uint64_t LexicalOffset = 0;
- uint64_t VisibleOffset = 0;
- uint64_t ModuleLocalOffset = 0;
- uint64_t TULocalOffset = 0;
+ LookupBlockOffsets Offsets;
- Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset, ModuleLocalOffset,
- TULocalOffset);
+ Reader.VisitDeclContext(DC, Offsets);
// Get the lexical and visible block for the delayed namespace.
// It is sufficient to judge if ID is in DelayedNamespaceOffsetMap.
// But it may be more efficient to filter the other cases.
- if (!LexicalOffset && !VisibleOffset && !ModuleLocalOffset &&
- isa<NamespaceDecl>(D))
+ if (!Offsets && isa<NamespaceDecl>(D))
if (auto Iter = DelayedNamespaceOffsetMap.find(ID);
- Iter != DelayedNamespaceOffsetMap.end()) {
- LexicalOffset = Iter->second.LexicalOffset;
- VisibleOffset = Iter->second.VisibleOffset;
- ModuleLocalOffset = Iter->second.ModuleLocalOffset;
- TULocalOffset = Iter->second.TULocalOffset;
- }
+ Iter != DelayedNamespaceOffsetMap.end())
+ Offsets = Iter->second;
- if (LexicalOffset &&
- ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, LexicalOffset, DC))
- return nullptr;
- if (VisibleOffset && ReadVisibleDeclContextStorage(
- *Loc.F, DeclsCursor, VisibleOffset, ID,
- VisibleDeclContextStorageKind::GenerallyVisible))
+ if (Offsets.VisibleOffset &&
+ ReadVisibleDeclContextStorage(
+ *Loc.F, DeclsCursor, Offsets.VisibleOffset, ID,
+ VisibleDeclContextStorageKind::GenerallyVisible))
return nullptr;
- if (ModuleLocalOffset &&
+ if (Offsets.ModuleLocalOffset &&
ReadVisibleDeclContextStorage(
- *Loc.F, DeclsCursor, ModuleLocalOffset, ID,
+ *Loc.F, DeclsCursor, Offsets.ModuleLocalOffset, ID,
VisibleDeclContextStorageKind::ModuleLocalVisible))
return nullptr;
- if (TULocalOffset && ReadVisibleDeclContextStorage(
- *Loc.F, DeclsCursor, TULocalOffset, ID,
- VisibleDeclContextStorageKind::TULocalVisible))
+ if (Offsets.TULocalOffset &&
+ ReadVisibleDeclContextStorage(
+ *Loc.F, DeclsCursor, Offsets.TULocalOffset, ID,
+ VisibleDeclContextStorageKind::TULocalVisible))
+ return nullptr;
+
+ if (Offsets.LexicalOffset &&
+ ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor,
+ Offsets.LexicalOffset, DC))
return nullptr;
}
assert(Record.getIdx() == Record.size());
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index be22ee5221911..af7229d748872 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -4089,11 +4089,9 @@ class ASTDeclContextNameLookupTraitBase {
using hash_value_type = unsigned;
using offset_type = unsigned;
-protected:
explicit ASTDeclContextNameLookupTraitBase(ASTWriter &Writer)
: Writer(Writer) {}
-public:
data_type getData(const DeclIDsTy &LocalIDs) {
unsigned Start = DeclIDs.size();
for (auto ID : LocalIDs)
@@ -4231,6 +4229,38 @@ class ModuleLevelNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
}
};
+class ASTDeclContextNameTrivialLookupTrait
+ : public ASTDeclContextNameLookupTraitBase {
+public:
+ using key_type = DeclarationNameKey;
+ using key_type_ref = key_type;
+
+public:
+ using ASTDeclContextNameLookupTraitBase::ASTDeclContextNameLookupTraitBase;
+
+ using ASTDeclContextNameLookupTraitBase::getData;
+
+ static bool EqualKey(key_type_ref a, key_type_ref b) { return a == b; }
+
+ hash_value_type ComputeHash(key_type Name) { return Name.getHash(); }
+
+ std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
+ DeclarationNameKey Name,
+ data_type_ref Lookup) {
+ auto [KeyLen, DataLen] = EmitKeyDataLengthBase(Out, Name, Lookup);
+ return emitULEBKeyDataLength(KeyLen, DataLen, Out);
+ }
+
+ void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
+ return EmitKeyBase(Out, Name);
+ }
+
+ void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
+ unsigned DataLen) {
+ EmitDataBase(Out, Lookup, DataLen);
+ }
+};
+
static bool isModuleLocalDecl(NamedDecl *D) {
// For decls not in a file context, they should have the same visibility
// with their parent.
@@ -4273,25 +4303,43 @@ static bool isTULocalInNamedModules(NamedDecl *D) {
return D->getLinkageInternal() == Linkage::Internal;
}
-// Trait used for the on-disk hash table used in the method pool.
-template <bool CollectingTULocalDecls>
-class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
+class ASTDeclContextNameLookupTrait
+ : public ASTDeclContextNameTrivialLookupTrait {
public:
+ using TULocalDeclsMapTy = llvm::DenseMap<key_type, DeclIDsTy>;
+
using ModuleLevelDeclsMapTy =
llvm::DenseMap<ModuleLevelNameLookupTrait::key_type, DeclIDsTy>;
- using key_type = DeclarationNameKey;
- using key_type_ref = key_type;
+private:
+ enum class LookupVisibility {
+ GenerallyVisibile,
+ // The decls can only be found by other TU in the same module.
+ // Note a clang::Module models a module unit instead of logical module
+ // in C++20.
+ ModuleLocalVisible,
+ // The decls can only be found by the TU itself that defines it.
+ TULocal,
+ };
- using TULocalDeclsMapTy = llvm::DenseMap<key_type, DeclIDsTy>;
+ LookupVisibility getLookupVisibility(NamedDecl *D) const {
+ // Only named modules have other lookup visibility.
+ if (!Writer.isWritingStdCXXNamedModules())
+ return LookupVisibility::GenerallyVisibile;
+
+ if (isModuleLocalDecl(D))
+ return LookupVisibility::ModuleLocalVisible;
+ if (isTULocalInNamedModules(D))
+ return LookupVisibility::TULocal;
+ return LookupVisibility::GenerallyVisibile;
+ }
-private:
ModuleLevelDeclsMapTy ModuleLocalDeclsMap;
TULocalDeclsMapTy TULocalDeclsMap;
public:
- explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer)
- : ASTDeclContextNameLookupTraitBase(Writer) {}
+ using ASTDeclContextNameTrivialLookupTrait::
+ ASTDeclContextNameTrivialLookupTrait;
template <typename Coll> data_type getData(const Coll &Decls) {
unsigned Start = DeclIDs.size();
@@ -4312,7 +4360,8 @@ class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
auto ID = Writer.GetDeclRef(DeclForLocalLookup);
- if (isModuleLocalDecl(D)) {
+ switch (getLookupVisibility(DeclForLocalLookup)) {
+ case LookupVisibility::ModuleLocalVisible:
if (UnsignedOrNone PrimaryModuleHash =
getPrimaryModuleHash(D->getOwningModule())) {
auto Key = std::make_pair(D->getDeclName(), *PrimaryModuleHash);
@@ -4323,17 +4372,18 @@ class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
Iter->second.push_back(ID);
continue;
}
+ break;
+ case LookupVisibility::TULocal: {
+ auto Iter = TULocalDeclsMap.find(D->getDeclName());
+ if (Iter == TULocalDeclsMap.end())
+ TULocalDeclsMap.insert({D->getDeclName(), DeclIDsTy{ID}});
+ else
+ Iter->second.push_back(ID);
+ continue;
}
-
- if constexpr (CollectingTULocalDecls) {
- if (isTULocalInNamedModules(D)) {
- auto Iter = TULocalDeclsMap.find(D->getDeclName());
- if (Iter == TULocalDeclsMap.end())
- TULocalDeclsMap.insert({D->getDeclName(), DeclIDsTy{ID}});
- else
- Iter->second.push_back(ID);
- continue;
- }
+ case LookupVisibility::GenerallyVisibile:
+ // Generally visible decls go into the general lookup table.
+ break;
}
DeclIDs.push_back(ID);
@@ -4341,33 +4391,11 @@ class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
return std::make_pair(Start, DeclIDs.size());
}
- using ASTDeclContextNameLookupTraitBase::getData;
-
const ModuleLevelDeclsMapTy &getModuleLocalDecls() {
return ModuleLocalDeclsMap;
}
const TULocalDeclsMapTy &getTULocalDecls() { return TULocalDeclsMap; }
-
- static bool EqualKey(key_type_ref a, key_type_ref b) { return a == b; }
-
- hash_value_type ComputeHash(key_type Name) { return Name.getHash(); }
-
- std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
- DeclarationNameKey Name,
- data_type_ref Lookup) {
- auto [KeyLen, DataLen] = EmitKeyDataLengthBase(Out, Name, Lookup);
- return emitULEBKeyDataLength(KeyLen, DataLen, Out);
- }
-
- void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
- return EmitKeyBase(Out, Name);
- }
-
- void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
- unsigned DataLen) {
- EmitDataBase(Out, Lookup, DataLen);
- }
};
} // namespace
@@ -4581,11 +4609,10 @@ void ASTWriter::GenerateNameLookupTable(
assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table");
// Create the on-disk hash table representation.
- MultiOnDiskHashTableGenerator<
- reader::ASTDeclContextNameLookupTrait,
- ASTDeclContextNameLookupTrait</*CollectingTULocal=*/true>>
+ MultiOnDiskHashTableGenerator<reader::ASTDeclContextNameLookupTrait,
+ ASTDeclContextNameLookupTrait>
Generator;
- ASTDeclContextNameLookupTrait</*CollectingTULocal=*/true> Trait(*this);
+ ASTDeclContextNameLookupTrait Trait(*this);
// The first step is to collect the declaration names which we need to
// serialize into the name lookup table, and to collect them in a stable
@@ -4743,12 +4770,10 @@ void ASTWriter::GenerateNameLookupTable(
const auto &TULocalDecls = Trait.getTULocalDecls();
if (!TULocalDecls.empty() && !isGeneratingReducedBMI()) {
- MultiOnDiskHashTableGenerator<
- reader::ASTDeclContextNameLookupTrait,
- ASTDeclContextNameLookupTrait</*CollectingTULocal=*/false>>
+ MultiOnDiskHashTableGenerator<reader::ASTDeclContextNameLookupTrait,
+ ASTDeclContextNameTrivialLookupTrait>
TULookupGenerator;
- ASTDeclContextNameLookupTrait</*CollectingTULocal=*/false> TULocalTrait(
- *this);
+ ASTDeclContextNameTrivialLookupTrait TULocalTrait(*this);
for (const auto &TULocalIter : TULocalDecls) {
const auto &Key = TULocalIter.first;
@@ -4767,14 +4792,9 @@ void ASTWriter::GenerateNameLookupTable(
///
/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
/// bitstream, or 0 if no block was written.
-void ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
- DeclContext *DC,
- uint64_t &VisibleBlockOffset,
- uint64_t &ModuleLocalBlockOffset,
- uint64_t &TULocalBlockOffset) {
- assert(VisibleBlockOffset == 0);
- assert(ModuleLocalBlockOffset == 0);
- assert(TULocalBlockOffset == 0);
+void ASTWriter::WriteDeclContextVisibleBlock(
+ ASTContext &Context, DeclContext *DC, VisibleLookupBlockOffsets &Offsets) {
+ assert(!Offsets);
// If we imported a key declaration of this namespace, write the visible
// lookup results as an update record for it rather than including them
@@ -4858,7 +4878,7 @@ void ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
if (!Map || Map->empty())
return;
- VisibleBlockOffset = Stream.GetCurrentBitNo();
+ Offsets.VisibleOffset = Stream.GetCurrentBitNo();
// Create the on-disk hash table in a buffer.
SmallString<4096> LookupTable;
SmallString<4096> ModuleLocalLookupTable;
@@ -4873,8 +4893,8 @@ void ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
++NumVisibleDeclContexts;
if (!ModuleLocalLookupTable.empty()) {
- ModuleLocalBlockOffset = Stream.GetCurrentBitNo();
- assert(ModuleLocalBlockOffset > VisibleBlockOffset);
+ Offsets.ModuleLocalOffset = Stream.GetCurrentBitNo();
+ assert(Offsets.ModuleLocalOffset > Offsets.VisibleOffset);
// Write the lookup table
RecordData::value_type ModuleLocalRecord[] = {
DECL_CONTEXT_MODULE_LOCAL_VISIBLE};
@@ -4884,7 +4904,7 @@ void ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
}
if (!TULookupTable.empty()) {
- TULocalBlockOffset = Stream.GetCurrentBitNo();
+ Offsets.TULocalOffset = Stream.GetCurrentBitNo();
// Write the lookup table
RecordData::value_type TULocalDeclsRecord[] = {
DECL_CONTEXT_TU_LOCAL_VISIBLE};
@@ -6203,31 +6223,26 @@ void ASTWriter::WriteDeclAndTypes(ASTContext &Context) {
assert(DelayedNamespace.empty() || GeneratingReducedBMI);
RecordData DelayedNamespaceRecord;
for (NamespaceDecl *NS : DelayedNamespace) {
- uint64_t LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);
- uint64_t VisibleOffset = 0;
- uint64_t ModuleLocalOffset = 0;
- uint64_t TULocalOffset = 0;
- WriteDeclContextVisibleBlock(Context, NS, VisibleOffset, ModuleLocalOffset,
- TULocalOffset);
+ LookupBlockOffsets Offsets;
- // Write the offset relative to current block.
- if (LexicalOffset)
- LexicalOffset -= DeclTypesBlockStartOffset;
+ Offsets.LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);
+ WriteDeclContextVisibleBlock(Context, NS, Offsets);
- if (VisibleOffset)
- VisibleOffset -= DeclTypesBlockStartOffset;
+ if (Offsets.LexicalOffset)
+ Offsets.LexicalOffset -= DeclTypesBlockStartOffset;
- if (ModuleLocalOffset)
- ModuleLocalOffset -= DeclTypesBlockStartOffset;
+ // Write the offset relative to current block.
+ if (Offsets.VisibleOffset)
+ Offsets.VisibleOffset -= DeclTypesBlockStartOffset;
- if (TULocalOffset)
- TULocalOffset -= DeclTypesBlockStartOffset;
+ if (Offsets.ModuleLocalOffset)
+ Offsets.ModuleLocalOffset -= DeclTypesBlockStartOffset;
+
+ if (Offsets.TULocalOffset)
+ Offsets.TULocalOffset -= DeclTypesBlockStartOffset;
AddDeclRef(NS, DelayedNamespaceRecord);
- DelayedNamespaceRecord.push_back(LexicalOffset);
- DelayedNamespaceRecord.push_back(VisibleOffset);
- DelayedNamespaceRecord.push_back(ModuleLocalOffset);
- DelayedNamespaceRecord.push_back(TULocalOffset);
+ AddLookupOffsets(Offsets, DelayedNamespaceRecord);
}
// The process of writing lexical and visible block for delayed namespace
@@ -6818,6 +6833,14 @@ TypeID ASTWriter::GetOrCreateTypeID(ASTContext &Context, QualType T) {
});
}
+void ASTWriter::AddLookupOffsets(const LookupBlockOffsets &Offsets,
+ RecordDataImpl &Record) {
+ Record.push_back(Offsets.LexicalOffset);
+ Record.push_back(Offsets.VisibleOffset);
+ Record.push_back(Offsets.ModuleLocalOffset);
+ Record.push_back(Offsets.TULocalOffset);
+}
+
void ASTWriter::AddEmittedDeclRef(const Decl *D, RecordDataImpl &Record) {
if (!wasDeclEmitted(D))
return;
diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp
index 052cb5a253bf7..2d93832a9ac31 100644
--- a/clang/lib/Serialization/ASTWriterDecl.cpp
+++ b/clang/lib/Serialization/ASTWriterDecl.cpp
@@ -2189,11 +2189,7 @@ void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
static_assert(DeclContext::NumDeclContextBits == 13,
"You need to update the serializer after you change the "
"DeclContextBits");
-
- uint64_t LexicalOffset = 0;
- uint64_t VisibleOffset = 0;
- uint64_t ModuleLocalOffset = 0;
- uint64_t TULocalOffset = 0;
+ LookupBlockOffsets Offsets;
if (Writer.isGeneratingReducedBMI() && isa<NamespaceDecl>(DC) &&
cast<NamespaceDecl>(DC)->isFromExplicitGlobalModule()) {
@@ -2202,17 +2198,12 @@ void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
// details.
Writer.DelayedNamespace.push_back(cast<NamespaceDecl>(DC));
} else {
- LexicalOffset =
+ Offsets.LexicalOffset =
Writer.WriteDeclContextLexicalBlock(Record.getASTContext(), DC);
- Writer.WriteDeclContextVisibleBlock(Record.getASTContext(), DC,
- VisibleOffset, ModuleLocalOffset,
- TULocalOffset);
+ Writer.WriteDeclContextVisibleBlock(Record.getASTContext(), DC, Offsets);
}
- Record.AddOffset(LexicalOffset);
- Record.AddOffset(VisibleOffset);
- Record.AddOffset(ModuleLocalOffset);
- Record.AddOffset(TULocalOffset);
+ Record.AddLookupOffsets(Offsets);
}
const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
More information about the cfe-commits
mailing list