Make llvm-readobj symbol dumper use the RecordIterator

[zturner]

Summary

Note that this doesn't go quite far enough. In a subsequent patch I will convert the symbol dumper to a visitor pattern, and move this into libcodeview just like CVTypeDumper. For now, this is the first step towards that, and a proof of concept that the RecordIterator is generic enough to handle more than just types.

[rnk]

So, while llvm-readobj may not have error handling, it *does* have very careful bounds checking, and I really want to keep it. This was an important part of our refactor away from DataExtractor to StringRef / consumeObject.

include/llvm/DebugInfo/CodeView/RecordIterator.h

35

This also loses the bounds checking we had before.

include/llvm/DebugInfo/CodeView/SymbolRecord.h

57

Please don't do this, the old code was very careful to avoid buffer overruns when the string was not null terminated. It also throws off consumeObject, which will consume one extra byte, so SymData / LeafData won't hold the full string.

tools/llvm-readobj/COFFDumper.cpp

1019

If there is no terminating nul, split('\0') would give you all of SymData. I think that's the best behavior we can hope for.

include/llvm/DebugInfo/CodeView/RecordIterator.h

 namespace codeview {
 // A const input iterator interface to the CodeView record stream.
 template <typename Kind> class RecordIterator {
-private:
   struct RecordPrefix {
     support::ulittle16_t Len;  // Record length, starting from &Leaf
     support::ulittle16_t Kind; // Record kind (a value from the `Kind` enum).
   };
 
 public:
+  static const size_t PrefixSize = sizeof(RecordPrefix);
+
   struct Record {
     std::size_t Length;
     Kind Type;
     ArrayRef<uint8_t> Data;
+
+    template <typename T> const T *getData() const {
+      return reinterpret_cast<const T *>(Data.data());
+    }
   };
 
   explicit RecordIterator(const ArrayRef<uint8_t> &RecordBytes)

include/llvm/DebugInfo/CodeView/SymbolRecord.h

 #include "CVSymbolTypes.def"
 };
 
-/// Data preceding all symbol records.
-struct SymRecord {
-  ulittle16_t RecordLength; // Record length, starting from the next field
-  ulittle16_t RecordKind;   // Record kind (SymbolRecordKind)
-  // Symbol data follows.
-
-  SymbolRecordKind getKind() const {
-    return SymbolRecordKind(uint16_t(RecordKind));
-  }
-};
-
 /// Corresponds to the CV_PROCFLAGS bitfield.
 enum ProcFlags : uint8_t {
   HasFP = 1 << 0,

   ulittle32_t CodeOffset;
   ulittle16_t Segment;
   uint8_t Flags; // CV_PROCFLAGS
-  // Name: The null-terminated name follows.
+  char Name[1];  // null-terminated string
 };
 
 enum BinaryAnnotationsOpCode : uint32_t {

     IsEnregisteredGlobal = 1 << 9,
     IsEnregisteredStatic = 1 << 10,
   };
-  // Name: The null-terminated name follows.
+  char Name[1]; // Null terminated string.
 };
 
 struct LocalVariableAddrRange {

   ulittle32_t CodeSize;
   ulittle32_t CodeOffset;
   ulittle16_t Segment;
-  // Name: The null-terminated name follows.
+  char Name[1]; // null-terminated string.
 };
 
 // S_LABEL32

   ulittle32_t CodeOffset;
   ulittle16_t Segment;
   uint8_t Flags; // CV_PROCFLAGS
-  // Name: The null-terminated name follows.
+  char Name[1];  // null-terminated string.
 };
 
 // S_OBJNAME
 struct ObjNameSym {
   ulittle32_t Signature;
-  // Name: The null-terminated name follows.
+  char Name[1]; // null-terminated string.
 };
 
 // S_COMPILE3

   ulittle16_t VersionBackendMinor;
   ulittle16_t VersionBackendBuild;
   ulittle16_t VersionBackendQFE;
-  // VersionString: The null-terminated version string follows.
+  char Version[1]; // null-terminated string.
 };
 
 // S_FRAMEPROC

 // S_UDT, S_COBOLUDT
 struct UDTSym {
   TypeIndex Type; // Type of the UDT
-  // Name: The null-terminated name follows.
+  char Name[1];   // null-terminated string.
 };
 
 // S_BUILDINFO

 struct BPRelativeSym {
   little32_t Offset;  // Offset from the base pointer register
   TypeIndex Type;     // Type of the variable
-  // Name: The null-terminated name follows.
+  char Name[1];       // null-terminated string.
 };
 
 // S_REGREL32

   ulittle32_t Offset;   // Offset from the register
   TypeIndex Type;       // Type of the variable
   ulittle16_t Register; // Register to which the variable is relative
-  // Name: The null-terminated name follows.
+  char Name[1];         // null-terminated string.
 };
 
 // S_CONSTANT, S_MANCONSTANT

   TypeIndex Type;
   ulittle32_t DataOffset;
   ulittle16_t Segment;
-  // Name: The null-terminated name follows.
+  char Name[1]; // null-terminated string.
 };
 
 // S_LTHREAD32, S_GTHREAD32

   TypeIndex Type;
   ulittle32_t DataOffset;
   ulittle16_t Segment;
-  // Name: The null-terminated name follows.
+  char Name[1]; // null-terminated string.
 };
 
 typedef RecordIterator<SymbolRecordKind> SymbolIterator;

include/llvm/DebugInfo/CodeView/TypeStream.h

 /// Consumes sizeof(T) bytes from the given byte sequence. Returns an error if
 /// there are not enough bytes remaining. Reinterprets the consumed bytes as a
 /// T object and points 'Res' at them.
-template <typename T>
-inline std::error_code consumeObject(StringRef &Data, const T *&Res) {
+template <typename S, typename T>
+inline std::error_code consumeObject(S &Data, const T *&Res) {
   if (Data.size() < sizeof(*Res))
     return object::object_error::parse_failed;
   Res = reinterpret_cast<const T *>(Data.data());

   return std::error_code();
 }
 
-inline std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
+template <typename S>
+inline std::error_code consumeUInt32(S &Data, uint32_t &Res) {
   const support::ulittle32_t *IntPtr;
   if (auto EC = consumeObject(Data, IntPtr))
     return EC;

tools/llvm-readobj/COFFDumper.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
+#include "llvm/DebugInfo/CodeView/RecordIterator.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"

   void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
                                    const coff_section *Sec,
                                    StringRef SectionContents);
-  void printLocalVariableAddrGap(StringRef &SymData);
+  void printLocalVariableAddrGap(ArrayRef<uint8_t> &SymData);
 
   void printCodeViewSymbolsSubsection(StringRef Subsection,
                                       const SectionRef &Section,

                                             const SectionRef &Sec,
                                             StringRef SectionContents,
                                             StringRef Block) {
+  outs().flush();
   W.printBinaryBlock(Label, Block);
+  outs().flush();
 
   assert(SectionContents.begin() < Block.begin() &&
          SectionContents.end() >= Block.end() &&

     if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd)
       printRelocation(Sec, Relocation, OffsetStart);
   }
+  outs().flush();
 }
 
 static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {

 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
                                                 const SectionRef &Section,
                                                 StringRef SectionContents) {
-  if (Subsection.size() < sizeof(SymRecord))
+  if (Subsection.size() < sizeof(SymbolIterator::PrefixSize))
     return error(object_error::parse_failed);
 
   const coff_section *Sec = Obj->getCOFFSection(Section);
 
-  // This holds the remaining data to parse.
-  StringRef Data = Subsection;
-
   bool InFunctionScope = false;
-  while (!Data.empty()) {
-    const SymRecord *Rec;
-    error(consumeObject(Data, Rec));
+  ArrayRef<uint8_t> Data((uint8_t *)(Subsection.data()), Subsection.size());
+  for (const auto &Record : makeSymbolRange(Data)) {
 
-    StringRef SymData = Data.substr(0, Rec->RecordLength - 2);
-    StringRef OrigSymData = SymData;
-
-    Data = Data.drop_front(Rec->RecordLength - 2);
-
-    SymbolRecordKind Kind = Rec->getKind();
-    switch (Kind) {
+    switch (Record.Type) {
     case S_LPROC32:
     case S_GPROC32:
     case S_GPROC32_ID:

     case S_LPROC32_DPC:
     case S_LPROC32_DPC_ID: {
       DictScope S(W, "ProcStart");
-      const ProcSym *Proc;
-      error(consumeObject(SymData, Proc));
+      auto Proc = Record.getData<ProcSym>();
       if (InFunctionScope)
         return error(object_error::parse_failed);
       InFunctionScope = true;
 
       StringRef LinkageName;
-      StringRef DisplayName = SymData.split('\0').first;
+      StringRef DisplayName = Proc->Name;
       W.printHex("PtrParent", Proc->PtrParent);
       W.printHex("PtrEnd", Proc->PtrEnd);
       W.printHex("PtrNext", Proc->PtrNext);

 
     case S_BLOCK32: {
       DictScope S(W, "BlockStart");
-      const BlockSym *Block;
-      error(consumeObject(SymData, Block));
+      const BlockSym *Block = Record.getData<BlockSym>();
 
-      StringRef BlockName = SymData.split('\0').first;
+      StringRef BlockName = Block->Name;
       StringRef LinkageName;
       W.printHex("PtrParent", Block->PtrParent);
       W.printHex("PtrEnd", Block->PtrEnd);

 
     case S_LABEL32: {
       DictScope S(W, "Label");
-      const LabelSym *Label;
-      error(consumeObject(SymData, Label));
+      const LabelSym *Label = Record.getData<LabelSym>();
 
-      StringRef DisplayName = SymData.split('\0').first;
+      StringRef DisplayName = Label->Name;
       StringRef LinkageName;
       printRelocatedField("CodeOffset", Sec, SectionContents,
                           &Label->CodeOffset, &LinkageName);

 
     case S_INLINESITE: {
       DictScope S(W, "InlineSite");
-      const InlineSiteSym *InlineSite;
-      error(consumeObject(SymData, InlineSite));
+      const InlineSiteSym *InlineSite = Record.getData<InlineSiteSym>();
       W.printHex("PtrParent", InlineSite->PtrParent);
       W.printHex("PtrEnd", InlineSite->PtrEnd);
       printTypeIndex("Inlinee", InlineSite->Inlinee);
 
+      auto SymData = Record.Data.slice(sizeof(InlineSiteSym));
       auto GetCompressedAnnotation = [&]() -> uint32_t {
         if (SymData.empty())
           return -1;

 
     case S_CALLERS:
     case S_CALLEES: {
-      ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers");
+      ListScope S(W, Record.Type == S_CALLEES ? "Callees" : "Callers");
       uint32_t Count;
+      auto SymData = Record.Data;
       error(consumeUInt32(SymData, Count));
       for (uint32_t I = 0; I < Count; ++I) {
         const TypeIndex *FuncID;

 
     case S_LOCAL: {
       DictScope S(W, "Local");
-      const LocalSym *Local;
-      error(consumeObject(SymData, Local));
+      const LocalSym *Local = Record.getData<LocalSym>();
       printTypeIndex("Type", Local->Type);
       W.printFlags("Flags", uint16_t(Local->Flags), makeArrayRef(LocalFlags));
-      StringRef VarName = SymData.split('\0').first;
+      StringRef VarName = Local->Name;
       W.printString("VarName", VarName);
       break;
     }
 
     case S_DEFRANGE: {
       DictScope S(W, "DefRange");
-      const DefRangeSym *DefRange;
-      error(consumeObject(SymData, DefRange));
+      const DefRangeSym *DefRange = Record.getData<DefRangeSym>();
       W.printString(
           "Program",
           CVStringTable.drop_front(DefRange->Program).split('\0').first);
       printLocalVariableAddrRange(DefRange->Range, Sec, SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
     case S_DEFRANGE_SUBFIELD: {
       DictScope S(W, "DefRangeSubfield");
-      const DefRangeSubfieldSym *DefRangeSubfield;
-      error(consumeObject(SymData, DefRangeSubfield));
+      const DefRangeSubfieldSym *DefRangeSubfield =
+          Record.getData<DefRangeSubfieldSym>();
       W.printString("Program",
                     CVStringTable.drop_front(DefRangeSubfield->Program)
                         .split('\0')

       W.printNumber("OffsetInParent", DefRangeSubfield->OffsetInParent);
       printLocalVariableAddrRange(DefRangeSubfield->Range, Sec,
                                   SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeSubfieldSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
     case S_DEFRANGE_REGISTER: {
       DictScope S(W, "DefRangeRegister");
-      const DefRangeRegisterSym *DefRangeRegister;
-      error(consumeObject(SymData, DefRangeRegister));
+      const DefRangeRegisterSym *DefRangeRegister =
+          Record.getData<DefRangeRegisterSym>();
       W.printNumber("Register", DefRangeRegister->Register);
       W.printNumber("MayHaveNoName", DefRangeRegister->MayHaveNoName);
       printLocalVariableAddrRange(DefRangeRegister->Range, Sec,
                                   SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeRegisterSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
     case S_DEFRANGE_SUBFIELD_REGISTER: {
       DictScope S(W, "DefRangeSubfieldRegister");
-      const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegisterSym;
-      error(consumeObject(SymData, DefRangeSubfieldRegisterSym));
-      W.printNumber("Register", DefRangeSubfieldRegisterSym->Register);
-      W.printNumber("MayHaveNoName",
-                    DefRangeSubfieldRegisterSym->MayHaveNoName);
-      W.printNumber("OffsetInParent",
-                    DefRangeSubfieldRegisterSym->OffsetInParent);
-      printLocalVariableAddrRange(DefRangeSubfieldRegisterSym->Range, Sec,
+      const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegister =
+          Record.getData<DefRangeSubfieldRegisterSym>();
+      W.printNumber("Register", DefRangeSubfieldRegister->Register);
+      W.printNumber("MayHaveNoName", DefRangeSubfieldRegister->MayHaveNoName);
+      W.printNumber("OffsetInParent", DefRangeSubfieldRegister->OffsetInParent);
+      printLocalVariableAddrRange(DefRangeSubfieldRegister->Range, Sec,
                                   SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeSubfieldRegisterSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
     case S_DEFRANGE_FRAMEPOINTER_REL: {
       DictScope S(W, "DefRangeFramePointerRel");
-      const DefRangeFramePointerRelSym *DefRangeFramePointerRel;
-      error(consumeObject(SymData, DefRangeFramePointerRel));
+      const DefRangeFramePointerRelSym *DefRangeFramePointerRel =
+          Record.getData<DefRangeFramePointerRelSym>();
       W.printNumber("Offset", DefRangeFramePointerRel->Offset);
       printLocalVariableAddrRange(DefRangeFramePointerRel->Range, Sec,
                                   SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeFramePointerRelSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
     case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: {
       DictScope S(W, "DefRangeFramePointerRelFullScope");
       const DefRangeFramePointerRelFullScopeSym
-          *DefRangeFramePointerRelFullScope;
-      error(consumeObject(SymData, DefRangeFramePointerRelFullScope));
+          *DefRangeFramePointerRelFullScope =
+              Record.getData<DefRangeFramePointerRelFullScopeSym>();
       W.printNumber("Offset", DefRangeFramePointerRelFullScope->Offset);
       break;
     }
     case S_DEFRANGE_REGISTER_REL: {
       DictScope S(W, "DefRangeRegisterRel");
-      const DefRangeRegisterRelSym *DefRangeRegisterRel;
-      error(consumeObject(SymData, DefRangeRegisterRel));
+      const DefRangeRegisterRelSym *DefRangeRegisterRel =
+          Record.getData<DefRangeRegisterRelSym>();
       W.printNumber("BaseRegister", DefRangeRegisterRel->BaseRegister);
       W.printBoolean("HasSpilledUDTMember",
                      DefRangeRegisterRel->hasSpilledUDTMember());

                     DefRangeRegisterRel->BasePointerOffset);
       printLocalVariableAddrRange(DefRangeRegisterRel->Range, Sec,
                                   SectionContents);
-      printLocalVariableAddrGap(SymData);
+      auto Data = Record.Data.slice(sizeof(DefRangeRegisterRelSym));
+      printLocalVariableAddrGap(Data);
       break;
     }
 
     case S_CALLSITEINFO: {
       DictScope S(W, "CallSiteInfo");
-      const CallSiteInfoSym *CallSiteInfo;
-      error(consumeObject(SymData, CallSiteInfo));
+      const CallSiteInfoSym *CallSiteInfo = Record.getData<CallSiteInfoSym>();
 
       StringRef LinkageName;
       printRelocatedField("CodeOffset", Sec, SectionContents,

 
     case S_HEAPALLOCSITE: {
       DictScope S(W, "HeapAllocationSite");
-      const HeapAllocationSiteSym *HeapAllocationSite;
-      error(consumeObject(SymData, HeapAllocationSite));
+      const HeapAllocationSiteSym *HeapAllocationSite =
+          Record.getData<HeapAllocationSiteSym>();
 
       StringRef LinkageName;
       printRelocatedField("CodeOffset", Sec, SectionContents,

 
     case S_FRAMECOOKIE: {
       DictScope S(W, "FrameCookie");
-      const FrameCookieSym *FrameCookie;
-      error(consumeObject(SymData, FrameCookie));
+      const FrameCookieSym *FrameCookie = Record.getData<FrameCookieSym>();
 
       StringRef LinkageName;
       printRelocatedField("CodeOffset", Sec, SectionContents,

     case S_LMANDATA:
     case S_GMANDATA: {
       DictScope S(W, "DataSym");
-      const DataSym *Data;
-      error(consumeObject(SymData, Data));
+      const DataSym *Data = Record.getData<DataSym>();
 
-      StringRef DisplayName = SymData.split('\0').first;
+      StringRef DisplayName = Data->Name;
       StringRef LinkageName;
       printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset,
                           &LinkageName);

     case S_LTHREAD32:
     case S_GTHREAD32: {
       DictScope S(W, "ThreadLocalDataSym");
-      const ThreadLocalDataSym *Data;
-      error(consumeObject(SymData, Data));
+      const ThreadLocalDataSym *Data = Record.getData<ThreadLocalDataSym>();
 
-      StringRef DisplayName = SymData.split('\0').first;
+      StringRef DisplayName = Data->Name;
       StringRef LinkageName;
       printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset,
                           &LinkageName);

 
     case S_OBJNAME: {
       DictScope S(W, "ObjectName");
-      const ObjNameSym *ObjName;
-      error(consumeObject(SymData, ObjName));
+      const ObjNameSym *ObjName = Record.getData<ObjNameSym>();
       W.printHex("Signature", ObjName->Signature);
-      StringRef ObjectName = SymData.split('\0').first;
+      StringRef ObjectName = ObjName->Name;
       W.printString("ObjectName", ObjectName);
       break;
     }
 
     case S_COMPILE3: {
       DictScope S(W, "CompilerFlags");
-      const CompileSym3 *CompFlags;
-      error(consumeObject(SymData, CompFlags));
+      const CompileSym3 *CompFlags = Record.getData<CompileSym3>();
       W.printEnum("Language", CompFlags->getLanguage(),
                   makeArrayRef(SourceLanguages));
       W.printFlags("Flags", CompFlags->flags & ~0xff,

       }
       W.printString("FrontendVersion", FrontendVersion);
       W.printString("BackendVersion", BackendVersion);
-      StringRef VersionName = SymData.split('\0').first;
+      StringRef VersionName = CompFlags->Version;
       W.printString("VersionName", VersionName);
       break;
     }
 
     case S_FRAMEPROC: {
       DictScope S(W, "FrameProc");
-      const FrameProcSym *FrameProc;
-      error(consumeObject(SymData, FrameProc));
+      const FrameProcSym *FrameProc = Record.getData<FrameProcSym>();
+
       W.printHex("TotalFrameBytes", FrameProc->TotalFrameBytes);
       W.printHex("PaddingFrameBytes", FrameProc->PaddingFrameBytes);
       W.printHex("OffsetToPadding", FrameProc->OffsetToPadding);

     case S_UDT:
     case S_COBOLUDT: {
       DictScope S(W, "UDT");
-      const UDTSym *UDT;
-      error(consumeObject(SymData, UDT));
+      const UDTSym *UDT = Record.getData<UDTSym>();
+
       printTypeIndex("Type", UDT->Type);
-      StringRef UDTName = SymData.split('\0').first;
+      StringRef UDTName = UDT->Name;
       W.printString("UDTName", UDTName);
       break;
     }
 
     case S_BPREL32: {
       DictScope S(W, "BPRelativeSym");
-      const BPRelativeSym *BPRel;
-      error(consumeObject(SymData, BPRel));
+      const BPRelativeSym *BPRel = Record.getData<BPRelativeSym>();
+
       W.printNumber("Offset", BPRel->Offset);
       printTypeIndex("Type", BPRel->Type);
-      StringRef VarName = SymData.split('\0').first;
+      StringRef VarName = BPRel->Name;
       W.printString("VarName", VarName);
       break;
     }
 
     case S_REGREL32: {
       DictScope S(W, "RegRelativeSym");
-      const RegRelativeSym *RegRel;
-      error(consumeObject(SymData, RegRel));
+      const RegRelativeSym *RegRel = Record.getData<RegRelativeSym>();
+
       W.printHex("Offset", RegRel->Offset);
       printTypeIndex("Type", RegRel->Type);
       W.printHex("Register", RegRel->Register);
-      StringRef VarName = SymData.split('\0').first;
+      StringRef VarName = RegRel->Name;
       W.printString("VarName", VarName);
       break;
     }
 
     case S_BUILDINFO: {
       DictScope S(W, "BuildInfo");
-      const BuildInfoSym *BuildInfo;
-      error(consumeObject(SymData, BuildInfo));
+      const BuildInfoSym *BuildInfo = Record.getData<BuildInfoSym>();
+
       W.printNumber("BuildId", BuildInfo->BuildId);
       break;
     }

     case S_CONSTANT:
     case S_MANCONSTANT: {
       DictScope S(W, "Constant");
-      const ConstantSym *Constant;
-      error(consumeObject(SymData, Constant));
+      const ConstantSym *Constant = Record.getData<ConstantSym>();
+
+      ArrayRef<uint8_t> SymData = Record.Data.slice(sizeof(ConstantSym));
+
       printTypeIndex("Type", Constant->Type);
       APSInt Value;
       if (!decodeNumericLeaf(SymData, Value))
         error(object_error::parse_failed);
       W.printNumber("Value", Value);
-      StringRef Name = SymData.split('\0').first;
+      StringRef Name((const char *)SymData.begin(), SymData.size());
+      Name = Name.split('\0').first;
       W.printString("Name", Name);
       break;
     }
 
     default: {
       DictScope S(W, "UnknownSym");
-      W.printHex("Kind", unsigned(Kind));
-      W.printHex("Size", Rec->RecordLength);
+      W.printHex("Kind", unsigned(Record.Type));
+      W.printHex("Size", Record.Length);
       break;
     }
     }
 
     if (opts::CodeViewSubsectionBytes)
-      printBinaryBlockWithRelocs("SymData", Section, SectionContents,
-                                 OrigSymData);
+      printBinaryBlockWithRelocs(
+          "SymData", Section, SectionContents,
+          StringRef((const char *)Record.Data.data(), Record.Data.size()));
     W.flush();
   }
   W.flush();

   W.printHex("Range", Range.Range);
 }
 
-void COFFDumper::printLocalVariableAddrGap(StringRef &SymData) {
+void COFFDumper::printLocalVariableAddrGap(ArrayRef<uint8_t> &SymData) {
   while (!SymData.empty()) {
     const LocalVariableAddrGap *Gap;
     error(consumeObject(SymData, Gap));