[CodeView] Add CodeViewRecordIO for reading and writing, and use it for reading type records.

[zturner]

Summary

This is the first of two patches intended to merge the reading and writing codepaths for CodeView symbol and type records. This patch contains the following pieces:

1. Introduces CodeViewRecordIO, which is similar to YamlIO in that it provides a single interface for reading or writing native types from an underlying byte stream, depending on what mode the class is in.
2. Introduces TypeRecordMapping which uses CodeViewRecordIO to define the layout of CodeView Type records.
3. Hook TypeRecordMapping up to the existing Pdb -> Yaml code to prove that it works in "reading" (e.g. bytes -> semantic record) mode.

What this patch does NOT do:

1. Add any of the writing support. Doing so is somewhat non-trivial, as it requires taking all of the logic from TypeRecordBuilder, TypeTableBuilder, ListRecordBuilder, and dealing with record splitting and many other intricacies. That will be part 2 of this review sequence. I have that patch fully working and tested, but it will make this quite large and difficult to review to do it all at once.

Just to be clear: After patch 2, TypeTableBuilder, TypeRecordBuilder, ListRecordBuilder, and MemoryTypeTableBuilder will be deleted. The only thing left will be TypeRecordMapping and perhaps a small facade on top of that to simplify the interface.

Looking out further than that, with patch 3 (which I have not started working on yet), I plan to introduce a SymbolRecordMapping class. This will allow us to then delete all of the deserialize methods in SymbolRecord.h, the entire files RecordSerialization.h and RecordSerialization.cpp, and additionally give us Symbol serialization (which we do not yet have) for free.

[ruiu]

How much is this similar to YamlIO? From my experience, I have to say that YamlIO is extremely slow when we give a fairly large (but not that large, like a few megabytes) data. I wonder if this is fast enough to handle hundreds of megabytes of debug info.

[ruiu]

include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

130–132

This invariant

IsWriting == (Writer != nullptr)

always holds, so IsWriting is redundant. You could replace all occurrences of if (IsWriting) with if (Writer).

include/llvm/DebugInfo/CodeView/TypeRecord.h

55–56

explicit for a ctor with three parameters?

include/llvm/DebugInfo/CodeView/TypeRecordMapping.h

37

Don't you want to #undef these macros after #include for safety?

[zturner]

include/llvm/DebugInfo/CodeView/TypeRecordMapping.h

37

This is such a common pattern that they're already #undef'ed at the end of the include file.

[inglorion]

I like how this gives us basically a single definition of how to map between objects and byte streams that we can then use for reading and writing. I am a bit unhappy with the repeated if (IsWriting) ... in CodeViewRecordIO. How would you feel about making two different classes - one to implement the reading and one to implement the writing?

[zturner]

In D26040#582267, @inglorion wrote:

I like how this gives us basically a single definition of how to map between objects and byte streams that we can then use for reading and writing. I am a bit unhappy with the repeated if (IsWriting) ... in CodeViewRecordIO. How would you feel about making two different classes - one to implement the reading and one to implement the writing?

Luckily CodeViewRecordIO is really low level and not intended to be the external interface to this thing. For that you use TypeRecordMapping (and in the future, SymbolRecordMapping). If we had something like std::variant<> this would be cleaner, but for now there's always going to be a check. We could hide it through a virtual function indirection, where you make an abstract base class with all the map methods, and then make a ReadMapper and a WriteMapper, and TypeRecordMapper just stores a std::unique_ptr<MapperBase>.

[zturner]

Fixed suggestions from ruiu.

I looked into using virtual function indirection as a means of hiding the branches, and it's not entirely straightforward since there's some template functions to handle many types at once. I could make it work, but I'm not sure it's a win.

Another idea is to raise this whole thing up into CodeView/MSF and make it more generic by using traits classes instead of Mapping functors. That would allow a single Map method that uses template specializations to find mapping classes, and allow the mapping classes to provide read() and write() methods that separate the logic. I gave it a try but it was a little hairy and gets into some design issues, but it seems like a reasonable avenue for improvement in a followup patch.

[inglorion]

Thanks for looking into my suggestions, @zturner. I also thought we might want to do traits in a follow-up. I'm good with this if @ruiu is good with it, so I'll let him accept.

[zturner]

Ping. Anyone can stamp this or offer further suggestions?

[ruiu]

LGTM

include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

+//===- CodeViewRecordIO.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_CODEVIEWRECORDIO_H
+#define LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDIO_H
+
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/MSF/StreamReader.h"
+#include "llvm/DebugInfo/MSF/StreamWriter.h"
+#include "llvm/Support/Error.h"
+
+#include <stdint.h>
+#include <type_traits>
+
+namespace llvm {
+namespace msf {
+class StreamReader;
+class StreamWriter;
+}
+namespace codeview {
+
+class CodeViewRecordIO {
+  struct ActiveRecord {
+    uint16_t Kind;
+  };
+
+public:
+  explicit CodeViewRecordIO(msf::StreamReader &Reader)
+      : Reader(&Reader), IsWriting(false) {}
+  explicit CodeViewRecordIO(msf::StreamWriter &Writer)
+      : Writer(&Writer), IsWriting(true) {}
+
+  Error beginRecord(uint16_t Kind);
+  Error endRecord();
+  Error mapInteger(TypeIndex &TypeInd);
+
+  template <typename T> Error mapInteger(T &Value) {
+    if (IsWriting)
+      return Writer->writeInteger(Value);
+
+    return Reader->readInteger(Value);
+  }
+
+  template <typename T> Error mapEnum(T &Value) {
+    using U = typename std::underlying_type<T>::type;
+    U X;
+    if (IsWriting)
+      X = static_cast<U>(Value);
+
+    if (auto EC = mapInteger(X))
+      return EC;
+    if (!IsWriting)
+      Value = static_cast<T>(X);
+    return Error::success();
+  }
+
+  Error mapEncodedInteger(int64_t &Value);
+  Error mapEncodedInteger(uint64_t &Value);
+  Error mapEncodedInteger(APSInt &Value);
+  Error mapStringZ(StringRef &Value);
+  Error mapGuid(StringRef &Guid);
+
+  template <typename SizeType, typename T, typename ElementMapper>
+  Error mapVectorN(T &Items, const ElementMapper &Mapper) {
+    SizeType Size;
+    if (IsWriting) {
+      Size = static_cast<SizeType>(Items.size());
+      if (auto EC = Writer->writeInteger(Size))
+        return EC;
+
+      for (auto &X : Items) {
+        if (auto EC = Mapper(*this, X))
+          return EC;
+      }
+    } else {
+      if (auto EC = Reader->readInteger(Size))
+        return EC;
+      for (SizeType I = 0; I < Size; ++I) {
+        typename T::value_type Item;
+        if (auto EC = Mapper(*this, Item))
+          return EC;
+        Items.push_back(Item);
+      }
+    }
+
+    return Error::success();
+  }
+
+  template <typename T, typename ElementMapper>
+  Error mapVectorTail(T &Items, const ElementMapper &Mapper) {
+    if (IsWriting) {
+      for (auto &Item : Items) {
+        if (auto EC = Mapper(*this, Item))
+          return EC;
+      }
+    } else {
+      typename T::value_type Field;
+      // Stop when we run out of bytes or we hit record padding bytes.
+      while (!Reader->empty() && Reader->peek() < LF_PAD0) {
+        if (auto EC = Mapper(*this, Field))
+          return EC;
+        Items.push_back(Field);
+      }
+    }
+    return Error::success();
+  }
+
+  Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes);
+
+  bool isWriting() const { return IsWriting; }
+
+  Error skipPadding();
+
+private:
+  Error writeEncodedSignedInteger(const int64_t &Value);
+  Error writeEncodedUnsignedInteger(const uint64_t &Value);
+
+  Optional<ActiveRecord> CurrentRecord;
+
+  msf::StreamReader *Reader = nullptr;
+  msf::StreamWriter *Writer = nullptr;
+  bool IsWriting = false;
+};
+}
+}
+
+#endif

include/llvm/DebugInfo/CodeView/TypeDeserializer.h

 //===- TypeDeserializer.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_TYPEDESERIALIZER_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEDESERIALIZER_H
 
+#include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
+#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
+#include "llvm/DebugInfo/MSF/StreamWriter.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
+
 class TypeDeserializer : public TypeVisitorCallbacks {
+  struct MappingInfo {
+    explicit MappingInfo(ArrayRef<uint8_t> RecordData)
+        : Stream(RecordData), Reader(Stream), Mapping(Reader) {}
+
+    msf::ByteStream Stream;
+    msf::StreamReader Reader;
+    TypeRecordMapping Mapping;
+  };
+
 public:
   TypeDeserializer() {}
 
+  Error visitTypeBegin(CVType &Record) override {
+    assert(!Mapping && "Already in a type mapping!");
+    Mapping = llvm::make_unique<MappingInfo>(Record.content());
+    return Mapping->Mapping.visitTypeBegin(Record);
+  }
+  Error visitTypeEnd(CVType &Record) override {
+    assert(Mapping && "Not in a type mapping!");
+    auto EC = Mapping->Mapping.visitTypeEnd(Record);
+    Mapping.reset();
+    return EC;
+  }
+
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error visitKnownRecord(CVType &CVR, Name##Record &Record) override {         \
-    return defaultVisitKnownRecord(CVR, Record);                               \
-  }
-#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
-    return defaultVisitKnownMember(CVR, Record);                               \
+    return visitKnownRecordImpl<Name##Record>(CVR, Record);                    \
   }
+#define MEMBER_RECORD(EnumName, EnumVal, Name)
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
-protected:
-  template <typename T>
-  Error deserializeRecord(msf::StreamReader &Reader, TypeLeafKind Kind,
-                          T &Record) const {
-    TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
-    auto ExpectedRecord = T::deserialize(RK, Reader);
-    if (!ExpectedRecord)
-      return ExpectedRecord.takeError();
-    Record = std::move(*ExpectedRecord);
-    return Error::success();
+private:
+  template <typename RecordType>
+  Error visitKnownRecordImpl(CVType &CVR, RecordType &Record) {
+    return Mapping->Mapping.visitKnownRecord(CVR, Record);
   }
 
-private:
-  template <typename T> Error defaultVisitKnownRecord(CVType &CVR, T &Record) {
-    msf::ByteStream S(CVR.content());
-    msf::StreamReader SR(S);
-    if (auto EC = deserializeRecord(SR, CVR.Type, Record))
+  std::unique_ptr<MappingInfo> Mapping;
+};
+
+class FieldListDeserializer : public TypeVisitorCallbacks {
+  struct MappingInfo {
+    explicit MappingInfo(msf::StreamReader &R)
+        : Reader(R), Mapping(Reader), StartOffset(0) {}
+
+    msf::StreamReader &Reader;
+    TypeRecordMapping Mapping;
+    uint32_t StartOffset;
+  };
+
+public:
+  explicit FieldListDeserializer(msf::StreamReader &Reader) : Mapping(Reader) {}
+
+  Error visitMemberBegin(CVMemberRecord &Record) override {
+    Mapping.StartOffset = Mapping.Reader.getOffset();
+    return Mapping.Mapping.visitMemberBegin(Record);
+  }
+  Error visitMemberEnd(CVMemberRecord &Record) override {
+    if (auto EC = Mapping.Mapping.visitMemberEnd(Record))
       return EC;
     return Error::success();
   }
-  template <typename T>
-  Error defaultVisitKnownMember(CVMemberRecord &CVMR, T &Record) {
-    msf::ByteStream S(CVMR.Data);
-    msf::StreamReader SR(S);
-    if (auto EC = deserializeRecord(SR, CVMR.Kind, Record))
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
+    return visitKnownMemberImpl<Name##Record>(CVR, Record);                    \
+  }
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "TypeRecords.def"
+
+private:
+  template <typename RecordType>
+  Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) {
+    if (auto EC = Mapping.Mapping.visitKnownMember(CVR, Record))
+      return EC;
+
+    uint32_t EndOffset = Mapping.Reader.getOffset();
+    uint32_t RecordLength = EndOffset - Mapping.StartOffset;
+    Mapping.Reader.setOffset(Mapping.StartOffset);
+    if (auto EC = Mapping.Reader.readBytes(CVR.Data, RecordLength))
       return EC;
+    assert(Mapping.Reader.getOffset() == EndOffset);
     return Error::success();
   }
+  MappingInfo Mapping;
 };
 }
 }
 
 #endif

include/llvm/DebugInfo/CodeView/TypeIndex.h

public:
   TypeIndex() : Index(0) {}
   explicit TypeIndex(uint32_t Index) : Index(Index) {}
   explicit TypeIndex(SimpleTypeKind Kind)
       : Index(static_cast<uint32_t>(Kind)) {}
   TypeIndex(SimpleTypeKind Kind, SimpleTypeMode Mode)
       : Index(static_cast<uint32_t>(Kind) | static_cast<uint32_t>(Mode)) {}
 
   uint32_t getIndex() const { return Index; }
+  void setIndex(uint32_t I) { Index = I; }
   bool isSimple() const { return Index < FirstNonSimpleIndex; }
 
   bool isNoneType() const { return *this == None(); }
 
   SimpleTypeKind getSimpleKind() const {
     assert(isSimple());
     return static_cast<SimpleTypeKind>(Index & SimpleKindMask);
   }

include/llvm/DebugInfo/CodeView/TypeRecord.h

 struct CVMemberRecord {
   TypeLeafKind Kind;
   ArrayRef<uint8_t> Data;
 };
 typedef msf::VarStreamArray<CVType> CVTypeArray;
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
-  ulittle16_t Attrs;
+  uint16_t Attrs;
   enum {
     MethodKindShift = 2,
   };
+  MemberAttributes() : Attrs(0) {}
+
+  explicit MemberAttributes(MemberAccess Access)
+      : Attrs(static_cast<uint16_t>(Access)) {}
+
+  explicit MemberAttributes(MemberAccess Access, MethodKind Kind,
+                            MethodOptions Flags) {
+    Attrs = static_cast<uint16_t>(Access);
+    Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);
+    Attrs |= static_cast<uint16_t>(Flags);
+  }
 
   /// Get the access specifier. Valid for any kind of member.
   MemberAccess getAccess() const {
     return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
   }
 
   /// Indicates if a method is defined with friend, virtual, static, etc.
   MethodKind getMethodKind() const {
public:
   MemberPointerInfo(TypeIndex ContainingType,
                     PointerToMemberRepresentation Representation)
       : ContainingType(ContainingType), Representation(Representation) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<MemberPointerInfo> deserialize(msf::StreamReader &Reader);
-
   TypeIndex getContainingType() const { return ContainingType; }
   PointerToMemberRepresentation getRepresentation() const {
     return Representation;
   }
 
   TypeIndex ContainingType;
   PointerToMemberRepresentation Representation;
-
-private:
-  struct Layout {
-    TypeIndex ClassType;
-    ulittle16_t Representation; // PointerToMemberRepresentation
-  };
 };
 
 class TypeRecord {
 protected:
   TypeRecord() {}
   explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
 
 public:
public:
   ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
       : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),
         Modifiers(Modifiers) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<ModifierRecord> deserialize(TypeRecordKind Kind,
-                                              msf::StreamReader &Reader);
-
   TypeIndex getModifiedType() const { return ModifiedType; }
   ModifierOptions getModifiers() const { return Modifiers; }
 
   TypeIndex ModifiedType;
   ModifierOptions Modifiers;
-
-private:
-  struct Layout {
-    TypeIndex ModifiedType;
-    ulittle16_t Modifiers; // ModifierOptions
-  };
 };
 
 // LF_PROCEDURE
 class ProcedureRecord : public TypeRecord {
 public:
   explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
                   FunctionOptions Options, uint16_t ParameterCount,
                   TypeIndex ArgumentList)
       : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),
         CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),
         ArgumentList(ArgumentList) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<ProcedureRecord> deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader);
-
-  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;
-  };
 };
 
 // LF_MFUNCTION
 class MemberFunctionRecord : public TypeRecord {
 public:
   explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
 
   MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
                        TypeIndex ThisType, CallingConvention CallConv,
                        FunctionOptions Options, uint16_t ParameterCount,
                        TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
       : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),
         ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
         Options(Options), ParameterCount(ParameterCount),
         ArgumentList(ArgumentList),
         ThisPointerAdjustment(ThisPointerAdjustment) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<MemberFunctionRecord> deserialize(TypeRecordKind Kind,
-                                                    msf::StreamReader &Reader);
-
   TypeIndex getReturnType() const { return ReturnType; }
   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; }
 
   TypeIndex ReturnType;
   TypeIndex ClassType;
   TypeIndex ThisType;
   CallingConvention CallConv;
   FunctionOptions Options;
   uint16_t ParameterCount;
   TypeIndex ArgumentList;
   int32_t ThisPointerAdjustment;
-
-private:
-  struct Layout {
-    TypeIndex ReturnType;
-    TypeIndex ClassType;
-    TypeIndex ThisType;
-    CallingConvention CallConv;
-    FunctionOptions Options;
-    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,
-                                                  msf::StreamReader &Reader);
   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.
-  };
 };
 
 // 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,
-                                             msf::StreamReader &Reader);
-
   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
-  };
 };
 
 // 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 PointerOptionMask = 0xFF;
+
   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(TypeIndex ReferentType, uint32_t Attrs)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        PtrKind(Kind), Mode(Mode), Options(Options), Size(Size) {}
+        Attrs(Attrs) {}
 
-  PointerRecord(TypeIndex ReferentType, PointerKind Kind, PointerMode Mode,
-                PointerOptions Options, uint8_t Size,
+  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
+                PointerOptions PO, uint8_t Size)
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        Attrs(calcAttrs(PK, PM, PO, Size)) {}
+
+  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
+                PointerOptions PO, uint8_t Size,
                 const MemberPointerInfo &Member)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        PtrKind(Kind), Mode(Mode), Options(Options), Size(Size),
-        MemberInfo(Member) {}
+        Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(Member) {}
+
+  PointerRecord(TypeIndex ReferentType, uint32_t Attrs,
+                const MemberPointerInfo &Member)
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        Attrs(Attrs), 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,
-                                             msf::StreamReader &Reader);
-
   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; }
+  PointerKind getPointerKind() const {
+    return static_cast<PointerKind>((Attrs >> PointerKindShift) &
+                                    PointerKindMask);
+  }
+  PointerMode getMode() const {
+    return static_cast<PointerMode>((Attrs >> PointerModeShift) &
+                                    PointerModeMask);
+  }
+  PointerOptions getOptions() const {
+    return static_cast<PointerOptions>(Attrs);
+  }
+  uint8_t getSize() const {
+    return (Attrs >> PointerSizeShift) & PointerSizeMask;
+  }
   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));
+    return getMode() == PointerMode::PointerToDataMember ||
+           getMode() == PointerMode::PointerToMemberFunction;
   }
+  bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
+  bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
   bool isVolatile() const {
-    return !!(uint32_t(Options) & uint32_t(PointerOptions::Volatile));
+    return !!(Attrs & uint32_t(PointerOptions::Volatile));
   }
   bool isUnaligned() const {
-    return !!(uint32_t(Options) & uint32_t(PointerOptions::Unaligned));
+    return !!(Attrs & uint32_t(PointerOptions::Unaligned));
   }
 
   TypeIndex ReferentType;
-  PointerKind PtrKind;
-  PointerMode Mode;
-  PointerOptions Options;
-  uint8_t Size;
+  uint32_t Attrs;
+
   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);
-    }
-    PointerMode getPtrMode() const {
-      return PointerMode((Attrs >> PointerModeShift) & PointerModeMask);
-    }
-    uint8_t getPtrSize() const {
-      return (Attrs >> PointerSizeShift) & PointerSizeMask;
-    }
-    bool isFlat() const { return Attrs & (1 << 8); }
-    bool isVolatile() const { return Attrs & (1 << 9); }
-    bool isConst() const { return Attrs & (1 << 10); }
-    bool isUnaligned() const { return Attrs & (1 << 11); }
-
-    bool isPointerToDataMember() const {
-      return getPtrMode() == PointerMode::PointerToDataMember;
-    }
-    bool isPointerToMemberFunction() const {
-      return getPtrMode() == PointerMode::PointerToMemberFunction;
-    }
-    bool isPointerToMember() const {
-      return isPointerToMemberFunction() || isPointerToDataMember();
-    }
-  };
-};
+  static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
+                            uint8_t Size) {
+    uint32_t A = 0;
+    A |= static_cast<uint32_t>(PK);
+    A |= static_cast<uint32_t>(PO);
+    A |= (static_cast<uint32_t>(PM) << PointerModeShift);
+    A |= (static_cast<uint32_t>(Size) << PointerSizeShift);
+    return A;
 
 // 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,
-                                                msf::StreamReader &Reader);
-
   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
-  };
 };
 
 // LF_FIELDLIST
 class FieldListRecord : public TypeRecord {
 public:
   explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   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,
-                                               msf::StreamReader &Reader);
-
   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,
-                                           msf::StreamReader &Reader);
-
   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.
-  };
 };
 
 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),
         FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}
 
 public:
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static const int HfaKindShift = 11;
   static const int HfaKindMask = 0x1800;
   static const int WinRTKindShift = 14;
   static const int WinRTKindMask = 0xC000;
 
+  bool hasUniqueName() const {
+    return (Options & ClassOptions::HasUniqueName) != ClassOptions::None;
+  }
+
   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; }
 
   uint16_t MemberCount;
   ClassOptions Options;
   TypeIndex FieldList;
   StringRef Name;
   StringRef UniqueName;
 };
 
 // LF_CLASS, LF_STRUCTURE, LF_INTERFACE
 class ClassRecord : public TagRecord {
 public:
   explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
   ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
-              HfaKind Hfa, WindowsRTClassKind WinRTKind, TypeIndex FieldList,
-              TypeIndex DerivationList, TypeIndex VTableShape, uint64_t Size,
-              StringRef Name, StringRef UniqueName)
+              TypeIndex FieldList, TypeIndex DerivationList,
+              TypeIndex VTableShape, uint64_t Size, StringRef Name,
+              StringRef UniqueName)
       : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),
-        Hfa(Hfa), WinRTKind(WinRTKind), DerivationList(DerivationList),
-        VTableShape(VTableShape), Size(Size) {}
+        DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<ClassRecord> deserialize(TypeRecordKind Kind,
-                                           msf::StreamReader &Reader);
-
-  HfaKind getHfa() const { return Hfa; }
-  WindowsRTClassKind getWinRTKind() const { return WinRTKind; }
+  HfaKind getHfa() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & HfaKindMask) >> HfaKindShift;
+    return static_cast<HfaKind>(Value);
+  }
+  WindowsRTClassKind getWinRTKind() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & WinRTKindMask) >> WinRTKindShift;
+    return static_cast<WindowsRTClassKind>(Value);
+  }
   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);
-    }
-  };
 };
 
 // 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)
+  UnionRecord(uint16_t MemberCount, ClassOptions Options, 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,
-                                           msf::StreamReader &Reader);
+        Size(Size) {}
 
-  HfaKind getHfa() const { return Hfa; }
+  HfaKind getHfa() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & HfaKindMask) >> HfaKindShift;
+    return static_cast<HfaKind>(Value);
+  }
   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);
-    }
-  };
 };
 
 // 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,
-                                          msf::StreamReader &Reader);
-
   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);
-    }
-  };
-
 };
 
 // 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,
-                                              msf::StreamReader &Reader);
-
   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;
-  };
-
 };
 
 // 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,
-                                                  msf::StreamReader &Reader);
-
   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.
-  };
-
 };
 
 // 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,
-                                                 msf::StreamReader &Reader);
-
   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
-  };
 };
 
 // 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,
-                                              msf::StreamReader &Reader);
-
   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
-  };
 };
 
 // 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,
-                                            msf::StreamReader &Reader);
-
   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.
-  };
-
 };
 
 // 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,
-                                                   msf::StreamReader &Reader);
-
   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;
-  };
-
 };
 
 // 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)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}
 
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<UdtModSourceLineRecord>
-  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-    const Layout *L = nullptr;
-    CV_DESERIALIZE(Reader, L);
-
-    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
-  };
-
 };
 
 // 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,
-                                               msf::StreamReader &Reader);
-
   ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
   SmallVector<TypeIndex, 4> ArgIndices;
-
-private:
-  struct Layout {
-    ulittle16_t NumArgs; // Number of arguments
-                         // ArgTypes[]: Type indicies of arguments
-  };
 };
 
 // LF_VFTABLE
 class VFTableRecord : public TypeRecord {
 public:
   explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
   VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
                 uint32_t VFPtrOffset, StringRef Name,
                 ArrayRef<StringRef> Methods)
-      : TypeRecord(TypeRecordKind::VFTable),
-        CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
-        VFPtrOffset(VFPtrOffset), Name(Name), MethodNamesRef(Methods) {}
-  VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
-                uint32_t VFPtrOffset, StringRef Name,
-                const std::vector<StringRef> &Methods)
-      : TypeRecord(TypeRecordKind::VFTable),
-        CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
-        VFPtrOffset(VFPtrOffset), Name(Name), MethodNames(Methods) {}
+      : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),
+        OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {
+    MethodNames.push_back(Name);
+    MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.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<VFTableRecord> deserialize(TypeRecordKind Kind,
-                                             msf::StreamReader &Reader);
-
   TypeIndex getCompleteClass() const { return CompleteClass; }
   TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
   uint32_t getVFPtrOffset() const { return VFPtrOffset; }
-  StringRef getName() const { return Name; }
+  StringRef getName() const { return makeArrayRef(MethodNames).front(); }
   ArrayRef<StringRef> getMethodNames() const {
-    if (!MethodNamesRef.empty())
-      return MethodNamesRef;
-    return MethodNames;
+    return makeArrayRef(MethodNames).drop_front();
   }
+
   TypeIndex CompleteClass;
   TypeIndex OverriddenVFTable;
-  ulittle32_t VFPtrOffset;
-  StringRef Name;
-  ArrayRef<StringRef> MethodNamesRef;
+  uint32_t VFPtrOffset;
   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.
-  };
-
 };
 
 // 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) {}
+  OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
+                  StringRef Name)
+      : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs),
+        VFTableOffset(VFTableOffset), Name(Name) {}
+  OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind Kind,
+                  MethodOptions Options, int32_t VFTableOffset, StringRef Name)
+      : TypeRecord(TypeRecordKind::OneMethod), Type(Type),
+        Attrs(Access, Kind, Options), VFTableOffset(VFTableOffset), Name(Name) {
+  }
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<OneMethodRecord> deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader);
-
   TypeIndex getType() const { return Type; }
-  MethodKind getKind() const { return Kind; }
-  MethodOptions getOptions() const { return Options; }
-  MemberAccess getAccess() const { return Access; }
+  MethodKind getKind() const { return Attrs.getMethodKind(); }
+  MethodOptions getOptions() const { return Attrs.getFlags(); }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   int32_t getVFTableOffset() const { return VFTableOffset; }
   StringRef getName() const { return Name; }
 
   bool isIntroducingVirtual() const {
-    return Kind == MethodKind::IntroducingVirtual ||
-           Kind == MethodKind::PureIntroducingVirtual;
+    return getKind() == MethodKind::IntroducingVirtual ||
+           getKind() == MethodKind::PureIntroducingVirtual;
   }
   TypeIndex Type;
-  MethodKind Kind;
-  MethodOptions Options;
-  MemberAccess Access;
+  MemberAttributes Attrs;
   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
-  };
-
 };
 
 // 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, msf::StreamReader &Reader);
-
   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
-  };
-
 };
 
 /// 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, msf::StreamReader &Reader);
-
   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
-  };
-
 };
 
 // LF_MEMBER
 class DataMemberRecord : public TypeRecord {
 public:
   explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,
+                   StringRef Name)
+      : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type),
+        FieldOffset(Offset), Name(Name) {}
   DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
                    StringRef Name)
-      : TypeRecord(TypeRecordKind::DataMember), Access(Access), Type(Type),
+      : TypeRecord(TypeRecordKind::DataMember), Attrs(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,
-                                                msf::StreamReader &Reader);
-
-  MemberAccess getAccess() const { return Access; }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getType() const { return Type; }
   uint64_t getFieldOffset() const { return FieldOffset; }
   StringRef getName() const { return Name; }
-  MemberAccess Access;
+  MemberAttributes Attrs;
   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
-  };
-
 };
 
 // LF_STMEMBER
 class StaticDataMemberRecord : public TypeRecord {
 public:
   explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
+      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),
+        Name(Name) {}
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
-      : TypeRecord(TypeRecordKind::StaticDataMember), Access(Access),
-        Type(Type), Name(Name) {}
+      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(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, msf::StreamReader &Reader);
-
-  MemberAccess getAccess() const { return Access; }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getType() const { return Type; }
   StringRef getName() const { return Name; }
-  MemberAccess Access;
+  MemberAttributes Attrs;
   TypeIndex Type;
   StringRef Name;
-
-private:
-  struct Layout {
-    MemberAttributes Attrs; // Access control attributes, etc
-    TypeIndex Type;
-    // Name: Null-terminated string
-  };
-
 };
 
 // LF_ENUMERATE
 class EnumeratorRecord : public TypeRecord {
 public:
   explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)
+      : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),
+        Value(std::move(Value)), Name(Name) {}
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
-      : TypeRecord(TypeRecordKind::Enumerator), Access(Access),
+      : TypeRecord(TypeRecordKind::Enumerator), Attrs(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,
-                                                msf::StreamReader &Reader);
-
-  MemberAccess getAccess() const { return Access; }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   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
-  };
-
+  MemberAttributes Attrs;
 };
 
 // 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,
-                                           msf::StreamReader &Reader);
-
   TypeIndex getType() const { return Type; }
   TypeIndex Type;
-
-private:
-  struct Layout {
-    ulittle16_t Pad0;
-    TypeIndex Type; // Type of vfptr
-  };
 };
 
 // LF_BCLASS, LF_BINTERFACE
 class BaseClassRecord : public TypeRecord {
 public:
   explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
+      : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),
+        Offset(Offset) {}
   BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
-      : TypeRecord(TypeRecordKind::BaseClass), Access(Access), Type(Type),
+      : TypeRecord(TypeRecordKind::BaseClass), Attrs(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,
-                                               msf::StreamReader &Reader);
-
-  MemberAccess getAccess() const { return Access; }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getBaseType() const { return Type; }
   uint64_t getBaseOffset() const { return Offset; }
-  MemberAccess Access;
+  MemberAttributes Attrs;
   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.
-  };
 };
 
 // LF_VBCLASS, LF_IVBCLASS
 class VirtualBaseClassRecord : public TypeRecord {
 public:
   explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs,
+                         TypeIndex BaseType, TypeIndex VBPtrType,
+                         uint64_t Offset, uint64_t Index)
+      : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType),
+        VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
   VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access,
                          TypeIndex BaseType, TypeIndex VBPtrType,
                          uint64_t Offset, uint64_t Index)
-      : TypeRecord(Kind), Access(Access), BaseType(BaseType),
+      : TypeRecord(Kind), Attrs(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, msf::StreamReader &Reader);
-
-  MemberAccess getAccess() const { return Access; }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }
   uint64_t getVBPtrOffset() const { return VBPtrOffset; }
   uint64_t getVTableIndex() const { return VTableIndex; }
-  MemberAccess Access;
+  MemberAttributes Attrs;
   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.
-  };
 };
 
 /// 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, msf::StreamReader &Reader);
   TypeIndex ContinuationIndex;
-
-private:
-  struct Layout {
-    ulittle16_t Pad0;
-    TypeIndex ContinuationIndex;
-  };
 };
 
 }
 }
 
 #endif

include/llvm/DebugInfo/CodeView/TypeRecordMapping.h

+//===- TypeRecordMapping.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_TYPERECORDMAPPING_H
+#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORDMAPPING_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace codeview {
+class TypeRecordMapping : public TypeVisitorCallbacks {
+public:
+  explicit TypeRecordMapping(msf::StreamReader &Reader) : IO(Reader) {}
+
+  Error visitTypeBegin(CVType &Record) override;
+  Error visitTypeEnd(CVType &Record) override;
+
+  Error visitMemberBegin(CVMemberRecord &Record) override;
+  Error visitMemberEnd(CVMemberRecord &Record) override;
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override;
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "TypeRecords.def"
+
+private:
+  Optional<TypeLeafKind> TypeKind;
+
+  CodeViewRecordIO IO;
+};
+}
+}
+
+#endif

include/llvm/DebugInfo/MSF/StreamWriter.h

 
 #include <string>
 
 namespace llvm {
 namespace msf {
 
 class StreamWriter {
 public:
+  StreamWriter() {}
   StreamWriter(WritableStreamRef Stream);
 
   Error writeBytes(ArrayRef<uint8_t> Buffer);
+  Error writeInteger(uint8_t Int);
   Error writeInteger(uint16_t Dest);
   Error writeInteger(uint32_t Dest);
+  Error writeInteger(uint64_t Dest);
+  Error writeInteger(int8_t Int);
+  Error writeInteger(int16_t Dest);
+  Error writeInteger(int32_t Dest);
+  Error writeInteger(int64_t Dest);
   Error writeZeroString(StringRef Str);
   Error writeFixedString(StringRef Str);
   Error writeStreamRef(ReadableStreamRef Ref);
   Error writeStreamRef(ReadableStreamRef Ref, uint32_t Size);
 
   template <typename T> Error writeEnum(T Num) {
     return writeInteger(
         static_cast<typename std::underlying_type<T>::type>(Num));
public:
 
   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:
   WritableStreamRef Stream;
-  uint32_t Offset;
+  uint32_t Offset = 0;
 };
 } // namespace msf
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_MSF_STREAMWRITER_H

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 
 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
   // First, construct the forward decl.  Don't look into Ty to compute the
   // forward decl options, since it might not be available in all TUs.
   TypeRecordKind Kind = getRecordKind(Ty);
   ClassOptions CO =
       ClassOptions::ForwardReference | getCommonClassOptions(Ty);
   std::string FullName = getFullyQualifiedName(Ty);
-  TypeIndex FwdDeclTI = TypeTable.writeKnownType(ClassRecord(
-      Kind, 0, CO, HfaKind::None, WindowsRTClassKind::None, TypeIndex(),
-      TypeIndex(), TypeIndex(), 0, FullName, Ty->getIdentifier()));
+  TypeIndex FwdDeclTI = TypeTable.writeKnownType(
+      ClassRecord(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
+                  FullName, Ty->getIdentifier()));
   if (!Ty->isForwardDecl())
     DeferredCompleteTypes.push_back(Ty);
   return FwdDeclTI;
 }
 
 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
   // Construct the field list and complete type record.
   TypeRecordKind Kind = getRecordKind(Ty);
   ClassOptions CO = getCommonClassOptions(Ty);
   TypeIndex FieldTI;
   TypeIndex VShapeTI;
   unsigned FieldCount;
   bool ContainsNestedClass;
   std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
       lowerRecordFieldList(Ty);
 
   if (ContainsNestedClass)
     CO |= ClassOptions::ContainsNestedClass;
 
   std::string FullName = getFullyQualifiedName(Ty);
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
 
-  TypeIndex ClassTI = TypeTable.writeKnownType(ClassRecord(
-      Kind, FieldCount, CO, HfaKind::None, WindowsRTClassKind::None, FieldTI,
-      TypeIndex(), VShapeTI, SizeInBytes, FullName, Ty->getIdentifier()));
+  TypeIndex ClassTI = TypeTable.writeKnownType(
+      ClassRecord(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
+                  SizeInBytes, FullName, Ty->getIdentifier()));
 
   TypeTable.writeKnownType(UdtSourceLineRecord(
       ClassTI, TypeTable.writeKnownType(StringIdRecord(
                    TypeIndex(0x0), getFullFilepath(Ty->getFile()))),
       Ty->getLine()));
 
   addToUDTs(Ty, ClassTI);
 
   return ClassTI;
 }
 
 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO =
       ClassOptions::ForwardReference | getCommonClassOptions(Ty);
   std::string FullName = getFullyQualifiedName(Ty);
-  TypeIndex FwdDeclTI = TypeTable.writeKnownType(UnionRecord(
-      0, CO, HfaKind::None, TypeIndex(), 0, FullName, Ty->getIdentifier()));
+  TypeIndex FwdDeclTI = TypeTable.writeKnownType(
+      UnionRecord(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier()));
   if (!Ty->isForwardDecl())
     DeferredCompleteTypes.push_back(Ty);
   return FwdDeclTI;
 }
 
 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
   TypeIndex FieldTI;
   unsigned FieldCount;
   bool ContainsNestedClass;
   std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
       lowerRecordFieldList(Ty);
 
   if (ContainsNestedClass)
     CO |= ClassOptions::ContainsNestedClass;
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
   std::string FullName = getFullyQualifiedName(Ty);
 
-  TypeIndex UnionTI = TypeTable.writeKnownType(
-      UnionRecord(FieldCount, CO, HfaKind::None, FieldTI, SizeInBytes, FullName,
-                  Ty->getIdentifier()));
+  TypeIndex UnionTI = TypeTable.writeKnownType(UnionRecord(
+      FieldCount, CO, FieldTI, SizeInBytes, FullName, Ty->getIdentifier()));
 
   TypeTable.writeKnownType(UdtSourceLineRecord(
       UnionTI, TypeTable.writeKnownType(StringIdRecord(
                    TypeIndex(0x0), getFullFilepath(Ty->getFile()))),
       Ty->getLine()));
 
   addToUDTs(Ty, UnionTI);
 
for (auto &MethodItr : Info.Methods) {
     for (const DISubprogram *SP : MethodItr.second) {
       TypeIndex MethodType = getMemberFunctionType(SP, Ty);
       bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
 
       unsigned VFTableOffset = -1;
       if (Introduced)
         VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
 
-      Methods.push_back(
-          OneMethodRecord(MethodType, translateMethodKindFlags(SP, Introduced),
-                          translateMethodOptionFlags(SP),
-                          translateAccessFlags(Ty->getTag(), SP->getFlags()),
-                          VFTableOffset, Name));
+      Methods.push_back(OneMethodRecord(
+          MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
+          translateMethodKindFlags(SP, Introduced),
+          translateMethodOptionFlags(SP), VFTableOffset, Name));
       MemberCount++;
     }
     assert(Methods.size() > 0 && "Empty methods map entry");
     if (Methods.size() == 1)
       Fields.writeMemberType(Methods[0]);
     else {
       TypeIndex MethodList =
           TypeTable.writeKnownType(MethodOverloadListRecord(Methods));

lib/DebugInfo/CodeView/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoCodeView
   CodeViewError.cpp
+  CodeViewRecordIO.cpp
   CVSymbolVisitor.cpp
   CVTypeVisitor.cpp
   EnumTables.cpp
   FieldListRecordBuilder.cpp
   Line.cpp
   ListRecordBuilder.cpp
   MemoryTypeTableBuilder.cpp
   MethodListRecordBuilder.cpp
   ModuleSubstream.cpp
   ModuleSubstreamVisitor.cpp
   RecordSerialization.cpp
   SymbolDumper.cpp
   TypeDumper.cpp
   TypeRecord.cpp
   TypeRecordBuilder.cpp
+  TypeRecordMapping.cpp
   TypeStreamMerger.cpp
   TypeTableBuilder.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/CodeView
   )

lib/DebugInfo/CodeView/CVTypeVisitor.cpp

 //===- CVTypeVisitor.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/CVTypeVisitor.h"
 
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
-static Error skipPadding(msf::StreamReader &Reader) {
-  if (Reader.empty())
-    return Error::success();
-
-  uint8_t Leaf = Reader.peek();
-  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;
-  return Reader.skip(BytesToAdvance);
-}
-
 template <typename T>
 static Expected<CVMemberRecord>
-deserializeMemberRecord(msf::StreamReader &Reader, TypeLeafKind Kind) {
-  msf::StreamReader OldReader = Reader;
-  TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
-  auto ExpectedRecord = T::deserialize(RK, Reader);
-  if (!ExpectedRecord)
-    return ExpectedRecord.takeError();
-  assert(Reader.bytesRemaining() < OldReader.bytesRemaining());
-  if (auto EC = skipPadding(Reader))
-    return std::move(EC);
-
-  CVMemberRecord CVMR;
-  CVMR.Kind = Kind;
+deserializeMemberRecord(FieldListDeserializer &Deserializer,
+                        msf::StreamReader &Reader, TypeLeafKind Kind) {
+  T MR(static_cast<TypeRecordKind>(Kind));
+  CVMemberRecord CVR;
+  CVR.Kind = Kind;
 
-  uint32_t RecordLength = OldReader.bytesRemaining() - Reader.bytesRemaining();
-  if (auto EC = OldReader.readBytes(CVMR.Data, RecordLength))
+  if (auto EC = Deserializer.visitMemberBegin(CVR))
+    return std::move(EC);
+  if (auto EC = Deserializer.visitKnownMember(CVR, MR))
+    return std::move(EC);
+  if (auto EC = Deserializer.visitMemberEnd(CVR))
     return std::move(EC);
 
-  return CVMR;
+  return CVR;
 }
 
 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
     : Callbacks(Callbacks) {}
 
 template <typename T>
 static Error visitKnownRecord(CVType &Record, TypeVisitorCallbacks &Callbacks) {
   TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Type);
Error CVTypeVisitor::visitTypeStream(const CVTypeArray &Types) {
   for (auto I : Types) {
     if (auto EC = visitTypeRecord(I))
       return EC;
   }
   return Error::success();
 }
 
 template <typename MR>
-static Error visitKnownMember(msf::StreamReader &Reader, TypeLeafKind Leaf,
+static Error visitKnownMember(FieldListDeserializer &Deserializer,
+                              msf::StreamReader &Reader, TypeLeafKind Leaf,
                               TypeVisitorCallbacks &Callbacks) {
-  auto ExpectedRecord = deserializeMemberRecord<MR>(Reader, Leaf);
-  if (!ExpectedRecord)
-    return ExpectedRecord.takeError();
-  CVMemberRecord &Record = *ExpectedRecord;
-  if (auto EC = Callbacks.visitMemberBegin(Record))
+  MR Record(static_cast<TypeRecordKind>(Leaf));
+  CVMemberRecord CVR;
+  CVR.Kind = Leaf;
+
+  if (auto EC = Callbacks.visitMemberBegin(CVR))
     return EC;
-  if (auto EC = visitKnownMember<MR>(Record, Callbacks))
+  if (auto EC = Callbacks.visitKnownMember(CVR, Record))
     return EC;
-  if (auto EC = Callbacks.visitMemberEnd(Record))
+  if (auto EC = Callbacks.visitMemberEnd(CVR))
     return EC;
   return Error::success();
 }
 
 Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) {
+  FieldListDeserializer Deserializer(Reader);
+  TypeVisitorCallbackPipeline Pipeline;
+  Pipeline.addCallbackToPipeline(Deserializer);
+  Pipeline.addCallbackToPipeline(Callbacks);
+
   TypeLeafKind Leaf;
   while (!Reader.empty()) {
     if (auto EC = Reader.readEnum(Leaf))
       return EC;
 
     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: {                                                             \
-    if (auto EC = visitKnownMember<Name##Record>(Reader, Leaf, Callbacks))     \
+    if (auto EC = visitKnownMember<Name##Record>(Deserializer, Reader, Leaf,   \
+                                                 Pipeline))                    \
       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();
 }
 
 Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef<uint8_t> Data) {
   msf::ByteStream S(Data);
   msf::StreamReader SR(S);
   return visitFieldListMemberStream(SR);
 }

lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

+//===- CodeViewRecordIO.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/CodeViewRecordIO.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/RecordSerialization.h"
+#include "llvm/DebugInfo/msf/StreamReader.h"
+#include "llvm/DebugInfo/msf/StreamWriter.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+Error CodeViewRecordIO::beginRecord(uint16_t Kind) {
+  assert(!CurrentRecord.hasValue() && "There is already a record active!");
+  CurrentRecord.emplace();
+
+  CurrentRecord->Kind = Kind;
+  return Error::success();
+}
+
+Error CodeViewRecordIO::endRecord() {
+  assert(CurrentRecord.hasValue() && "Not in a record!");
+  CurrentRecord.reset();
+  return Error::success();
+}
+
+Error CodeViewRecordIO::skipPadding() {
+  assert(!IsWriting && "Cannot skip padding while writing!");
+
+  if (Reader->bytesRemaining() == 0)
+    return Error::success();
+
+  uint8_t Leaf = Reader->peek();
+  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;
+  return Reader->skip(BytesToAdvance);
+}
+
+Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes) {
+  if (IsWriting) {
+    if (auto EC = Writer->writeBytes(Bytes))
+      return EC;
+  } else {
+    if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
+      return EC;
+  }
+  return Error::success();
+}
+
+Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) {
+  if (IsWriting) {
+    if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
+      return EC;
+    return Error::success();
+  }
+
+  uint32_t I;
+  if (auto EC = Reader->readInteger(I))
+    return EC;
+  TypeInd.setIndex(I);
+  return Error::success();
+}
+
+Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value) {
+  if (IsWriting) {
+    if (Value >= 0) {
+      if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
+        return EC;
+    } else {
+      if (auto EC = writeEncodedSignedInteger(Value))
+        return EC;
+    }
+  } else {
+    APSInt N;
+    if (auto EC = consume(*Reader, N))
+      return EC;
+    Value = N.getExtValue();
+  }
+
+  return Error::success();
+}
+
+Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value) {
+  if (IsWriting) {
+    if (auto EC = writeEncodedUnsignedInteger(Value))
+      return EC;
+  } else {
+    APSInt N;
+    if (auto EC = consume(*Reader, N))
+      return EC;
+    Value = N.getZExtValue();
+  }
+  return Error::success();
+}
+
+Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value) {
+  if (IsWriting) {
+    if (Value.isSigned())
+      return writeEncodedSignedInteger(Value.getSExtValue());
+    return writeEncodedUnsignedInteger(Value.getZExtValue());
+  }
+
+  return consume(*Reader, Value);
+}
+
+Error CodeViewRecordIO::mapStringZ(StringRef &Value) {
+  if (IsWriting) {
+    if (auto EC = Writer->writeZeroString(Value))
+      return EC;
+  } else {
+    if (auto EC = Reader->readZeroString(Value))
+      return EC;
+  }
+  return Error::success();
+}
+
+Error CodeViewRecordIO::mapGuid(StringRef &Guid) {
+  if (IsWriting) {
+    assert(Guid.size() == 16 && "Invalid Guid Size!");
+    if (auto EC = Writer->writeFixedString(Guid))
+      return EC;
+  } else {
+    if (auto EC = Reader->readFixedString(Guid, 16))
+      return EC;
+  }
+  return Error::success();
+}
+
+Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
+  assert(Value < 0 && "Encoded integer is not signed!");
+  if (Value >= std::numeric_limits<int8_t>::min()) {
+    if (auto EC = Writer->writeInteger(LF_CHAR))
+      return EC;
+    if (auto EC = Writer->writeInteger(static_cast<int8_t>(Value)))
+      return EC;
+  } else if (Value >= std::numeric_limits<int16_t>::min()) {
+    if (auto EC = Writer->writeInteger(LF_SHORT))
+      return EC;
+    if (auto EC = Writer->writeInteger(static_cast<int16_t>(Value)))
+      return EC;
+  } else if (Value >= std::numeric_limits<int32_t>::min()) {
+    if (auto EC = Writer->writeInteger(LF_LONG))
+      return EC;
+    if (auto EC = Writer->writeInteger(static_cast<int32_t>(Value)))
+      return EC;
+  } else {
+    if (auto EC = Writer->writeInteger(LF_QUADWORD))
+      return EC;
+    if (auto EC = Writer->writeInteger(Value))
+      return EC;
+  }
+  return Error::success();
+}
+
+Error CodeViewRecordIO::writeEncodedUnsignedInteger(const uint64_t &Value) {
+  if (Value < LF_NUMERIC) {
+    if (auto EC = Writer->writeInteger(static_cast<uint16_t>(Value)))
+      return EC;
+  } else if (Value <= std::numeric_limits<uint16_t>::min()) {
+    if (auto EC = Writer->writeInteger(LF_USHORT))
+      return EC;
+    if (auto EC = Writer->writeInteger(static_cast<uint16_t>(Value)))
+      return EC;
+  } else if (Value >= std::numeric_limits<uint32_t>::min()) {
+    if (auto EC = Writer->writeInteger(LF_ULONG))
+      return EC;
+    if (auto EC = Writer->writeInteger(static_cast<uint32_t>(Value)))
+      return EC;
+  } else {
+    if (auto EC = Writer->writeInteger(LF_UQUADWORD))
+      return EC;
+    if (auto EC = Writer->writeInteger(Value))
+      return EC;
+  }
+
+  return Error::success();
+}

lib/DebugInfo/CodeView/TypeDumper.cpp

Error CVTypeDumper::visitMemberEnd(CVMemberRecord &Record) {
 
   W->unindent();
   W->startLine() << "}\n";
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      FieldListRecord &FieldList) {
-  TypeDeserializer Deserializer;
-  TypeVisitorCallbackPipeline Pipeline;
-  Pipeline.addCallbackToPipeline(Deserializer);
-  Pipeline.addCallbackToPipeline(*this);
-
-  CVTypeVisitor Visitor(Pipeline);
+  CVTypeVisitor Visitor(*this);
   if (auto EC = Visitor.visitFieldListMemberStream(FieldList.Data))
     return EC;
 
   Name = "<field list>";
   return Error::success();
 }
 
 Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,

lib/DebugInfo/CodeView/TypeRecord.cpp

 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 //===----------------------------------------------------------------------===//
-// Type record deserialization
-//===----------------------------------------------------------------------===//
-
-Expected<MemberPointerInfo>
-MemberPointerInfo::deserialize(msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-
-  TypeIndex T = L->ClassType;
-  uint16_t R = L->Representation;
-  PointerToMemberRepresentation PMR =
-      static_cast<PointerToMemberRepresentation>(R);
-  return MemberPointerInfo(T, PMR);
-}
-
-Expected<ModifierRecord>
-ModifierRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-
-  TypeIndex M = L->ModifiedType;
-  uint16_t O = L->Modifiers;
-  ModifierOptions MO = static_cast<ModifierOptions>(O);
-  return ModifierRecord(M, MO);
-}
-
-Expected<ProcedureRecord>
-ProcedureRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-  return ProcedureRecord(L->ReturnType, L->CallConv, L->Options,
-                         L->NumParameters, L->ArgListType);
-}
-
-Expected<MemberFunctionRecord>
-MemberFunctionRecord::deserialize(TypeRecordKind Kind,
-                                  msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  CV_DESERIALIZE(Reader, L);
-  return MemberFunctionRecord(L->ReturnType, L->ClassType, L->ThisType,
-                              L->CallConv, L->Options, L->NumParameters,
-                              L->ArgListType, L->ThisAdjustment);
-}
-
-Expected<MemberFuncIdRecord>
-MemberFuncIdRecord::deserialize(TypeRecordKind Kind,
-                                msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return MemberFuncIdRecord(L->ClassType, L->FunctionType, Name);
-}
-
-Expected<ArgListRecord> ArgListRecord::deserialize(TypeRecordKind Kind,
-                                                   msf::StreamReader &Reader) {
-  if (Kind != TypeRecordKind::StringList && Kind != TypeRecordKind::ArgList)
-    return make_error<CodeViewError>(
-        cv_error_code::corrupt_record,
-        "ArgListRecord contains unexpected TypeRecordKind");
-
-  const Layout *L = nullptr;
-  ArrayRef<TypeIndex> Indices;
-  CV_DESERIALIZE(Reader, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
-  return ArgListRecord(Kind, Indices);
-}
-
-Expected<PointerRecord> PointerRecord::deserialize(TypeRecordKind Kind,
-                                                   msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-
-  PointerKind PtrKind = L->getPtrKind();
-  PointerMode Mode = L->getPtrMode();
-  uint32_t Opts = L->Attrs;
-  PointerOptions Options = static_cast<PointerOptions>(Opts);
-  uint8_t Size = L->getPtrSize();
-
-  if (L->isPointerToMember()) {
-    if (auto ExpectedMPI = MemberPointerInfo::deserialize(Reader))
-      return PointerRecord(L->PointeeType, PtrKind, Mode, Options, Size,
-                           *ExpectedMPI);
-    else
-      return ExpectedMPI.takeError();
-  }
-
-  return PointerRecord(L->PointeeType, PtrKind, Mode, Options, Size);
-}
-
-Expected<NestedTypeRecord>
-NestedTypeRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return NestedTypeRecord(L->Type, Name);
-}
-
-Expected<FieldListRecord>
-FieldListRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  ArrayRef<uint8_t> Data;
-  if (auto EC = Reader.readBytes(Data, Reader.bytesRemaining()))
-    return std::move(EC);
-  return FieldListRecord(Data);
-}
-
-Expected<ArrayRecord> ArrayRecord::deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  uint64_t Size;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Size), Name);
-  return ArrayRecord(L->ElementType, L->IndexType, Size, Name);
-}
-
-Expected<ClassRecord> ClassRecord::deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader) {
-  uint64_t Size = 0;
-  StringRef Name;
-  StringRef UniqueName;
-  uint16_t Props;
-  const Layout *L = nullptr;
-
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Size), Name,
-                 CV_CONDITIONAL_FIELD(UniqueName, L->hasUniqueName()));
-
-  Props = L->Properties;
-  uint16_t WrtValue = (Props & WinRTKindMask) >> WinRTKindShift;
-  WindowsRTClassKind WRT = static_cast<WindowsRTClassKind>(WrtValue);
-  uint16_t HfaMask = (Props & HfaKindMask) >> HfaKindShift;
-  HfaKind Hfa = static_cast<HfaKind>(HfaMask);
-
-  ClassOptions Options = static_cast<ClassOptions>(Props);
-  return ClassRecord(Kind, L->MemberCount, Options, Hfa, WRT, L->FieldList,
-                     L->DerivedFrom, L->VShape, Size, Name, UniqueName);
-}
-
-Expected<UnionRecord> UnionRecord::deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader) {
-  uint64_t Size = 0;
-  StringRef Name;
-  StringRef UniqueName;
-  uint16_t Props;
-
-  const Layout *L = nullptr;
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Size), Name,
-                 CV_CONDITIONAL_FIELD(UniqueName, L->hasUniqueName()));
-
-  Props = L->Properties;
-
-  uint16_t HfaMask = (Props & HfaKindMask) >> HfaKindShift;
-  HfaKind Hfa = static_cast<HfaKind>(HfaMask);
-  ClassOptions Options = static_cast<ClassOptions>(Props);
-  return UnionRecord(L->MemberCount, Options, Hfa, L->FieldList, Size, Name,
-                     UniqueName);
-}
-
-Expected<EnumRecord> EnumRecord::deserialize(TypeRecordKind Kind,
-                                             msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  StringRef UniqueName;
-  CV_DESERIALIZE(Reader, L, Name,
-                 CV_CONDITIONAL_FIELD(UniqueName, L->hasUniqueName()));
-
-  uint16_t P = L->Properties;
-  ClassOptions Options = static_cast<ClassOptions>(P);
-  return EnumRecord(L->NumEnumerators, Options, L->FieldListType, Name,
-                    UniqueName, L->UnderlyingType);
-}
-
-Expected<BitFieldRecord>
-BitFieldRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  CV_DESERIALIZE(Reader, L);
-  return BitFieldRecord(L->Type, L->BitSize, L->BitOffset);
-}
-
-Expected<VFTableShapeRecord>
-VFTableShapeRecord::deserialize(TypeRecordKind Kind,
-                                msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-
-  std::vector<VFTableSlotKind> Slots;
-  uint16_t Count = L->VFEntryCount;
-  while (Count > 0) {
-    // Process up to 2 nibbles at a time (if there are at least 2 remaining)
-    uint8_t Data;
-    if (auto EC = Reader.readInteger(Data))
-      return std::move(EC);
-
-    uint8_t Value = Data & 0x0F;
-    Slots.push_back(static_cast<VFTableSlotKind>(Value));
-    if (--Count > 0) {
-      Value = (Data & 0xF0) >> 4;
-      Slots.push_back(static_cast<VFTableSlotKind>(Value));
-      --Count;
-    }
-  }
-
-  return VFTableShapeRecord(Slots);
-}
-
-Expected<TypeServer2Record>
-TypeServer2Record::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return TypeServer2Record(StringRef(L->Guid, 16), L->Age, Name);
-}
-
-Expected<StringIdRecord>
-StringIdRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return StringIdRecord(L->id, Name);
-}
-
-Expected<FuncIdRecord> FuncIdRecord::deserialize(TypeRecordKind Kind,
-                                                 msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return FuncIdRecord(L->ParentScope, L->FunctionType, Name);
-}
-
-Expected<UdtSourceLineRecord>
-UdtSourceLineRecord::deserialize(TypeRecordKind Kind,
-                                 msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  CV_DESERIALIZE(Reader, L);
-  return UdtSourceLineRecord(L->UDT, L->SourceFile, L->LineNumber);
-}
-
-Expected<BuildInfoRecord>
-BuildInfoRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  ArrayRef<TypeIndex> Indices;
-  CV_DESERIALIZE(Reader, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
-  return BuildInfoRecord(Indices);
-}
-
-Expected<VFTableRecord> VFTableRecord::deserialize(TypeRecordKind Kind,
-                                                   msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  std::vector<StringRef> Names;
-  CV_DESERIALIZE(Reader, L, Name, CV_ARRAY_FIELD_TAIL(Names));
-  return VFTableRecord(L->CompleteClass, L->OverriddenVFTable, L->VFPtrOffset,
-                       Name, Names);
-}
-
-Expected<OneMethodRecord>
-OneMethodRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  int32_t VFTableOffset = -1;
-
-  CV_DESERIALIZE(Reader, L, CV_CONDITIONAL_FIELD(
-                                VFTableOffset, L->Attrs.isIntroducedVirtual()),
-                 Name);
-
-  MethodOptions Options = L->Attrs.getFlags();
-  MethodKind MethKind = L->Attrs.getMethodKind();
-  MemberAccess Access = L->Attrs.getAccess();
-  OneMethodRecord Method(L->Type, MethKind, Options, Access, VFTableOffset,
-                         Name);
-  // Validate the vftable offset.
-  if (Method.isIntroducingVirtual() && Method.getVFTableOffset() < 0)
-    return make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                     "Invalid VFTableOffset");
-  return Method;
-}
-
-Expected<MethodOverloadListRecord>
-MethodOverloadListRecord::deserialize(TypeRecordKind Kind,
-                                      msf::StreamReader &Reader) {
-  std::vector<OneMethodRecord> Methods;
-  while (!Reader.empty()) {
-    const Layout *L = nullptr;
-    int32_t VFTableOffset = -1;
-    CV_DESERIALIZE(
-        Reader, L,
-        CV_CONDITIONAL_FIELD(VFTableOffset, L->Attrs.isIntroducedVirtual()));
-
-    MethodOptions Options = L->Attrs.getFlags();
-    MethodKind MethKind = L->Attrs.getMethodKind();
-    MemberAccess Access = L->Attrs.getAccess();
-
-    Methods.emplace_back(L->Type, MethKind, Options, Access, VFTableOffset,
-                         StringRef());
-
-    // Validate the vftable offset.
-    auto &Method = Methods.back();
-    if (Method.isIntroducingVirtual() && Method.getVFTableOffset() < 0)
-      return make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                       "Invalid VFTableOffset");
-  }
-  return MethodOverloadListRecord(Methods);
-}
-
-Expected<OverloadedMethodRecord>
-OverloadedMethodRecord::deserialize(TypeRecordKind Kind,
-                                    msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return OverloadedMethodRecord(L->MethodCount, L->MethList, Name);
-}
-
-Expected<DataMemberRecord>
-DataMemberRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  uint64_t Offset;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Offset), Name);
-  return DataMemberRecord(L->Attrs.getAccess(), L->Type, Offset, Name);
-}
-
-Expected<StaticDataMemberRecord>
-StaticDataMemberRecord::deserialize(TypeRecordKind Kind,
-                                    msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Name);
-  return StaticDataMemberRecord(L->Attrs.getAccess(), L->Type, Name);
-}
-
-Expected<EnumeratorRecord>
-EnumeratorRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  APSInt Value;
-  StringRef Name;
-  CV_DESERIALIZE(Reader, L, Value, Name);
-  return EnumeratorRecord(L->Attrs.getAccess(), Value, Name);
-}
-
-Expected<VFPtrRecord> VFPtrRecord::deserialize(TypeRecordKind Kind,
-                                               msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  if (auto EC = Reader.readObject(L))
-    return std::move(EC);
-  return VFPtrRecord(L->Type);
-}
-
-Expected<BaseClassRecord>
-BaseClassRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  uint64_t Offset;
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Offset));
-  return BaseClassRecord(L->Attrs.getAccess(), L->BaseType, Offset);
-}
-
-Expected<VirtualBaseClassRecord>
-VirtualBaseClassRecord::deserialize(TypeRecordKind Kind,
-                                    msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  uint64_t Offset;
-  uint64_t Index;
-  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
-  return VirtualBaseClassRecord(Kind, L->Attrs.getAccess(), L->BaseType,
-                                L->VBPtrType, Offset, Index);
-}
-
-Expected<ListContinuationRecord>
-ListContinuationRecord::deserialize(TypeRecordKind Kind,
-                                    msf::StreamReader &Reader) {
-  const Layout *L = nullptr;
-  CV_DESERIALIZE(Reader, L);
-  return ListContinuationRecord(L->ContinuationIndex);
-}
-
-//===----------------------------------------------------------------------===//
 // Type index remapping
 //===----------------------------------------------------------------------===//
 
 static bool remapIndex(ArrayRef<TypeIndex> IndexMap, TypeIndex &Idx) {
   // Simple types are unchanged.
   if (Idx.isSimple())
     return true;
   unsigned MapPos = Idx.getIndex() - TypeIndex::FirstNonSimpleIndex;

lib/DebugInfo/CodeView/TypeRecordMapping.cpp

+//===- TypeRecordMapping.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/TypeRecordMapping.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+#define error(X)                                                               \
+  if (auto EC = X)                                                             \
+    return EC;
+
+namespace {
+struct MapStringZ {
+  Error operator()(CodeViewRecordIO &IO, StringRef &S) const {
+    return IO.mapStringZ(S);
+  }
+};
+
+struct MapInteger {
+  template <typename T> Error operator()(CodeViewRecordIO &IO, T &N) const {
+    return IO.mapInteger(N);
+  }
+};
+
+struct MapEnum {
+  template <typename T> Error operator()(CodeViewRecordIO &IO, T &N) const {
+    return IO.mapEnum(N);
+  }
+};
+
+struct MapOneMethodRecord {
+  explicit MapOneMethodRecord(bool IsFromOverloadList)
+      : IsFromOverloadList(IsFromOverloadList) {}
+
+  Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
+    error(IO.mapInteger(Method.Attrs.Attrs));
+    if (IsFromOverloadList) {
+      uint16_t Padding = 0;
+      error(IO.mapInteger(Padding));
+    }
+    error(IO.mapInteger(Method.Type));
+    if (Method.isIntroducingVirtual()) {
+      error(IO.mapInteger(Method.VFTableOffset));
+    } else if (!IO.isWriting())
+      Method.VFTableOffset = -1;
+
+    if (!IsFromOverloadList)
+      error(IO.mapStringZ(Method.Name));
+
+    return Error::success();
+  }
+
+private:
+  bool IsFromOverloadList;
+};
+}
+
+static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,
+                                  StringRef &UniqueName, bool HasUniqueName) {
+  error(IO.mapStringZ(Name));
+  if (HasUniqueName)
+    error(IO.mapStringZ(UniqueName));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {
+  error(IO.beginRecord(CVR.Type));
+  TypeKind = CVR.Type;
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitTypeEnd(CVType &Record) {
+  error(IO.endRecord());
+  TypeKind.reset();
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
+  if (!IO.isWriting()) {
+    if (auto EC = IO.skipPadding())
+      return EC;
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
+  error(IO.mapInteger(Record.ModifiedType));
+  error(IO.mapEnum(Record.Modifiers));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          ProcedureRecord &Record) {
+  error(IO.mapInteger(Record.ReturnType));
+  error(IO.mapEnum(Record.CallConv));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.ParameterCount));
+  error(IO.mapInteger(Record.ArgumentList));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MemberFunctionRecord &Record) {
+  error(IO.mapInteger(Record.ReturnType));
+  error(IO.mapInteger(Record.ClassType));
+  error(IO.mapInteger(Record.ThisType));
+  error(IO.mapEnum(Record.CallConv));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.ParameterCount));
+  error(IO.mapInteger(Record.ArgumentList));
+  error(IO.mapInteger(Record.ThisPointerAdjustment));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {
+  error(IO.mapVectorN<uint32_t>(Record.StringIndices, MapInteger()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
+  error(IO.mapInteger(Record.ReferentType));
+  error(IO.mapInteger(Record.Attrs));
+
+  if (Record.isPointerToMember()) {
+    if (!IO.isWriting())
+      Record.MemberInfo.emplace();
+
+    MemberPointerInfo &M = *Record.MemberInfo;
+    error(IO.mapInteger(M.ContainingType));
+    error(IO.mapEnum(M.Representation));
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {
+  error(IO.mapInteger(Record.ElementType));
+  error(IO.mapInteger(Record.IndexType));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {
+  assert((CVR.Type == TypeLeafKind::LF_STRUCTURE) ||
+         (CVR.Type == TypeLeafKind::LF_CLASS) ||
+         (CVR.Type == TypeLeafKind::LF_INTERFACE));
+
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.FieldList));
+  error(IO.mapInteger(Record.DerivationList));
+  error(IO.mapInteger(Record.VTableShape));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.FieldList));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.UnderlyingType));
+  error(IO.mapInteger(Record.FieldList));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapInteger(Record.BitSize));
+  error(IO.mapInteger(Record.BitOffset));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          VFTableShapeRecord &Record) {
+  uint16_t Size;
+  if (IO.isWriting()) {
+    ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
+    Size = Slots.size();
+    error(IO.mapInteger(Size));
+
+    for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
+      uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
+      if ((SlotIndex + 1) < Slots.size()) {
+        Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
+      }
+      error(IO.mapInteger(Byte));
+    }
+  } else {
+    error(IO.mapInteger(Size));
+    for (uint16_t I = 0; I < Size; I += 2) {
+      uint8_t Byte;
+      error(IO.mapInteger(Byte));
+      Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));
+      if ((I + 1) < Size)
+        Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));
+    }
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {
+  error(IO.mapInteger(Record.CompleteClass));
+  error(IO.mapInteger(Record.OverriddenVFTable));
+  error(IO.mapInteger(Record.VFPtrOffset));
+  uint32_t NamesLen = 0;
+  if (IO.isWriting()) {
+    for (auto Name : Record.MethodNames)
+      NamesLen += Name.size() + 1;
+  }
+  error(IO.mapInteger(NamesLen));
+  error(IO.mapVectorTail(Record.MethodNames, MapStringZ()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {
+  error(IO.mapInteger(Record.Id));
+  error(IO.mapStringZ(Record.String));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          UdtSourceLineRecord &Record) {
+  error(IO.mapInteger(Record.UDT));
+  error(IO.mapInteger(Record.SourceFile));
+  error(IO.mapInteger(Record.LineNumber));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          UdtModSourceLineRecord &Record) {
+  error(IO.mapInteger(Record.UDT));
+  error(IO.mapInteger(Record.SourceFile));
+  error(IO.mapInteger(Record.LineNumber));
+  error(IO.mapInteger(Record.Module));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {
+  error(IO.mapInteger(Record.ParentScope));
+  error(IO.mapInteger(Record.FunctionType));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MemberFuncIdRecord &Record) {
+  error(IO.mapInteger(Record.ClassType));
+  error(IO.mapInteger(Record.FunctionType));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          BuildInfoRecord &Record) {
+  error(IO.mapVectorN<uint16_t>(Record.ArgIndices, MapInteger()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MethodOverloadListRecord &Record) {
+  // TODO: Split the list into multiple records if it's longer than 64KB, using
+  // a subrecord of TypeRecordKind::Index to chain the records together.
+  error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          FieldListRecord &Record) {
+  error(IO.mapByteVectorTail(Record.Data));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          TypeServer2Record &Record) {
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          BaseClassRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapEncodedInteger(Record.Offset));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          EnumeratorRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+
+  // FIXME: Handle full APInt such as __int128.
+  error(IO.mapEncodedInteger(Record.Value));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          DataMemberRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapEncodedInteger(Record.FieldOffset));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          OverloadedMethodRecord &Record) {
+  error(IO.mapInteger(Record.NumOverloads));
+  error(IO.mapInteger(Record.MethodList));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          OneMethodRecord &Record) {
+  MapOneMethodRecord Mapper(false);
+  return Mapper(IO, Record);
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          NestedTypeRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          StaticDataMemberRecord &Record) {
+
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          VirtualBaseClassRecord &Record) {
+
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.BaseType));
+  error(IO.mapInteger(Record.VBPtrType));
+  error(IO.mapEncodedInteger(Record.VBPtrOffset));
+  error(IO.mapEncodedInteger(Record.VTableIndex));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          VFPtrRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.Type));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          ListContinuationRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.ContinuationIndex));
+
+  return Error::success();
+}

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

private:
   template <typename RecordType>
   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().
-    TypeVisitorCallbackPipeline Pipeline;
-    TypeDeserializer Deserializer;
-
-    Pipeline.addCallbackToPipeline(Deserializer);
-    Pipeline.addCallbackToPipeline(*this);
-
-    CVTypeVisitor Visitor(Pipeline);
+    CVTypeVisitor Visitor(*this);
 
     if (auto EC = Visitor.visitFieldListMemberStream(Record.Data))
       return EC;
     return Error::success();
   }
 
   template <typename RecordType>
   Error visitKnownMemberRecordImpl(RecordType &Record) {

lib/DebugInfo/CodeView/TypeTableBuilder.cpp

TypeIndex TypeTableBuilder::writeKnownType(const ArgListRecord &Record) {
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeKnownType(const PointerRecord &Record) {
   TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getReferentType());
-  uint32_t flags = static_cast<uint32_t>(Record.getOptions()) |
-                   (Record.getSize() << PointerRecord::PointerSizeShift) |
-                   (static_cast<uint32_t>(Record.getMode())
-                    << PointerRecord::PointerModeShift) |
-                   (static_cast<uint32_t>(Record.getPointerKind())
-                    << PointerRecord::PointerKindShift);
-  Builder.writeUInt32(flags);
+  Builder.writeUInt32(Record.Attrs);
 
   if (Record.isPointerToMember()) {
     const MemberPointerInfo &M = Record.getMemberInfo();
     Builder.writeTypeIndex(M.getContainingType());
     Builder.writeUInt16(static_cast<uint16_t>(M.getRepresentation()));
   }
 
   return writeRecord(Builder);

lib/DebugInfo/MSF/StreamWriter.cpp

 
 Error StreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) {
   if (auto EC = Stream.writeBytes(Offset, Buffer))
     return EC;
   Offset += Buffer.size();
   return Error::success();
 }
 
+Error StreamWriter::writeInteger(uint8_t Int) { return writeObject(Int); }
+
 Error StreamWriter::writeInteger(uint16_t Int) {
   return writeObject(support::ulittle16_t(Int));
 }
 
 Error StreamWriter::writeInteger(uint32_t Int) {
   return writeObject(support::ulittle32_t(Int));
 }
 
+Error StreamWriter::writeInteger(uint64_t Int) {
+  return writeObject(support::ulittle64_t(Int));
+}
+
+Error StreamWriter::writeInteger(int8_t Int) { return writeObject(Int); }
+
+Error StreamWriter::writeInteger(int16_t Int) {
+  return writeObject(support::little16_t(Int));
+}
+
+Error StreamWriter::writeInteger(int32_t Int) {
+  return writeObject(support::little32_t(Int));
+}
+
+Error StreamWriter::writeInteger(int64_t Int) {
+  return writeObject(support::little64_t(Int));
+}
+
 Error StreamWriter::writeZeroString(StringRef Str) {
   if (auto EC = writeFixedString(Str))
     return EC;
   if (auto EC = writeObject('\0'))
     return EC;
 
   return Error::success();
 }

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

 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:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            apartment
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2
 YAML:             Name:            single
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           3
 YAML:             Name:            free
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           4
 YAML:             Name:            neutral
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:         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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4104
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           0
 YAML:             Name:            native
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            com
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:         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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4115
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4116
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Type:            4109
 YAML:             FieldOffset:     0
 YAML:             Name:            type
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           0
 YAML:             Name:            never
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            allowed
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:         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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4126
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           0
 YAML:             Name:            speed
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:         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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4137
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Type:            4130
 YAML:             FieldOffset:     0
 YAML:             Name:            type
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4132
 YAML:             FieldOffset:     4
 YAML:             Name:            optimize
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            dll
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2
 YAML:             Name:            exe
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           3
 YAML:             Name:            service
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           4
 YAML:             Name:            unspecified
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2
 YAML:             Name:            EXE
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:         Attrs:           32778
 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:         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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4150
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            ''
 YAML:           - Type:            4151
-YAML:             Kind:            Vanilla
-YAML:             Options:         [ None ]
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Type:            4142
 YAML:             FieldOffset:     0
 YAML:             Name:            type
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     4
 YAML:             Name:            name
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     8
 YAML:             Name:            version
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     12
 YAML:             Name:            uuid
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            116
 YAML:             FieldOffset:     16
 YAML:             Name:            lcid
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            48
 YAML:             FieldOffset:     20
 YAML:             Name:            control
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     24
 YAML:             Name:            helpstring
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            116
 YAML:             FieldOffset:     28
 YAML:             Name:            helpstringcontext
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     32
 YAML:             Name:            helpstringdll
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     36
 YAML:             Name:            helpfile
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            116
 YAML:             FieldOffset:     40
 YAML:             Name:            helpcontext
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            48
 YAML:             FieldOffset:     44
 YAML:             Name:            hidden
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            48
 YAML:             FieldOffset:     45
 YAML:             Name:            restricted
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Type:            4146
 YAML:             FieldOffset:     48
 YAML:             Name:            custom
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           0
 YAML:             Name:            eAnyUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            eCoClassUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2
 YAML:             Name:            eCOMInterfaceUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           6
 YAML:             Name:            eInterfaceUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           8
 YAML:             Name:            eMemberUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           16
 YAML:             Name:            eMethodUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           32
 YAML:             Name:            eInterfaceMethodUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           64
 YAML:             Name:            eInterfaceMemberUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           128
 YAML:             Name:            eCoClassMemberUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           256
 YAML:             Name:            eCoClassMethodUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           768
 YAML:             Name:            eGlobalMethodUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1024
 YAML:             Name:            eGlobalDataUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2048
 YAML:             Name:            eClassUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           4096
 YAML:             Name:            eInterfaceParameterUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           12288
 YAML:             Name:            eMethodParameterUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           16384
 YAML:             Name:            eIDLModuleUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           -32768
 YAML:             Name:            eAnonymousUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           65536
 YAML:             Name:            eTypedefUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           131072
 YAML:             Name:            eUnionUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           262144
 YAML:             Name:            eEnumUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           524288
 YAML:             Name:            eDefineTagUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1048576
 YAML:             Name:            eStructUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2097152
 YAML:             Name:            eLocalUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           4194304
 YAML:             Name:            ePropertyUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           8388608
 YAML:             Name:            eEventUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           16777216
 YAML:             Name:            eTemplateUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           16777216
 YAML:             Name:            eModuleUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           33554432
 YAML:             Name:            eIllegalUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           67108864
 YAML:             Name:            eAsynchronousUsage
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            usageAttribute
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:             Attrs:           3
 YAML:             Value:           0
 YAML:             Name:            eBoolean
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           1
 YAML:             Name:            eInteger
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 YAML:             Value:           2
 YAML:             Name:            eFloat
 YAML:         - Kind:            LF_ENUMERATE
 YAML:           Enumerator:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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:         Attrs:           33802
 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:             Attrs:           3
 YAML:             VFTableOffset:   -1
 YAML:             Name:            v1_alttypeAttribute
 YAML:         - Kind:            LF_MEMBER
 YAML:           DataMember:      
-YAML:             Access:          Public
+YAML:             Attrs:           3
 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: ...

tools/llvm-pdbdump/YamlTypeDumper.cpp

 }
 
 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<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.mapRequired("Attrs", Ptr.Attrs);
   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<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("Attrs", Method.Attrs.Attrs);
   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("Attrs", Field.Attrs.Attrs);
   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("Attrs", Field.Attrs.Attrs);
   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("Attrs", Enum.Attrs.Attrs);
   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("Attrs", Base.Attrs.Attrs);
   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("Attrs", Base.Attrs.Attrs);
   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) {

 namespace llvm {
 namespace yaml {
 template <>
 struct MappingContextTraits<pdb::yaml::PdbTpiFieldListRecord,
                             pdb::yaml::SerializationContext> {
   static void mapping(IO &IO, pdb::yaml::PdbTpiFieldListRecord &Obj,
                       pdb::yaml::SerializationContext &Context) {
     codeview::TypeVisitorCallbackPipeline Pipeline;
-    codeview::TypeDeserializer Deserializer;
+
+    msf::ByteStream Data(Obj.Record.Data);
+    msf::StreamReader FieldReader(Data);
+    codeview::FieldListDeserializer Deserializer(FieldReader);
     codeview::TypeSerializationVisitor Serializer(Context.FieldListBuilder,
                                                   Context.TypeTableBuilder);
     pdb::TpiHashUpdater Hasher;
 
     if (IO.outputting()) {
       // For PDB to Yaml, deserialize into a high level record type, then dump
       // it.
       Pipeline.addCallbackToPipeline(Deserializer);