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) { _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
