Dump TPI records to Yaml

[zturner]

Summary

Note this does not yet convert the Yaml back into a serialized Tpi stream or write them to the File. That's a little bit more work, so I figured it would be better to get this in first.

[ruiu]

test/DebugInfo/PDB/pdbdump-yaml-types.test

33 ↗

(On Diff #67014)

Value is an integer type, so it's odd that the value is quoted with single quotes. Can you print it out without quote?

[zturner]

Print integral values without quotes.

[ruiu]

LGTM

[zturner]

I found some problems with the previous version of the diff. Namely, that we weren't printing the TypeLeafKind for field list members because it was still using a little bit of a special code path. Although technically the information was still there, it wasn't in the right format that would have allowed the YAML to re-extract it. This is because it would print something like

Enumerator {
}

So sure, if you look at the file in an editor it looks like there's enough info to determine what kind of member field this is, but the YAML api doesn't expose this value, we need to print it like this:

Field {
   Kind: LF_ENUMERATE
   Enumerator {
   }
}

The logical way to do this is to re-use the same visitor code for visiting the members of the field list as we do for visiting top level members of the TPI stream. As this code already prints stuff in exactly the format we need. But, this is complicated by the fact that field lists and field list members have always had special handling in the visitor dispatch.

This patch tries to solve all this by merging the field list member and top level member code paths. A FieldListRecord is introduced which contains a vector<CVType>. When a FieldList is encountered in the TPI stream, it is Decomposed into a vector<CVType> and then passed to a single call visitKnownRecord(FieldList&). This method, being part of the visitor, can then do whatever it wants, including iterating over and re-visiting the members of the field list, or throwing them away and doing nothing.

The only real downside of this is that we have to deserialize the field list members twice. We can probably solve this if it's important by changing FieldListRecord to be a little smarter. But for simply dumping records it doesn't seem to be an issue.

[zturner]

I managed to get it working where it's not deserializing twice. Basically FieldListRecord just stores an ArrayRef<uint8_t> of the entire list of FieldList bytes. Then the visitor uses the visitor again to visit all the members.

[rnk]

tools/llvm-pdbdump/PdbYaml.cpp

208 ↗

(On Diff #67604)

These both seem like they can fail in interesting ways. What do you think we should do with the error code, assert? The yaml validation method for error handling seems inappropriate.

[rnk]

include/llvm/DebugInfo/CodeView/TypeRecord.h

438 ↗

(On Diff #67604)

This could be a StreamRef, to avoid the need to copy the entire field list record into contiguous memory.

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

 public:
   explicit CVTypeVisitor(TypeVisitorCallbacks &Callbacks);
 
   Error visitTypeRecord(const CVRecord<TypeLeafKind> &Record);
 
   /// Visits the type records in Data. Sets the error flag on parse failures.
   Error visitTypeStream(const CVTypeArray &Types);
 
+  Error visitFieldListMemberStream(ArrayRef<uint8_t> FieldList);
+
 private:
   /// The interface to the class that gets notified of each visitation.
   TypeVisitorCallbacks &Callbacks;
 };
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H

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

 #include "llvm/Support/COFF.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include <stdint.h>
 
 namespace llvm {
 namespace codeview {
 ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames();
+ArrayRef<EnumEntry<TypeLeafKind>> getTypeLeafNames();
 ArrayRef<EnumEntry<uint16_t>> getRegisterNames();
 ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames();
 ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames();
 ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames();
 ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames();
 ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames();
 ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames();
 ArrayRef<EnumEntry<uint32_t>> getFileChecksumNames();

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

 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H
 
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
-class TypeDeserializerBase : public TypeVisitorCallbacks {
+class TypeDeserializer : public TypeVisitorCallbacks {
 public:
-  explicit TypeDeserializerBase(TypeVisitorCallbacks &Recipient)
+  explicit TypeDeserializer(TypeVisitorCallbacks &Recipient)
       : Recipient(Recipient) {}
 
   Error visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override {
     return Recipient.visitTypeBegin(Record);
   }
 
   Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) override {
     return Recipient.visitTypeEnd(Record);
private:
   template <typename T>
   Error defaultVisitKnownRecord(const CVRecord<TypeLeafKind> &CVR, T &Record) {
     ArrayRef<uint8_t> RD = CVR.Data;
     if (auto EC = deserializeRecord(RD, CVR.Type, Record))
       return EC;
     return Recipient.visitKnownRecord(CVR, Record);
   }
 };
-
-class TypeDeserializer : public TypeDeserializerBase {
-public:
-  explicit TypeDeserializer(TypeVisitorCallbacks &Recipient)
-      : TypeDeserializerBase(Recipient) {}
-
-  /// FieldList records need special handling.  For starters, they do not
-  /// describe their own length, so a different extraction algorithm is
-  /// necessary.  Secondly, a single FieldList record will result in the
-  /// deserialization of many records.  So even though the top level visitor
-  /// calls visitFieldBegin() on a single record, multiple records get visited
-  /// through the callback interface.
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
-                         FieldListRecord &Record) override;
-
-private:
-  template <typename T>
-  Error visitKnownMember(ArrayRef<uint8_t> &Data, TypeLeafKind Kind,
-                         T &Record) {
-    ArrayRef<uint8_t> OldData = Data;
-    if (auto EC = deserializeRecord(Data, Kind, Record))
-      return EC;
-    assert(Data.size() < OldData.size());
-
-    CVRecord<TypeLeafKind> CVR;
-    CVR.Length = OldData.size() - Data.size();
-    CVR.Data = OldData.slice(0, CVR.Length);
-    CVR.RawData = CVR.Data;
-    return Recipient.visitKnownRecord(CVR, Record);
-  }
-
-  Error skipPadding(ArrayRef<uint8_t> &Data);
-};
 }
 }
 
 #endif

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

 
 private:
   void printMemberAttributes(MemberAttributes Attrs);
   void printMemberAttributes(MemberAccess Access, MethodKind Kind,
                              MethodOptions Options);
 
   ScopedPrinter *W;
 
+  bool IsInFieldList = false;
   bool PrintRecordBytes = false;
 
   /// Name of the current type. Only valid before visitTypeEnd.
   StringRef Name;
 
   /// All user defined type records in .debug$T live in here. Type indices
   /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to
   /// index into this vector.

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

 //===- TypeRecord.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_TYPERECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Error.h"
 #include <cinttypes>
 #include <utility>
 
 namespace llvm {
 namespace codeview {
 
 using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
+typedef CVRecord<TypeLeafKind> CVType;
+typedef msf::VarStreamArray<CVType> CVTypeArray;
+
 /// 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.
public:
 
   static Expected<MemberPointerInfo> deserialize(ArrayRef<uint8_t> &Data);
 
   TypeIndex getContainingType() const { return ContainingType; }
   PointerToMemberRepresentation getRepresentation() const {
     return Representation;
   }
 
+  TypeIndex ContainingType;
+  PointerToMemberRepresentation Representation;
+
 private:
   struct Layout {
     TypeIndex ClassType;
     ulittle16_t Representation; // PointerToMemberRepresentation
   };
-
-  TypeIndex ContainingType;
-  PointerToMemberRepresentation Representation;
 };
 
 class TypeRecord {
 protected:
+  TypeRecord() {}
   explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
 
 public:
   TypeRecordKind getKind() const { return Kind; }
 
 private:
   TypeRecordKind Kind;
 };
public:
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<ModifierRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data);
 
   TypeIndex getModifiedType() const { return ModifiedType; }
   ModifierOptions getModifiers() const { return Modifiers; }
 
+  TypeIndex ModifiedType;
+  ModifierOptions Modifiers;
+
 private:
   struct Layout {
     TypeIndex ModifiedType;
     ulittle16_t Modifiers; // ModifierOptions
   };
-
-  TypeIndex ModifiedType;
-  ModifierOptions Modifiers;
 };
 
 // LF_PROCEDURE
 class ProcedureRecord : public TypeRecord {
 public:
   explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
                   FunctionOptions Options, uint16_t ParameterCount,
public:
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
   TypeIndex getReturnType() const { return ReturnType; }
   CallingConvention getCallConv() const { return CallConv; }
   FunctionOptions getOptions() const { return Options; }
   uint16_t getParameterCount() const { return ParameterCount; }
   TypeIndex getArgumentList() const { return ArgumentList; }
 
+  TypeIndex ReturnType;
+  CallingConvention CallConv;
+  FunctionOptions Options;
+  uint16_t ParameterCount;
+  TypeIndex ArgumentList;
+
 private:
   struct Layout {
     TypeIndex ReturnType;
     CallingConvention CallConv;
     FunctionOptions Options;
     ulittle16_t NumParameters;
     TypeIndex ArgListType;
   };
-
-  TypeIndex ReturnType;
-  CallingConvention CallConv;
-  FunctionOptions Options;
-  uint16_t ParameterCount;
-  TypeIndex ArgumentList;
 };
 
 // LF_MFUNCTION
 class MemberFunctionRecord : public TypeRecord {
 public:
   explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
 
   MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
public:
   TypeIndex getClassType() const { return ClassType; }
   TypeIndex getThisType() const { return ThisType; }
   CallingConvention getCallConv() const { return CallConv; }
   FunctionOptions getOptions() const { return Options; }
   uint16_t getParameterCount() const { return ParameterCount; }
   TypeIndex getArgumentList() const { return ArgumentList; }
   int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }
 
-private:
-  struct Layout {
-    TypeIndex ReturnType;
-    TypeIndex ClassType;
-    TypeIndex ThisType;
-    CallingConvention CallConv;
-    FunctionOptions Options;
-    ulittle16_t NumParameters;
-    TypeIndex ArgListType;
-    little32_t ThisAdjustment;
-  };
+  uint16_t ParameterCount;
+  TypeIndex ArgumentList;
+  int32_t ThisPointerAdjustment;
 
+private:
+  struct Layout {
     TypeIndex ReturnType;
     TypeIndex ClassType;
     TypeIndex ThisType;
     CallingConvention CallConv;
     FunctionOptions Options;
-  uint16_t ParameterCount;
-  TypeIndex ArgumentList;
-  int32_t ThisPointerAdjustment;
+    ulittle16_t NumParameters;
+    TypeIndex ArgListType;
+    little32_t ThisAdjustment;
+  };
 };
 
 // LF_MFUNC_ID
 class MemberFuncIdRecord : public TypeRecord {
 public:
   explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<MemberFuncIdRecord> deserialize(TypeRecordKind Kind,
                                                   ArrayRef<uint8_t> &Data);
   TypeIndex getClassType() const { return ClassType; }
   TypeIndex getFunctionType() const { return FunctionType; }
   StringRef getName() const { return Name; }
+  TypeIndex ClassType;
+  TypeIndex FunctionType;
+  StringRef Name;
 
 private:
   struct Layout {
     TypeIndex ClassType;
     TypeIndex FunctionType;
     // Name: The null-terminated name follows.
   };
-  TypeIndex ClassType;
-  TypeIndex FunctionType;
-  StringRef Name;
 };
 
 // LF_ARGLIST, LF_SUBSTR_LIST
 class ArgListRecord : public TypeRecord {
 public:
   explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
 
   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 Expected<ArgListRecord> deserialize(TypeRecordKind Kind,
                                              ArrayRef<uint8_t> &Data);
 
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
+  std::vector<TypeIndex> StringIndices;
+
 private:
   struct Layout {
     ulittle32_t NumArgs; // Number of arguments
                          // ArgTypes[]: Type indicies of arguments
   };
-
-  std::vector<TypeIndex> StringIndices;
 };
 
 // LF_POINTER
 class PointerRecord : public TypeRecord {
 public:
   static const uint32_t PointerKindShift = 0;
   static const uint32_t PointerKindMask = 0x1F;
 
   static const uint32_t PointerModeShift = 5;
   static const uint32_t PointerModeMask = 0x07;
 
   static const uint32_t PointerSizeShift = 13;
   static const uint32_t PointerSizeMask = 0xFF;
 
   explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
 
   PointerRecord(TypeIndex ReferentType, PointerKind Kind, PointerMode Mode,
                 PointerOptions Options, uint8_t Size)
-      : PointerRecord(ReferentType, Kind, Mode, Options, Size,
-                      MemberPointerInfo()) {}
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        PtrKind(Kind), Mode(Mode), Options(Options), Size(Size) {}
 
   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 Expected<PointerRecord> deserialize(TypeRecordKind Kind,
                                              ArrayRef<uint8_t> &Data);
 
   TypeIndex getReferentType() const { return ReferentType; }
   PointerKind getPointerKind() const { return PtrKind; }
   PointerMode getMode() const { return Mode; }
   PointerOptions getOptions() const { return Options; }
   uint8_t getSize() const { return Size; }
-  MemberPointerInfo getMemberInfo() const { return MemberInfo; }
+  MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
 
   bool isPointerToMember() const {
     return Mode == PointerMode::PointerToDataMember ||
            Mode == PointerMode::PointerToMemberFunction;
   }
   bool isFlat() const {
     return !!(uint32_t(Options) & uint32_t(PointerOptions::Flat32));
   }
   bool isConst() const {
     return !!(uint32_t(Options) & uint32_t(PointerOptions::Const));
   }
   bool isVolatile() const {
     return !!(uint32_t(Options) & uint32_t(PointerOptions::Volatile));
   }
   bool isUnaligned() const {
     return !!(uint32_t(Options) & uint32_t(PointerOptions::Unaligned));
   }
 
+  TypeIndex ReferentType;
+  PointerKind PtrKind;
+  PointerMode Mode;
+  PointerOptions Options;
+  uint8_t Size;
+  Optional<MemberPointerInfo> MemberInfo;
+
 private:
   struct Layout {
     TypeIndex PointeeType;
     ulittle32_t Attrs; // pointer attributes
                        // if pointer to member:
                        //   PointerToMemberTail
     PointerKind getPtrKind() const {
       return PointerKind(Attrs & PointerKindMask);
struct Layout {
     }
     bool isPointerToMemberFunction() const {
       return getPtrMode() == PointerMode::PointerToMemberFunction;
     }
     bool isPointerToMember() const {
       return isPointerToMemberFunction() || isPointerToDataMember();
     }
   };
-
-  TypeIndex ReferentType;
-  PointerKind PtrKind;
-  PointerMode Mode;
-  PointerOptions Options;
-  uint8_t Size;
-  MemberPointerInfo MemberInfo;
 };
 
 // LF_NESTTYPE
 class NestedTypeRecord : public TypeRecord {
 public:
   explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<NestedTypeRecord> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data);
 
   TypeIndex getNestedType() const { return Type; }
   StringRef getName() const { return Name; }
 
+  TypeIndex Type;
+  StringRef Name;
+
 private:
   struct Layout {
     ulittle16_t Pad0; // Should be zero
     TypeIndex Type;   // Type index of nested type
                       // Name: Null-terminated string
   };
-
-  TypeIndex Type;
-  StringRef Name;
 };
 
 // LF_FIELDLIST
 class FieldListRecord : public TypeRecord {
 public:
   explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  FieldListRecord(ArrayRef<uint8_t> ListData)
-      : TypeRecord(TypeRecordKind::FieldList), ListData(ListData) {}
+  explicit FieldListRecord(ArrayRef<uint8_t> Data)
+      : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap) { return false; }
 
   static Expected<FieldListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data);
 
-  ArrayRef<uint8_t> getFieldListData() const { return ListData; }
-
-private:
-  ArrayRef<uint8_t> ListData;
+  ArrayRef<uint8_t> Data;
 };
 
 // LF_ARRAY
 class ArrayRecord : public TypeRecord {
 public:
   explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<ArrayRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data);
 
   TypeIndex getElementType() const { return ElementType; }
   TypeIndex getIndexType() const { return IndexType; }
   uint64_t getSize() const { return Size; }
   llvm::StringRef getName() const { return Name; }
 
+  TypeIndex ElementType;
+  TypeIndex IndexType;
+  uint64_t Size;
+  llvm::StringRef Name;
+
 private:
   struct Layout {
     TypeIndex ElementType;
     TypeIndex IndexType;
     // SizeOf: LF_NUMERIC encoded size in bytes. Not element count!
     // Name: The null-terminated name follows.
   };
-
-  TypeIndex ElementType;
-  TypeIndex IndexType;
-  uint64_t Size;
-  llvm::StringRef Name;
 };
 
 class TagRecord : public TypeRecord {
 protected:
   explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
             TypeIndex FieldList, StringRef Name, StringRef UniqueName)
       : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
public:
   static const int WinRTKindMask = 0xC000;
 
   uint16_t getMemberCount() const { return MemberCount; }
   ClassOptions getOptions() const { return Options; }
   TypeIndex getFieldList() const { return FieldList; }
   StringRef getName() const { return Name; }
   StringRef getUniqueName() const { return UniqueName; }
 
-private:
   uint16_t MemberCount;
   ClassOptions Options;
   TypeIndex FieldList;
   StringRef Name;
   StringRef UniqueName;
 };
 
 // LF_CLASS, LF_STRUCTURE, LF_INTERFACE
static Expected<ClassRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data);
 
   HfaKind getHfa() const { return Hfa; }
   WindowsRTClassKind getWinRTKind() const { return WinRTKind; }
   TypeIndex getDerivationList() const { return DerivationList; }
   TypeIndex getVTableShape() const { return VTableShape; }
   uint64_t getSize() const { return Size; }
 
+  HfaKind Hfa;
+  WindowsRTClassKind WinRTKind;
+  TypeIndex DerivationList;
+  TypeIndex VTableShape;
+  uint64_t Size;
+
 private:
   struct Layout {
     ulittle16_t MemberCount; // Number of members in FieldList.
     ulittle16_t Properties;  // ClassOptions bitset
     TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
     TypeIndex DerivedFrom;   // LF_DERIVED: List of known derived classes
     TypeIndex VShape;        // LF_VTSHAPE: Shape of the vftable
     // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC
     // integer.
     // Name: The null-terminated name follows.
 
     bool hasUniqueName() const {
       return Properties & uint16_t(ClassOptions::HasUniqueName);
     }
   };
-
-  HfaKind Hfa;
-  WindowsRTClassKind WinRTKind;
-  TypeIndex DerivationList;
-  TypeIndex VTableShape;
-  uint64_t Size;
 };
 
 // LF_UNION
 struct UnionRecord : public TagRecord {
   explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
   UnionRecord(uint16_t MemberCount, ClassOptions Options, HfaKind Hfa,
               TypeIndex FieldList, uint64_t Size, StringRef Name,
               StringRef UniqueName)
       : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
                   UniqueName),
         Hfa(Hfa), Size(Size) {}
 
   static Expected<UnionRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data);
 
   HfaKind getHfa() const { return Hfa; }
   uint64_t getSize() const { return Size; }
 
+  HfaKind Hfa;
+  uint64_t Size;
+
 private:
   struct Layout {
     ulittle16_t MemberCount; // Number of members in FieldList.
     ulittle16_t Properties;  // ClassOptions bitset
     TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
     // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC
     // integer.
     // Name: The null-terminated name follows.
 
     bool hasUniqueName() const {
       return Properties & uint16_t(ClassOptions::HasUniqueName);
     }
   };
-
-  HfaKind Hfa;
-  uint64_t Size;
 };
 
 // LF_ENUM
 class EnumRecord : public TagRecord {
 public:
   explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
   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 Expected<EnumRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data);
 
   TypeIndex getUnderlyingType() const { return UnderlyingType; }
+  TypeIndex UnderlyingType;
 
 private:
   struct Layout {
     ulittle16_t NumEnumerators; // Number of enumerators
     ulittle16_t Properties;
     TypeIndex UnderlyingType;
     TypeIndex FieldListType;
     // Name: The null-terminated name follows.
 
     bool hasUniqueName() const {
       return Properties & uint16_t(ClassOptions::HasUniqueName);
     }
   };
 
-  TypeIndex UnderlyingType;
 };
 
 // LF_BITFIELD
 class BitFieldRecord : public TypeRecord {
 public:
   explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
       : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),
         BitOffset(BitOffset) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<BitFieldRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data);
 
   TypeIndex getType() const { return Type; }
   uint8_t getBitOffset() const { return BitOffset; }
   uint8_t getBitSize() const { return BitSize; }
+  TypeIndex Type;
+  uint8_t BitSize;
+  uint8_t BitOffset;
 
 private:
   struct Layout {
     TypeIndex Type;
     uint8_t BitSize;
     uint8_t BitOffset;
   };
 
-  TypeIndex Type;
-  uint8_t BitSize;
-  uint8_t BitOffset;
 };
 
 // LF_VTSHAPE
 class VFTableShapeRecord : public TypeRecord {
 public:
   explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
   explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<VFTableShapeRecord> deserialize(TypeRecordKind Kind,
                                                   ArrayRef<uint8_t> &Data);
 
   ArrayRef<VFTableSlotKind> getSlots() const {
     if (!SlotsRef.empty())
       return SlotsRef;
     return Slots;
   }
   uint32_t getEntryCount() const { return getSlots().size(); }
+  ArrayRef<VFTableSlotKind> SlotsRef;
+  std::vector<VFTableSlotKind> Slots;
 
 private:
   struct Layout {
     // Number of vftable entries. Each method may have more than one entry due
     // to
     // things like covariant return types.
     ulittle16_t VFEntryCount;
     // Descriptors[]: 4-bit virtual method descriptors of type CV_VTS_desc_e.
   };
 
-private:
-  ArrayRef<VFTableSlotKind> SlotsRef;
-  std::vector<VFTableSlotKind> Slots;
 };
 
 // LF_TYPESERVER2
 class TypeServer2Record : public TypeRecord {
 public:
   explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<TypeServer2Record> deserialize(TypeRecordKind Kind,
                                                  ArrayRef<uint8_t> &Data);
 
   StringRef getGuid() const { return Guid; }
 
   uint32_t getAge() const { return Age; }
 
   StringRef getName() const { return Name; }
+  StringRef Guid;
+  uint32_t Age;
+  StringRef Name;
 
 private:
   struct Layout {
     char Guid[16]; // GUID
     ulittle32_t Age;
     // Name: Name of the PDB as a null-terminated string
   };
-
-  StringRef Guid;
-  uint32_t Age;
-  StringRef Name;
 };
 
 // LF_STRING_ID
 class StringIdRecord : public TypeRecord {
 public:
   explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<StringIdRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data);
 
   TypeIndex getId() const { return Id; }
 
   StringRef getString() const { return String; }
+  TypeIndex Id;
+  StringRef String;
 
 private:
   struct Layout {
     TypeIndex id;
     // Name: Name of the PDB as a null-terminated string
   };
-
-  TypeIndex Id;
-  StringRef String;
 };
 
 // LF_FUNC_ID
 class FuncIdRecord : public TypeRecord {
 public:
   explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<FuncIdRecord> deserialize(TypeRecordKind Kind,
                                             ArrayRef<uint8_t> &Data);
 
   TypeIndex getParentScope() const { return ParentScope; }
 
   TypeIndex getFunctionType() const { return FunctionType; }
 
   StringRef getName() const { return Name; }
+  TypeIndex ParentScope;
+  TypeIndex FunctionType;
+  StringRef Name;
 
 private:
   struct Layout {
     TypeIndex ParentScope;
     TypeIndex FunctionType;
     // Name: The null-terminated name follows.
   };
 
-  TypeIndex ParentScope;
-  TypeIndex FunctionType;
-  StringRef Name;
 };
 
 // LF_UDT_SRC_LINE
 class UdtSourceLineRecord : public TypeRecord {
 public:
   explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<UdtSourceLineRecord> deserialize(TypeRecordKind Kind,
                                                    ArrayRef<uint8_t> &Data);
 
   TypeIndex getUDT() const { return UDT; }
   TypeIndex getSourceFile() const { return SourceFile; }
   uint32_t getLineNumber() const { return LineNumber; }
+  TypeIndex UDT;
+  TypeIndex SourceFile;
+  uint32_t LineNumber;
 
 private:
   struct Layout {
     TypeIndex UDT;        // The user-defined type
     TypeIndex SourceFile; // StringID containing the source filename
     ulittle32_t LineNumber;
   };
 
-  TypeIndex UDT;
-  TypeIndex SourceFile;
-  uint32_t LineNumber;
 };
 
 // LF_UDT_MOD_SRC_LINE
 class UdtModSourceLineRecord : public TypeRecord {
 public:
   explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
                          uint32_t LineNumber, uint16_t Module)
static Expected<UdtModSourceLineRecord> deserialize(TypeRecordKind Kind,
     return UdtModSourceLineRecord(L->UDT, L->SourceFile, L->LineNumber,
                                   L->Module);
   }
 
   TypeIndex getUDT() const { return UDT; }
   TypeIndex getSourceFile() const { return SourceFile; }
   uint32_t getLineNumber() const { return LineNumber; }
   uint16_t getModule() const { return Module; }
+  TypeIndex UDT;
+  TypeIndex SourceFile;
+  uint32_t LineNumber;
+  uint16_t Module;
 
 private:
   struct Layout {
     TypeIndex UDT;        // The user-defined type
     TypeIndex SourceFile; // StringID containing the source filename
     ulittle32_t LineNumber;
     ulittle16_t Module; // Module that contributes this UDT definition
   };
 
-  TypeIndex UDT;
-  TypeIndex SourceFile;
-  uint32_t LineNumber;
-  uint16_t Module;
 };
 
 // LF_BUILDINFO
 class BuildInfoRecord : public TypeRecord {
 public:
   explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   BuildInfoRecord(ArrayRef<TypeIndex> 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 Expected<BuildInfoRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data);
 
   ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
+  SmallVector<TypeIndex, 4> ArgIndices;
 
 private:
   struct Layout {
     ulittle16_t NumArgs; // Number of arguments
                          // ArgTypes[]: Type indicies of arguments
   };
-  SmallVector<TypeIndex, 4> ArgIndices;
 };
 
 // LF_VFTABLE
 class VFTableRecord : public TypeRecord {
 public:
   explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
                 uint32_t VFPtrOffset, StringRef Name,
public:
   TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
   uint32_t getVFPtrOffset() const { return VFPtrOffset; }
   StringRef getName() const { return Name; }
   ArrayRef<StringRef> getMethodNames() const {
     if (!MethodNamesRef.empty())
       return MethodNamesRef;
     return MethodNames;
   }
+  TypeIndex CompleteClass;
+  TypeIndex OverriddenVFTable;
+  ulittle32_t VFPtrOffset;
+  StringRef Name;
+  ArrayRef<StringRef> MethodNamesRef;
+  std::vector<StringRef> MethodNames;
 
 private:
   struct Layout {
     TypeIndex CompleteClass;     // Class that owns this vftable.
     TypeIndex OverriddenVFTable; // VFTable that this overrides.
     ulittle32_t VFPtrOffset;     // VFPtr offset in CompleteClass
     ulittle32_t NamesLen;        // Length of subsequent names array in bytes.
     // Names: A sequence of null-terminated strings. First string is vftable
     // names.
   };
 
-  TypeIndex CompleteClass;
-  TypeIndex OverriddenVFTable;
-  ulittle32_t VFPtrOffset;
-  StringRef Name;
-  ArrayRef<StringRef> MethodNamesRef;
-  std::vector<StringRef> MethodNames;
 };
 
 // LF_ONEMETHOD
 class OneMethodRecord : public TypeRecord {
 public:
+  OneMethodRecord() : TypeRecord(TypeRecordKind::OneMethod) {}
   explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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
public:
   MemberAccess getAccess() const { return Access; }
   int32_t getVFTableOffset() const { return VFTableOffset; }
   StringRef getName() const { return Name; }
 
   bool isIntroducingVirtual() const {
     return Kind == MethodKind::IntroducingVirtual ||
            Kind == MethodKind::PureIntroducingVirtual;
   }
+  TypeIndex Type;
+  MethodKind Kind;
+  MethodOptions Options;
+  MemberAccess Access;
+  int32_t VFTableOffset;
+  StringRef Name;
 
 private:
   struct Layout {
     MemberAttributes Attrs;
     TypeIndex Type;
     // If is introduced virtual method:
     //   VFTableOffset: int32_t offset in vftable
     // Name: Null-terminated string
   };
 
-  TypeIndex Type;
-  MethodKind Kind;
-  MethodOptions Options;
-  MemberAccess Access;
-  int32_t VFTableOffset;
-  StringRef Name;
 };
 
 // LF_METHODLIST
 class MethodOverloadListRecord : public TypeRecord {
 public:
   explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   MethodOverloadListRecord(ArrayRef<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 Expected<MethodOverloadListRecord>
   deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data);
 
   ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
+  std::vector<OneMethodRecord> Methods;
 
 private:
   struct Layout {
     MemberAttributes Attrs;
     ulittle16_t Padding;
 
     TypeIndex Type;
     // If is introduced virtual method:
     //   VFTableOffset: int32_t offset in vftable
   };
 
-  std::vector<OneMethodRecord> Methods;
 };
 
 /// For method overload sets.  LF_METHOD
 class OverloadedMethodRecord : public TypeRecord {
 public:
   explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<OverloadedMethodRecord> deserialize(TypeRecordKind Kind,
                                                       ArrayRef<uint8_t> &Data);
 
   uint16_t getNumOverloads() const { return NumOverloads; }
   TypeIndex getMethodList() const { return MethodList; }
   StringRef getName() const { return Name; }
+  uint16_t NumOverloads;
+  TypeIndex MethodList;
+  StringRef Name;
 
 private:
   struct Layout {
     ulittle16_t MethodCount; // Size of overload set
     TypeIndex MethList;      // Type index of methods in overload set
                              // Name: Null-terminated string
   };
 
-  uint16_t NumOverloads;
-  TypeIndex MethodList;
-  StringRef Name;
 };
 
 // LF_MEMBER
 class DataMemberRecord : public TypeRecord {
 public:
   explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<DataMemberRecord> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   uint64_t getFieldOffset() const { return FieldOffset; }
   StringRef getName() const { return Name; }
+  MemberAccess Access;
+  TypeIndex Type;
+  uint64_t FieldOffset;
+  StringRef Name;
 
 private:
   struct Layout {
     MemberAttributes Attrs; // Access control attributes, etc
     TypeIndex Type;
     // FieldOffset: LF_NUMERIC encoded byte offset
     // Name: Null-terminated string
   };
 
-  MemberAccess Access;
-  TypeIndex Type;
-  uint64_t FieldOffset;
-  StringRef Name;
 };
 
 // LF_STMEMBER
 class StaticDataMemberRecord : public TypeRecord {
 public:
   explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<StaticDataMemberRecord> deserialize(TypeRecordKind Kind,
                                                       ArrayRef<uint8_t> &Data);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   StringRef getName() const { return Name; }
+  MemberAccess Access;
+  TypeIndex Type;
+  StringRef Name;
 
 private:
   struct Layout {
     MemberAttributes Attrs; // Access control attributes, etc
     TypeIndex Type;
     // Name: Null-terminated string
   };
 
-  MemberAccess Access;
-  TypeIndex Type;
-  StringRef Name;
 };
 
 // LF_ENUMERATE
 class EnumeratorRecord : public TypeRecord {
 public:
   explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerator), Access(Access),
         Value(std::move(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 Expected<EnumeratorRecord> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data);
 
   MemberAccess getAccess() const { return Access; }
   APSInt getValue() const { return Value; }
   StringRef getName() const { return Name; }
+  MemberAccess Access;
+  APSInt Value;
+  StringRef Name;
 
 private:
   struct Layout {
     MemberAttributes Attrs; // Access control attributes, etc
                             // EnumValue: LF_NUMERIC encoded enumerator value
                             // Name: Null-terminated string
   };
 
-  MemberAccess Access;
-  APSInt Value;
-  StringRef Name;
 };
 
 // LF_VFUNCTAB
 class VFPtrRecord : public TypeRecord {
 public:
   explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<VFPtrRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data);
 
   TypeIndex getType() const { return Type; }
+  TypeIndex Type;
 
 private:
   struct Layout {
     ulittle16_t Pad0;
     TypeIndex Type; // Type of vfptr
   };
-  TypeIndex Type;
 };
 
 // LF_BCLASS, LF_BINTERFACE
 class BaseClassRecord : public TypeRecord {
 public:
   explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<BaseClassRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return Type; }
   uint64_t getBaseOffset() const { return Offset; }
+  MemberAccess Access;
+  TypeIndex Type;
+  uint64_t Offset;
 
 private:
   struct Layout {
     MemberAttributes Attrs; // Access control attributes, etc
     TypeIndex BaseType;     // Base class type
     // BaseOffset: LF_NUMERIC encoded byte offset of base from derived.
   };
-  MemberAccess Access;
-  TypeIndex Type;
-  uint64_t Offset;
 };
 
 // LF_VBCLASS, LF_IVBCLASS
 class VirtualBaseClassRecord : public TypeRecord {
 public:
   explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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 Expected<VirtualBaseClassRecord> deserialize(TypeRecordKind Kind,
                                                       ArrayRef<uint8_t> &Data);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }
   uint64_t getVBPtrOffset() const { return VBPtrOffset; }
   uint64_t getVTableIndex() const { return VTableIndex; }
+  MemberAccess Access;
+  TypeIndex BaseType;
+  TypeIndex VBPtrType;
+  uint64_t VBPtrOffset;
+  uint64_t VTableIndex;
 
 private:
   struct Layout {
     MemberAttributes Attrs; // Access control attributes, etc.
     TypeIndex BaseType;     // Base class type
     TypeIndex VBPtrType;    // Virtual base pointer type
     // VBPtrOffset: Offset of vbptr from vfptr encoded as LF_NUMERIC.
     // VBTableIndex: Index of vbase within vbtable encoded as LF_NUMERIC.
   };
-  MemberAccess Access;
-  TypeIndex BaseType;
-  TypeIndex VBPtrType;
-  uint64_t VBPtrOffset;
-  uint64_t VTableIndex;
 };
 
 /// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
 /// together. The first will end in an LF_INDEX record that points to the next.
 class ListContinuationRecord : public TypeRecord {
 public:
   explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   ListContinuationRecord(TypeIndex ContinuationIndex)
       : TypeRecord(TypeRecordKind::ListContinuation),
         ContinuationIndex(ContinuationIndex) {}
 
   TypeIndex getContinuationIndex() const { return ContinuationIndex; }
 
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<ListContinuationRecord> deserialize(TypeRecordKind Kind,
                                                       ArrayRef<uint8_t> &Data);
+  TypeIndex ContinuationIndex;
 
 private:
   struct Layout {
     ulittle16_t Pad0;
     TypeIndex ContinuationIndex;
   };
-  TypeIndex ContinuationIndex;
 };
 
-typedef CVRecord<TypeLeafKind> CVType;
-typedef msf::VarStreamArray<CVType> CVTypeArray;
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/MSF/StreamReader.h

Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
     if (Offset + Length > Stream.getLength())
       return make_error<MSFError>(msf_error_code::insufficient_buffer);
     ReadableStreamRef View = Stream.slice(Offset, Length);
     Array = FixedStreamArray<T>(View);
     Offset += Length;
     return Error::success();
   }
 
+  bool empty() const { return bytesRemaining() == 0; }
   void setOffset(uint32_t Off) { Offset = Off; }
   uint32_t getOffset() const { return Offset; }
   uint32_t getLength() const { return Stream.getLength(); }
   uint32_t bytesRemaining() const { return getLength() - getOffset(); }
 
 private:
   ReadableStreamRef Stream;
   uint32_t Offset;
 };
 } // namespace msf
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_MSF_STREAMREADER_H

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

 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
+template <typename T>
+static Error takeObject(ArrayRef<uint8_t> &Data, const T *&Res) {
+  if (Data.size() < sizeof(*Res))
+    return llvm::make_error<CodeViewError>(cv_error_code::insufficient_buffer);
+  Res = reinterpret_cast<const T *>(Data.data());
+  Data = Data.drop_front(sizeof(*Res));
+  return Error::success();
+}
+
+template <typename T>
+static Expected<CVType> deserializeMemberRecord(ArrayRef<uint8_t> &Data,
+                                                TypeLeafKind Kind) {
+  ArrayRef<uint8_t> OldData = Data;
+  TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
+  auto ExpectedRecord = T::deserialize(RK, Data);
+  if (!ExpectedRecord)
+    return ExpectedRecord.takeError();
+  assert(Data.size() < OldData.size());
+  if (auto EC = skipPadding(Data))
+    return std::move(EC);
+
+  CVType CVR;
+  CVR.Type = Kind;
+  CVR.Length = OldData.size() - Data.size();
+  CVR.Data = OldData.slice(0, CVR.Length);
+  CVR.RawData = CVR.Data;
+  return CVR;
+}
+
+static Error skipPadding(ArrayRef<uint8_t> &Data) {
+  if (Data.empty())
+    return Error::success();
+  uint8_t Leaf = Data.front();
+  if (Leaf < LF_PAD0)
+    return Error::success();
+  // Leaf is greater than 0xf0. We should advance by the number of bytes in
+  // the low 4 bits.
+  unsigned BytesToAdvance = Leaf & 0x0F;
+  if (Data.size() < BytesToAdvance) {
+    return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record,
+                                           "Invalid padding bytes!");
+  }
+  Data = Data.drop_front(BytesToAdvance);
+  return Error::success();
+}
+
 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
     : Callbacks(Callbacks) {}
 
 template <typename T>
 static Error visitKnownRecord(const CVRecord<TypeLeafKind> &Record,
                               TypeVisitorCallbacks &Callbacks) {
   TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Type);
   T KnownRecord(RK);

 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
     if (auto EC = visitKnownRecord<Name##Record>(Record, Callbacks))           \
       return EC;                                                               \
     break;                                                                     \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
   TYPE_RECORD(EnumVal, EnumVal, AliasName)
-#define MEMBER_RECORD(EnumName, EnumVal, Name)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  TYPE_RECORD(EnumName, EnumVal, Name)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
+  MEMBER_RECORD(EnumName, EnumVal, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   }
 
   if (auto EC = Callbacks.visitTypeEnd(Record))
     return EC;
 
   return Error::success();
 }
 
 /// Visits the type records in Data. Sets the error flag on parse failures.
 Error CVTypeVisitor::visitTypeStream(const CVTypeArray &Types) {
   for (const auto &I : Types) {
     if (auto EC = visitTypeRecord(I))
       return EC;
   }
   return Error::success();
 }
+
+Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef<uint8_t> Data) {
+  while (!Data.empty()) {
+    const support::ulittle16_t *LeafValue;
+    if (auto EC = takeObject(Data, LeafValue))
+      return std::move(EC);
+
+    TypeLeafKind Leaf = static_cast<TypeLeafKind>(uint16_t(*LeafValue));
+    CVType Record;
+    switch (Leaf) {
+    default:
+      // Field list records do not describe their own length, so we cannot
+      // continue parsing past a type that we don't know how to deserialize.
+      return llvm::make_error<CodeViewError>(
+          cv_error_code::unknown_member_record);
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  case EnumName: {                                                             \
+    auto ExpectedRecord = deserializeMemberRecord<Name##Record>(Data, Leaf);   \
+    if (!ExpectedRecord)                                                       \
+      return ExpectedRecord.takeError();                                       \
+    auto &Record = *ExpectedRecord;                                            \
+    if (auto EC = Callbacks.visitTypeBegin(Record))                            \
+      return EC;                                                               \
+    if (auto EC = visitKnownRecord<Name##Record>(Record, Callbacks))           \
+      return EC;                                                               \
+    if (auto EC = Callbacks.visitTypeEnd(Record))                              \
+      return EC;                                                               \
+    break;                                                                     \
+  }
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
+  MEMBER_RECORD(EnumVal, EnumVal, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+    }
+  }
+  return Error::success();
+}

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

#define CV_ENUM_ENT(ns, enum)                                                  \
   { #enum, ns::enum }
 
 static const EnumEntry<SymbolKind> SymbolTypeNames[] = {
 #define CV_SYMBOL(enum, val) {#enum, enum},
 #include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
 #undef CV_SYMBOL
 };
 
+static const EnumEntry<TypeLeafKind> TypeLeafNames[] = {
+#define CV_TYPE(name, val) {#name, name},
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+#undef CV_TYPE
+};
+
 static const EnumEntry<uint16_t> RegisterNames[] = {
     CV_ENUM_CLASS_ENT(RegisterId, Unknown),
     CV_ENUM_CLASS_ENT(RegisterId, VFrame),
     CV_ENUM_CLASS_ENT(RegisterId, AL),
     CV_ENUM_CLASS_ENT(RegisterId, CL),
     CV_ENUM_CLASS_ENT(RegisterId, DL),
     CV_ENUM_CLASS_ENT(RegisterId, BL),
     CV_ENUM_CLASS_ENT(RegisterId, AH),
ImageSectionCharacteristicNames[] = {
         CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE)};
 
 namespace llvm {
 namespace codeview {
 ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames() {
   return makeArrayRef(SymbolTypeNames);
 }
 
+ArrayRef<EnumEntry<TypeLeafKind>> getTypeLeafNames() {
+  return makeArrayRef(TypeLeafNames);
+}
+
 ArrayRef<EnumEntry<uint16_t>> getRegisterNames() {
   return makeArrayRef(RegisterNames);
 }
 
 ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() {
   return makeArrayRef(ProcSymFlagNames);
 }
 ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames() {

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

 //===- TypeDeserializer.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/TypeDeserializer.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
-
-template <typename T>
-static Error takeObject(ArrayRef<uint8_t> &Data, const T *&Res) {
-  if (Data.size() < sizeof(*Res))
-    return llvm::make_error<CodeViewError>(cv_error_code::insufficient_buffer);
-  Res = reinterpret_cast<const T *>(Data.data());
-  Data = Data.drop_front(sizeof(*Res));
-  return Error::success();
-}
-
-Error TypeDeserializer::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
-                                         FieldListRecord &Record) {
-  ArrayRef<uint8_t> FieldListRecordData = CVR.Data;
-  auto ExpectedRecord = FieldListRecord::deserialize(TypeRecordKind::FieldList,
-                                                     FieldListRecordData);
-  if (!ExpectedRecord)
-    return ExpectedRecord.takeError();
-
-  Record = *ExpectedRecord;
-  ArrayRef<uint8_t> MemberData = Record.getFieldListData();
-
-  while (!MemberData.empty()) {
-    const ulittle16_t *LeafPtr;
-    if (auto EC = takeObject(MemberData, LeafPtr))
-      return EC;
-    TypeLeafKind Leaf = TypeLeafKind(unsigned(*LeafPtr));
-    switch (Leaf) {
-    default:
-      // Field list records do not describe their own length, so we cannot
-      // continue parsing past a type that we don't know how to deserialize.
-      if (auto EC = Recipient.visitUnknownMember(CVR))
-        return EC;
-      return llvm::make_error<CodeViewError>(
-          cv_error_code::unknown_member_record);
-#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  case EnumName: {                                                             \
-    TypeRecordKind RK = static_cast<TypeRecordKind>(Leaf);                     \
-    Name##Record Member(RK);                                                   \
-    if (auto EC = visitKnownMember(MemberData, Leaf, Member))                  \
-      return EC;                                                               \
-    break;                                                                     \
-  }
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
-  MEMBER_RECORD(EnumVal, EnumVal, AliasName)
-#include "llvm/DebugInfo/CodeView/TypeRecords.def"
-    }
-    if (auto EC = skipPadding(MemberData))
-      return EC;
-  }
-  return Error::success();
-}
-
-Error TypeDeserializer::skipPadding(ArrayRef<uint8_t> &Data) {
-  if (Data.empty())
-    return Error::success();
-  uint8_t Leaf = Data.front();
-  if (Leaf < LF_PAD0)
-    return Error::success();
-  // Leaf is greater than 0xf0. We should advance by the number of bytes in
-  // the low 4 bits.
-  unsigned BytesToAdvance = Leaf & 0x0F;
-  if (Data.size() < BytesToAdvance) {
-    return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                           "Invalid padding bytes!");
-  }
-  Data = Data.drop_front(BytesToAdvance);
-  return Error::success();
-}

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

#include "llvm/DebugInfo/CodeView/TypeRecords.def"
   }
   return "UnknownLeaf";
 }
 
 Error CVTypeDumper::visitTypeBegin(const CVRecord<TypeLeafKind> &Record) {
   // Reset Name to the empty string. If the visitor sets it, we know it.
   Name = "";
 
-  W->startLine() << getLeafTypeName(Record.Type) << " ("
-                 << HexNumber(getNextTypeIndex()) << ") {\n";
+  W->startLine() << getLeafTypeName(Record.Type);
+  if (!IsInFieldList) {
+    // If this is a field list member, don't record its type index because it
+    // doesn't have one.  Only the outer field list has a type index.
+    W->getOStream() << " (" << HexNumber(getNextTypeIndex()) << ")";
+  }
+  W->getOStream() << " {\n";
   W->indent();
   W->printEnum("TypeLeafKind", unsigned(Record.Type),
                makeArrayRef(LeafTypeNames));
+  if (Record.Type == LF_FIELDLIST) {
+    // Record that we're in a field list so that members do not get assigned
+    // type indices.
+    assert(!IsInFieldList);
+    IsInFieldList = true;
+  }
   return Error::success();
 }
 
 Error CVTypeDumper::visitTypeEnd(const CVRecord<TypeLeafKind> &Record) {
-  if (Record.Type == LF_FIELDLIST)
-    Name = "<field list>";
+  if (Record.Type == LF_FIELDLIST) {
+    assert(IsInFieldList);
+    IsInFieldList = false;
+  }
 
-  // Always record some name for every type, even if Name is empty. CVUDTNames
-  // is indexed by type index, and must have one entry for every type.
+  if (!IsInFieldList) {
+    // Record every type that is not a field list member, even if Name is empty.
+    // CVUDTNames is indexed by type index, and must have one entry for every
+    // type.  Field list members are not recorded, and are only referenced by
+    // their containing field list record.
     recordType(Name);
+  }
 
   if (PrintRecordBytes)
     W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
 
   W->unindent();
   W->startLine() << "}\n";
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      FieldListRecord &FieldList) {
+  TypeDeserializer Deserializer(*this);
+  CVTypeVisitor Visitor(Deserializer);
+  if (auto EC = Visitor.visitFieldListMemberStream(FieldList.Data))
+    return EC;
+
+  Name = "<field list>";
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W->printString("StringData", String.getString());
   // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.

 }
 
 Error CVTypeDumper::visitUnknownMember(const CVRecord<TypeLeafKind> &Record) {
   W->printHex("UnknownMember", unsigned(Record.Type));
   return Error::success();
 }
 
 Error CVTypeDumper::visitUnknownType(const CVRecord<TypeLeafKind> &Record) {
-  DictScope S(*W, "UnknownType");
   W->printEnum("Kind", uint16_t(Record.Type), makeArrayRef(LeafTypeNames));
   W->printNumber("Length", uint32_t(Record.Data.size()));
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      NestedTypeRecord &Nested) {
-  DictScope S(*W, "NestedType");
   printTypeIndex("Type", Nested.getNestedType());
   W->printString("Name", Nested.getName());
   Name = Nested.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      OneMethodRecord &Method) {
-  DictScope S(*W, "OneMethod");
   MethodKind K = Method.getKind();
   printMemberAttributes(Method.getAccess(), K, Method.getOptions());
   printTypeIndex("Type", Method.getType());
   // If virtual, then read the vftable offset.
   if (Method.isIntroducingVirtual())
     W->printHex("VFTableOffset", Method.getVFTableOffset());
   W->printString("Name", Method.getName());
   Name = Method.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      OverloadedMethodRecord &Method) {
-  DictScope S(*W, "OverloadedMethod");
   W->printHex("MethodCount", Method.getNumOverloads());
   printTypeIndex("MethodListIndex", Method.getMethodList());
   W->printString("Name", Method.getName());
   Name = Method.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      DataMemberRecord &Field) {
-  DictScope S(*W, "DataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W->printHex("FieldOffset", Field.getFieldOffset());
   W->printString("Name", Field.getName());
   Name = Field.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      StaticDataMemberRecord &Field) {
-  DictScope S(*W, "StaticDataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W->printString("Name", Field.getName());
   Name = Field.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      VFPtrRecord &VFTable) {
-  DictScope S(*W, "VFPtr");
   printTypeIndex("Type", VFTable.getType());
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      EnumeratorRecord &Enum) {
-  DictScope S(*W, "Enumerator");
   printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   W->printNumber("EnumValue", Enum.getValue());
   W->printString("Name", Enum.getName());
   Name = Enum.getName();
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      BaseClassRecord &Base) {
-  DictScope S(*W, "BaseClass");
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   W->printHex("BaseOffset", Base.getBaseOffset());
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      VirtualBaseClassRecord &Base) {
-  DictScope S(*W, "VirtualBaseClass");
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   printTypeIndex("VBPtrType", Base.getVBPtrType());
   W->printHex("VBPtrOffset", Base.getVBPtrOffset());
   W->printHex("VBTableIndex", Base.getVTableIndex());
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
                                      ListContinuationRecord &Cont) {
-  DictScope S(*W, "ListContinuation");
   printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
   return Error::success();
 }
 
 StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   if (TI.isNoneType())
     return "<no type>";
 

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"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/MSF/ByteStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 //===----------------------------------------------------------------------===//
 // Type record deserialization
 //===----------------------------------------------------------------------===//
 
NestedTypeRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
   const Layout *L = nullptr;
   StringRef Name;
   CV_DESERIALIZE(Data, L, Name);
   return NestedTypeRecord(L->Type, Name);
 }
 
 Expected<FieldListRecord>
 FieldListRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
-  return FieldListRecord(Data);
+  auto FieldListData = Data;
+  Data = ArrayRef<uint8_t>();
+  return FieldListRecord(FieldListData);
 }
 
 Expected<ArrayRecord> 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);

 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);
+    Success &= MemberInfo->remapTypeIndices(IndexMap);
   return Success;
 }
 
 bool NestedTypeRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {
   return remapIndex(IndexMap, Type);
 }
 
 bool ArrayRecord::remapTypeIndices(ArrayRef<TypeIndex> IndexMap) {

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

private:
   Error visitKnownRecordImpl(RecordType &Record) {
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);
     IndexMap.push_back(DestStream.writeKnownType(Record));
     return Error::success();
   }
 
   Error visitKnownRecordImpl(FieldListRecord &Record) {
     // Don't do anything, this will get written in the call to visitTypeEnd().
+    TypeDeserializer Deserializer(*this);
+    CVTypeVisitor Visitor(Deserializer);
+
+    if (auto EC = Visitor.visitFieldListMemberStream(Record.Data))
+      return std::move(EC);
     return Error::success();
   }
 
   template <typename RecordType>
   Error visitKnownMemberRecordImpl(RecordType &Record) {
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);
     FieldBuilder.writeMemberType(Record);
     return Error::success();
   }
 
   bool hadError() { return FoundBadTypeIndex; }
 
   bool FoundBadTypeIndex = false;
 
   FieldListRecordBuilder FieldBuilder;
 
   TypeTableBuilder &DestStream;
 
+  bool IsInFieldList{false};
   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
 
 Error TypeStreamMerger::visitTypeBegin(const CVRecord<TypeLeafKind> &Rec) {
-  if (Rec.Type != TypeLeafKind::LF_FIELDLIST)
+  if (Rec.Type == TypeLeafKind::LF_FIELDLIST) {
+    assert(!IsInFieldList);
+    IsInFieldList = true;
+  } else
     BeginIndexMapSize = IndexMap.size();
   return Error::success();
 }
 
 Error TypeStreamMerger::visitTypeEnd(const CVRecord<TypeLeafKind> &Rec) {
   if (Rec.Type == TypeLeafKind::LF_FIELDLIST) {
     IndexMap.push_back(DestStream.writeFieldList(FieldBuilder));
     FieldBuilder.reset();
-  } else {
+    IsInFieldList = false;
+  } else if (!IsInFieldList) {
     assert(IndexMap.size() == BeginIndexMapSize + 1);
   }
   return Error::success();
 }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error TypeStreamMerger::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,  \
                                            Name##Record &Record) {             \

llvm/trunk/test/DebugInfo/COFF/big-type.ll

 ; RUN: llc -filetype=obj < %s | llvm-readobj - -codeview | FileCheck %s
 
 ; We need three continuation records for this.
 
 ; CHECK-LABEL: FieldList (0x1000)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
+; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   EnumValue: 5460
 ; CHECK-NEXT:   Name: EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE5461
 ; CHECK-NEXT: }
 ; CHECK-NOT: ContinuationIndex
 
 ; CHECK-LABEL: FieldList (0x1001)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
+; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   EnumValue: 4095
 ; CHECK-NEXT:   Name: EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE4096
 ; CHECK-NEXT: }
 ; CHECK: ContinuationIndex: <field list> (0x1000)
 
 ; CHECK-LABEL: FieldList (0x1002)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
+; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   EnumValue: 2730
 ; CHECK-NEXT:   Name: EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE2731
 ; CHECK-NEXT: }
 ; CHECK: ContinuationIndex: <field list> (0x1001)
 
 ; CHECK-LABEL: FieldList (0x1003)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
+; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   EnumValue: 1365
 ; CHECK-NEXT:   Name: EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE1366
 ; CHECK-NEXT: }
 ; CHECK: ContinuationIndex: <field list> (0x1002)
 
 ; CHECK-LABEL: FieldList (0x1004)
 ; CHECK-NEXT: TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT: Enumerator {
+; CHECK-NEXT:   TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   EnumValue: 0
 ; CHECK-NEXT:   Name: EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE1
 ; CHECK-NEXT: }
 ; CHECK: ContinuationIndex: <field list> (0x1003)
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"

llvm/trunk/test/DebugInfo/COFF/enum.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
 
 ; Generated from the following C++ source:
 ; enum E : int { BLAH };
 ; E e;
 
 ; CHECK:     CodeViewTypes [
 ; CHECK:       FieldList (0x1000) {
 ; CHECK-NEXT:    TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT:    Enumerator {
+; CHECK-NEXT:      TypeLeafKind: LF_ENUMERATE (0x1502)
 ; CHECK-NEXT:      AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:      EnumValue: 0
 ; CHECK-NEXT:      Name: BLAH
 ; CHECK-NEXT:    }
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Enum (0x1001) {
 ; CHECK-NEXT:    TypeLeafKind: LF_ENUM (0x1507)
 ; CHECK-NEXT:    NumEnumerators: 1

llvm/trunk/test/DebugInfo/COFF/inheritance.ll

 ; };
 ; D d;
 ; $ clang -fno-rtti -g -gcodeview t.cpp -emit-llvm -S -o t.ll -O1
 
 ; D's field list comes first.
 ; CHECK:        FieldList ({{.*}}) {
 ; CHECK-NEXT:     TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT:     BaseClass {
+; CHECK-NEXT:       TypeLeafKind: LF_BCLASS (0x1400)
 ; CHECK-NEXT:       AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:       BaseType: B ({{.*}})
 ; CHECK-NEXT:       BaseOffset: 0x8
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     BaseClass {
+; CHECK-NEXT:       TypeLeafKind: LF_BCLASS (0x1400)
 ; CHECK-NEXT:       AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:       BaseType: C ({{.*}})
 ; CHECK-NEXT:       BaseOffset: 0x18
 ; CHECK-NEXT:     }
 ; CHECK:        }
 
 ; Then B's field list.
 ; CHECK:        FieldList ({{.*}}) {
 ; CHECK-NEXT:     TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT:     VirtualBaseClass {
+; CHECK-NEXT:       TypeLeafKind: LF_VBCLASS (0x1401)
 ; CHECK-NEXT:       AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:       BaseType: A ({{.*}})
 ; CHECK-NEXT:       VBPtrType: const int* ({{.*}})
 ; CHECK-NEXT:       VBPtrOffset: 0x0
 ; CHECK-NEXT:       VBTableIndex: 0x1
 ; CHECK-NEXT:     }
 ; CHECK:        }
 
 ; Then C's field list.
 ; CHECK:        FieldList ({{.*}}) {
 ; CHECK-NEXT:     TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT:     VirtualBaseClass {
+; CHECK-NEXT:       TypeLeafKind: LF_VBCLASS (0x1401)
 ; CHECK-NEXT:       AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:       BaseType: A ({{.*}})
 ; CHECK-NEXT:       VBPtrType: const int* ({{.*}})
 ; CHECK-NEXT:       VBPtrOffset: 0x0
 ; CHECK-NEXT:       VBTableIndex: 0x1
 ; CHECK-NEXT:     }
 ; CHECK:        }
 

llvm/trunk/test/DebugInfo/COFF/virtual-method-kinds.ll

 ; struct C : B {
 ;   void f() override;     // Virtual
 ;   void g() override;     // Virtual
 ; };
 ; C *p = new C;
 ; $ clang t.cpp -S -emit-llvm -g -gcodeview -o t.ll
 
 ; CHECK:      OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: Virtual (0x1)
 ; CHECK-NEXT:   Type: void C::() ({{.*}})
 ; CHECK-NEXT:   Name: f
 ; CHECK-NEXT: }
 ; CHECK-NEXT: OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: Virtual (0x1)
 ; CHECK-NEXT:   Type: void C::() ({{.*}})
 ; CHECK-NEXT:   Name: g
 ; CHECK-NEXT: }
 
 ; CHECK:      OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: PureVirtual (0x5)
 ; CHECK-NEXT:   Type: void B::() ({{.*}})
 ; CHECK-NEXT:   Name: f
 ; CHECK-NEXT: }
 ; CHECK-NEXT: OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: Virtual (0x1)
 ; CHECK-NEXT:   Type: void B::() ({{.*}})
 ; CHECK-NEXT:   Name: g
 ; CHECK-NEXT: }
 
 ; CHECK:      OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: IntroducingVirtual (0x4)
 ; CHECK-NEXT:   Type: void A::() ({{.*}})
 ; CHECK-NEXT:   VFTableOffset: 0x0
 ; CHECK-NEXT:   Name: f
 ; CHECK-NEXT: }
 ; CHECK-NEXT: OneMethod {
+; CHECK-NEXT:   TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:   AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:   MethodKind: PureIntroducingVirtual (0x6)
 ; CHECK-NEXT:   Type: void A::() ({{.*}})
 ; CHECK-NEXT:   VFTableOffset: 0x8
 ; CHECK-NEXT:   Name: g
 ; CHECK-NEXT: }
 
 ; ModuleID = 't.cpp'

llvm/trunk/test/DebugInfo/COFF/virtual-methods.ll

 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 8
 ; CHECK-NEXT: }
 
 ; CHECK:      FieldList ({{.*}}) {
 ; CHECK:        OneMethod {
+; CHECK-NEXT:     TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:     AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:     MethodKind: Virtual (0x1)
 ; CHECK-NEXT:     Type: int C::() ([[C_g]])
 ; CHECK-NEXT:     Name: g
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: }
 
 ; D::g
 ; CHECK:      MemberFunction ([[D_g:.*]]) {
 ; CHECK-NEXT:   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:   ReturnType: int (0x74)
 ; CHECK-NEXT:   ClassType: D ({{.*}})
 ; CHECK-NEXT:   ThisType: D* ({{.*}})
 ; CHECK-NEXT:   CallingConvention: NearC (0x0)
 ; CHECK-NEXT:   FunctionOptions [ (0x0)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 16
 ; CHECK-NEXT: }
 
 ; CHECK:      FieldList ({{.*}}) {
 ; CHECK:        OneMethod {
+; CHECK-NEXT:     TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:     AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:     MethodKind: Virtual (0x1)
 ; CHECK-NEXT:     Type: int D::() ([[D_g]])
 ; CHECK-NEXT:     Name: g
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: }
 
 ; Need to skip constructor IDs...

llvm/trunk/test/DebugInfo/PDB/pdbdump-headers.test

 ; EMPTY-NEXT:       Bytes (
 ; EMPTY-NEXT:         0000: 74000000 00000000 00100000           |t...........|
 ; EMPTY-NEXT:       )
 ; EMPTY-NEXT:     }
 ; EMPTY-NEXT:     {
 ; EMPTY-NEXT:       FieldList (0x1002) {
 ; EMPTY-NEXT:         TypeLeafKind: LF_FIELDLIST (0x1203)
 ; EMPTY-NEXT:         Enumerator {
+; EMPTY-NEXT:           TypeLeafKind: LF_ENUMERATE (0x1502)
 ; EMPTY-NEXT:           AccessSpecifier: Public (0x3)
 ; EMPTY-NEXT:           EnumValue: 1
 ; EMPTY-NEXT:           Name: apartment
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         Enumerator {
+; EMPTY-NEXT:           TypeLeafKind: LF_ENUMERATE (0x1502)
 ; EMPTY-NEXT:           AccessSpecifier: Public (0x3)
 ; EMPTY-NEXT:           EnumValue: 2
 ; EMPTY-NEXT:           Name: single
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         Enumerator {
+; EMPTY-NEXT:           TypeLeafKind: LF_ENUMERATE (0x1502)
 ; EMPTY-NEXT:           AccessSpecifier: Public (0x3)
 ; EMPTY-NEXT:           EnumValue: 3
 ; EMPTY-NEXT:           Name: free
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         Enumerator {
+; EMPTY-NEXT:           TypeLeafKind: LF_ENUMERATE (0x1502)
 ; EMPTY-NEXT:           AccessSpecifier: Public (0x3)
 ; EMPTY-NEXT:           EnumValue: 4
 ; EMPTY-NEXT:           Name: neutral
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         Enumerator {
+; EMPTY-NEXT:           TypeLeafKind: LF_ENUMERATE (0x1502)
 ; EMPTY-NEXT:           AccessSpecifier: Public (0x3)
 ; EMPTY-NEXT:           EnumValue: 5
 ; EMPTY-NEXT:           Name: both
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:       }
 ; EMPTY-NEXT:       Bytes (
 ; EMPTY-NEXT:         0000: 02150300 01006170 6172746D 656E7400  |......apartment.|
 ; EMPTY-NEXT:         0010: 02150300 02007369 6E676C65 00F3F2F1  |......single....|

llvm/trunk/test/DebugInfo/PDB/pdbdump-yaml-types.test

+; RUN: llvm-pdbdump pdb2yaml -tpi-stream %p/Inputs/empty.pdb \
+; RUN:   | FileCheck -check-prefix=YAML %s
+
+YAML: ---
+YAML: MSF:             
+YAML:   SuperBlock:      
+YAML:     BlockSize:       4096
+YAML:     FreeBlockMap:    2
+YAML:     NumBlocks:       25
+YAML:     NumDirectoryBytes: 136
+YAML:     Unknown1:        0
+YAML:     BlockMapAddr:    24
+YAML:   NumDirectoryBlocks: 1
+YAML:   DirectoryBlocks: [ 23 ]
+YAML:   NumStreams:      0
+YAML:   FileSize:        102400
+YAML: TpiStream:       
+YAML:   Version:         VC80
+YAML:   Records:         
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [  ]
+YAML:     - Kind:            LF_PROCEDURE
+YAML:       Procedure:       
+YAML:         ReturnType:      116
+YAML:         CallConv:        NearC
+YAML:         Options:         [ None ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            apartment
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            single
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           3
+YAML:           Name:            free
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           4
+YAML:           Name:            neutral
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           5
+YAML:           Name:            both
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  5
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4098
+YAML:         Name:            '__vc_attributes::threadingAttribute::threading_e'
+YAML:         UniqueName:      '.?AW4threading_e@threadingAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::threadingAttribute'
+YAML:         UniqueName:      '.?AUthreadingAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4100
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4099 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4100
+YAML:         ThisType:        4101
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4102
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4100
+YAML:         ThisType:        4101
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_METHODLIST
+YAML:       MethodOverloadList: 
+YAML:         Methods:         
+YAML:           - Type:            4103
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4104
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4099
+YAML:           Name:            threading_e
+YAML:         Kind:            LF_METHOD
+YAML:         OverloadedMethod: 
+YAML:           NumOverloads:    2
+YAML:           MethodList:      4105
+YAML:           Name:            threadingAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4099
+YAML:           FieldOffset:     0
+YAML:           Name:            value
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     4
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4106
+YAML:         Name:            '__vc_attributes::threadingAttribute'
+YAML:         UniqueName:      '.?AUthreadingAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            4
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           0
+YAML:           Name:            native
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            com
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            managed
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  3
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4108
+YAML:         Name:            '__vc_attributes::event_receiverAttribute::type_e'
+YAML:         UniqueName:      '.?AW4type_e@event_receiverAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::event_receiverAttribute'
+YAML:         UniqueName:      '.?AUevent_receiverAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4110
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4109, 48 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4110
+YAML:         ThisType:        4111
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  2
+YAML:         ArgumentList:    4112
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4109 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4110
+YAML:         ThisType:        4111
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4114
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4110
+YAML:         ThisType:        4111
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_METHODLIST
+YAML:       MethodOverloadList: 
+YAML:         Methods:         
+YAML:           - Type:            4113
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4115
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4116
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4109
+YAML:           Name:            type_e
+YAML:         Kind:            LF_METHOD
+YAML:         OverloadedMethod: 
+YAML:           NumOverloads:    3
+YAML:           MethodList:      4117
+YAML:           Name:            event_receiverAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4109
+YAML:           FieldOffset:     0
+YAML:           Name:            type
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            48
+YAML:           FieldOffset:     4
+YAML:           Name:            layout_dependent
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     6
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4118
+YAML:         Name:            '__vc_attributes::event_receiverAttribute'
+YAML:         UniqueName:      '.?AUevent_receiverAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            8
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           0
+YAML:           Name:            never
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            allowed
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            always
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  3
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4120
+YAML:         Name:            '__vc_attributes::aggregatableAttribute::type_e'
+YAML:         UniqueName:      '.?AW4type_e@aggregatableAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::aggregatableAttribute'
+YAML:         UniqueName:      '.?AUaggregatableAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4122
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4121 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4122
+YAML:         ThisType:        4123
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4124
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4122
+YAML:         ThisType:        4123
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_METHODLIST
+YAML:       MethodOverloadList: 
+YAML:         Methods:         
+YAML:           - Type:            4125
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4126
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4121
+YAML:           Name:            type_e
+YAML:         Kind:            LF_METHOD
+YAML:         OverloadedMethod: 
+YAML:           NumOverloads:    2
+YAML:           MethodList:      4127
+YAML:           Name:            aggregatableAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4121
+YAML:           FieldOffset:     0
+YAML:           Name:            type
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     4
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4128
+YAML:         Name:            '__vc_attributes::aggregatableAttribute'
+YAML:         UniqueName:      '.?AUaggregatableAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            4
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  3
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4108
+YAML:         Name:            '__vc_attributes::event_sourceAttribute::type_e'
+YAML:         UniqueName:      '.?AW4type_e@event_sourceAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           0
+YAML:           Name:            speed
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            size
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  2
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4131
+YAML:         Name:            '__vc_attributes::event_sourceAttribute::optimize_e'
+YAML:         UniqueName:      '.?AW4optimize_e@event_sourceAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::event_sourceAttribute'
+YAML:         UniqueName:      '.?AUevent_sourceAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4133
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4130 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4133
+YAML:         ThisType:        4134
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4135
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4133
+YAML:         ThisType:        4134
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_METHODLIST
+YAML:       MethodOverloadList: 
+YAML:         Methods:         
+YAML:           - Type:            4136
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4137
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4130
+YAML:           Name:            type_e
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4132
+YAML:           Name:            optimize_e
+YAML:         Kind:            LF_METHOD
+YAML:         OverloadedMethod: 
+YAML:           NumOverloads:    2
+YAML:           MethodList:      4138
+YAML:           Name:            event_sourceAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4130
+YAML:           FieldOffset:     0
+YAML:           Name:            type
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4132
+YAML:           FieldOffset:     4
+YAML:           Name:            optimize
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            48
+YAML:           FieldOffset:     8
+YAML:           Name:            decorate
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     7
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4139
+YAML:         Name:            '__vc_attributes::event_sourceAttribute'
+YAML:         UniqueName:      '.?AUevent_sourceAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            12
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            dll
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            exe
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           3
+YAML:           Name:            service
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           4
+YAML:           Name:            unspecified
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            EXE
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           3
+YAML:           Name:            SERVICE
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  6
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4141
+YAML:         Name:            '__vc_attributes::moduleAttribute::type_e'
+YAML:         UniqueName:      '.?AW4type_e@moduleAttribute@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::moduleAttribute'
+YAML:         UniqueName:      '.?AUmoduleAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4143
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_MODIFIER
+YAML:       Modifier:        
+YAML:         ModifiedType:    112
+YAML:         Modifiers:       [ None, Const ]
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4145
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4142, 4146, 4146, 4146, 116, 48, 4146, 116, 
+YAML:                            4146, 4146, 116, 48, 48, 4146, 4146 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4143
+YAML:         ThisType:        4144
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  15
+YAML:         ArgumentList:    4147
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4142 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4143
+YAML:         ThisType:        4144
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4149
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4143
+YAML:         ThisType:        4144
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  0
+YAML:         ArgumentList:    4096
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_METHODLIST
+YAML:       MethodOverloadList: 
+YAML:         Methods:         
+YAML:           - Type:            4148
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4150
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:           - Type:            4151
+YAML:             Kind:            Vanilla
+YAML:             Options:         [ None ]
+YAML:             Access:          Public
+YAML:             VFTableOffset:   -1
+YAML:             Name:            ''
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4142
+YAML:           Name:            type_e
+YAML:         Kind:            LF_METHOD
+YAML:         OverloadedMethod: 
+YAML:           NumOverloads:    3
+YAML:           MethodList:      4152
+YAML:           Name:            moduleAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4142
+YAML:           FieldOffset:     0
+YAML:           Name:            type
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     4
+YAML:           Name:            name
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     8
+YAML:           Name:            version
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     12
+YAML:           Name:            uuid
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            116
+YAML:           FieldOffset:     16
+YAML:           Name:            lcid
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            48
+YAML:           FieldOffset:     20
+YAML:           Name:            control
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     24
+YAML:           Name:            helpstring
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            116
+YAML:           FieldOffset:     28
+YAML:           Name:            helpstringcontext
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     32
+YAML:           Name:            helpstringdll
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     36
+YAML:           Name:            helpfile
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            116
+YAML:           FieldOffset:     40
+YAML:           Name:            helpcontext
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            48
+YAML:           FieldOffset:     44
+YAML:           Name:            hidden
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            48
+YAML:           FieldOffset:     45
+YAML:           Name:            restricted
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     48
+YAML:           Name:            custom
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4146
+YAML:           FieldOffset:     52
+YAML:           Name:            resource_name
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     19
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4153
+YAML:         Name:            '__vc_attributes::moduleAttribute'
+YAML:         UniqueName:      '.?AUmoduleAttribute@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            56
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           0
+YAML:           Name:            eAnyUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            eCoClassUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            eCOMInterfaceUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           6
+YAML:           Name:            eInterfaceUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           8
+YAML:           Name:            eMemberUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           16
+YAML:           Name:            eMethodUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           32
+YAML:           Name:            eInterfaceMethodUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           64
+YAML:           Name:            eInterfaceMemberUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           128
+YAML:           Name:            eCoClassMemberUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           256
+YAML:           Name:            eCoClassMethodUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           768
+YAML:           Name:            eGlobalMethodUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1024
+YAML:           Name:            eGlobalDataUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2048
+YAML:           Name:            eClassUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           4096
+YAML:           Name:            eInterfaceParameterUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           12288
+YAML:           Name:            eMethodParameterUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           16384
+YAML:           Name:            eIDLModuleUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           -32768
+YAML:           Name:            eAnonymousUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           65536
+YAML:           Name:            eTypedefUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           131072
+YAML:           Name:            eUnionUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           262144
+YAML:           Name:            eEnumUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           524288
+YAML:           Name:            eDefineTagUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1048576
+YAML:           Name:            eStructUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2097152
+YAML:           Name:            eLocalUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           4194304
+YAML:           Name:            ePropertyUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           8388608
+YAML:           Name:            eEventUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           16777216
+YAML:           Name:            eTemplateUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           16777216
+YAML:           Name:            eModuleUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           33554432
+YAML:           Name:            eIllegalUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           67108864
+YAML:           Name:            eAsynchronousUsage
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           4161535
+YAML:           Name:            eAnyIDLUsage
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  30
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4155
+YAML:         Name:            '__vc_attributes::helper_attributes::usageAttribute::usage_e'
+YAML:         UniqueName:      '.?AW4usage_e@usageAttribute@helper_attributes@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::helper_attributes::usageAttribute'
+YAML:         UniqueName:      '.?AUusageAttribute@helper_attributes@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4157
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 117 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4157
+YAML:         ThisType:        4158
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4159
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4156
+YAML:           Name:            usage_e
+YAML:         Kind:            LF_ONEMETHOD
+YAML:         OneMethod:       
+YAML:           Type:            4160
+YAML:           Kind:            Vanilla
+YAML:           Options:         [ None ]
+YAML:           Access:          Public
+YAML:           VFTableOffset:   -1
+YAML:           Name:            usageAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            117
+YAML:           FieldOffset:     0
+YAML:           Name:            value
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     3
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4161
+YAML:         Name:            '__vc_attributes::helper_attributes::usageAttribute'
+YAML:         UniqueName:      '.?AUusageAttribute@helper_attributes@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            4
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           0
+YAML:           Name:            eBoolean
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           1
+YAML:           Name:            eInteger
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           2
+YAML:           Name:            eFloat
+YAML:         Kind:            LF_ENUMERATE
+YAML:         Enumerator:      
+YAML:           Access:          Public
+YAML:           Value:           3
+YAML:           Name:            eDouble
+YAML:     - Kind:            LF_ENUM
+YAML:       Enum:            
+YAML:         NumEnumerators:  4
+YAML:         Options:         [ None, Nested, HasUniqueName ]
+YAML:         FieldList:       4163
+YAML:         Name:            '__vc_attributes::helper_attributes::v1_alttypeAttribute::type_e'
+YAML:         UniqueName:      '.?AW4type_e@v1_alttypeAttribute@helper_attributes@__vc_attributes@@'
+YAML:         UnderlyingType:  116
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     0
+YAML:         Options:         [ None, ForwardReference, HasUniqueName ]
+YAML:         FieldList:       0
+YAML:         Name:            '__vc_attributes::helper_attributes::v1_alttypeAttribute'
+YAML:         UniqueName:      '.?AUv1_alttypeAttribute@helper_attributes@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            0
+YAML:     - Kind:            LF_POINTER
+YAML:       Pointer:         
+YAML:         ReferentType:    4165
+YAML:         PtrKind:         Near32
+YAML:         Mode:            Pointer
+YAML:         Options:         [ None, Const ]
+YAML:         Size:            4
+YAML:     - Kind:            LF_ARGLIST
+YAML:       ArgList:         
+YAML:         ArgIndices:      [ 4164 ]
+YAML:     - Kind:            LF_MFUNCTION
+YAML:       MemberFunction:  
+YAML:         ReturnType:      3
+YAML:         ClassType:       4165
+YAML:         ThisType:        4166
+YAML:         CallConv:        ThisCall
+YAML:         Options:         [ None, Constructor ]
+YAML:         ParameterCount:  1
+YAML:         ArgumentList:    4167
+YAML:         ThisPointerAdjustment: 0
+YAML:     - Kind:            LF_FIELDLIST
+YAML:       FieldList:       
+YAML:         Kind:            LF_NESTTYPE
+YAML:         NestedType:      
+YAML:           Type:            4164
+YAML:           Name:            type_e
+YAML:         Kind:            LF_ONEMETHOD
+YAML:         OneMethod:       
+YAML:           Type:            4168
+YAML:           Kind:            Vanilla
+YAML:           Options:         [ None ]
+YAML:           Access:          Public
+YAML:           VFTableOffset:   -1
+YAML:           Name:            v1_alttypeAttribute
+YAML:         Kind:            LF_MEMBER
+YAML:         DataMember:      
+YAML:           Access:          Public
+YAML:           Type:            4164
+YAML:           FieldOffset:     0
+YAML:           Name:            type
+YAML:     - Kind:            LF_STRUCTURE
+YAML:       Class:           
+YAML:         MemberCount:     3
+YAML:         Options:         [ None, HasConstructorOrDestructor, ContainsNestedClass, HasUniqueName ]
+YAML:         FieldList:       4169
+YAML:         Name:            '__vc_attributes::helper_attributes::v1_alttypeAttribute'
+YAML:         UniqueName:      '.?AUv1_alttypeAttribute@helper_attributes@__vc_attributes@@'
+YAML:         Hfa:             None
+YAML:         WinRTKind:       None
+YAML:         DerivationList:  0
+YAML:         VTableShape:     0
+YAML:         Size:            4
+YAML: ...

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

 set(LLVM_LINK_COMPONENTS
   DebugInfoCodeView
   DebugInfoMSF
   DebugInfoPDB
   Object
   Support
   )
 
 add_llvm_tool(llvm-pdbdump
   llvm-pdbdump.cpp
   BuiltinDumper.cpp
   ClassDefinitionDumper.cpp
+  CodeViewYaml.cpp
   CompilandDumper.cpp
   EnumDumper.cpp
   ExternalSymbolDumper.cpp
   FunctionDumper.cpp
   LinePrinter.cpp
   LLVMOutputStyle.cpp
   PdbYaml.cpp
   TypeDumper.cpp
   TypedefDumper.cpp
   VariableDumper.cpp
   YAMLOutputStyle.cpp
   )
 
 if(LLVM_USE_SANITIZE_COVERAGE)
   add_subdirectory(fuzzer)
 endif()

llvm/trunk/tools/llvm-pdbdump/CodeViewYaml.h

+//===- PdbYAML.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_TOOLS_LLVMPDBDUMP_CODEVIEWYAML_H
+#define LLVM_TOOLS_LLVMPDBDUMP_CODEVIEWYAML_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/Support/YAMLTraits.h"
+
+namespace llvm {
+namespace codeview {
+namespace yaml {
+class YamlTypeDumperCallbacks : public TypeVisitorCallbacks {
+public:
+  YamlTypeDumperCallbacks(llvm::yaml::IO &IO) : YamlIO(IO) {}
+
+  virtual Error visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override;
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,                    \
+                         Name##Record &Record) override {                      \
+    YamlIO.mapRequired(#Name, Record);                                         \
+    return Error::success();                                                   \
+  }
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  TYPE_RECORD(EnumName, EnumVal, Name)
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+
+private:
+  llvm::yaml::IO &YamlIO;
+};
+}
+}
+}
+
+namespace llvm {
+namespace yaml {
+template <> struct MappingTraits<codeview::MemberPointerInfo> {
+  static void mapping(IO &IO, codeview::MemberPointerInfo &Obj);
+};
+
+template <> struct MappingTraits<codeview::CVType> {
+  static void mapping(IO &IO, codeview::CVType &Obj);
+};
+
+template <> struct ScalarEnumerationTraits<codeview::TypeLeafKind> {
+  static void enumeration(IO &io, codeview::TypeLeafKind &Value);
+};
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  template <> struct MappingTraits<codeview::Name##Record> {                   \
+    static void mapping(IO &IO, codeview::Name##Record &Obj);                  \
+  };
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  TYPE_RECORD(EnumName, EnumVal, Name)
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+}
+}
+
+#endif

llvm/trunk/tools/llvm-pdbdump/CodeViewYaml.cpp

+//===- PdbYAML.cpp -------------------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeViewYaml.h"
+
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::codeview::yaml;
+
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
+LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
+LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
+LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
+LLVM_YAML_IS_SEQUENCE_VECTOR(CVType)
+
+namespace llvm {
+namespace yaml {
+template <> struct ScalarEnumerationTraits<PointerToMemberRepresentation> {
+  static void enumeration(IO &IO, PointerToMemberRepresentation &Value) {
+    IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
+    IO.enumCase(Value, "SingleInheritanceData",
+                PointerToMemberRepresentation::SingleInheritanceData);
+    IO.enumCase(Value, "MultipleInheritanceData",
+                PointerToMemberRepresentation::MultipleInheritanceData);
+    IO.enumCase(Value, "VirtualInheritanceData",
+                PointerToMemberRepresentation::VirtualInheritanceData);
+    IO.enumCase(Value, "GeneralData",
+                PointerToMemberRepresentation::GeneralData);
+    IO.enumCase(Value, "SingleInheritanceFunction",
+                PointerToMemberRepresentation::SingleInheritanceFunction);
+    IO.enumCase(Value, "MultipleInheritanceFunction",
+                PointerToMemberRepresentation::MultipleInheritanceFunction);
+    IO.enumCase(Value, "VirtualInheritanceFunction",
+                PointerToMemberRepresentation::VirtualInheritanceFunction);
+    IO.enumCase(Value, "GeneralFunction",
+                PointerToMemberRepresentation::GeneralFunction);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<VFTableSlotKind> {
+  static void enumeration(IO &IO, VFTableSlotKind &Kind) {
+    IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
+    IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
+    IO.enumCase(Kind, "This", VFTableSlotKind::This);
+    IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
+    IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
+    IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
+    IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<CallingConvention> {
+  static void enumeration(IO &IO, CallingConvention &Value) {
+    IO.enumCase(Value, "NearC", CallingConvention::NearC);
+    IO.enumCase(Value, "FarC", CallingConvention::FarC);
+    IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
+    IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
+    IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
+    IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
+    IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
+    IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
+    IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
+    IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
+    IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
+    IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
+    IO.enumCase(Value, "Generic", CallingConvention::Generic);
+    IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
+    IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
+    IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
+    IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
+    IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
+    IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
+    IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
+    IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
+    IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
+    IO.enumCase(Value, "Inline", CallingConvention::Inline);
+    IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<PointerKind> {
+  static void enumeration(IO &IO, PointerKind &Kind) {
+    IO.enumCase(Kind, "Near16", PointerKind::Near16);
+    IO.enumCase(Kind, "Far16", PointerKind::Far16);
+    IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
+    IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
+    IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
+    IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
+    IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
+    IO.enumCase(Kind, "BasedOnSegmentAddress",
+                PointerKind::BasedOnSegmentAddress);
+    IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
+    IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
+    IO.enumCase(Kind, "Near32", PointerKind::Near32);
+    IO.enumCase(Kind, "Far32", PointerKind::Far32);
+    IO.enumCase(Kind, "Near64", PointerKind::Near64);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<PointerMode> {
+  static void enumeration(IO &IO, PointerMode &Mode) {
+    IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
+    IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
+    IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
+    IO.enumCase(Mode, "PointerToMemberFunction",
+                PointerMode::PointerToMemberFunction);
+    IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<HfaKind> {
+  static void enumeration(IO &IO, HfaKind &Value) {
+    IO.enumCase(Value, "None", HfaKind::None);
+    IO.enumCase(Value, "Float", HfaKind::Float);
+    IO.enumCase(Value, "Double", HfaKind::Double);
+    IO.enumCase(Value, "Other", HfaKind::Other);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<MemberAccess> {
+  static void enumeration(IO &IO, MemberAccess &Access) {
+    IO.enumCase(Access, "None", MemberAccess::None);
+    IO.enumCase(Access, "Private", MemberAccess::Private);
+    IO.enumCase(Access, "Protected", MemberAccess::Protected);
+    IO.enumCase(Access, "Public", MemberAccess::Public);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<MethodKind> {
+  static void enumeration(IO &IO, MethodKind &Kind) {
+    IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
+    IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
+    IO.enumCase(Kind, "Static", MethodKind::Static);
+    IO.enumCase(Kind, "Friend", MethodKind::Friend);
+    IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
+    IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
+    IO.enumCase(Kind, "PureIntroducingVirtual",
+                MethodKind::PureIntroducingVirtual);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<WindowsRTClassKind> {
+  static void enumeration(IO &IO, WindowsRTClassKind &Value) {
+    IO.enumCase(Value, "None", WindowsRTClassKind::None);
+    IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
+    IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
+    IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
+  }
+};
+
+template <> struct ScalarBitSetTraits<PointerOptions> {
+  static void bitset(IO &IO, PointerOptions &Options) {
+    IO.bitSetCase(Options, "None", PointerOptions::None);
+    IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
+    IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
+    IO.bitSetCase(Options, "Const", PointerOptions::Const);
+    IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
+    IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
+    IO.bitSetCase(Options, "WinRTSmartPointer",
+                  PointerOptions::WinRTSmartPointer);
+  }
+};
+
+template <> struct ScalarBitSetTraits<ModifierOptions> {
+  static void bitset(IO &IO, ModifierOptions &Options) {
+    IO.bitSetCase(Options, "None", ModifierOptions::None);
+    IO.bitSetCase(Options, "Const", ModifierOptions::Const);
+    IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
+    IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
+  }
+};
+
+template <> struct ScalarBitSetTraits<FunctionOptions> {
+  static void bitset(IO &IO, FunctionOptions &Options) {
+    IO.bitSetCase(Options, "None", FunctionOptions::None);
+    IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
+    IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
+    IO.bitSetCase(Options, "ConstructorWithVirtualBases",
+                  FunctionOptions::ConstructorWithVirtualBases);
+  }
+};
+
+template <> struct ScalarBitSetTraits<ClassOptions> {
+  static void bitset(IO &IO, ClassOptions &Options) {
+    IO.bitSetCase(Options, "None", ClassOptions::None);
+    IO.bitSetCase(Options, "HasConstructorOrDestructor",
+                  ClassOptions::HasConstructorOrDestructor);
+    IO.bitSetCase(Options, "HasOverloadedOperator",
+                  ClassOptions::HasOverloadedOperator);
+    IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
+    IO.bitSetCase(Options, "ContainsNestedClass",
+                  ClassOptions::ContainsNestedClass);
+    IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
+                  ClassOptions::HasOverloadedAssignmentOperator);
+    IO.bitSetCase(Options, "HasConversionOperator",
+                  ClassOptions::HasConversionOperator);
+    IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
+    IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
+    IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
+    IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
+    IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
+  }
+};
+
+template <> struct ScalarBitSetTraits<MethodOptions> {
+  static void bitset(IO &IO, MethodOptions &Options) {
+    IO.bitSetCase(Options, "None", MethodOptions::None);
+    IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
+    IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
+    IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
+    IO.bitSetCase(Options, "CompilerGenerated",
+                  MethodOptions::CompilerGenerated);
+    IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
+  }
+};
+
+template <> struct ScalarTraits<APSInt> {
+  static void output(const APSInt &S, void *, llvm::raw_ostream &OS) {
+    S.print(OS, true);
+  }
+  static StringRef input(StringRef Scalar, void *Ctx, APSInt &S) {
+    S = APSInt(Scalar);
+    return "";
+  }
+
+  static bool mustQuote(StringRef Scalar) { return false; }
+};
+
+void MappingTraits<CVType>::mapping(IO &IO, CVType &Record) {
+  if (IO.outputting()) {
+    codeview::yaml::YamlTypeDumperCallbacks Callbacks(IO);
+    codeview::TypeDeserializer Deserializer(Callbacks);
+
+    codeview::CVTypeVisitor Visitor(Deserializer);
+    consumeError(Visitor.visitTypeRecord(Record));
+  }
+}
+
+void MappingTraits<FieldListRecord>::mapping(IO &IO,
+                                             FieldListRecord &FieldList) {
+  if (IO.outputting()) {
+    codeview::yaml::YamlTypeDumperCallbacks Callbacks(IO);
+    codeview::TypeDeserializer Deserializer(Callbacks);
+    codeview::CVTypeVisitor Visitor(Deserializer);
+    consumeError(Visitor.visitFieldListMemberStream(FieldList.Data));
+  }
+}
+
+void MappingTraits<StringIdRecord>::mapping(IO &IO, StringIdRecord &String) {
+  IO.mapRequired("Id", String.Id);
+  IO.mapRequired("String", String.String);
+}
+
+void MappingTraits<ArgListRecord>::mapping(IO &IO, ArgListRecord &Args) {
+  IO.mapRequired("ArgIndices", Args.StringIndices);
+}
+
+void MappingTraits<ClassRecord>::mapping(IO &IO, ClassRecord &Class) {
+  IO.mapRequired("MemberCount", Class.MemberCount);
+  IO.mapRequired("Options", Class.Options);
+  IO.mapRequired("FieldList", Class.FieldList);
+  IO.mapRequired("Name", Class.Name);
+  IO.mapRequired("UniqueName", Class.UniqueName);
+  IO.mapRequired("Hfa", Class.Hfa);
+  IO.mapRequired("WinRTKind", Class.WinRTKind);
+  IO.mapRequired("DerivationList", Class.DerivationList);
+  IO.mapRequired("VTableShape", Class.VTableShape);
+  IO.mapRequired("Size", Class.Size);
+}
+
+void MappingTraits<UnionRecord>::mapping(IO &IO, UnionRecord &Union) {
+  IO.mapRequired("MemberCount", Union.MemberCount);
+  IO.mapRequired("Options", Union.Options);
+  IO.mapRequired("FieldList", Union.FieldList);
+  IO.mapRequired("Name", Union.Name);
+  IO.mapRequired("UniqueName", Union.UniqueName);
+  IO.mapRequired("Hfa", Union.Hfa);
+  IO.mapRequired("Size", Union.Size);
+}
+
+void MappingTraits<EnumRecord>::mapping(IO &IO, EnumRecord &Enum) {
+  IO.mapRequired("NumEnumerators", Enum.MemberCount);
+  IO.mapRequired("Options", Enum.Options);
+  IO.mapRequired("FieldList", Enum.FieldList);
+  IO.mapRequired("Name", Enum.Name);
+  IO.mapRequired("UniqueName", Enum.UniqueName);
+  IO.mapRequired("UnderlyingType", Enum.UnderlyingType);
+}
+
+void MappingTraits<ArrayRecord>::mapping(IO &IO, ArrayRecord &AT) {
+  IO.mapRequired("ElementType", AT.ElementType);
+  IO.mapRequired("IndexType", AT.IndexType);
+  IO.mapRequired("Size", AT.Size);
+  IO.mapRequired("Name", AT.Name);
+}
+
+void MappingTraits<VFTableRecord>::mapping(IO &IO, VFTableRecord &VFT) {
+  IO.mapRequired("CompleteClass", VFT.CompleteClass);
+  IO.mapRequired("OverriddenVFTable", VFT.OverriddenVFTable);
+  IO.mapRequired("VFPtrOffset", VFT.VFPtrOffset);
+  IO.mapRequired("Name", VFT.Name);
+  IO.mapRequired("MethodNames", VFT.MethodNames);
+}
+
+void MappingTraits<MemberFuncIdRecord>::mapping(IO &IO,
+                                                MemberFuncIdRecord &Id) {
+  IO.mapRequired("ClassType", Id.ClassType);
+  IO.mapRequired("FunctionType", Id.FunctionType);
+  IO.mapRequired("Name", Id.Name);
+}
+
+void MappingTraits<ProcedureRecord>::mapping(IO &IO, ProcedureRecord &Proc) {
+  IO.mapRequired("ReturnType", Proc.ReturnType);
+  IO.mapRequired("CallConv", Proc.CallConv);
+  IO.mapRequired("Options", Proc.Options);
+  IO.mapRequired("ParameterCount", Proc.ParameterCount);
+  IO.mapRequired("ArgumentList", Proc.ArgumentList);
+}
+
+void MappingTraits<MemberFunctionRecord>::mapping(IO &IO,
+                                                  MemberFunctionRecord &MF) {
+  IO.mapRequired("ReturnType", MF.ReturnType);
+  IO.mapRequired("ClassType", MF.ClassType);
+  IO.mapRequired("ThisType", MF.ThisType);
+  IO.mapRequired("CallConv", MF.CallConv);
+  IO.mapRequired("Options", MF.Options);
+  IO.mapRequired("ParameterCount", MF.ParameterCount);
+  IO.mapRequired("ArgumentList", MF.ArgumentList);
+  IO.mapRequired("ThisPointerAdjustment", MF.ThisPointerAdjustment);
+}
+
+void MappingTraits<MethodOverloadListRecord>::mapping(
+    IO &IO, MethodOverloadListRecord &MethodList) {
+  IO.mapRequired("Methods", MethodList.Methods);
+}
+
+void MappingTraits<FuncIdRecord>::mapping(IO &IO, FuncIdRecord &Func) {
+  IO.mapRequired("ParentScope", Func.ParentScope);
+  IO.mapRequired("FunctionType", Func.FunctionType);
+  IO.mapRequired("Name", Func.Name);
+}
+
+void MappingTraits<TypeServer2Record>::mapping(IO &IO, TypeServer2Record &TS) {
+  IO.mapRequired("Guid", TS.Guid);
+  IO.mapRequired("Age", TS.Age);
+  IO.mapRequired("Name", TS.Name);
+}
+
+void MappingTraits<PointerRecord>::mapping(IO &IO, PointerRecord &Ptr) {
+  IO.mapRequired("ReferentType", Ptr.ReferentType);
+  IO.mapRequired("PtrKind", Ptr.PtrKind);
+  IO.mapRequired("Mode", Ptr.Mode);
+  IO.mapRequired("Options", Ptr.Options);
+  IO.mapRequired("Size", Ptr.Size);
+  IO.mapOptional("MemberInfo", Ptr.MemberInfo);
+}
+
+void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
+  IO.mapRequired("ContainingType", MPI.ContainingType);
+  IO.mapRequired("Representation", MPI.Representation);
+}
+
+void MappingTraits<ModifierRecord>::mapping(IO &IO, ModifierRecord &Mod) {
+  IO.mapRequired("ModifiedType", Mod.ModifiedType);
+  IO.mapRequired("Modifiers", Mod.Modifiers);
+}
+
+void MappingTraits<BitFieldRecord>::mapping(IO &IO, BitFieldRecord &BitField) {
+  IO.mapRequired("Type", BitField.Type);
+  IO.mapRequired("BitSize", BitField.BitSize);
+  IO.mapRequired("BitOffset", BitField.BitOffset);
+}
+
+void MappingTraits<VFTableShapeRecord>::mapping(IO &IO,
+                                                VFTableShapeRecord &Shape) {
+  IO.mapRequired("Slots", Shape.Slots);
+}
+
+void MappingTraits<UdtSourceLineRecord>::mapping(IO &IO,
+                                                 UdtSourceLineRecord &Line) {
+  IO.mapRequired("UDT", Line.UDT);
+  IO.mapRequired("SourceFile", Line.SourceFile);
+  IO.mapRequired("LineNumber", Line.LineNumber);
+}
+
+void MappingTraits<UdtModSourceLineRecord>::mapping(
+    IO &IO, UdtModSourceLineRecord &Line) {
+  IO.mapRequired("UDT", Line.UDT);
+  IO.mapRequired("SourceFile", Line.SourceFile);
+  IO.mapRequired("LineNumber", Line.LineNumber);
+  IO.mapRequired("Module", Line.Module);
+}
+
+void MappingTraits<BuildInfoRecord>::mapping(IO &IO, BuildInfoRecord &Args) {
+  IO.mapRequired("ArgIndices", Args.ArgIndices);
+}
+
+void MappingTraits<NestedTypeRecord>::mapping(IO &IO,
+                                              NestedTypeRecord &Nested) {
+  IO.mapRequired("Type", Nested.Type);
+  IO.mapRequired("Name", Nested.Name);
+}
+
+void MappingTraits<OneMethodRecord>::mapping(IO &IO, OneMethodRecord &Method) {
+  IO.mapRequired("Type", Method.Type);
+  IO.mapRequired("Kind", Method.Kind);
+  IO.mapRequired("Options", Method.Options);
+  IO.mapRequired("Access", Method.Access);
+  IO.mapRequired("VFTableOffset", Method.VFTableOffset);
+  IO.mapRequired("Name", Method.Name);
+}
+
+void MappingTraits<OverloadedMethodRecord>::mapping(
+    IO &IO, OverloadedMethodRecord &Method) {
+  IO.mapRequired("NumOverloads", Method.NumOverloads);
+  IO.mapRequired("MethodList", Method.MethodList);
+  IO.mapRequired("Name", Method.Name);
+}
+
+void MappingTraits<DataMemberRecord>::mapping(IO &IO, DataMemberRecord &Field) {
+  IO.mapRequired("Access", Field.Access);
+  IO.mapRequired("Type", Field.Type);
+  IO.mapRequired("FieldOffset", Field.FieldOffset);
+  IO.mapRequired("Name", Field.Name);
+}
+
+void MappingTraits<StaticDataMemberRecord>::mapping(
+    IO &IO, StaticDataMemberRecord &Field) {
+  IO.mapRequired("Access", Field.Access);
+  IO.mapRequired("Type", Field.Type);
+  IO.mapRequired("Name", Field.Name);
+}
+
+void MappingTraits<VFPtrRecord>::mapping(IO &IO, VFPtrRecord &VFTable) {
+  IO.mapRequired("Type", VFTable.Type);
+}
+
+void MappingTraits<EnumeratorRecord>::mapping(IO &IO, EnumeratorRecord &Enum) {
+  IO.mapRequired("Access", Enum.Access);
+  IO.mapRequired("Value", Enum.Value);
+  IO.mapRequired("Name", Enum.Name);
+}
+
+void MappingTraits<BaseClassRecord>::mapping(IO &IO, BaseClassRecord &Base) {
+  IO.mapRequired("Access", Base.Access);
+  IO.mapRequired("Type", Base.Type);
+  IO.mapRequired("Offset", Base.Offset);
+}
+
+void MappingTraits<VirtualBaseClassRecord>::mapping(
+    IO &IO, VirtualBaseClassRecord &Base) {
+  IO.mapRequired("Access", Base.Access);
+  IO.mapRequired("BaseType", Base.BaseType);
+  IO.mapRequired("VBPtrType", Base.VBPtrType);
+  IO.mapRequired("VBPtrOffset", Base.VBPtrOffset);
+  IO.mapRequired("VTableIndex", Base.VTableIndex);
+}
+
+void MappingTraits<ListContinuationRecord>::mapping(
+    IO &IO, ListContinuationRecord &Cont) {
+  IO.mapRequired("ContinuationIndex", Cont.ContinuationIndex);
+}
+
+template <> struct ScalarTraits<codeview::TypeIndex> {
+  static void output(const codeview::TypeIndex &S, void *,
+                     llvm::raw_ostream &OS) {
+    OS << S.getIndex();
+  }
+  static StringRef input(StringRef Scalar, void *Ctx, codeview::TypeIndex &S) {
+    uint32_t I;
+    StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
+    if (!Result.empty())
+      return Result;
+    S = TypeIndex(I);
+    return "";
+  }
+  static bool mustQuote(StringRef Scalar) { return false; }
+};
+
+void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
+                                                        TypeLeafKind &Value) {
+  auto TypeLeafNames = getTypeLeafNames();
+  for (const auto &E : TypeLeafNames)
+    io.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+}
+}
+
+Error llvm::codeview::yaml::YamlTypeDumperCallbacks::visitTypeBegin(
+    const CVRecord<TypeLeafKind> &CVR) {
+  TypeLeafKind K = CVR.Type;
+  YamlIO.mapRequired("Kind", K);
+  return Error::success();
+}

llvm/trunk/tools/llvm-pdbdump/PdbYaml.h

struct PdbDbiStream {
   uint32_t PdbDllVersion;
   uint16_t PdbDllRbld;
   uint16_t Flags;
   PDB_Machine MachineType;
 
   std::vector<PdbDbiModuleInfo> ModInfos;
 };
 
+struct PdbTpiRecord {
+  std::vector<uint8_t> RecordData;
+  codeview::CVType Record;
+};
+
+struct PdbTpiStream {
+  PdbRaw_TpiVer Version;
+  std::vector<PdbTpiRecord> Records;
+};
+
 struct PdbObject {
   Optional<MSFHeaders> Headers;
   Optional<std::vector<uint32_t>> StreamSizes;
   Optional<std::vector<StreamBlockList>> StreamMap;
   Optional<PdbInfoStream> PdbStream;
   Optional<PdbDbiStream> DbiStream;
+  Optional<PdbTpiStream> TpiStream;
 };
 }
 }
 }
 
 namespace llvm {
 namespace yaml {
 

 template <> struct MappingTraits<pdb::yaml::PdbInfoStream> {
   static void mapping(IO &IO, pdb::yaml::PdbInfoStream &Obj);
 };
 
 template <> struct MappingTraits<pdb::yaml::PdbDbiStream> {
   static void mapping(IO &IO, pdb::yaml::PdbDbiStream &Obj);
 };
 
+template <> struct MappingTraits<pdb::yaml::PdbTpiStream> {
+  static void mapping(IO &IO, pdb::yaml::PdbTpiStream &Obj);
+};
+
 template <> struct MappingTraits<pdb::yaml::NamedStreamMapping> {
   static void mapping(IO &IO, pdb::yaml::NamedStreamMapping &Obj);
 };
 
 template <> struct MappingTraits<pdb::yaml::PdbDbiModuleInfo> {
   static void mapping(IO &IO, pdb::yaml::PdbDbiModuleInfo &Obj);
 };
+
+template <> struct MappingTraits<pdb::yaml::PdbTpiRecord> {
+  static void mapping(IO &IO, pdb::yaml::PdbTpiRecord &Obj);
+};
 }
 }
 
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::StringRef)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::NamedStreamMapping)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbDbiModuleInfo)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamBlockList)
-
 #endif // LLVM_TOOLS_LLVMPDBDUMP_PDBYAML_H

llvm/trunk/tools/llvm-pdbdump/PdbYaml.cpp

 //===- PdbYAML.cpp -------------------------------------------- *- C++ --*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PdbYaml.h"
+#include "CodeViewYaml.h"
 
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
+#include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 
 using namespace llvm;
-using namespace llvm::msf;
-using namespace llvm::yaml;
 using namespace llvm::pdb;
 using namespace llvm::pdb::yaml;
+using namespace llvm::yaml;
+
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::StringRef)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::NamedStreamMapping)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbDbiModuleInfo)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbTpiRecord)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamBlockList)
 
 namespace llvm {
 namespace yaml {
+
 template <> struct ScalarTraits<llvm::pdb::PDB_UniqueId> {
   static void output(const llvm::pdb::PDB_UniqueId &S, void *,
                      llvm::raw_ostream &OS) {
     OS << S;
   }
 
   static StringRef input(StringRef Scalar, void *Ctx,
                          llvm::pdb::PDB_UniqueId &S) {
static void enumeration(IO &io, llvm::pdb::PdbRaw_ImplVer &Value) {
     io.enumCase(Value, "VC98", llvm::pdb::PdbRaw_ImplVer::PdbImplVC98);
     io.enumCase(Value, "VC70Dep", llvm::pdb::PdbRaw_ImplVer::PdbImplVC70Dep);
     io.enumCase(Value, "VC70", llvm::pdb::PdbRaw_ImplVer::PdbImplVC70);
     io.enumCase(Value, "VC80", llvm::pdb::PdbRaw_ImplVer::PdbImplVC80);
     io.enumCase(Value, "VC110", llvm::pdb::PdbRaw_ImplVer::PdbImplVC110);
     io.enumCase(Value, "VC140", llvm::pdb::PdbRaw_ImplVer::PdbImplVC140);
   }
 };
+
+template <> struct ScalarEnumerationTraits<llvm::pdb::PdbRaw_TpiVer> {
+  static void enumeration(IO &io, llvm::pdb::PdbRaw_TpiVer &Value) {
+    io.enumCase(Value, "VC40", llvm::pdb::PdbRaw_TpiVer::PdbTpiV40);
+    io.enumCase(Value, "VC41", llvm::pdb::PdbRaw_TpiVer::PdbTpiV41);
+    io.enumCase(Value, "VC50", llvm::pdb::PdbRaw_TpiVer::PdbTpiV50);
+    io.enumCase(Value, "VC70", llvm::pdb::PdbRaw_TpiVer::PdbTpiV70);
+    io.enumCase(Value, "VC80", llvm::pdb::PdbRaw_TpiVer::PdbTpiV80);
+  }
+};
 }
 }
 
 void MappingTraits<PdbObject>::mapping(IO &IO, PdbObject &Obj) {
   IO.mapOptional("MSF", Obj.Headers);
   IO.mapOptional("StreamSizes", Obj.StreamSizes);
   IO.mapOptional("StreamMap", Obj.StreamMap);
   IO.mapOptional("PdbStream", Obj.PdbStream);
   IO.mapOptional("DbiStream", Obj.DbiStream);
+  IO.mapOptional("TpiStream", Obj.TpiStream);
 }
 
 void MappingTraits<MSFHeaders>::mapping(IO &IO, MSFHeaders &Obj) {
   IO.mapRequired("SuperBlock", Obj.SuperBlock);
   IO.mapRequired("NumDirectoryBlocks", Obj.NumDirectoryBlocks);
   IO.mapRequired("DirectoryBlocks", Obj.DirectoryBlocks);
   IO.mapRequired("NumStreams", Obj.NumStreams);
   IO.mapRequired("FileSize", Obj.FileSize);
void MappingTraits<PdbDbiStream>::mapping(IO &IO, PdbDbiStream &Obj) {
   IO.mapRequired("BuildNumber", Obj.BuildNumber);
   IO.mapRequired("PdbDllVersion", Obj.PdbDllVersion);
   IO.mapRequired("PdbDllRbld", Obj.PdbDllRbld);
   IO.mapRequired("Flags", Obj.Flags);
   IO.mapRequired("MachineType", Obj.MachineType);
   IO.mapOptional("Modules", Obj.ModInfos);
 }
 
+void MappingTraits<PdbTpiStream>::mapping(IO &IO,
+                                          pdb::yaml::PdbTpiStream &Obj) {
+  IO.mapRequired("Version", Obj.Version);
+  IO.mapRequired("Records", Obj.Records);
+}
+
 void MappingTraits<NamedStreamMapping>::mapping(IO &IO,
                                                 NamedStreamMapping &Obj) {
   IO.mapRequired("Name", Obj.StreamName);
   IO.mapRequired("StreamNum", Obj.StreamNumber);
 }
 
 void MappingTraits<PdbDbiModuleInfo>::mapping(IO &IO, PdbDbiModuleInfo &Obj) {
   IO.mapRequired("Module", Obj.Mod);
   IO.mapRequired("ObjFile", Obj.Obj);
   IO.mapOptional("SourceFiles", Obj.SourceFiles);
 }
+
+void MappingTraits<PdbTpiRecord>::mapping(IO &IO,
+                                          pdb::yaml::PdbTpiRecord &Obj) {
+  if (IO.outputting()) {
+    // If we're going from Pdb To Yaml, deserialize the Pdb record
+    codeview::yaml::YamlTypeDumperCallbacks Callbacks(IO);
+    codeview::TypeDeserializer Deserializer(Callbacks);
+
+    codeview::CVTypeVisitor Visitor(Deserializer);
+    consumeError(Visitor.visitTypeRecord(Obj.Record));
+  } else {
+    codeview::yaml::YamlTypeDumperCallbacks Callbacks(IO);
+    codeview::CVTypeVisitor Visitor(Callbacks);
+    consumeError(Visitor.visitTypeRecord(Obj.Record));
+  }
+}

llvm/trunk/tools/llvm-pdbdump/YAMLOutputStyle.h

public:
   Error dump() override;
 
 private:
   Error dumpFileHeaders();
   Error dumpStreamMetadata();
   Error dumpStreamDirectory();
   Error dumpPDBStream();
   Error dumpDbiStream();
+  Error dumpTpiStream();
 
   void flush();
 
   PDBFile &File;
   llvm::yaml::Output Out;
 
   yaml::PdbObject Obj;
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVMPDBDUMP_YAMLOUTPUTSTYLE_H

llvm/trunk/tools/llvm-pdbdump/YAMLOutputStyle.cpp

 
 #include "PdbYaml.h"
 #include "llvm-pdbdump.h"
 
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+#include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 YAMLOutputStyle::YAMLOutputStyle(PDBFile &File) : File(File), Out(outs()) {}
 
 Error YAMLOutputStyle::dump() {
   if (opts::pdb2yaml::StreamDirectory)
if (auto EC = dumpStreamDirectory())
     return EC;
 
   if (auto EC = dumpPDBStream())
     return EC;
 
   if (auto EC = dumpDbiStream())
     return EC;
 
+  if (auto EC = dumpTpiStream())
+    return EC;
+
   flush();
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpFileHeaders() {
   if (opts::pdb2yaml::NoFileHeaders)
     return Error::success();
 
for (const auto &MI : DS.modules()) {
       if (opts::pdb2yaml::DbiModuleSourceFileInfo)
         DMI.SourceFiles = MI.SourceFiles;
       Obj.DbiStream->ModInfos.push_back(DMI);
     }
   }
   return Error::success();
 }
 
+Error YAMLOutputStyle::dumpTpiStream() {
+  if (!opts::pdb2yaml::TpiStream)
+    return Error::success();
+
+  auto TpiS = File.getPDBTpiStream();
+  if (!TpiS)
+    return TpiS.takeError();
+
+  auto &TS = TpiS.get();
+  Obj.TpiStream.emplace();
+  Obj.TpiStream->Version = TS.getTpiVersion();
+  for (auto &Record : TS.types(nullptr)) {
+    yaml::PdbTpiRecord R;
+    // It's not necessary to set R.RecordData here.  That only exists as a
+    // way to have the `PdbTpiRecord` structure own the memory that `R.Record`
+    // references.  In the case of reading an existing PDB though, that memory
+    // is owned by the backing stream.
+    R.Record = Record;
+    Obj.TpiStream->Records.push_back(R);
+  }
+
+  return Error::success();
+}
+
 void YAMLOutputStyle::flush() {
   Out << Obj;
   outs().flush();
 }

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h

 namespace pdb2yaml {
 extern llvm::cl::opt<bool> NoFileHeaders;
 extern llvm::cl::opt<bool> StreamMetadata;
 extern llvm::cl::opt<bool> StreamDirectory;
 extern llvm::cl::opt<bool> PdbStream;
 extern llvm::cl::opt<bool> DbiStream;
 extern llvm::cl::opt<bool> DbiModuleInfo;
 extern llvm::cl::opt<bool> DbiModuleSourceFileInfo;
+extern llvm::cl::opt<bool> TpiStream;
 extern llvm::cl::list<std::string> InputFilename;
 }
 }
 
 #endif

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp

DbiModuleInfo("dbi-module-info",
                   cl::sub(PdbToYamlSubcommand), cl::init(false));
 
 cl::opt<bool> DbiModuleSourceFileInfo(
     "dbi-module-source-info",
     cl::desc(
         "Dump DBI Module Source File Information (implies -dbi-module-info"),
     cl::sub(PdbToYamlSubcommand), cl::init(false));
 
+cl::opt<bool> TpiStream("tpi-stream",
+                        cl::desc("Dump the TPI Stream (Stream 3)"),
+                        cl::sub(PdbToYamlSubcommand), cl::init(false));
+
 cl::list<std::string> InputFilename(cl::Positional,
                                     cl::desc("<input PDB file>"), cl::Required,
                                     cl::sub(PdbToYamlSubcommand));
 }
 }
 
 static ExitOnError ExitOnErr;
 
int main(int argc_, const char *argv_[]) {
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
 
-  // These options are shared by two subcommands.
-  if ((opts::PdbToYamlSubcommand || opts::RawSubcommand) && opts::raw::RawAll) {
+  if (opts::RawSubcommand && opts::raw::RawAll) {
     opts::raw::DumpHeaders = true;
     opts::raw::DumpModules = true;
     opts::raw::DumpModuleFiles = true;
     opts::raw::DumpModuleSyms = true;
     opts::raw::DumpPublics = true;
     opts::raw::DumpSectionHeaders = true;
     opts::raw::DumpStreamSummary = true;
     opts::raw::DumpPageStats = true;