Generalize the module offset map to include mapping information for

all of the kinds of IDs that can be offset. No effectively
functionality change; this is preparation for adding remapping for
IDs.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@136686 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 86 insertions, 29 deletions

diff --git a/include/clang/Serialization/ContinuousRangeMap.h b/include/clang/Serialization/ContinuousRangeMap.h
index b1b7b6ede8..820086e820 100644
--- a/include/clang/Serialization/ContinuousRangeMap.h
+++ b/include/clang/Serialization/ContinuousRangeMap.h
@@ -89,6 +89,30 @@ public:
 
   reference back() { return Rep.back(); }
   const_reference back() const { return Rep.back(); }
+  
+  /// \brief An object that helps properly build a continuous range map
+  /// from a set of values.
+  class Builder {
+    ContinuousRangeMap &Self;
+    SmallVector<std::pair<Int, V>, InitialCapacity> Elements;
+    
+    Builder(const Builder&); // DO NOT IMPLEMENT
+    Builder &operator=(const Builder&); // DO NOT IMPLEMENT
+    
+  public:
+    explicit Builder(ContinuousRangeMap &Self) : Self(Self) { }
+    
+    ~Builder() {
+      std::sort(Elements.begin(), Elements.end(), Compare());
+      for (unsigned I = 0, N = Elements.size(); I != N; ++I)
+        Self.insert(Elements[I]);
+    }
+    
+    void insert(const value_type &Val) {
+      Elements.push_back(Val);
+    }
+  };
+  friend class Builder;
 };
 
 }
diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp
index 6521e7c3bd..177d4c91af 100644
--- a/lib/Serialization/ASTReader.cpp
+++ b/lib/Serialization/ASTReader.cpp
@@ -2275,19 +2275,41 @@ ASTReader::ReadASTBlock(Module &F) {
       // Additional remapping information.
       const unsigned char *Data = (const unsigned char*)BlobStart;
       const unsigned char *DataEnd = Data + BlobLen;
+      
+      // Continuous range maps we may be updating in our module.
+      ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
+      
       while(Data < DataEnd) {
-        uint32_t Offset = io::ReadUnalignedLE32(Data);
         uint16_t Len = io::ReadUnalignedLE16(Data);
         StringRef Name = StringRef((const char*)Data, Len);
+        Data += Len;
         Module *OM = ModuleMgr.lookup(Name);
         if (!OM) {
           Error("SourceLocation remap refers to unknown module");
           return Failure;
         }
-        // My Offset is mapped to OM->SLocEntryBaseOffset.
-        F.SLocRemap.insert(std::make_pair(Offset,
-                        static_cast<int>(OM->SLocEntryBaseOffset - Offset)));
-        Data += Len;
+
+        uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
+        uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t CXXBaseSpecifiersIDOffset = io::ReadUnalignedLE32(Data);
+        uint32_t TypeIDOffset = io::ReadUnalignedLE32(Data);
+        
+        // Source location offset is mapped to OM->SLocEntryBaseOffset.
+        SLocRemap.insert(std::make_pair(SLocOffset,
+          static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
+        
+        // FIXME: Map other locations
+        (void)IdentifierIDOffset;
+        (void)PreprocessedEntityIDOffset;
+        (void)MacroDefinitionIDOffset;
+        (void)SelectorIDOffset;
+        (void)DeclIDOffset;
+        (void)CXXBaseSpecifiersIDOffset;
+        (void)TypeIDOffset;
       }
       break;
     }
@@ -5434,15 +5456,18 @@ Module::Module(ModuleKind Kind)
   : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
     SLocEntryBaseOffset(0), SLocEntryOffsets(0),
     SLocFileOffsets(0), LocalNumIdentifiers(0), 
-    IdentifierOffsets(0), IdentifierTableData(0),
-    IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
-    MacroDefinitionOffsets(0), LocalNumHeaderFileInfos(0), 
+    IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0),
+    IdentifierLookupTable(0), BasePreprocessedEntityID(0),
+    LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0), 
+    BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0), 
     HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
     HeaderFileFrameworkStrings(0),
-    LocalNumSelectors(0), SelectorOffsets(0),
+    LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0),
     SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
-    DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
-    LocalNumTypes(0), TypeOffsets(0), StatCache(0),
+    DeclOffsets(0), BaseDeclID(0),
+    LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
+    BaseCXXBaseSpecifiersID(0),
+    LocalNumTypes(0), TypeOffsets(0), BaseTypeID(0), StatCache(0),
     NumPreallocatedPreprocessingEntities(0)
 {}
 
diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp
index 06200d8db0..fb24f85188 100644
--- a/lib/Serialization/ASTWriter.cpp
+++ b/lib/Serialization/ASTWriter.cpp
@@ -3041,35 +3041,43 @@ void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
   // Write the mapping information describing our module dependencies and how
   // each of those modules were mapped into our own offset/ID space, so that
   // the reader can build the appropriate mapping to its own offset/ID space.
-  
-  // If we have module dependencies, write the mapping from source locations to
-  // their containing modules, so that the reader can build the remapping.
   // The map consists solely of a blob with the following format:
-  // *(offset:i32 len:i16 name:len*i8)
-  // Sorted by offset.
-  typedef std::pair<uint32_t, StringRef> ModuleOffset;
-  SmallVector<ModuleOffset, 16> Modules;
-  
-  Chain->ModuleMgr.exportLookup(Modules);
-  
+  // *(module-name-len:i16 module-name:len*i8
+  //   source-location-offset:i32
+  //   identifier-id:i32
+  //   preprocessed-entity-id:i32
+  //   macro-definition-id:i32
+  //   selector-id:i32
+  //   declaration-id:i32
+  //   c++-base-specifiers-id:i32
+  //   type-id:i32)
+  // 
   llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
-  unsigned SLocMapAbbrev = Stream.EmitAbbrev(Abbrev);
+  unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
   llvm::SmallString<2048> Buffer;
   {
     llvm::raw_svector_ostream Out(Buffer);
-    for (SmallVector<ModuleOffset, 16>::iterator I = Modules.begin(),
-         E = Modules.end();
-         I != E; ++I) {
-      io::Emit32(Out, I->first);
-      io::Emit16(Out, I->second.size());
-      Out.write(I->second.data(), I->second.size());
+    for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
+                                         MEnd = Chain->ModuleMgr.end();
+         M != MEnd; ++M) {
+      StringRef FileName = (*M)->FileName;
+      io::Emit16(Out, FileName.size());
+      Out.write(FileName.data(), FileName.size());
+      io::Emit32(Out, (*M)->SLocEntryBaseOffset);
+      io::Emit32(Out, (*M)->BaseIdentifierID);
+      io::Emit32(Out, (*M)->BasePreprocessedEntityID);
+      io::Emit32(Out, (*M)->BaseMacroDefinitionID);
+      io::Emit32(Out, (*M)->BaseSelectorID);
+      io::Emit32(Out, (*M)->BaseDeclID);
+      io::Emit32(Out, (*M)->BaseCXXBaseSpecifiersID);
+      io::Emit32(Out, (*M)->BaseTypeID);
     }
   }
   Record.clear();
   Record.push_back(MODULE_OFFSET_MAP);
-  Stream.EmitRecordWithBlob(SLocMapAbbrev, Record,
+  Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
                             Buffer.data(), Buffer.size());
   
   // The special types are in the chained PCH.