From: Ben Langmuir Date: Mon, 20 Oct 2014 16:27:30 +0000 (+0000) Subject: Don't add ID mappings for offsets with no entities in a module X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=6894808d29b9f8499dbb219a1f17a518f69d8b0c;p=clang Don't add ID mappings for offsets with no entities in a module This is a better fix for 'duplicate key' problems in module continuous range maps (vs what I added in r215810) by not adding any mappings at all when there are no local entities. Now it also covers selectors, which were not always being bumped because the record SELECTOR_OFFSET is not always emitted. I'll back out most of r215810 in a future commit, since it should no longer be needed. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@220207 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp index 51cee8cf64..e2e21626ca 100644 --- a/lib/Serialization/ASTReader.cpp +++ b/lib/Serialization/ASTReader.cpp @@ -2900,19 +2900,16 @@ ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) { } // Continuous range maps we may be updating in our module. - ContinuousRangeMap::Builder SLocRemap(F.SLocRemap); - ContinuousRangeMap::Builder - IdentifierRemap(F.IdentifierRemap); - ContinuousRangeMap::Builder - MacroRemap(F.MacroRemap); - ContinuousRangeMap::Builder - PreprocessedEntityRemap(F.PreprocessedEntityRemap); - ContinuousRangeMap::Builder - SubmoduleRemap(F.SubmoduleRemap); - ContinuousRangeMap::Builder - SelectorRemap(F.SelectorRemap); - ContinuousRangeMap::Builder DeclRemap(F.DeclRemap); - ContinuousRangeMap::Builder TypeRemap(F.TypeRemap); + typedef ContinuousRangeMap::Builder + RemapBuilder; + RemapBuilder SLocRemap(F.SLocRemap); + RemapBuilder IdentifierRemap(F.IdentifierRemap); + RemapBuilder MacroRemap(F.MacroRemap); + RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap); + RemapBuilder SubmoduleRemap(F.SubmoduleRemap); + RemapBuilder SelectorRemap(F.SelectorRemap); + RemapBuilder DeclRemap(F.DeclRemap); + RemapBuilder TypeRemap(F.TypeRemap); while(Data < DataEnd) { using namespace llvm::support; @@ -2942,26 +2939,23 @@ ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) { uint32_t TypeIndexOffset = endian::readNext(Data); - // Source location offset is mapped to OM->SLocEntryBaseOffset. - SLocRemap.insert(std::make_pair(SLocOffset, - static_cast(OM->SLocEntryBaseOffset - SLocOffset))); - IdentifierRemap.insert( - std::make_pair(IdentifierIDOffset, - OM->BaseIdentifierID - IdentifierIDOffset)); - MacroRemap.insert(std::make_pair(MacroIDOffset, - OM->BaseMacroID - MacroIDOffset)); - PreprocessedEntityRemap.insert( - std::make_pair(PreprocessedEntityIDOffset, - OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); - SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset, - OM->BaseSubmoduleID - SubmoduleIDOffset)); - SelectorRemap.insert(std::make_pair(SelectorIDOffset, - OM->BaseSelectorID - SelectorIDOffset)); - DeclRemap.insert(std::make_pair(DeclIDOffset, - OM->BaseDeclID - DeclIDOffset)); - - TypeRemap.insert(std::make_pair(TypeIndexOffset, - OM->BaseTypeIndex - TypeIndexOffset)); + uint32_t None = std::numeric_limits::max(); + + auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset, + RemapBuilder &Remap) { + if (Offset != None) + Remap.insert(std::make_pair(Offset, + static_cast(BaseOffset - Offset))); + }; + mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap); + mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap); + mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap); + mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID, + PreprocessedEntityRemap); + mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap); + mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap); + mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap); + mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap); // Global -> local mappings. F.GlobalToLocalDeclIDs[OM] = DeclIDOffset; diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp index 5f8f5961be..474ea279e3 100644 --- a/lib/Serialization/ASTWriter.cpp +++ b/lib/Serialization/ASTWriter.cpp @@ -4455,25 +4455,36 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, SmallString<2048> Buffer; { llvm::raw_svector_ostream Out(Buffer); - for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), - MEnd = Chain->ModuleMgr.end(); - M != MEnd; ++M) { + for (ModuleFile *M : Chain->ModuleMgr) { using namespace llvm::support; endian::Writer LE(Out); - StringRef FileName = (*M)->FileName; + StringRef FileName = M->FileName; LE.write(FileName.size()); Out.write(FileName.data(), FileName.size()); + // Note: if a base ID was uint max, it would not be possible to load + // another module after it or have more than one entity inside it. + uint32_t None = std::numeric_limits::max(); + + auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) { + assert(BaseID < std::numeric_limits::max() && "base id too high"); + if (ShouldWrite) + LE.write(BaseID); + else + LE.write(None); + }; + // These values should be unique within a chain, since they will be read // as keys into ContinuousRangeMaps. - LE.write((*M)->SLocEntryBaseOffset); - LE.write((*M)->BaseIdentifierID); - LE.write((*M)->BaseMacroID); - LE.write((*M)->BasePreprocessedEntityID); - LE.write((*M)->BaseSubmoduleID); - LE.write((*M)->BaseSelectorID); - LE.write((*M)->BaseDeclID); - LE.write((*M)->BaseTypeIndex); + writeBaseIDOrNone(M->SLocEntryBaseOffset, M->LocalNumSLocEntries); + writeBaseIDOrNone(M->BaseIdentifierID, M->LocalNumIdentifiers); + writeBaseIDOrNone(M->BaseMacroID, M->LocalNumMacros); + writeBaseIDOrNone(M->BasePreprocessedEntityID, + M->NumPreprocessedEntities); + writeBaseIDOrNone(M->BaseSubmoduleID, M->LocalNumSubmodules); + writeBaseIDOrNone(M->BaseSelectorID, M->LocalNumSelectors); + writeBaseIDOrNone(M->BaseDeclID, M->LocalNumDecls); + writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes); } } Record.clear();