[codeview] Add a type visitor to help abstract away type stream handling

[rnk]

Summary

Port the dumper in llvm-readobj over to it.

I'm planning to use this visitor to power type stream merging.

While we're at it, try to switch from StringRef to ArrayRef<uint8_t> in some
places.

[amccarth]

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

39

s/does nothing/they do nothing/

40

delete comma

58

I would avoid these repeated casts by doing it once and saving the result:

auto DerivedThis = static_cast<Derived *>(this);

66

I'd put the default either first or last.

70

I realize the mechanical style rules call for this level of indentation, but it seems the intent would be clearer if this were indented to match the other cases.

78

#undef TYPE_RECORD

Oh, but that might mess up the other visitor loops below. Yuck. This macro looks tightly scoped, but it really isn't.

83

Is there any harm in just calling skipPadding here? We do that already for field lists.

Also, this comment is copied from the iterator. It seems like it should be in only one place, and I think it makes most sense in the iterator code.

107

I'm not clear what you mean by "By default." This looks like it always visits the members one by one. Do you mean that the derived class may override this method to get other behavior?

129

#undef MEMBER_RECORD

137

For the benefit of people making a derived class, I'd make this comment emphasize that processing will stop after the first unknown member. "Action to take on unknown members" suggests that this will be called for each unknown member.

tools/llvm-readobj/COFFDumper.cpp

1284

Typo: remove the t in the midst of decodeNumerictLeaf.

1999

It makes me sad that this formatting detail is back out at this level.

[zturner]

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

30–36

In the future we could get rid of this entirely and use the StreamReader interface in DebugInfoPDB. It wouldn't work right now and some refactoring would have to happen, but I think the design of it is flexible enough to support this in theory.

69

How about moving this #define before the switch statement so it doesn't mess up the indentation?

include/llvm/DebugInfo/CodeView/TypeRecords.def

20–22

Why do we need these _ALIAS macros? They seem to do nothing, why not just use TYPE_RECORD() everywhere?

[rnk]

Thanks! New patch coming

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

30–36

I agree, we need something that lets us read records from a possibly non-contiguous stream like those in PDBs.

66

done, I didn't like it after the macro goo

78

It is tightly scoped, it's undef'd by the .def file. It's confusing, but it is the standard pattern you see in places like include/llvm/IR/Metadata.def.

83

Oops, yeah that's the responsibility of the iterator.

107

That was the idea, but I don't think there's a real use case for it. I should rewrite this comment to remove that implication.

129

not needed

include/llvm/DebugInfo/CodeView/TypeRecords.def

20–22

I do this with them when stamping out declarations of the visit##ClassType methods:

#define TYPE_RECORD_ALIAS(ClassName, LeafEnum)

Otherwise we end up re-declaring things like void visitBaseClass(... const BaseClass *Rec, ...) multiple times.

The alternative to this might be variadic macros, which would let us emit cases like this, but I felt like that was too much metaprogramming:

case LF_BCLASS:
case LF_IBCLASS: { ... }

tools/llvm-readobj/COFFDumper.cpp

1284

That's a pre-existing issue. I thought maybe David Majnemer did it intentionally, but I'm not sure. I'll ask him and fix this separately, either way.

1999

Well, the magic isn't part of the stream in the PDB, so we were going to need to do this eventually.

I should use the consumeUInt32 helper though...

[rnk]

• Address review comments

[amccarth]

LGTM

include/llvm/DebugInfo/CodeView/CVLeafTypes.def

 LEAF_TYPE(LF_POINTER_16t, 0x0002)
 LEAF_TYPE(LF_ARRAY_16t, 0x0003)
 LEAF_TYPE(LF_CLASS_16t, 0x0004)
 LEAF_TYPE(LF_STRUCTURE_16t, 0x0005)
 LEAF_TYPE(LF_UNION_16t, 0x0006)
 LEAF_TYPE(LF_ENUM_16t, 0x0007)
 LEAF_TYPE(LF_PROCEDURE_16t, 0x0008)
 LEAF_TYPE(LF_MFUNCTION_16t, 0x0009)
-LEAF_TYPE(LF_VTSHAPE, 0x000a)
+KNOWN_TYPE(LF_VTSHAPE, 0x000a, VTableShape)
 LEAF_TYPE(LF_COBOL0_16t, 0x000b)
 LEAF_TYPE(LF_COBOL1, 0x000c)
 LEAF_TYPE(LF_BARRAY_16t, 0x000d)
 LEAF_TYPE(LF_LABEL, 0x000e)
 LEAF_TYPE(LF_NULLLEAF, 0x000f) // LF_NULL
 LEAF_TYPE(LF_NOTTRAN, 0x0010)
 LEAF_TYPE(LF_DIMARRAY_16t, 0x0011)
 LEAF_TYPE(LF_VFTPATH_16t, 0x0012)

 LEAF_TYPE(LF_NESTTYPE_16t, 0x0409)
 LEAF_TYPE(LF_VFUNCTAB_16t, 0x040a)
 LEAF_TYPE(LF_FRIENDCLS_16t, 0x040b)
 LEAF_TYPE(LF_ONEMETHOD_16t, 0x040c)
 LEAF_TYPE(LF_VFUNCOFF_16t, 0x040d)
 
 LEAF_TYPE(LF_TI16_MAX, 0x1000)
 
-LEAF_TYPE(LF_MODIFIER, 0x1001)
-LEAF_TYPE(LF_POINTER, 0x1002)
+KNOWN_TYPE(LF_MODIFIER, 0x1001, TypeModifier)
+KNOWN_TYPE(LF_POINTER, 0x1002, PointerType)
 LEAF_TYPE(LF_ARRAY_ST, 0x1003)
 LEAF_TYPE(LF_CLASS_ST, 0x1004)
 LEAF_TYPE(LF_STRUCTURE_ST, 0x1005)
 LEAF_TYPE(LF_UNION_ST, 0x1006)
 LEAF_TYPE(LF_ENUM_ST, 0x1007)
 KNOWN_TYPE(LF_PROCEDURE, 0x1008, ProcedureType)
 KNOWN_TYPE(LF_MFUNCTION, 0x1009, MemberFunctionType)
 LEAF_TYPE(LF_COBOL0, 0x100a)

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

+//===- CVTypeVisitor.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
+#define LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeStream.h"
+
+namespace llvm {
+namespace codeview {
+
+template <typename Derived>
+class CVTypeVisitor {
+public:
+  CVTypeVisitor() {}
+
+  bool hadError() const { return HadError; }
+
+  template <typename T>
+  bool consumeObject(ArrayRef<uint8_t> &Data, const T *&Res) {
+    if (Data.size() < sizeof(*Res)) {
+      HadError = true;
+      return false;
+    }
+    Res = reinterpret_cast<const T *>(Data.data());
+    Data = Data.drop_front(sizeof(*Res));
+    return true;
+  }
+
+  /// Actions to take on known types. By default, does nothing. Regular type
+  /// records describe their own lengths, and take LeafData as is.
+  /// FIXME: Avoid making FieldData in-out to make the visitor easier to use.
+#define TYPE_RECORD(ClassName, LeafEnum)                                       \
+  void visit##ClassName(TypeLeafKind LeafType, const ClassName *Record,        \
+                        ArrayRef<uint8_t> LeafData) {}
+#define TYPE_RECORD_ALIAS(ClassName, LeafEnum)
+#define MEMBER_RECORD(ClassName, LeafEnum)                                     \
+  void visit##ClassName(TypeLeafKind LeafType, const ClassName *Record,        \
+                        ArrayRef<uint8_t> &FieldData) {}
+#define MEMBER_RECORD_ALIAS(ClassName, LeafEnum)
+#include "TypeRecords.def"
+
+  /// Visits the type records in Data, and returns remaining data. Sets the
+  /// error flag on parse failures.
+  void visitTypeStream(ArrayRef<uint8_t> Data) {
+    for (const auto &I : makeTypeRange(Data)) {
+      ArrayRef<uint8_t> LeafData = I.LeafData;
+      ArrayRef<uint8_t> RecordData = LeafData;
+      static_cast<Derived *>(this)->visitTypeBegin(I.Leaf, RecordData);
+      switch (I.Leaf) {
+      case LF_FIELDLIST:
+        static_cast<Derived *>(this)->visitFieldList(I.Leaf, LeafData);
+        break;
+      case LF_METHODLIST:
+        static_cast<Derived *>(this)->visitMethodList(I.Leaf, LeafData);
+        break;
+      default:
+        static_cast<Derived *>(this)->visitUnknownType(I.Leaf);
+        break;
+#define TYPE_RECORD(ClassName, LeafEnum)                                       \
+  case LeafEnum: {                                                             \
+    const ClassName *Rec;                                                      \
+    if (!CVTypeVisitor::consumeObject(LeafData, Rec))                          \
+      return;                                                                  \
+    static_cast<Derived *>(this)->visit##ClassName(I.Leaf, Rec, LeafData);     \
+    break;                                                                     \
+  }
+#include "TypeRecords.def"
+      }
+      static_cast<Derived *>(this)->visitTypeEnd(I.Leaf, RecordData);
+
+      // FIXME: Documentation suggests that one day we may need to ignore LF_PAD
+      // bytes here. All tested versions of MSVC include LF_PAD bytes in
+      // LeafData, though. If we find them, call skipPadding.
+    }
+  }
+
+  /// Action to take on unknown types. By default, they are ignored.
+  void visitUnknownType(TypeLeafKind Leaf) {}
+
+  /// Paired begin/end actions for all types. Receives all record data,
+  /// including the fixed-length record prefix.
+  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {}
+  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {}
+
+  static ArrayRef<uint8_t> skipPadding(ArrayRef<uint8_t> Data) {
+    if (Data.empty())
+      return Data;
+    uint8_t Leaf = Data.front();
+    if (Leaf < LF_PAD0)
+      return Data;
+    // Leaf is greater than 0xf0. We should advance by the number of bytes in
+    // the low 4 bits.
+    return Data.drop_front(Leaf & 0x0F);
+  }
+
+  /// Action to take on field lists. By default, we visit the members one by
+  /// one.
+  void visitFieldList(TypeLeafKind Leaf, ArrayRef<uint8_t> FieldData) {
+    while (!FieldData.empty()) {
+      const ulittle16_t *LeafPtr;
+      if (!CVTypeVisitor::consumeObject(FieldData, LeafPtr))
+        return;
+      TypeLeafKind Leaf = TypeLeafKind(unsigned(*LeafPtr));
+      switch (Leaf) {
+      default:
+        // Field list records do not describe their own length, so we cannot
+        // continue parsing past an unknown member type.
+        visitUnknownMember(Leaf);
+        HadError = true;
+        return;
+#define MEMBER_RECORD(ClassName, LeafEnum)                                     \
+  case LeafEnum: {                                                             \
+    const ClassName *Rec;                                                      \
+    if (!CVTypeVisitor::consumeObject(FieldData, Rec))                         \
+      return;                                                                  \
+    static_cast<Derived *>(this)->visit##ClassName(Leaf, Rec, FieldData);      \
+    break;                                                                     \
+  }
+#include "TypeRecords.def"
+      }
+      FieldData = skipPadding(FieldData);
+    }
+  }
+
+  void visitMethodList(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData) {}
+
+  /// Action to take on unknown members. By default, they are ignored.
+  void visitUnknownMember(TypeLeafKind Leaf) {}
+
+private:
+  /// Whether a type stream parsing error was encountered.
+  bool HadError = false;
+};
+
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H

include/llvm/DebugInfo/CodeView/TypeRecords.def

+
+//===-- CVLeafTypes.def - All CodeView leaf types ---------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// See LEAF_ENUM_e in cvinfo.h. This should match the constants there.
+//
+//===----------------------------------------------------------------------===//
+
+// If the type is known, then we have a record describing it in TypeRecord.h.
+#ifndef TYPE_RECORD
+#define TYPE_RECORD(ClassName, LeafEnum)
+#endif
+
+#ifndef TYPE_RECORD_ALIAS
+#define TYPE_RECORD_ALIAS(ClassName, LeafEnum) TYPE_RECORD(ClassName, LeafEnum)
+#endif
+
+#ifndef MEMBER_RECORD
+#define MEMBER_RECORD(ClassName, LeafEnum) TYPE_RECORD(ClassName, LeafEnum)
+#endif
+
+#ifndef MEMBER_RECORD_ALIAS
+#define MEMBER_RECORD_ALIAS(ClassName, LeafEnum) MEMBER_RECORD(ClassName, LeafEnum)
+#endif
+
+
+TYPE_RECORD(PointerType, LF_POINTER)
+TYPE_RECORD(TypeModifier, LF_MODIFIER)
+TYPE_RECORD(ProcedureType, LF_PROCEDURE)
+TYPE_RECORD(MemberFunctionType, LF_MFUNCTION)
+TYPE_RECORD(ArgList, LF_ARGLIST)
+
+TYPE_RECORD(ArrayType, LF_ARRAY)
+TYPE_RECORD(ClassType, LF_CLASS)
+TYPE_RECORD_ALIAS(ClassType, LF_STRUCTURE)
+TYPE_RECORD_ALIAS(ClassType, LF_INTERFACE)
+TYPE_RECORD(UnionType, LF_UNION)
+TYPE_RECORD(EnumType, LF_ENUM)
+TYPE_RECORD(TypeServer2, LF_TYPESERVER2)
+TYPE_RECORD(VFTableType, LF_VFTABLE)
+TYPE_RECORD(VTableShape, LF_VTSHAPE)
+
+// Member type records. These are generally not length prefixed, and appear
+// inside of a field list record.
+MEMBER_RECORD(BaseClass, LF_BCLASS)
+MEMBER_RECORD_ALIAS(BaseClass, LF_BINTERFACE)
+MEMBER_RECORD(VirtualBaseClass, LF_VBCLASS)
+MEMBER_RECORD_ALIAS(VirtualBaseClass, LF_IVBCLASS)
+MEMBER_RECORD(VirtualFunctionPointer, LF_VFUNCTAB)
+MEMBER_RECORD(StaticDataMember, LF_STMEMBER)
+MEMBER_RECORD(OverloadedMethod, LF_METHOD)
+MEMBER_RECORD(DataMember, LF_MEMBER)
+MEMBER_RECORD(NestedType, LF_NESTTYPE)
+MEMBER_RECORD(OneMethod, LF_ONEMETHOD)
+MEMBER_RECORD(Enumerator, LF_ENUMERATE)
+
+// ID leaf records. Subsequent leaf types may be referenced from .debug$S.
+
+TYPE_RECORD(FuncId, LF_FUNC_ID)
+TYPE_RECORD(MemberFuncId, LF_MFUNC_ID)
+TYPE_RECORD(BuildInfo, LF_BUILDINFO)
+TYPE_RECORD_ALIAS(ArgList, LF_SUBSTR_LIST)
+TYPE_RECORD(StringId, LF_STRING_ID)
+TYPE_RECORD(UDTSrcLine, LF_UDT_SRC_LINE)
+
+#undef TYPE_RECORD
+#undef TYPE_RECORD_ALIAS
+#undef MEMBER_RECORD
+#undef MEMBER_RECORD_ALIAS

include/llvm/DebugInfo/CodeView/TypeStream.h

 }
 
 // A const input iterator interface to the CodeView type stream.
 class TypeIterator {
 public:
   struct TypeRecord {
     std::size_t Length;
     TypeLeafKind Leaf;
-    StringRef LeafData;
+    ArrayRef<uint8_t> LeafData;
   };
 
-  explicit TypeIterator(const StringRef &SectionData)
+  explicit TypeIterator(const ArrayRef<uint8_t> &SectionData)
       : Data(SectionData), AtEnd(false) {
     next(); // Prime the pump
   }
 
   TypeIterator() : AtEnd(true) {}
 
   // For iterators to compare equal, they must both point at the same record
   // in the same data stream, or they must both be at the end of a stream.
private:
   void next() {
     assert(!AtEnd && "Attempted to advance more than one past the last rec");
     if (Data.empty()) {
       // We've advanced past the last record.
       AtEnd = true;
       return;
     }
 
-    const TypeRecordPrefix *Rec;
-    if (consumeObject(Data, Rec))
+    // FIXME: Use consumeObject when it deals in ArrayRef<uint8_t>.
+    if (Data.size() < sizeof(TypeRecordPrefix))
       return;
+    const auto *Rec = reinterpret_cast<const TypeRecordPrefix *>(Data.data());
+    Data = Data.drop_front(sizeof(TypeRecordPrefix));
+
     Current.Length = Rec->Len;
     Current.Leaf = static_cast<TypeLeafKind>(uint16_t(Rec->Leaf));
-    Current.LeafData = Data.substr(0, Current.Length - 2);
+    Current.LeafData = Data.slice(0, Current.Length - 2);
 
     // The next record starts immediately after this one.
     Data = Data.drop_front(Current.LeafData.size());
 
     // FIXME: The stream contains LF_PAD bytes that we need to ignore, but those
     // are typically included in LeafData. We may need to call skipPadding() if
     // we ever find a record that doesn't count those bytes.
 
     return;
   }
 
-  StringRef Data;
+  ArrayRef<uint8_t> Data;
   TypeRecord Current;
   bool AtEnd;
 };
 
-inline iterator_range<TypeIterator> makeTypeRange(StringRef Data) {
+inline iterator_range<TypeIterator> makeTypeRange(ArrayRef<uint8_t> Data) {
   return make_range(TypeIterator(Data), TypeIterator());
 }
-}
-}
+
+} // end namespace codeview
+} // end namespace llvm
 
 #endif

tools/llvm-readobj/COFFDumper.cpp

 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "Win64EHDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeStream.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ObjectFile.h"

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::codeview;
 using namespace llvm::support;
 using namespace llvm::Win64EH;
 
 namespace {
 
-class CVTypeDumper {
+class CVTypeDumper : public CVTypeVisitor<CVTypeDumper> {
 public:
   CVTypeDumper(ScopedPrinter &W) : W(W) {}
 
   StringRef getTypeName(TypeIndex TI);
   void printTypeIndex(StringRef FieldName, TypeIndex TI);
 
   void dump(StringRef Data);
 
+  /// CVTypeVisitor overrides.
+#define TYPE_RECORD(ClassName, LeafEnum)                                       \
+  void visit##ClassName(TypeLeafKind LeafType, const ClassName *Record,        \
+                        ArrayRef<uint8_t> LeafData);
+#define TYPE_RECORD_ALIAS(ClassName, LeafEnum)
+#define MEMBER_RECORD(ClassName, LeafEnum)                                     \
+  void visit##ClassName(TypeLeafKind LeafType, const ClassName *Record,        \
+                        ArrayRef<uint8_t> &FieldData);
+#define MEMBER_RECORD_ALIAS(ClassName, LeafEnum)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+
+  /// Method overload lists are a special case.
+  void visitMethodList(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
+
+  void visitUnknownMember(TypeLeafKind Leaf);
+
+  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
+  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
+
 private:
-  void printCodeViewFieldList(StringRef FieldData);
   void printMemberAttributes(MemberAttributes Attrs);
 
+  /// Reinterpret a byte array as an array of characters. Does not interpret as
+  /// a C string, as StringRef has several helpers (split) that make that easy.
+  static StringRef getBytesAsCharacters(ArrayRef<uint8_t> LeafData) {
+    return StringRef(reinterpret_cast<const char *>(LeafData.data()),
+                     LeafData.size());
+  }
+
+  static StringRef getBytesAsCString(ArrayRef<uint8_t> LeafData) {
+    return getBytesAsCharacters(LeafData).split('\0').first;
+  }
+
   ScopedPrinter &W;
 
+  /// Name of the current type. Only valid before visitTypeEnd.
+  StringRef Name;
+
   /// All user defined type records in .debug$T live in here. Type indices
   /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to
   /// index into this vector.
   SmallVector<StringRef, 10> CVUDTNames;
 
   StringSet<> TypeNames;
 };
 
while (DE.isValidOffset(Offset)) {
              LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) {
           DE.getU32(&Offset);
         }
       }
     }
   }
 }
 
-static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
+static std::error_code decodeNumerictLeaf(ArrayRef<uint8_t> &Data,
+                                          APSInt &Num) {
   // Used to avoid overload ambiguity on APInt construtor.
   bool FalseVal = false;
   if (Data.size() < 2)
     return object_error::parse_failed;
   uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
   Data = Data.drop_front(2);
   if (Short < LF_NUMERIC) {
     Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
Num = APSInt(APInt(/*numBits=*/64,
                        /*isSigned=*/false),
                  /*isUnsigned=*/true);
     Data = Data.drop_front(8);
     return std::error_code();
   }
   return object_error::parse_failed;
 }
 
+static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
+  ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()),
+                          Data.size());
+  auto EC = decodeNumerictLeaf(Bytes, Num);
+  Data = StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size());
+  return EC;
+}
+
 /// Decode an unsigned integer numeric leaf value.
-std::error_code decodeUIntLeaf(StringRef &Data, uint64_t &Num) {
+std::error_code decodeUIntLeaf(ArrayRef<uint8_t> &Data, uint64_t &Num) {
   APSInt N;
   if (std::error_code err = decodeNumerictLeaf(Data, N))
     return err;
   if (N.isSigned() || !N.isIntN(64))
     return object_error::parse_failed;
   Num = N.getLimitedValue();
   return std::error_code();
 }
 
+
 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
                                                 const SectionRef &Section,
                                                 StringRef SectionContents) {
   if (Subsection.size() < sizeof(SymRecord))
     return error(object_error::parse_failed);
 
   const coff_section *Sec = Obj->getCOFFSection(Section);
 
if (HasExtraFiles) {
         uint32_t FileID;
         error(consumeUInt32(Data, FileID));
         printFileNameForOffset("FileID", FileID);
       }
     }
   }
 }
 
-StringRef getLeafDataBytesAsString(StringRef LeafData) {
-  StringRef Leading;
-  std::tie(Leading, std::ignore) = LeafData.split('\0');
-  return Leading;
-}
-
 StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   if (TI.isNoType())
     return "<no type>";
 
   if (TI.isSimple()) {
     // This is a simple type.
     for (const auto &SimpleTypeName : SimpleTypeNames) {
       if (SimpleTypeName.Value == TI.getSimpleKind()) {
#define KNOWN_TYPE(LeafName, Value, ClassName) \
   case LeafName: return #ClassName;
 #include "llvm/DebugInfo/CodeView/CVLeafTypes.def"
   default:
     break;
   }
   return "UnknownLeaf";
 }
 
-
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   StringRef Data;
   error(Section.getContents(Data));
   if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
+
+  if (Data.size() > 4) {
+    unsigned Magic = *reinterpret_cast<const ulittle32_t *>(Data.data());
+    W.printHex("Magic", Magic);
+    Data = Data.drop_front(4);
+  }
+
   CVTD.dump(Data);
 }
 
 void CVTypeDumper::dump(StringRef Data) {
-  uint32_t Magic;
-  if (consumeUInt32(Data, Magic))
-    return;
-  if (Magic != COFF::DEBUG_SECTION_MAGIC)
-    return;
+  ArrayRef<uint8_t> BinaryData(reinterpret_cast<const uint8_t *>(Data.data()),
+                               Data.size());
+  visitTypeStream(BinaryData);
+  if (hadError())
+    error(object_error::parse_failed);
+}
 
-  W.printHex("Magic", Magic);
-  for (const auto &Record : makeTypeRange(Data)) {
-    StringRef LeafData = Record.LeafData;
+void CVTypeDumper::visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData) {
+  // Reset Name to the empty string. If the visitor sets it, we know it.
+  Name = "";
 
-    // Find the name of this leaf type.
-    StringRef LeafName = getLeafTypeName(Record.Leaf);
-    DictScope S(W, LeafName);
-    unsigned NextTypeIndex = 0x1000 + CVUDTNames.size();
-    W.printEnum("TypeLeafKind", unsigned(Record.Leaf),
-                makeArrayRef(LeafTypeNames));
-    W.printHex("TypeIndex", NextTypeIndex);
+  W.startLine() << getLeafTypeName(Leaf) << " {\n";
+  W.indent();
+  W.printEnum("TypeLeafKind", unsigned(Leaf), makeArrayRef(LeafTypeNames));
+  W.flush();
+}
 
-    // Fill this in inside the switch to get something in CVUDTNames.
-    StringRef Name;
+void CVTypeDumper::visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData) {
+  // Always record some name for every type, even if Name is empty, since
+  // CVUDTNames is indexed by TypeIndex.
+  CVUDTNames.push_back(Name);
 
-    switch (Record.Leaf) {
-    default: {
-      W.printHex("Size", Record.Length);
-      break;
-    }
+  if (opts::CodeViewSubsectionBytes)
+    W.printBinaryBlock("LeafData", getBytesAsCharacters(LeafData));
+
+  W.unindent();
+  W.startLine() << "}\n";
+  W.flush();
 
-    case LF_STRING_ID: {
-      const StringId *String;
-      error(consumeObject(LeafData, String));
-      W.printHex("Id", String->id.getIndex());
-      StringRef StringData = getLeafDataBytesAsString(LeafData);
-      W.printString("StringData", StringData);
-      // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
-      Name = StringData;
-      break;
-    }
-
-    case LF_FIELDLIST: {
-      W.printHex("Size", Record.Length);
-      // FieldList has no fixed prefix that can be described with a struct. All
-      // the bytes must be interpreted as more records.
-      printCodeViewFieldList(LeafData);
-      break;
-    }
+void CVTypeDumper::visitStringId(TypeLeafKind Leaf, const StringId *String,
+                                 ArrayRef<uint8_t> LeafData) {
+  StringRef StringData = getBytesAsCString(LeafData);
 
-    case LF_ARGLIST:
-    case LF_SUBSTR_LIST: {
-      const ArgList *Args;
-      error(consumeObject(LeafData, Args));
-      W.printNumber("NumArgs", Args->NumArgs);
-      ListScope Arguments(W, "Arguments");
-      SmallString<256> TypeName("(");
-      for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) {
-        const TypeIndex *Type;
-        error(consumeObject(LeafData, Type));
-        printTypeIndex("ArgType", *Type);
-        StringRef ArgTypeName = getTypeName(*Type);
-        TypeName.append(ArgTypeName);
-        if (ArgI + 1 != Args->NumArgs)
-          TypeName.append(", ");
-      }
-      TypeName.push_back(')');
-      Name = TypeNames.insert(TypeName).first->getKey();
-      break;
-    }
+void CVTypeDumper::visitArgList(TypeLeafKind Leaf, const ArgList *Args,
+                                ArrayRef<uint8_t> LeafData) {
+    if (!consumeObject(LeafData, Type))
+      return;
 
-    case LF_CLASS:
-    case LF_STRUCTURE:
-    case LF_INTERFACE: {
-      const ClassType *Class;
-      error(consumeObject(LeafData, Class));
-      W.printNumber("MemberCount", Class->MemberCount);
-      uint16_t Props = Class->Properties;
-      W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
-      printTypeIndex("FieldList", Class->FieldList);
-      printTypeIndex("DerivedFrom", Class->DerivedFrom);
-      printTypeIndex("VShape", Class->VShape);
-      uint64_t SizeOf;
-      error(decodeUIntLeaf(LeafData, SizeOf));
-      W.printNumber("SizeOf", SizeOf);
-      StringRef LinkageName;
-      std::tie(Name, LinkageName) = LeafData.split('\0');
-      W.printString("Name", Name);
-      if (Props & uint16_t(ClassOptions::HasUniqueName)) {
-        LinkageName = getLeafDataBytesAsString(LinkageName);
-        if (LinkageName.empty())
-          return error(object_error::parse_failed);
-        W.printString("LinkageName", LinkageName);
-      }
-      break;
-    }
+void CVTypeDumper::visitClassType(TypeLeafKind Leaf, const ClassType *Class,
+                                  ArrayRef<uint8_t> LeafData) {
+  StringRef LeafChars = getBytesAsCharacters(LeafData);
+  std::tie(Name, LinkageName) = LeafChars.split('\0');
+    LinkageName = LinkageName.split('\0').first;
 
-    case LF_UNION: {
-      const UnionType *Union;
-      error(consumeObject(LeafData, Union));
-      W.printNumber("MemberCount", Union->MemberCount);
-      uint16_t Props = Union->Properties;
-      W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
-      printTypeIndex("FieldList", Union->FieldList);
-      uint64_t SizeOf;
-      error(decodeUIntLeaf(LeafData, SizeOf));
-      W.printNumber("SizeOf", SizeOf);
-      StringRef LinkageName;
-      std::tie(Name, LinkageName) = LeafData.split('\0');
-      W.printString("Name", Name);
-      if (Props & uint16_t(ClassOptions::HasUniqueName)) {
-        LinkageName = getLeafDataBytesAsString(LinkageName);
-        if (LinkageName.empty())
-          return error(object_error::parse_failed);
-        W.printString("LinkageName", LinkageName);
-      }
-      break;
-    }
+void CVTypeDumper::visitUnionType(TypeLeafKind Leaf, const UnionType *Union,
+                                  ArrayRef<uint8_t> LeafData) {
+  StringRef LeafChars = getBytesAsCharacters(LeafData);
+  std::tie(Name, LinkageName) = LeafChars.split('\0');
+    LinkageName = LinkageName.split('\0').first;
 
-    case LF_ENUM: {
-      const EnumType *Enum;
-      error(consumeObject(LeafData, Enum));
-      W.printNumber("NumEnumerators", Enum->NumEnumerators);
-      W.printFlags("Properties", uint16_t(Enum->Properties),
-                   makeArrayRef(ClassOptionNames));
-      printTypeIndex("UnderlyingType", Enum->UnderlyingType);
-      printTypeIndex("FieldListType", Enum->FieldListType);
-      Name = LeafData.split('\0').first;
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitEnumType(TypeLeafKind Leaf, const EnumType *Enum,
+                                 ArrayRef<uint8_t> LeafData) {
+  Name = getBytesAsCString(LeafData);
 
-    case LF_ARRAY: {
-      const ArrayType *AT;
-      error(consumeObject(LeafData, AT));
-      printTypeIndex("ElementType", AT->ElementType);
-      printTypeIndex("IndexType", AT->IndexType);
-      uint64_t SizeOf;
-      error(decodeUIntLeaf(LeafData, SizeOf));
-      W.printNumber("SizeOf", SizeOf);
-      Name = LeafData.split('\0').first;
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitArrayType(TypeLeafKind Leaf, const ArrayType *AT,
+                                  ArrayRef<uint8_t> LeafData) {
+  Name = getBytesAsCString(LeafData);
 
-    case LF_VFTABLE: {
-      const VFTableType *VFT;
-      error(consumeObject(LeafData, VFT));
-      printTypeIndex("CompleteClass", VFT->CompleteClass);
-      printTypeIndex("OverriddenVFTable", VFT->OverriddenVFTable);
-      W.printHex("VFPtrOffset", VFT->VFPtrOffset);
-      StringRef NamesData = LeafData.substr(0, VFT->NamesLen);
-      std::tie(Name, NamesData) = NamesData.split('\0');
-      W.printString("VFTableName", Name);
-      while (!NamesData.empty()) {
-        StringRef MethodName;
-        std::tie(MethodName, NamesData) = NamesData.split('\0');
-        W.printString("MethodName", MethodName);
-      }
-      break;
-    }
+void CVTypeDumper::visitVFTableType(TypeLeafKind Leaf, const VFTableType *VFT,
+                                    ArrayRef<uint8_t> LeafData) {
+  StringRef NamesData = getBytesAsCharacters(LeafData.slice(0, VFT->NamesLen));
 
-    case LF_MFUNC_ID: {
-      const MemberFuncId *Id;
-      error(consumeObject(LeafData, Id));
-      printTypeIndex("ClassType", Id->ClassType);
-      printTypeIndex("FunctionType", Id->FunctionType);
-      Name = LeafData.split('\0').first;
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitMemberFuncId(TypeLeafKind Leaf, const MemberFuncId *Id,
+                                     ArrayRef<uint8_t> LeafData) {
+  Name = getBytesAsCString(LeafData);
 
-    case LF_PROCEDURE: {
-      const ProcedureType *Proc;
-      error(consumeObject(LeafData, Proc));
-      printTypeIndex("ReturnType", Proc->ReturnType);
-      W.printEnum("CallingConvention", uint8_t(Proc->CallConv),
-                  makeArrayRef(CallingConventions));
-      W.printFlags("FunctionOptions", uint8_t(Proc->Options),
-                   makeArrayRef(FunctionOptionEnum));
-      W.printNumber("NumParameters", Proc->NumParameters);
-      printTypeIndex("ArgListType", Proc->ArgListType);
+void CVTypeDumper::visitProcedureType(TypeLeafKind Leaf,
+                                      const ProcedureType *Proc,
+                                      ArrayRef<uint8_t> LeafData) {
 
-      StringRef ReturnTypeName = getTypeName(Proc->ReturnType);
-      StringRef ArgListTypeName = getTypeName(Proc->ArgListType);
-      SmallString<256> TypeName(ReturnTypeName);
-      TypeName.push_back(' ');
-      TypeName.append(ArgListTypeName);
-      Name = TypeNames.insert(TypeName).first->getKey();
-      break;
-    }
 
-    case LF_MFUNCTION: {
-      const MemberFunctionType *MemberFunc;
-      error(consumeObject(LeafData, MemberFunc));
-      printTypeIndex("ReturnType", MemberFunc->ReturnType);
-      printTypeIndex("ClassType", MemberFunc->ClassType);
-      printTypeIndex("ThisType", MemberFunc->ThisType);
-      W.printEnum("CallingConvention", uint8_t(MemberFunc->CallConv),
-                  makeArrayRef(CallingConventions));
-      W.printFlags("FunctionOptions", uint8_t(MemberFunc->Options),
-                   makeArrayRef(FunctionOptionEnum));
-      W.printNumber("NumParameters", MemberFunc->NumParameters);
-      printTypeIndex("ArgListType", MemberFunc->ArgListType);
-      W.printNumber("ThisAdjustment", MemberFunc->ThisAdjustment);
+void CVTypeDumper::visitMemberFunctionType(TypeLeafKind Leaf,
+                                           const MemberFunctionType *MemberFunc,
+                                           ArrayRef<uint8_t> LeafData) {
 
-      StringRef ReturnTypeName = getTypeName(MemberFunc->ReturnType);
-      StringRef ClassTypeName = getTypeName(MemberFunc->ClassType);
-      StringRef ArgListTypeName = getTypeName(MemberFunc->ArgListType);
-      SmallString<256> TypeName(ReturnTypeName);
-      TypeName.push_back(' ');
-      TypeName.append(ClassTypeName);
-      TypeName.append("::");
-      TypeName.append(ArgListTypeName);
-      Name = TypeNames.insert(TypeName).first->getKey();
-      break;
-    }
 
-    case LF_METHODLIST: {
-      while (!LeafData.empty()) {
-        const MethodListEntry *Method;
-        error(consumeObject(LeafData, Method));
-        ListScope S(W, "Method");
-        printMemberAttributes(Method->Attrs);
-        printTypeIndex("Type", Method->Type);
-        if (Method->isIntroducedVirtual()) {
-          const little32_t *VFTOffsetPtr;
-          error(consumeObject(LeafData, VFTOffsetPtr));
-          W.printHex("VFTableOffset", *VFTOffsetPtr);
-        }
-      }
-      break;
-    }
+void CVTypeDumper::visitMethodList(TypeLeafKind Leaf,
+                                   ArrayRef<uint8_t> LeafData) {
+    if (!consumeObject(LeafData, Method))
+      return;
+      if (!consumeObject(LeafData, VFTOffsetPtr))
+        return;
 
-    case LF_FUNC_ID: {
-      const FuncId *Func;
-      error(consumeObject(LeafData, Func));
-      printTypeIndex("ParentScope", Func->ParentScope);
-      printTypeIndex("FunctionType", Func->FunctionType);
-      StringRef Null;
-      std::tie(Name, Null) = LeafData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitFuncId(TypeLeafKind Leaf, const FuncId *Func,
+                               ArrayRef<uint8_t> LeafData) {
+  Name = getBytesAsCString(LeafData);
 
-    case LF_TYPESERVER2: {
-      const TypeServer2 *TypeServer;
-      error(consumeObject(LeafData, TypeServer));
-      W.printBinary("Signature", StringRef(TypeServer->Signature, 16));
-      W.printNumber("Age", TypeServer->Age);
-      Name = LeafData.split('\0').first;
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitTypeServer2(TypeLeafKind Leaf,
+                                    const TypeServer2 *TypeServer,
+                                    ArrayRef<uint8_t> LeafData) {
+  Name = getBytesAsCString(LeafData);
 
-    case LF_POINTER: {
-      const PointerType *Ptr;
-      error(consumeObject(LeafData, Ptr));
-      printTypeIndex("PointeeType", Ptr->PointeeType);
-      W.printHex("PointerAttributes", Ptr->Attrs);
-      W.printEnum("PtrType", unsigned(Ptr->getPtrKind()),
-                  makeArrayRef(PtrKindNames));
-      W.printEnum("PtrMode", unsigned(Ptr->getPtrMode()),
-                  makeArrayRef(PtrModeNames));
-      W.printNumber("IsFlat", Ptr->isFlat());
-      W.printNumber("IsConst", Ptr->isConst());
-      W.printNumber("IsVolatile", Ptr->isVolatile());
-      W.printNumber("IsUnaligned", Ptr->isUnaligned());
+void CVTypeDumper::visitPointerType(TypeLeafKind Leaf, const PointerType *Ptr,
+                                    ArrayRef<uint8_t> LeafData) {
 
-      if (Ptr->isPointerToMember()) {
-        const PointerToMemberTail *PMT;
-        error(consumeObject(LeafData, PMT));
-        printTypeIndex("ClassType", PMT->ClassType);
-        W.printEnum("Representation", PMT->Representation,
-                    makeArrayRef(PtrMemberRepNames));
+    if (!consumeObject(LeafData, PMT))
+      return;
 
-        StringRef PointeeName = getTypeName(Ptr->PointeeType);
-        StringRef ClassName = getTypeName(PMT->ClassType);
-        SmallString<256> TypeName(PointeeName);
-        TypeName.push_back(' ');
-        TypeName.append(ClassName);
-        TypeName.append("::*");
-        Name = TypeNames.insert(TypeName).first->getKey();
-      } else {
-        W.printBinaryBlock("TailData", LeafData);
+    W.printBinaryBlock("TailData", getBytesAsCharacters(LeafData));
 
-        SmallString<256> TypeName;
-        if (Ptr->isConst())
-          TypeName.append("const ");
-        if (Ptr->isVolatile())
-          TypeName.append("volatile ");
-        if (Ptr->isUnaligned())
-          TypeName.append("__unaligned ");
 
-        TypeName.append(getTypeName(Ptr->PointeeType));
 
-        if (Ptr->getPtrMode() == PointerMode::LValueReference)
-          TypeName.append("&");
-        else if (Ptr->getPtrMode() == PointerMode::RValueReference)
-          TypeName.append("&&");
-        else if (Ptr->getPtrMode() == PointerMode::Pointer)
-          TypeName.append("*");
 
-        Name = TypeNames.insert(TypeName).first->getKey();
-      }
-      break;
-    }
 
-    case LF_MODIFIER: {
-      const TypeModifier *Mod;
-      error(consumeObject(LeafData, Mod));
-      printTypeIndex("ModifiedType", Mod->ModifiedType);
-      W.printFlags("Modifiers", Mod->Modifiers,
-                   makeArrayRef(TypeModifierNames));
+void CVTypeDumper::visitTypeModifier(TypeLeafKind Leaf, const TypeModifier *Mod,
+                                     ArrayRef<uint8_t> LeafData) {
+  W.printFlags("Modifiers", Mod->Modifiers, makeArrayRef(TypeModifierNames));
 
-      StringRef ModifiedName = getTypeName(Mod->ModifiedType);
-      SmallString<256> TypeName;
-      if (Mod->Modifiers & uint16_t(ModifierOptions::Const))
-        TypeName.append("const ");
-      if (Mod->Modifiers & uint16_t(ModifierOptions::Volatile))
-        TypeName.append("volatile ");
-      if (Mod->Modifiers & uint16_t(ModifierOptions::Unaligned))
-        TypeName.append("__unaligned ");
-      TypeName.append(ModifiedName);
-      Name = TypeNames.insert(TypeName).first->getKey();
-      break;
-    }
 
-    case LF_VTSHAPE: {
-      const VTableShape *Shape;
-      error(consumeObject(LeafData, Shape));
-      unsigned VFEntryCount = Shape->VFEntryCount;
-      W.printNumber("VFEntryCount", VFEntryCount);
-      // We could print out whether the methods are near or far, but in practice
-      // today everything is CV_VTS_near32, so it's just noise.
-      break;
-    }
+void CVTypeDumper::visitVTableShape(TypeLeafKind Leaf, const VTableShape *Shape,
+                                    ArrayRef<uint8_t> LeafData) {
 
-    case LF_UDT_SRC_LINE: {
-      const UDTSrcLine *Line;
-      error(consumeObject(LeafData, Line));
-      printTypeIndex("UDT", Line->UDT);
-      printTypeIndex("SourceFile", Line->SourceFile);
-      W.printNumber("LineNumber", Line->LineNumber);
-      break;
-    }
+void CVTypeDumper::visitUDTSrcLine(TypeLeafKind Leaf, const UDTSrcLine *Line,
+                                   ArrayRef<uint8_t> LeafData) {
 
-    case LF_BUILDINFO: {
-      const BuildInfo *Args;
-      error(consumeObject(LeafData, Args));
-      W.printNumber("NumArgs", Args->NumArgs);
+void CVTypeDumper::visitBuildInfo(TypeLeafKind Leaf, const BuildInfo *Args,
+                                  ArrayRef<uint8_t> LeafData) {
 
-      ListScope Arguments(W, "Arguments");
-      for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) {
-        const TypeIndex *Type;
-        error(consumeObject(LeafData, Type));
-        printTypeIndex("ArgType", *Type);
-      }
-      break;
-    }
-    }
-
-    if (opts::CodeViewSubsectionBytes)
-      W.printBinaryBlock("LeafData", LeafData);
-
-    CVUDTNames.push_back(Name);
-  }
-}
-
-static StringRef skipPadding(StringRef Data) {
-  if (Data.empty())
-    return Data;
-  uint8_t Leaf = Data.front();
-  if (Leaf < LF_PAD0)
-    return Data;
-  // Leaf is greater than 0xf0. We should advance by the number of bytes in the
-  // low 4 bits.
-  return Data.drop_front(Leaf & 0x0F);
+    if (!consumeObject(LeafData, Type))
+      return;
 }
 
 void CVTypeDumper::printMemberAttributes(MemberAttributes Attrs) {
   W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()),
               makeArrayRef(MemberAccessNames));
   auto MK = Attrs.getMethodKind();
   // Data members will be vanilla. Don't try to print a method kind for them.
   if (MK != MethodKind::Vanilla)
     W.printEnum("MethodKind", unsigned(MK), makeArrayRef(MemberKindNames));
   if (Attrs.getFlags() != MethodOptions::None) {
     W.printFlags("MethodOptions", unsigned(Attrs.getFlags()),
                  makeArrayRef(MethodOptionNames));
   }
 }
 
-void CVTypeDumper::printCodeViewFieldList(StringRef FieldData) {
-  while (!FieldData.empty()) {
-    const ulittle16_t *LeafPtr;
-    error(consumeObject(FieldData, LeafPtr));
-    uint16_t Leaf = *LeafPtr;
-    switch (Leaf) {
-    default:
-      W.printHex("UnknownMember", Leaf);
-      // We can't advance once we hit an unknown field. The size is not encoded.
-      return;
+void CVTypeDumper::visitUnknownMember(TypeLeafKind Leaf) {
+  W.printHex("UnknownMember", unsigned(Leaf));
+}
 
-    case LF_NESTTYPE: {
-      const NestedType *Nested;
-      error(consumeObject(FieldData, Nested));
-      DictScope S(W, "NestedType");
-      printTypeIndex("Type", Nested->Type);
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitNestedType(TypeLeafKind Leaf, const NestedType *Nested,
+                                   ArrayRef<uint8_t> &FieldData) {
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_ONEMETHOD: {
-      const OneMethod *Method;
-      error(consumeObject(FieldData, Method));
-      DictScope S(W, "OneMethod");
-      printMemberAttributes(Method->Attrs);
-      printTypeIndex("Type", Method->Type);
-      // If virtual, then read the vftable offset.
-      if (Method->isIntroducedVirtual()) {
-        const little32_t *VFTOffsetPtr;
-        error(consumeObject(FieldData, VFTOffsetPtr));
-        W.printHex("VFTableOffset", *VFTOffsetPtr);
-      }
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitOneMethod(TypeLeafKind Leaf, const OneMethod *Method,
+                                  ArrayRef<uint8_t> &FieldData) {
+    if (!consumeObject(FieldData, VFTOffsetPtr))
+      return;
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_METHOD: {
-      const OverloadedMethod *Method;
-      error(consumeObject(FieldData, Method));
-      DictScope S(W, "OverloadedMethod");
-      W.printHex("MethodCount", Method->MethodCount);
-      W.printHex("MethodListIndex", Method->MethList.getIndex());
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitOverloadedMethod(TypeLeafKind Leaf,
+                                         const OverloadedMethod *Method,
+                                         ArrayRef<uint8_t> &FieldData) {
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_MEMBER: {
-      const DataMember *Field;
-      error(consumeObject(FieldData, Field));
-      DictScope S(W, "DataMember");
-      printMemberAttributes(Field->Attrs);
-      printTypeIndex("Type", Field->Type);
-      uint64_t FieldOffset;
-      error(decodeUIntLeaf(FieldData, FieldOffset));
-      W.printHex("FieldOffset", FieldOffset);
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitDataMember(TypeLeafKind Leaf, const DataMember *Field,
+                                   ArrayRef<uint8_t> &FieldData) {
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_STMEMBER: {
-      const StaticDataMember *Field;
-      error(consumeObject(FieldData, Field));
-      DictScope S(W, "StaticDataMember");
-      printMemberAttributes(Field->Attrs);
-      printTypeIndex("Type", Field->Type);
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitStaticDataMember(TypeLeafKind Leaf,
+                                         const StaticDataMember *Field,
+                                         ArrayRef<uint8_t> &FieldData) {
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_VFUNCTAB: {
-      const VirtualFunctionPointer *VFTable;
-      error(consumeObject(FieldData, VFTable));
-      DictScope S(W, "VirtualFunctionPointer");
-      printTypeIndex("Type", VFTable->Type);
-      break;
-    }
+void CVTypeDumper::visitVirtualFunctionPointer(
+    TypeLeafKind Leaf, const VirtualFunctionPointer *VFTable,
+    ArrayRef<uint8_t> &FieldData) {
 
-    case LF_ENUMERATE: {
-      const Enumerator *Enum;
-      error(consumeObject(FieldData, Enum));
-      DictScope S(W, "Enumerator");
-      printMemberAttributes(Enum->Attrs);
-      APSInt EnumValue;
-      error(decodeNumerictLeaf(FieldData, EnumValue));
-      W.printNumber("EnumValue", EnumValue);
-      StringRef Name;
-      std::tie(Name, FieldData) = FieldData.split('\0');
-      W.printString("Name", Name);
-      break;
-    }
+void CVTypeDumper::visitEnumerator(TypeLeafKind Leaf, const Enumerator *Enum,
+                                   ArrayRef<uint8_t> &FieldData) {
+  StringRef Name = getBytesAsCString(FieldData);
+  FieldData = FieldData.drop_front(Name.size() + 1);
 
-    case LF_BCLASS:
-    case LF_BINTERFACE: {
-      const BaseClass *Base;
-      error(consumeObject(FieldData, Base));
-      DictScope S(W, "BaseClass");
-      printMemberAttributes(Base->Attrs);
-      printTypeIndex("BaseType", Base->BaseType);
-      uint64_t BaseOffset;
-      error(decodeUIntLeaf(FieldData, BaseOffset));
-      W.printHex("BaseOffset", BaseOffset);
-      break;
-    }
+void CVTypeDumper::visitBaseClass(TypeLeafKind Leaf, const BaseClass *Base,
+                                  ArrayRef<uint8_t> &FieldData) {
 
-    case LF_VBCLASS:
-    case LF_IVBCLASS: {
-      const VirtualBaseClass *Base;
-      error(consumeObject(FieldData, Base));
-      DictScope S(W, "VirtualBaseClass");
-      printMemberAttributes(Base->Attrs);
-      printTypeIndex("BaseType",  Base->BaseType);
-      printTypeIndex("VBPtrType", Base->VBPtrType);
-      uint64_t VBPtrOffset, VBTableIndex;
-      error(decodeUIntLeaf(FieldData, VBPtrOffset));
-      error(decodeUIntLeaf(FieldData, VBTableIndex));
-      W.printHex("VBPtrOffset", VBPtrOffset);
-      W.printHex("VBTableIndex", VBTableIndex);
-      break;
-    }
-    }
-
-    // Handle padding.
-    FieldData = skipPadding(FieldData);
-  }
+void CVTypeDumper::visitVirtualBaseClass(TypeLeafKind Leaf,
+                                         const VirtualBaseClass *Base,
+                                         ArrayRef<uint8_t> &FieldData) {
+  printTypeIndex("BaseType", Base->BaseType);
 }
 
 void COFFDumper::printSections() {
   ListScope SectionsD(W, "Sections");
   int SectionNumber = 0;
   for (const SectionRef &Sec : Obj->sections()) {
     ++SectionNumber;
     const coff_section *Section = Obj->getCOFFSection(Sec);