[codeview] Add type stream merging prototype

[rnk]

Summary

This code is intended to be used as part of LLD's PDB writing. Until
that exists, this is exposed via llvm-readobj for testing purposes.

The .cpp file implementing the core merging algorithm only weighs in at
~400 lines of code.

Type stream merging uses the following algorithm:

• Begin with a new empty stream, and a new empty hash table that maps from type record contents to new type index.
• For each new type stream, maintain a map from source type index to destination type index.
• For each record, copy it and rewrite its type indices to be valid in the destination type stream.
• If the new type record is not already present in the destination stream hash table, append it to the destination type stream, assign it the next type index, and update the two hash tables.
• If the type record already exists in the destination stream, discard it and update the type index map to forward the source type index to the existing destination type index.

[ruiu]

I think this is going to be used in a speed critical path. I'm wondering if this is the fastest way to merge debug types -- one hash table lookup for each derived type may be a bit slow. But at least I don't come up with a better way, so hash table lookup might be unavoidable.

include/llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h

62 ↗

(On Diff #56768)

Why don't you use DenseMap?

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

38–39 ↗

(On Diff #56768)

It doesn't look like you are using hash table, but instead you are using vectors to map indices.

Ah, so the hash table is in MemoryTypeTableBuilder.h?

[rnk]

Hm, the latest changes to TypeVisitor made this a lot, lot harder. With the old visitor, I duplicated a lot of the layout knowledge, but now I'm having a hard time remapping all the type indices because the current high level record types are immutable.

[zturner]

Can't you make them mutable? I agree it's a bit annoying to change all
those classes, but it will probably need to happen eventually anyway

[rnk]

I have a working patch, but it's much larger now because it uses the high level TypeTableBuilder APIs, and those needed to be fleshed out. I'll see if I can cut it down a bit.

include/llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h

62 ↗

(On Diff #56768)

I didn't write it. I intend to come back here later and make it efficient, once it's correct and we can profile it.

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

38–39 ↗

(On Diff #56768)

Yeah, it's part of the implementation of TypeTableBuilder.

[rnk]

• Rewrite type stream merging to use new visitor
• Update TypeTableBuilder serialization code to work

[• dberlin]

It is possible to do it faster if the miss rate is high, and the hash
function is expensive.
Otherwise, it's not.

[zturner]

lib/DebugInfo/CodeView/TypeRecord.cpp

45–48 ↗

(On Diff #57236)

Will this short circuit if anything fails? Perhaps you should write Success = Success && remapIndex(IndexMap, ReturnType) etc.

[rnk]

lib/DebugInfo/CodeView/TypeRecord.cpp

45–48 ↗

(On Diff #57236)

The idea is that it won't short circuit. It will remap all the indices to the "untranslated" index, and then you can decide if you want to warn the user that some of the input was invalid. It seemed useful in the context of writing a PDB, where some object files might be busted, but you don't want to abort the whole link.

llvm/trunk/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

 //===- CVTypeVisitor.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
 #define LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/RecordIterator.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeStream.h"
 #include "llvm/Support/ErrorOr.h"
 
 namespace llvm {
 namespace codeview {
 
 template <typename Derived>
 class CVTypeVisitor {
 public:
static ArrayRef<uint8_t> skipPadding(ArrayRef<uint8_t> Data) {
     // Leaf is greater than 0xf0. We should advance by the number of bytes in
     // the low 4 bits.
     return Data.drop_front(Leaf & 0x0F);
   }
 
   /// Visits individual member records of a field list record. Member records do
   /// not describe their own length, and need special handling.
   void visitFieldList(TypeLeafKind Leaf, ArrayRef<uint8_t> FieldData) {
+    auto *DerivedThis = static_cast<Derived *>(this);
     while (!FieldData.empty()) {
       const ulittle16_t *LeafPtr;
       if (!CVTypeVisitor::consumeObject(FieldData, LeafPtr))
         return;
       TypeLeafKind Leaf = TypeLeafKind(unsigned(*LeafPtr));
       switch (Leaf) {
       default:
         // Field list records do not describe their own length, so we cannot
         // continue parsing past an unknown member type.
-        visitUnknownMember(Leaf);
+        DerivedThis->visitUnknownMember(Leaf);
         return parseError();
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
     auto Result = Name##Record::deserialize(RK, FieldData);                    \
     if (Result.getError())                                                     \
       return parseError();                                                     \
-    static_cast<Derived *>(this)->visit##Name(Leaf, *Result);                  \
+    DerivedThis->visit##Name(Leaf, *Result);                                   \
     break;                                                                     \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
   MEMBER_RECORD(EnumVal, EnumVal, AliasName)
 #include "TypeRecords.def"
       }
       FieldData = skipPadding(FieldData);
     }

llvm/trunk/include/llvm/DebugInfo/CodeView/FieldListRecordBuilder.h

 //===- FieldListRecordBuilder.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_FIELDLISTRECORDBUILDER_H
 #define LLVM_DEBUGINFO_CODEVIEW_FIELDLISTRECORDBUILDER_H
 
 #include "llvm/DebugInfo/CodeView/ListRecordBuilder.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 
 namespace llvm {
 namespace codeview {
 
 class MethodInfo {
 public:
   MethodInfo() : Access(), Kind(), Options(), Type(), VTableSlotOffset(-1) {}
 

 class FieldListRecordBuilder : public ListRecordBuilder {
 private:
   FieldListRecordBuilder(const FieldListRecordBuilder &) = delete;
   void operator=(const FieldListRecordBuilder &) = delete;
 
 public:
   FieldListRecordBuilder();
 
-  void writeBaseClass(MemberAccess Access, TypeIndex Type, uint64_t Offset);
-  void writeEnumerate(MemberAccess Access, uint64_t Value, StringRef Name);
-  void writeIndirectVirtualBaseClass(MemberAccess Access, TypeIndex Type,
-                                     TypeIndex VirtualBasePointerType,
-                                     int64_t VirtualBasePointerOffset,
-                                     uint64_t SlotIndex);
-  void writeMember(MemberAccess Access, TypeIndex Type, uint64_t Offset,
-                   StringRef Name);
-  void writeOneMethod(MemberAccess Access, MethodKind Kind,
-                      MethodOptions Options, TypeIndex Type,
-                      int32_t VTableSlotOffset, StringRef Name);
-  void writeOneMethod(const MethodInfo &Method, StringRef Name);
-  void writeMethod(uint16_t OverloadCount, TypeIndex MethodList,
-                   StringRef Name);
-  void writeNestedType(TypeIndex Type, StringRef Name);
-  void writeStaticMember(MemberAccess Access, TypeIndex Type, StringRef Name);
-  void writeVirtualBaseClass(MemberAccess Access, TypeIndex Type,
-                             TypeIndex VirtualBasePointerType,
-                             int64_t VirtualBasePointerOffset,
-                             uint64_t SlotIndex);
-  void writeVirtualBaseClass(TypeRecordKind Kind, MemberAccess Access,
-                             TypeIndex Type, TypeIndex VirtualBasePointerType,
-                             int64_t VirtualBasePointerOffset,
-                             uint64_t SlotIndex);
-  void writeVirtualFunctionTablePointer(TypeIndex Type);
+  void writeBaseClass(const BaseClassRecord &Record);
+  void writeEnumerator(const EnumeratorRecord &Record);
+  void writeDataMember(const DataMemberRecord &Record);
+  void writeOneMethod(const OneMethodRecord &Record);
+  void writeOverloadedMethod(const OverloadedMethodRecord &Record);
+  void writeNestedType(const NestedTypeRecord &Record);
+  void writeStaticDataMember(const StaticDataMemberRecord &Record);
+  void writeVirtualBaseClass(const VirtualBaseClassRecord &Record);
+  void writeVFPtr(const VFPtrRecord &Type);
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/CodeView/ListRecordBuilder.h

 protected:
   const int MethodKindShift = 2;
 
   explicit ListRecordBuilder(TypeRecordKind Kind);
 
 public:
   llvm::StringRef str() { return Builder.str(); }
 
+  void reset() { Builder.reset(); }
+
 protected:
   void finishSubRecord();
 
   TypeRecordBuilder &getBuilder() { return Builder; }
 
 private:
   TypeRecordBuilder Builder;
   SmallVector<size_t, 4> ContinuationOffsets;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h

template <typename TFunc> void ForEachRecord(TFunc Func) {
     uint32_t Index = TypeIndex::FirstNonSimpleIndex;
 
     for (const std::unique_ptr<Record> &R : Records) {
       Func(TypeIndex(Index), R.get());
       ++Index;
     }
   }
 
-private:
+protected:
   TypeIndex writeRecord(llvm::StringRef Data) override;
 
 private:
   std::vector<std::unique_ptr<Record>> Records;
   std::unordered_map<llvm::StringRef, TypeIndex, RecordHash> HashedRecords;
 };
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_MEMORYTYPETABLEBUILDER_H

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h

 using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
   ulittle16_t Attrs;
+  enum {
+    MethodKindShift = 2,
+  };
 
   /// Get the access specifier. Valid for any kind of member.
   MemberAccess getAccess() const {
     return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
   }
 
   /// Indicates if a method is defined with friend, virtual, static, etc.
   MethodKind getMethodKind() const {
     return MethodKind(
-        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >> 2);
+        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >>
+        MethodKindShift);
   }
 
   /// Get the flags that are not included in access control or method
   /// properties.
   MethodOptions getFlags() const {
     return MethodOptions(
         unsigned(Attrs) &
         ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));

 class MemberPointerInfo {
 public:
   MemberPointerInfo() {}
 
   MemberPointerInfo(TypeIndex ContainingType,
                     PointerToMemberRepresentation Representation)
       : ContainingType(ContainingType), Representation(Representation) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<MemberPointerInfo> deserialize(ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     TypeIndex T = L->ClassType;
     uint16_t R = L->Representation;
     PointerToMemberRepresentation PMR =

 
 // LF_MODIFIER
 class ModifierRecord : public TypeRecord {
 public:
   ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
       : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),
         Modifiers(Modifiers) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<ModifierRecord> deserialize(TypeRecordKind Kind,
                                              ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     TypeIndex M = L->ModifiedType;
     uint16_t O = L->Modifiers;

 public:
   ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
                   FunctionOptions Options, uint16_t ParameterCount,
                   TypeIndex ArgumentList)
       : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),
         CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),
         ArgumentList(ArgumentList) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<ProcedureRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     return ProcedureRecord(L->ReturnType, L->CallConv, L->Options,
                            L->NumParameters, L->ArgListType);
MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
                        FunctionOptions Options, uint16_t ParameterCount,
                        TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
       : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),
         ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
         Options(Options), ParameterCount(ParameterCount),
         ArgumentList(ArgumentList),
         ThisPointerAdjustment(ThisPointerAdjustment) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<MemberFunctionRecord> deserialize(TypeRecordKind Kind,
                                                    ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     CV_DESERIALIZE(Data, L);
 
     return MemberFunctionRecord(L->ReturnType, L->ClassType, L->ThisType,
                                 L->CallConv, L->Options, L->NumParameters,
                                 L->ArgListType, L->ThisAdjustment);

 // LF_MFUNC_ID
 class MemberFuncIdRecord : public TypeRecord {
 public:
   MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
                          StringRef Name)
       : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
         FunctionType(FunctionType), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<MemberFuncIdRecord> deserialize(TypeRecordKind Kind,
-                                                     ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return MemberFuncIdRecord(L->ClassType, L->FunctionType, Name);
   }
 
   TypeIndex getClassType() const { return ClassType; }

 };
 
 // LF_ARGLIST, LF_SUBSTR_LIST
 class ArgListRecord : public TypeRecord {
 public:
   ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
       : TypeRecord(Kind), StringIndices(Indices) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<ArgListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     if (Kind != TypeRecordKind::StringList && Kind != TypeRecordKind::ArgList)
       return std::make_error_code(std::errc::illegal_byte_sequence);
 
     const Layout *L = nullptr;
     ArrayRef<TypeIndex> Indices;
     CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
 
     return ArgListRecord(Kind, Indices);
   }
 
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
 private:
   struct Layout {
     ulittle32_t NumArgs; // Number of arguments
                          // ArgTypes[]: Type indicies of arguments
   };
 
-  ArrayRef<TypeIndex> StringIndices;
+  std::vector<TypeIndex> StringIndices;
 };
 
 // LF_POINTER
 class PointerRecord : public TypeRecord {
 public:
   static const uint32_t PointerKindShift = 0;
   static const uint32_t PointerKindMask = 0x1F;
 
public:
 
   PointerRecord(TypeIndex ReferentType, PointerKind Kind, PointerMode Mode,
                 PointerOptions Options, uint8_t Size,
                 const MemberPointerInfo &Member)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
         PtrKind(Kind), Mode(Mode), Options(Options), Size(Size),
         MemberInfo(Member) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<PointerRecord> deserialize(TypeRecordKind Kind,
                                             ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     PointerKind PtrKind = L->getPtrKind();
     PointerMode Mode = L->getPtrMode();

 };
 
 // LF_NESTTYPE
 class NestedTypeRecord : public TypeRecord {
 public:
   NestedTypeRecord(TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<NestedTypeRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return NestedTypeRecord(L->Type, Name);
   }

 // LF_ARRAY
 class ArrayRecord : public TypeRecord {
 public:
   ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
               StringRef Name)
       : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),
         IndexType(IndexType), Size(Size), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<ArrayRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Size;
     StringRef Name;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Size), Name);
 
     return ArrayRecord(L->ElementType, L->IndexType, Size, Name);

 class TagRecord : public TypeRecord {
 protected:
   TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
             TypeIndex FieldList, StringRef Name, StringRef UniqueName)
       : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
         FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}
 
 public:
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static const int HfaKindShift = 11;
   static const int HfaKindMask = 0x1800;
   static const int WinRTKindShift = 14;
   static const int WinRTKindMask = 0xC000;
 
   uint16_t getMemberCount() const { return MemberCount; }
   ClassOptions getOptions() const { return Options; }
   TypeIndex getFieldList() const { return FieldList; }
public:
   ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
               HfaKind Hfa, WindowsRTClassKind WinRTKind, TypeIndex FieldList,
               TypeIndex DerivationList, TypeIndex VTableShape, uint64_t Size,
               StringRef Name, StringRef UniqueName)
       : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),
         Hfa(Hfa), WinRTKind(WinRTKind), DerivationList(DerivationList),
         VTableShape(VTableShape), Size(Size) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<ClassRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data) {
     uint64_t Size = 0;
     StringRef Name;
     StringRef UniqueName;
     uint16_t Props;
     const Layout *L = nullptr;
 

 class EnumRecord : public TagRecord {
 public:
   EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
              StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
       : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
                   UniqueName),
         UnderlyingType(UnderlyingType) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<EnumRecord> deserialize(TypeRecordKind Kind,
                                          ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     uint16_t P = L->Properties;
     ClassOptions Options = static_cast<ClassOptions>(P);

 // LF_VTSHAPE
 class VFTableShapeRecord : public TypeRecord {
 public:
   explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
   explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VFTableShape), Slots(Slots) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<VFTableShapeRecord> deserialize(TypeRecordKind Kind,
-                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     std::vector<VFTableSlotKind> Slots;
     uint16_t Count = L->VFEntryCount;
     while (Count > 0) {
       if (Data.empty())

 
 // LF_TYPESERVER2
 class TypeServer2Record : public TypeRecord {
 public:
   TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
       : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
         Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<TypeServer2Record> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return TypeServer2Record(StringRef(L->Guid, 16), L->Age, Name);
   }

 };
 
 // LF_STRING_ID
 class StringIdRecord : public TypeRecord {
 public:
   StringIdRecord(TypeIndex Id, StringRef String)
       : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<StringIdRecord> deserialize(TypeRecordKind Kind,
                                              ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return StringIdRecord(L->id, Name);
   }

 
 // LF_FUNC_ID
 class FuncIdRecord : public TypeRecord {
 public:
   FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
       : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
         FunctionType(FunctionType), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<FuncIdRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return FuncIdRecord(L->ParentScope, L->FunctionType, Name);
   }

 
 // LF_UDT_SRC_LINE
 class UdtSourceLineRecord : public TypeRecord {
 public:
   UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<UdtSourceLineRecord> deserialize(TypeRecordKind Kind,
                                                   ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     CV_DESERIALIZE(Data, L);
 
     return UdtSourceLineRecord(L->UDT, L->SourceFile, L->LineNumber);
   }
 
private:
   TypeIndex SourceFile;
   uint32_t LineNumber;
 };
 
 // LF_BUILDINFO
 class BuildInfoRecord : public TypeRecord {
 public:
   BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
-      : TypeRecord(TypeRecordKind::Modifier), ArgIndices(ArgIndices) {}
+      : TypeRecord(TypeRecordKind::BuildInfo),
+        ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}
+
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static ErrorOr<BuildInfoRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     ArrayRef<TypeIndex> Indices;
     CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
 
     return BuildInfoRecord(Indices);
   }
 
   ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
 
 private:
   struct Layout {
     ulittle16_t NumArgs; // Number of arguments
                          // ArgTypes[]: Type indicies of arguments
   };
-  ArrayRef<TypeIndex> ArgIndices;
+  SmallVector<TypeIndex, 4> ArgIndices;
 };
 
 // LF_VFTABLE
 class VFTableRecord : public TypeRecord {
 public:
   VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
                 uint32_t VFPtrOffset, StringRef Name,
                 ArrayRef<StringRef> Methods)
       : TypeRecord(TypeRecordKind::VFTable),
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNamesRef(Methods) {}
   VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
                 uint32_t VFPtrOffset, StringRef Name,
                 const std::vector<StringRef> &Methods)
       : TypeRecord(TypeRecordKind::VFTable),
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNames(Methods) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<VFTableRecord> deserialize(TypeRecordKind Kind,
                                             ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     std::vector<StringRef> Names;
     CV_DESERIALIZE(Data, L, Name, CV_ARRAY_FIELD_TAIL(Names));
 
     return VFTableRecord(L->CompleteClass, L->OverriddenVFTable, L->VFPtrOffset,

 class OneMethodRecord : public TypeRecord {
 public:
   OneMethodRecord(TypeIndex Type, MethodKind Kind, MethodOptions Options,
                   MemberAccess Access, int32_t VFTableOffset, StringRef Name)
       : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Kind(Kind),
         Options(Options), Access(Access), VFTableOffset(VFTableOffset),
         Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<OneMethodRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
-    int32_t VFTableOffset = 0;
+    int32_t VFTableOffset = -1;
 
     CV_DESERIALIZE(Data, L, CV_CONDITIONAL_FIELD(
                                 VFTableOffset, L->Attrs.isIntroducedVirtual()),
                    Name);
 
     MethodOptions Options = L->Attrs.getFlags();
     MethodKind MethKind = L->Attrs.getMethodKind();
     MemberAccess Access = L->Attrs.getAccess();
private:
   MemberAccess Access;
   int32_t VFTableOffset;
   StringRef Name;
 };
 
 // LF_METHODLIST
 class MethodOverloadListRecord : public TypeRecord {
 public:
-  MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
-      : TypeRecord(TypeRecordKind::MethodOverloadList), MethodsRef(Methods) {}
   MethodOverloadListRecord(std::vector<OneMethodRecord> &Methods)
       : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<MethodOverloadListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     std::vector<OneMethodRecord> Methods;
     while (!Data.empty()) {
       const Layout *L = nullptr;
-      int32_t VFTableOffset = 0;
+      int32_t VFTableOffset = -1;
       CV_DESERIALIZE(
           Data, L,
           CV_CONDITIONAL_FIELD(VFTableOffset, L->Attrs.isIntroducedVirtual()));
 
       MethodOptions Options = L->Attrs.getFlags();
       MethodKind MethKind = L->Attrs.getMethodKind();
       MemberAccess Access = L->Attrs.getAccess();
 
       Methods.emplace_back(L->Type, MethKind, Options, Access, VFTableOffset,
                            StringRef());
     }
     return MethodOverloadListRecord(Methods);
   }
 
-  ArrayRef<OneMethodRecord> getMethods() const {
-    if (!MethodsRef.empty())
-      return MethodsRef;
-    return Methods;
-  }
+  ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
 
 private:
   struct Layout {
     MemberAttributes Attrs;
     ulittle16_t Padding;
 
     TypeIndex Type;
     // If is introduced virtual method:
     //   VFTableOffset: int32_t offset in vftable
   };
 
-  ArrayRef<OneMethodRecord> MethodsRef;
   std::vector<OneMethodRecord> Methods;
 };
 
 /// For method overload sets.  LF_METHOD
 class OverloadedMethodRecord : public TypeRecord {
 public:
   OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
                          StringRef Name)
       : TypeRecord(TypeRecordKind::OverloadedMethod),
         NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<OverloadedMethodRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return OverloadedMethodRecord(L->MethodCount, L->MethList, Name);
   }

 // LF_MEMBER
 class DataMemberRecord : public TypeRecord {
 public:
   DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
                    StringRef Name)
       : TypeRecord(TypeRecordKind::DataMember), Access(Access), Type(Type),
         FieldOffset(Offset), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<DataMemberRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Offset;
     StringRef Name;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), Name);
 
     return DataMemberRecord(L->Attrs.getAccess(), L->Type, Offset, Name);

 
 // LF_STMEMBER
 class StaticDataMemberRecord : public TypeRecord {
 public:
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::StaticDataMember), Access(Access),
         Type(Type), Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<StaticDataMemberRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return StaticDataMemberRecord(L->Attrs.getAccess(), L->Type, Name);
   }

 
 // LF_ENUMERATE
 class EnumeratorRecord : public TypeRecord {
 public:
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerator), Access(Access), Value(Value),
         Name(Name) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<EnumeratorRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     APSInt Value;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Value, Name);
 
     return EnumeratorRecord(L->Attrs.getAccess(), Value, Name);
private:
   StringRef Name;
 };
 
 // LF_VFUNCTAB
 class VFPtrRecord : public TypeRecord {
 public:
   VFPtrRecord(TypeIndex Type)
       : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
+
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<VFPtrRecord>
   deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
     return VFPtrRecord(L->Type);
   }

 
 // LF_BCLASS, LF_BINTERFACE
 class BaseClassRecord : public TypeRecord {
 public:
   BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
       : TypeRecord(TypeRecordKind::BaseClass), Access(Access), Type(Type),
         Offset(Offset) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<BaseClassRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Offset;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset));
 
     return BaseClassRecord(L->Attrs.getAccess(), L->BaseType, Offset);
   }

 class VirtualBaseClassRecord : public TypeRecord {
 public:
   VirtualBaseClassRecord(MemberAccess Access, TypeIndex BaseType,
                          TypeIndex VBPtrType, uint64_t Offset, uint64_t Index)
       : TypeRecord(TypeRecordKind::VirtualBaseClass), Access(Access),
         BaseType(BaseType), VBPtrType(VBPtrType), VBPtrOffset(Offset),
         VTableIndex(Index) {}
 
+  /// Rewrite member type indices with IndexMap. Returns false if a type index
+  /// is not in the map.
+  bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
+
   static ErrorOr<VirtualBaseClassRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Offset;
     uint64_t Index;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
 
     return VirtualBaseClassRecord(L->Attrs.getAccess(), L->BaseType,

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecordBuilder.h

public:
   void writeUInt64(uint64_t Value);
   void writeTypeIndex(TypeIndex TypeInd);
   void writeTypeRecordKind(TypeRecordKind Kind);
   void writeEncodedInteger(int64_t Value);
   void writeEncodedSignedInteger(int64_t Value);
   void writeEncodedUnsignedInteger(uint64_t Value);
   void writeNullTerminatedString(const char *Value);
   void writeNullTerminatedString(StringRef Value);
+  void writeGuid(StringRef Guid);
 
   llvm::StringRef str();
 
   uint64_t size() const { return Stream.tell(); }
 
+  void reset() { Buffer.clear(); }
+
 private:
   llvm::SmallVector<char, 256> Buffer;
   llvm::raw_svector_ostream Stream;
   llvm::support::endian::Writer<llvm::support::endianness::little> Writer;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h

+//===- TypeStreamMerger.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_CODEVIEW_TYPESTREAMMERGER_H
+#define LLVM_DEBUGINFO_CODEVIEW_TYPESTREAMMERGER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
+
+namespace llvm {
+namespace codeview {
+
+/// Merges one type stream into another. Returns true on success.
+bool mergeTypeStreams(TypeTableBuilder &DestStream,
+                      ArrayRef<uint8_t> SrcStream);
+
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPESTREAMMERGER_H

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeTableBuilder.h

 public:
   virtual ~TypeTableBuilder();
 
 public:
   TypeIndex writeModifier(const ModifierRecord &Record);
   TypeIndex writeProcedure(const ProcedureRecord &Record);
   TypeIndex writeMemberFunction(const MemberFunctionRecord &Record);
   TypeIndex writeArgList(const ArgListRecord &Record);
-  TypeIndex writeRecord(TypeRecordBuilder &builder);
   TypeIndex writePointer(const PointerRecord &Record);
   TypeIndex writeArray(const ArrayRecord &Record);
   TypeIndex writeClass(const ClassRecord &Record);
+  TypeIndex writeUnion(const UnionRecord &Record);
   TypeIndex writeEnum(const EnumRecord &Record);
   TypeIndex writeBitField(const BitFieldRecord &Record);
   TypeIndex writeVFTableShape(const VFTableShapeRecord &Record);
+  TypeIndex writeStringId(const StringIdRecord &Record);
+  TypeIndex writeVFTable(const VFTableRecord &Record);
+  TypeIndex writeUdtSourceLine(const UdtSourceLineRecord &Record);
+  TypeIndex writeFuncId(const FuncIdRecord &Record);
+  TypeIndex writeMemberFuncId(const MemberFuncIdRecord &Record);
+  TypeIndex writeBuildInfo(const BuildInfoRecord &Record);
+  TypeIndex writeMethodOverloadList(const MethodOverloadListRecord &Record);
+  TypeIndex writeTypeServer2(const TypeServer2Record &Record);
 
   TypeIndex writeFieldList(FieldListRecordBuilder &FieldList);
-  TypeIndex writeMethodList(MethodListRecordBuilder &MethodList);
 
-private:
+  TypeIndex writeRecord(TypeRecordBuilder &builder);
+
   virtual TypeIndex writeRecord(llvm::StringRef record) = 0;
 };
 }
 }
 
 #endif

llvm/trunk/lib/DebugInfo/CodeView/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoCodeView
   FieldListRecordBuilder.cpp
   Line.cpp
   ListRecordBuilder.cpp
   MemoryTypeTableBuilder.cpp
   MethodListRecordBuilder.cpp
   RecordSerialization.cpp
   TypeDumper.cpp
+  TypeRecord.cpp
   TypeRecordBuilder.cpp
+  TypeStreamMerger.cpp
   TypeTableBuilder.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/CodeView
   )

llvm/trunk/lib/DebugInfo/CodeView/FieldListRecordBuilder.cpp

 #include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
 
 using namespace llvm;
 using namespace codeview;
 
 FieldListRecordBuilder::FieldListRecordBuilder()
     : ListRecordBuilder(TypeRecordKind::FieldList) {}
 
-void FieldListRecordBuilder::writeBaseClass(MemberAccess Access, TypeIndex Type,
-                                            uint64_t Offset) {
+void FieldListRecordBuilder::writeBaseClass(const BaseClassRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
   Builder.writeTypeRecordKind(TypeRecordKind::BaseClass);
-  Builder.writeUInt16(static_cast<uint16_t>(Access));
-  Builder.writeTypeIndex(Type);
-  Builder.writeEncodedUnsignedInteger(Offset);
+  Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
+  Builder.writeTypeIndex(Record.getBaseType());
+  Builder.writeEncodedUnsignedInteger(Record.getBaseOffset());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeEnumerate(MemberAccess Access, uint64_t Value,
-                                            StringRef Name) {
+void FieldListRecordBuilder::writeEnumerator(const EnumeratorRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
   Builder.writeTypeRecordKind(TypeRecordKind::Enumerator);
-  Builder.writeUInt16(static_cast<uint16_t>(Access));
-  Builder.writeEncodedUnsignedInteger(Value);
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
+  // FIXME: Handle full APInt such as __int128.
+  Builder.writeEncodedUnsignedInteger(Record.getValue().getZExtValue());
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeMember(MemberAccess Access, TypeIndex Type,
-                                         uint64_t Offset, StringRef Name) {
+void FieldListRecordBuilder::writeDataMember(const DataMemberRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::DataMember);
-  Builder.writeUInt16(static_cast<uint16_t>(Access));
-  Builder.writeTypeIndex(Type);
-  Builder.writeEncodedUnsignedInteger(Offset);
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
+  Builder.writeTypeIndex(Record.getType());
+  Builder.writeEncodedUnsignedInteger(Record.getFieldOffset());
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeMethod(uint16_t OverloadCount,
-                                         TypeIndex MethodList, StringRef Name) {
+void FieldListRecordBuilder::writeOverloadedMethod(
+    const OverloadedMethodRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
   Builder.writeTypeRecordKind(TypeRecordKind::OverloadedMethod);
-  Builder.writeUInt16(OverloadCount);
-  Builder.writeTypeIndex(MethodList);
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeUInt16(Record.getNumOverloads());
+  Builder.writeTypeIndex(Record.getMethodList());
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeOneMethod(
-    MemberAccess Access, MethodKind Kind, MethodOptions Options, TypeIndex Type,
-    int32_t VTableSlotOffset, StringRef Name) {
+void FieldListRecordBuilder::writeOneMethod(const OneMethodRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  uint16_t Flags = static_cast<uint16_t>(Access);
-  Flags |= static_cast<uint16_t>(Kind) << MethodKindShift;
-  Flags |= static_cast<uint16_t>(Options);
+  uint16_t Flags = static_cast<uint16_t>(Record.getAccess());
+  Flags |= static_cast<uint16_t>(Record.getKind()) << MethodKindShift;
+  Flags |= static_cast<uint16_t>(Record.getOptions());
 
   Builder.writeTypeRecordKind(TypeRecordKind::OneMethod);
   Builder.writeUInt16(Flags);
-  Builder.writeTypeIndex(Type);
-  switch (Kind) {
-  case MethodKind::IntroducingVirtual:
-  case MethodKind::PureIntroducingVirtual:
-    assert(VTableSlotOffset >= 0);
-    Builder.writeInt32(VTableSlotOffset);
-    break;
-
-  default:
-    assert(VTableSlotOffset == -1);
-    break;
+  Builder.writeTypeIndex(Record.getType());
+  if (Record.isIntroducingVirtual()) {
+    assert(Record.getVFTableOffset() >= 0);
+    Builder.writeInt32(Record.getVFTableOffset());
+  } else {
+    assert(Record.getVFTableOffset() == -1);
   }
 
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeOneMethod(const MethodInfo &Method,
-                                            StringRef Name) {
-  writeOneMethod(Method.getAccess(), Method.getKind(), Method.getOptions(),
-                 Method.getType(), Method.getVTableSlotOffset(), Name);
-}
-
-void FieldListRecordBuilder::writeNestedType(TypeIndex Type, StringRef Name) {
+void FieldListRecordBuilder::writeNestedType(const NestedTypeRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::NestedType);
+  Builder.writeTypeRecordKind(Record.getKind());
   Builder.writeUInt16(0);
-  Builder.writeTypeIndex(Type);
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeTypeIndex(Record.getNestedType());
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeStaticMember(MemberAccess Access,
-                                               TypeIndex Type, StringRef Name) {
+void FieldListRecordBuilder::writeStaticDataMember(
+    const StaticDataMemberRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::StaticDataMember);
-  Builder.writeUInt16(static_cast<uint16_t>(Access));
-  Builder.writeTypeIndex(Type);
-  Builder.writeNullTerminatedString(Name);
+  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
+  Builder.writeTypeIndex(Record.getType());
+  Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeIndirectVirtualBaseClass(
-    MemberAccess Access, TypeIndex Type, TypeIndex VirtualBasePointerType,
-    int64_t VirtualBasePointerOffset, uint64_t SlotIndex) {
-  writeVirtualBaseClass(TypeRecordKind::IndirectVirtualBaseClass, Access, Type,
-                        VirtualBasePointerType, VirtualBasePointerOffset,
-                        SlotIndex);
-}
-
-void FieldListRecordBuilder::writeVirtualBaseClass(
-    MemberAccess Access, TypeIndex Type, TypeIndex VirtualBasePointerType,
-    int64_t VirtualBasePointerOffset, uint64_t SlotIndex) {
-  writeVirtualBaseClass(TypeRecordKind::VirtualBaseClass, Access, Type,
-                        VirtualBasePointerType, VirtualBasePointerOffset,
-                        SlotIndex);
-}
-
 void FieldListRecordBuilder::writeVirtualBaseClass(
-    TypeRecordKind Kind, MemberAccess Access, TypeIndex Type,
-    TypeIndex VirtualBasePointerType, int64_t VirtualBasePointerOffset,
-    uint64_t SlotIndex) {
+    const VirtualBaseClassRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(Kind);
-  Builder.writeUInt16(static_cast<uint16_t>(Access));
-  Builder.writeTypeIndex(Type);
-  Builder.writeTypeIndex(VirtualBasePointerType);
-  Builder.writeEncodedInteger(VirtualBasePointerOffset);
-  Builder.writeEncodedUnsignedInteger(SlotIndex);
+  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
+  Builder.writeTypeIndex(Record.getBaseType());
+  Builder.writeTypeIndex(Record.getVBPtrType());
+  Builder.writeEncodedInteger(Record.getVBPtrOffset());
+  Builder.writeEncodedUnsignedInteger(Record.getVTableIndex());
 
   finishSubRecord();
 }
 
-void FieldListRecordBuilder::writeVirtualFunctionTablePointer(TypeIndex Type) {
+void FieldListRecordBuilder::writeVFPtr(const VFPtrRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
   Builder.writeTypeRecordKind(TypeRecordKind::VFPtr);
   Builder.writeUInt16(0);
-  Builder.writeTypeIndex(Type);
+  Builder.writeTypeIndex(Record.getType());
 
   finishSubRecord();
 }

llvm/trunk/lib/DebugInfo/CodeView/TypeDumper.cpp

 
 void CVTypeDumperImpl::visitStringId(TypeLeafKind Leaf,
                                            StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W.printString("StringData", String.getString());
   // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
   Name = String.getString();
 }
+
 void CVTypeDumperImpl::visitArgList(TypeLeafKind Leaf, ArgListRecord &Args) {
   auto Indices = Args.getIndices();
   uint32_t Size = Indices.size();
   W.printNumber("NumArgs", Size);
   ListScope Arguments(W, "Arguments");
   SmallString<256> TypeName("(");
   for (uint32_t I = 0; I < Size; ++I) {
     printTypeIndex("ArgType", Indices[I]);

llvm/trunk/lib/DebugInfo/CodeView/TypeRecord.cpp

+//===-- TypeRecord.cpp ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+static bool remapIndex(ArrayRef<TypeIndex> IndexMap, TypeIndex &Idx) {
+  // Simple types are unchanged.
+  if (Idx.isSimple())
+    return true;
+  unsigned MapPos = Idx.getIndex() - TypeIndex::FirstNonSimpleIndex;
+  if (MapPos < IndexMap.size()) {
+    Idx = IndexMap[MapPos];
+    return true;
+  }
+
+  // This type index is invalid. Remap this to "not translated by cvpack",
+  // and return failure.
+  Idx = TypeIndex(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct);
+  return false;
+}
+
+bool ModifierRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, ModifiedType);
+}
+
+bool ProcedureRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ReturnType);
+  Success &= remapIndex(IndexMap, ArgumentList);
+  return Success;
+}
+
+bool MemberFunctionRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ReturnType);
+  Success &= remapIndex(IndexMap, ClassType);
+  Success &= remapIndex(IndexMap, ThisType);
+  Success &= remapIndex(IndexMap, ArgumentList);
+  return Success;
+}
+
+bool MemberFuncIdRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ClassType);
+  Success &= remapIndex(IndexMap, FunctionType);
+  return Success;
+}
+
+bool ArgListRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  for (TypeIndex &Str : StringIndices)
+    Success &= remapIndex(IndexMap, Str);
+  return Success;
+}
+
+bool MemberPointerInfo::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, ContainingType);
+}
+
+bool PointerRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ReferentType);
+  if (isPointerToMember())
+    Success &= MemberInfo.remapTypeIndices(IndexMap);
+  return Success;
+}
+
+bool NestedTypeRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Type);
+}
+
+bool ArrayRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ElementType);
+  Success &= remapIndex(IndexMap, IndexType);
+  return Success;
+}
+
+bool TagRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, FieldList);
+}
+
+bool ClassRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= TagRecord::remapTypeIndices(IndexMap);
+  Success &= remapIndex(IndexMap, DerivationList);
+  Success &= remapIndex(IndexMap, VTableShape);
+  return Success;
+}
+
+bool EnumRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= TagRecord::remapTypeIndices(IndexMap);
+  Success &= remapIndex(IndexMap, UnderlyingType);
+  return Success;
+}
+
+bool VFTableShapeRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return true;
+}
+
+bool TypeServer2Record::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return true;
+}
+
+bool StringIdRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Id);
+}
+
+bool FuncIdRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, ParentScope);
+  Success &= remapIndex(IndexMap, FunctionType);
+  return Success;
+}
+
+bool UdtSourceLineRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, UDT);
+  Success &= remapIndex(IndexMap, SourceFile);
+  return Success;
+}
+
+bool BuildInfoRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  for (TypeIndex &Arg : ArgIndices)
+    Success &= remapIndex(IndexMap, Arg);
+  return Success;
+}
+
+bool VFTableRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, CompleteClass);
+  Success &= remapIndex(IndexMap, OverriddenVFTable);
+  return Success;
+}
+
+bool OneMethodRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, Type);
+  return Success;
+}
+
+bool MethodOverloadListRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  for (OneMethodRecord &Meth : Methods)
+    if ((Success = Meth.remapTypeIndices(IndexMap)))
+      return Success;
+  return Success;
+}
+
+bool OverloadedMethodRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, MethodList);
+}
+
+bool DataMemberRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Type);
+}
+
+bool StaticDataMemberRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Type);
+}
+
+bool EnumeratorRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return true;
+}
+
+bool VFPtrRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Type);
+}
+
+bool BaseClassRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  return remapIndex(IndexMap, Type);
+}
+
+bool VirtualBaseClassRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
+  bool Success = true;
+  Success &= remapIndex(IndexMap, BaseType);
+  Success &= remapIndex(IndexMap, VBPtrType);
+  return Success;
+}

llvm/trunk/lib/DebugInfo/CodeView/TypeRecordBuilder.cpp

 //===-- TypeRecordBuilder.cpp ---------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/TypeRecordBuilder.h"
 
 using namespace llvm;
 using namespace codeview;
 
-TypeRecordBuilder::TypeRecordBuilder(TypeRecordKind Kind) : Stream(Buffer),
-  Writer(Stream) {
+TypeRecordBuilder::TypeRecordBuilder(TypeRecordKind Kind)
+    : Stream(Buffer), Writer(Stream) {
   writeTypeRecordKind(Kind);
 }
 
 StringRef TypeRecordBuilder::str() {
   return StringRef(Buffer.data(), Buffer.size());
 }
 
 void TypeRecordBuilder::writeUInt8(uint8_t Value) {
void TypeRecordBuilder::writeNullTerminatedString(const char *Value) {
   writeUInt8(0);
 }
 
 void TypeRecordBuilder::writeNullTerminatedString(StringRef Value) {
   Stream.write(Value.data(), Value.size());
   writeUInt8(0);
 }
 
+void TypeRecordBuilder::writeGuid(StringRef Guid) {
+  assert(Guid.size() == 16);
+  Stream.write(Guid.data(), 16);
+}
+
 void TypeRecordBuilder::writeTypeIndex(TypeIndex TypeInd) {
   writeUInt32(TypeInd.getIndex());
 }
 
 void TypeRecordBuilder::writeTypeRecordKind(TypeRecordKind Kind) {
   writeUInt16(static_cast<uint16_t>(Kind));
 }

llvm/trunk/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

+//===-- TypeStreamMerger.cpp ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeStream.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+namespace {
+
+/// Implementation of CodeView type stream merging.
+///
+/// A CodeView type stream is a series of records that reference each other
+/// through type indices. A type index is either "simple", meaning it is less
+/// than 0x1000 and refers to a builtin type, or it is complex, meaning it
+/// refers to a prior type record in the current stream. The type index of a
+/// record is equal to the number of records before it in the stream plus
+/// 0x1000.
+///
+/// Type records are only allowed to use type indices smaller than their own, so
+/// a type stream is effectively a topologically sorted DAG. Cycles occuring in
+/// the type graph of the source program are resolved with forward declarations
+/// of composite types. This class implements the following type stream merging
+/// algorithm, which relies on this DAG structure:
+///
+/// - Begin with a new empty stream, and a new empty hash table that maps from
+///   type record contents to new type index.
+/// - For each new type stream, maintain a map from source type index to
+///   destination type index.
+/// - For each record, copy it and rewrite its type indices to be valid in the
+///   destination type stream.
+/// - If the new type record is not already present in the destination stream
+///   hash table, append it to the destination type stream, assign it the next
+///   type index, and update the two hash tables.
+/// - If the type record already exists in the destination stream, discard it
+///   and update the type index map to forward the source type index to the
+///   existing destination type index.
+class TypeStreamMerger : public CVTypeVisitor<TypeStreamMerger> {
+public:
+  TypeStreamMerger(TypeTableBuilder &DestStream) : DestStream(DestStream) {
+    assert(!hadError());
+  }
+
+  /// CVTypeVisitor overrides.
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+
+  void visitUnknownMember(TypeLeafKind Leaf);
+
+  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
+  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
+
+  void visitFieldList(TypeLeafKind Leaf, ArrayRef<uint8_t> FieldData);
+
+  bool mergeStream(ArrayRef<uint8_t> SrcStream);
+
+private:
+  bool hadError() { return FoundBadTypeIndex || CVTypeVisitor::hadError(); }
+
+  bool FoundBadTypeIndex = false;
+
+  FieldListRecordBuilder FieldBuilder;
+
+  TypeTableBuilder &DestStream;
+
+  size_t BeginIndexMapSize = 0;
+
+  /// Map from source type index to destination type index. Indexed by source
+  /// type index minus 0x1000.
+  SmallVector<TypeIndex, 0> IndexMap;
+};
+
+} // end anonymous namespace
+
+void TypeStreamMerger::visitTypeBegin(TypeLeafKind Leaf,
+                                      ArrayRef<uint8_t> RecordData) {
+  BeginIndexMapSize = IndexMap.size();
+}
+
+void TypeStreamMerger::visitTypeEnd(TypeLeafKind Leaf,
+                                    ArrayRef<uint8_t> RecordData) {
+  assert(IndexMap.size() == BeginIndexMapSize + 1);
+}
+
+void TypeStreamMerger::visitFieldList(TypeLeafKind Leaf,
+                                      ArrayRef<uint8_t> FieldData) {
+  CVTypeVisitor::visitFieldList(Leaf, FieldData);
+  IndexMap.push_back(DestStream.writeFieldList(FieldBuilder));
+  FieldBuilder.reset();
+}
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
+                                     Name##Record &Record) {                   \
+    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);              \
+    IndexMap.push_back(DestStream.write##Name(Record));                        \
+  }
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
+                                     Name##Record &Record) {                   \
+    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);              \
+    FieldBuilder.write##Name(Record);                                          \
+  }
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+
+void TypeStreamMerger::visitUnknownMember(TypeLeafKind LF) {
+  // We failed to translate a type. Translate this index as "not translated".
+  IndexMap.push_back(
+      TypeIndex(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct));
+  parseError();
+}
+
+bool TypeStreamMerger::mergeStream(ArrayRef<uint8_t> SrcStream) {
+  assert(IndexMap.empty());
+  visitTypeStream(SrcStream);
+  IndexMap.clear();
+  return !hadError();
+}
+
+bool llvm::codeview::mergeTypeStreams(TypeTableBuilder &DestStream,
+                                      ArrayRef<uint8_t> SrcStream) {
+  return TypeStreamMerger(DestStream).mergeStream(SrcStream);
+}

llvm/trunk/lib/DebugInfo/CodeView/TypeTableBuilder.cpp

TypeIndex TypeTableBuilder::writeClass(const ClassRecord &Record) {
   if ((Record.getOptions() & ClassOptions::HasUniqueName) !=
       ClassOptions::None) {
     Builder.writeNullTerminatedString(Record.getUniqueName());
   }
 
   return writeRecord(Builder);
 }
 
+TypeIndex TypeTableBuilder::writeUnion(const UnionRecord &Record) {
+  TypeRecordBuilder Builder(TypeRecordKind::Union);
+  Builder.writeUInt16(Record.getMemberCount());
+  uint16_t Flags =
+      static_cast<uint16_t>(Record.getOptions()) |
+      (static_cast<uint16_t>(Record.getHfa()) << ClassRecord::HfaKindShift);
+  Builder.writeUInt16(Flags);
+  Builder.writeTypeIndex(Record.getFieldList());
+  Builder.writeEncodedUnsignedInteger(Record.getSize());
+  Builder.writeNullTerminatedString(Record.getName());
+  if ((Record.getOptions() & ClassOptions::HasUniqueName) !=
+      ClassOptions::None) {
+    Builder.writeNullTerminatedString(Record.getUniqueName());
+  }
+  return writeRecord(Builder);
+}
+
 TypeIndex TypeTableBuilder::writeEnum(const EnumRecord &Record) {
   TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeUInt16(Record.getMemberCount());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getOptions()));
   Builder.writeTypeIndex(Record.getUnderlyingType());
   Builder.writeTypeIndex(Record.getFieldList());
   Builder.writeNullTerminatedString(Record.getName());
if ((SlotIndex + 1) < Slots.size()) {
       Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
     }
     Builder.writeUInt8(Byte);
   }
 
   return writeRecord(Builder);
 }
 
+TypeIndex
+TypeTableBuilder::writeVFTable(const VFTableRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  Builder.writeTypeIndex(Record.getCompleteClass());
+  Builder.writeTypeIndex(Record.getOverriddenVTable());
+  Builder.writeUInt32(Record.getVFPtrOffset());
+
+  // Sum up the lengths of the null-terminated names.
+  size_t NamesLen = Record.getName().size() + 1;
+  for (StringRef MethodName : Record.getMethodNames())
+    NamesLen += MethodName.size() + 1;
+
+  Builder.writeUInt32(NamesLen);
+  Builder.writeNullTerminatedString(Record.getName());
+  for (StringRef MethodName : Record.getMethodNames())
+    Builder.writeNullTerminatedString(MethodName);
+
+  return writeRecord(Builder);
+}
+
+TypeIndex TypeTableBuilder::writeStringId(const StringIdRecord &Record) {
+  TypeRecordBuilder Builder(TypeRecordKind::StringId);
+  Builder.writeTypeIndex(Record.getId());
+  Builder.writeNullTerminatedString(Record.getString());
+  return writeRecord(Builder);
+}
+
+TypeIndex
+TypeTableBuilder::writeUdtSourceLine(const UdtSourceLineRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  Builder.writeTypeIndex(Record.getUDT());
+  Builder.writeTypeIndex(Record.getSourceFile());
+  Builder.writeUInt32(Record.getLineNumber());
+  return writeRecord(Builder);
+}
+
+TypeIndex
+TypeTableBuilder::writeFuncId(const FuncIdRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  Builder.writeTypeIndex(Record.getParentScope());
+  Builder.writeTypeIndex(Record.getFunctionType());
+  Builder.writeNullTerminatedString(Record.getName());
+  return writeRecord(Builder);
+}
+
+TypeIndex
+TypeTableBuilder::writeMemberFuncId(const MemberFuncIdRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  Builder.writeTypeIndex(Record.getClassType());
+  Builder.writeTypeIndex(Record.getFunctionType());
+  Builder.writeNullTerminatedString(Record.getName());
+  return writeRecord(Builder);
+}
+
+TypeIndex
+TypeTableBuilder::writeBuildInfo(const BuildInfoRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  assert(Record.getArgs().size() <= UINT16_MAX);
+  Builder.writeUInt16(Record.getArgs().size());
+  for (TypeIndex Arg : Record.getArgs())
+    Builder.writeTypeIndex(Arg);
+  return writeRecord(Builder);
+}
+
 TypeIndex TypeTableBuilder::writeRecord(TypeRecordBuilder &Builder) {
   return writeRecord(Builder.str());
 }
 
 TypeIndex TypeTableBuilder::writeFieldList(FieldListRecordBuilder &FieldList) {
   // TODO: Split the list into multiple records if it's longer than 64KB, using
   // a subrecord of TypeRecordKind::Index to chain the records together.
   return writeRecord(FieldList.str());
 }
 
-TypeIndex
-TypeTableBuilder::writeMethodList(MethodListRecordBuilder &MethodList) {
+TypeIndex TypeTableBuilder::writeMethodOverloadList(
+    const MethodOverloadListRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  for (const OneMethodRecord &Method : Record.getMethods()) {
+    uint16_t Flags = static_cast<uint16_t>(Method.getAccess());
+    Flags |= static_cast<uint16_t>(Method.getKind())
+             << MemberAttributes::MethodKindShift;
+    Flags |= static_cast<uint16_t>(Method.getOptions());
+    Builder.writeUInt16(Flags);
+    Builder.writeUInt16(0); // padding
+    Builder.writeTypeIndex(Method.getType());
+    if (Method.isIntroducingVirtual()) {
+      assert(Method.getVFTableOffset() >= 0);
+      Builder.writeInt32(Method.getVFTableOffset());
+    } else {
+      assert(Method.getVFTableOffset() == -1);
+    }
+  }
+
   // TODO: Split the list into multiple records if it's longer than 64KB, using
   // a subrecord of TypeRecordKind::Index to chain the records together.
-  return writeRecord(MethodList.str());
+  return writeRecord(Builder);
+}
+
+TypeIndex TypeTableBuilder::writeTypeServer2(const TypeServer2Record &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
+  Builder.writeGuid(Record.getGuid());
+  Builder.writeUInt32(Record.getAge());
+  Builder.writeNullTerminatedString(Record.getName());
+  return writeRecord(Builder);
 }

llvm/trunk/test/tools/llvm-readobj/codeview-merging.test

+# To regenerate t1.obj and t2.obj, run the following:
+# $ cat t.cpp
+# #ifdef CONFIG1
+# struct A;
+# struct B {
+#   A *a;
+# };
+# int f(A *a);
+# int g(B *b) { return f(b->a); }
+# #else
+# struct B;
+# struct A {
+#   B *b;
+# };
+# int g(B *b);
+# int f(A *a) { return g(a->b); }
+# #endif
+# $ cl -c -DCONFIG1 -Z7 t.cpp -Fot1.obj && cl -c -Z7 t.cpp -Fot2.obj
+
+RUN: llvm-readobj -codeview %S/Inputs/codeview-merging-1.obj | FileCheck %s --check-prefix=OBJ1
+RUN: llvm-readobj -codeview %S/Inputs/codeview-merging-2.obj | FileCheck %s --check-prefix=OBJ2
+RUN: llvm-readobj -codeview-merged-types %S/Inputs/codeview-merging-1.obj %S/Inputs/codeview-merging-2.obj | FileCheck %s
+
+OBJ1:       FuncId (0x100D) {
+OBJ1-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+OBJ1-NEXT:    ParentScope: 0x0
+OBJ1-NEXT:    FunctionType: int (B*) (0x100C)
+OBJ1-NEXT:    Name: g
+OBJ1-NEXT:  }
+OBJ1-NEXT:  FuncId (0x100E) {
+OBJ1-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+OBJ1-NEXT:    ParentScope: 0x0
+OBJ1-NEXT:    FunctionType: int (A*) (0x1003)
+OBJ1-NEXT:    Name: f
+OBJ1-NEXT:  }
+OBJ1-NOT: FuncId
+
+OBJ2:       FuncId (0x100D) {
+OBJ2-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+OBJ2-NEXT:    ParentScope: 0x0
+OBJ2-NEXT:    FunctionType: int (A*) (0x100C)
+OBJ2-NEXT:    Name: f
+OBJ2-NEXT:  }
+
+OBJ2:       FuncId (0x1069) {
+OBJ2-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+OBJ2-NEXT:    ParentScope: 0x0
+OBJ2-NEXT:    FunctionType: int (B*) (0x1003)
+OBJ2-NEXT:    Name: g
+OBJ2-NEXT:  }
+OBJ2-NOT: FuncId
+
+CHECK:       FuncId (0x100D) {
+CHECK-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+CHECK-NEXT:    ParentScope: 0x0
+CHECK-NEXT:    FunctionType: int (B*) (0x100C)
+CHECK-NEXT:    Name: g
+CHECK-NEXT:  }
+CHECK-NEXT:  FuncId (0x100E) {
+CHECK-NEXT:    TypeLeafKind: LF_FUNC_ID (0x1601)
+CHECK-NEXT:    ParentScope: 0x0
+CHECK-NEXT:    FunctionType: int (A*) (0x1003)
+CHECK-NEXT:    Name: f
+CHECK-NEXT:  }
+CHECK-NOT: FuncId

llvm/trunk/tools/llvm-readobj/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoCodeView
   Object
   Support
+  DebugInfoCodeView
   )
 
 add_llvm_tool(llvm-readobj
   ARMAttributeParser.cpp
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
   Error.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
   Win64EHDumper.cpp
   )

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

 #include "Win64EHDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
+#include "llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeStream.h"
+#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ScopedPrinter.h"
public:
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printCOFFImports() override;
   void printCOFFExports() override;
   void printCOFFDirectives() override;
   void printCOFFBaseReloc() override;
   void printCodeViewDebugInfo() override;
+  void
+  mergeCodeViewTypes(llvm::codeview::MemoryTypeTableBuilder &CVTypes) override;
   void printStackMap() const override;
 private:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
                        uint64_t Bias = 0);
   void printDataDirectory(uint32_t Index, const std::string &FieldName);
 
   void printDOSHeader(const dos_header *DH);
StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
   // Return the null-terminated string.
   return CVStringTable.drop_front(StringOffset).split('\0').first;
 }
 
 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
+void COFFDumper::mergeCodeViewTypes(MemoryTypeTableBuilder &CVTypes) {
+  for (const SectionRef &S : Obj->sections()) {
+    StringRef SectionName;
+    error(S.getName(SectionName));
+    if (SectionName == ".debug$T") {
+      StringRef Data;
+      error(S.getContents(Data));
+      unsigned Magic = *reinterpret_cast<const ulittle32_t *>(Data.data());
+      if (Magic != 4)
+        error(object_error::parse_failed);
+      Data = Data.drop_front(4);
+      ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()),
+                              Data.size());
+      if (!mergeTypeStreams(CVTypes, Bytes))
+        return error(object_error::parse_failed);
+    }
+  }
+}
+
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   StringRef Data;
   error(Section.getContents(Data));
   if (opts::CodeViewSubsectionBytes)
void COFFDumper::printStackMap() const {
   if (Obj->isLittleEndian())
     prettyPrintStackMap(
                       llvm::outs(),
                       StackMapV1Parser<support::little>(StackMapContentsArray));
   else
     prettyPrintStackMap(llvm::outs(),
                         StackMapV1Parser<support::big>(StackMapContentsArray));
 }
+
+void llvm::dumpCodeViewMergedTypes(
+    ScopedPrinter &Writer, llvm::codeview::MemoryTypeTableBuilder &CVTypes) {
+  // Flatten it first, then run our dumper on it.
+  ListScope S(Writer, "MergedTypeStream");
+  SmallString<0> Buf;
+  CVTypes.ForEachRecord([&](TypeIndex TI, MemoryTypeTableBuilder::Record *R) {
+    // The record data doesn't include the 16 bit size.
+    Buf.push_back(R->size() & 0xff);
+    Buf.push_back((R->size() >> 8) & 0xff);
+    Buf.append(R->data(), R->data() + R->size());
+  });
+  CVTypeDumper CVTD(Writer, opts::CodeViewSubsectionBytes);
+  ArrayRef<uint8_t> BinaryData(reinterpret_cast<const uint8_t *>(Buf.data()),
+                               Buf.size());
+  if (!CVTD.dump(BinaryData)) {
+    Writer.flush();
+    error(object_error::parse_failed);
+  }
+}

llvm/trunk/tools/llvm-readobj/ObjDumper.h

 #include <memory>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
 }
+namespace codeview {
+class MemoryTypeTableBuilder;
+};
 
 class ScopedPrinter;
 
 class ObjDumper {
 public:
   ObjDumper(ScopedPrinter &Writer);
   virtual ~ObjDumper();
 
public:
   virtual void printMipsOptions() { }
 
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }
   virtual void printCOFFExports() { }
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
   virtual void printCodeViewDebugInfo() { }
+  virtual void
+  mergeCodeViewTypes(llvm::codeview::MemoryTypeTableBuilder &CVTypes) {}
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }
std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result);
 
 void dumpCOFFImportFile(const object::COFFImportFile *File);
 
+void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
+                             llvm::codeview::MemoryTypeTableBuilder &CVTypes);
+
 } // namespace llvm
 
 #endif

llvm/trunk/tools/llvm-readobj/llvm-readobj.cpp

 //
 // Output should be specialized for each format where appropriate.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-readobj.h"
 #include "Error.h"
 #include "ObjDumper.h"
+#include "llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataTypes.h"
namespace opts {
   // -expand-relocs
   cl::opt<bool> ExpandRelocs("expand-relocs",
     cl::desc("Expand each shown relocation to multiple lines"));
 
   // -codeview
   cl::opt<bool> CodeView("codeview",
                          cl::desc("Display CodeView debug information"));
 
+  // -codeview-merged-types
+  cl::opt<bool>
+      CodeViewMergedTypes("codeview-merged-types",
+                          cl::desc("Display the merged CodeView type stream"));
+
   // -codeview-subsection-bytes
   cl::opt<bool> CodeViewSubsectionBytes(
       "codeview-subsection-bytes",
       cl::desc("Dump raw contents of codeview debug sections and records"));
 
   // -arm-attributes, -a
   cl::opt<bool> ARMAttributes("arm-attributes",
                               cl::desc("Display the ARM attributes section"));
static bool isMipsArch(unsigned Arch) {
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     return true;
   default:
     return false;
   }
 }
 
+static llvm::codeview::MemoryTypeTableBuilder CVTypes;
+
 /// @brief Creates an format-specific object file dumper.
 static std::error_code createDumper(const ObjectFile *Obj,
                                     ScopedPrinter &Writer,
                                     std::unique_ptr<ObjDumper> &Result) {
   if (!Obj)
     return readobj_error::unsupported_file_format;
 
   if (Obj->isCOFF())
if (Obj->isCOFF()) {
     if (opts::COFFExports)
       Dumper->printCOFFExports();
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)
       Dumper->printCOFFBaseReloc();
     if (opts::CodeView)
       Dumper->printCodeViewDebugInfo();
+    if (opts::CodeViewMergedTypes)
+      Dumper->mergeCodeViewTypes(CVTypes);
   }
   if (Obj->isMachO()) {
     if (opts::MachODataInCode)
       Dumper->printMachODataInCode();
     if (opts::MachOIndirectSymbols)
       Dumper->printMachOIndirectSymbols();
     if (opts::MachOLinkerOptions)
       Dumper->printMachOLinkerOptions();
int main(int argc, const char *argv[]) {
 
   // Default to stdin if no filename is specified.
   if (opts::InputFilenames.size() == 0)
     opts::InputFilenames.push_back("-");
 
   std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
                 dumpInput);
 
+  if (opts::CodeViewMergedTypes) {
+    ScopedPrinter W(outs());
+    dumpCodeViewMergedTypes(W, CVTypes);
+  }
+
   return 0;
 }