[CodeView] Refactor lots of stuff to use StreamRefs

[zturner]

Summary

I started down the path of trying to merge the serialization and deserialization for types and symbols. This is difficult as it stands, because all of the "real" PDB code uses StreamInterface stuff to avoid having to copy entire streams, which could be hundreds of MB. But the serialization code all uses ArrayRef for everything. This changes everything to use StreamReader. In the process, I found lots of duplicated code in RecordSerialization.cpp and RecordSerailization.h that was already written in StreamReader.cpp. All of that has been removed since everything is now using StreamReader.

[rnk]

lgtm

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

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

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

 #ifndef LLVM_DEBUGINFO_CODEVIEW_RECORDSERIALIZATION_H
 #define LLVM_DEBUGINFO_CODEVIEW_RECORDSERIALIZATION_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
+#include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include <cinttypes>
 #include <tuple>
 
 namespace llvm {
 namespace codeview {
 using llvm::support::little32_t;
struct RecordPrefix {
   ulittle16_t RecordKind; // Record kind enum (SymRecordKind or TypeRecordKind)
 };
 
 /// 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.
 StringRef getBytesAsCharacters(ArrayRef<uint8_t> LeafData);
 StringRef getBytesAsCString(ArrayRef<uint8_t> LeafData);
 
-/// 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, typename U>
-inline Error consumeObject(U &Data, const T *&Res) {
-  if (Data.size() < sizeof(*Res))
-    return make_error<CodeViewError>(
-        cv_error_code::insufficient_buffer,
-        "Insufficient bytes for expected object type");
-  Res = reinterpret_cast<const T *>(Data.data());
-  Data = Data.drop_front(sizeof(*Res));
-  return Error::success();
-}
-
-inline Error consume(ArrayRef<uint8_t> &Data) { return Error::success(); }
+inline Error consume(msf::StreamReader &Reader) { return Error::success(); }
 
 /// Decodes a numeric "leaf" value. These are integer literals encountered in
 /// the type stream. If the value is positive and less than LF_NUMERIC (1 <<
 /// 15), it is emitted directly in Data. Otherwise, it has a tag like LF_CHAR
 /// that indicates the bitwidth and sign of the numeric data.
-Error consume(ArrayRef<uint8_t> &Data, APSInt &Num);
-Error consume(StringRef &Data, APSInt &Num);
+Error consume(msf::StreamReader &Reader, APSInt &Num);
 
 /// Decodes a numeric leaf value that is known to be a particular type.
-Error consume_numeric(ArrayRef<uint8_t> &Data, uint64_t &Value);
+Error consume_numeric(msf::StreamReader &Reader, uint64_t &Value);
 
 /// Decodes signed and unsigned fixed-length integers.
-Error consume(ArrayRef<uint8_t> &Data, uint32_t &Item);
-Error consume(StringRef &Data, uint32_t &Item);
-Error consume(ArrayRef<uint8_t> &Data, int32_t &Item);
+Error consume(msf::StreamReader &Reader, uint32_t &Item);
+Error consume(msf::StreamReader &Reader, int32_t &Item);
 
 /// Decodes a null terminated string.
-Error consume(ArrayRef<uint8_t> &Data, StringRef &Item);
+Error consume(msf::StreamReader &Reader, StringRef &Item);
+
+Error consume(StringRef &Data, APSInt &Num);
+Error consume(StringRef &Data, uint32_t &Item);
 
 /// Decodes an arbitrary object whose layout matches that of the underlying
 /// byte sequence, and returns a pointer to the object.
-template <typename T> Error consume(ArrayRef<uint8_t> &Data, T *&Item) {
-  return consumeObject(Data, Item);
+template <typename T> Error consume(msf::StreamReader &Reader, T *&Item) {
+  return Reader.readObject(Item);
 }
 
 template <typename T, typename U> struct serialize_conditional_impl {
   serialize_conditional_impl(T &Item, U Func) : Item(Item), Func(Func) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
+  Error deserialize(msf::StreamReader &Reader) const {
     if (!Func())
       return Error::success();
-    return consume(Data, Item);
+    return consume(Reader, Item);
   }
 
   T &Item;
   U Func;
 };
 
 template <typename T, typename U>
 serialize_conditional_impl<T, U> serialize_conditional(T &Item, U Func) {
   return serialize_conditional_impl<T, U>(Item, Func);
 }
 
 template <typename T, typename U> struct serialize_array_impl {
   serialize_array_impl(ArrayRef<T> &Item, U Func) : Item(Item), Func(Func) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
-    uint32_t N = Func();
-    if (N == 0)
-      return Error::success();
-
-    uint32_t Size = sizeof(T) * N;
-
-    if (Size / sizeof(T) != N)
-      return make_error<CodeViewError>(
-          cv_error_code::corrupt_record,
-          "Array<T> length is not a multiple of sizeof(T)");
-
-    if (Data.size() < Size)
-      return make_error<CodeViewError>(
-          cv_error_code::corrupt_record,
-          "Array<T> does not contain enough data for all elements");
-
-    Item = ArrayRef<T>(reinterpret_cast<const T *>(Data.data()), N);
-    Data = Data.drop_front(Size);
-    return Error::success();
+  Error deserialize(msf::StreamReader &Reader) const {
+    return Reader.readArray(Item, Func());
   }
 
   ArrayRef<T> &Item;
   U Func;
 };
 
 template <typename T> struct serialize_vector_tail_impl {
   serialize_vector_tail_impl(std::vector<T> &Item) : Item(Item) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
+  Error deserialize(msf::StreamReader &Reader) const {
     T Field;
     // Stop when we run out of bytes or we hit record padding bytes.
-    while (!Data.empty() && Data.front() < LF_PAD0) {
-      if (auto EC = consume(Data, Field))
+    while (!Reader.empty() && Reader.peek() < LF_PAD0) {
+      if (auto EC = consume(Reader, Field))
         return EC;
       Item.push_back(Field);
     }
     return Error::success();
   }
 
   std::vector<T> &Item;
 };
 
 struct serialize_null_term_string_array_impl {
   serialize_null_term_string_array_impl(std::vector<StringRef> &Item)
       : Item(Item) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
-    if (Data.empty())
+  Error deserialize(msf::StreamReader &Reader) const {
+    if (Reader.empty())
       return make_error<CodeViewError>(cv_error_code::insufficient_buffer,
                                        "Null terminated string is empty!");
 
+    while (Reader.peek() != 0) {
       StringRef Field;
-    // Stop when we run out of bytes or we hit record padding bytes.
-    while (Data.front() != 0) {
-      if (auto EC = consume(Data, Field))
+      if (auto EC = Reader.readZeroString(Field))
         return EC;
       Item.push_back(Field);
-      if (Data.empty())
-        return make_error<CodeViewError>(
-            cv_error_code::insufficient_buffer,
-            "Null terminated string has no null terminator!");
     }
-    Data = Data.drop_front(1);
-    return Error::success();
+    return Reader.skip(1);
   }
 
   std::vector<StringRef> &Item;
 };
 
 template <typename T> struct serialize_arrayref_tail_impl {
   serialize_arrayref_tail_impl(ArrayRef<T> &Item) : Item(Item) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
-    uint32_t Count = Data.size() / sizeof(T);
-    Item = ArrayRef<T>(reinterpret_cast<const T *>(Data.begin()), Count);
-    return Error::success();
+  Error deserialize(msf::StreamReader &Reader) const {
+    uint32_t Count = Reader.bytesRemaining() / sizeof(T);
+    return Reader.readArray(Item, Count);
   }
 
   ArrayRef<T> &Item;
 };
 
 template <typename T> struct serialize_numeric_impl {
   serialize_numeric_impl(T &Item) : Item(Item) {}
 
-  Error deserialize(ArrayRef<uint8_t> &Data) const {
-    return consume_numeric(Data, Item);
+  Error deserialize(msf::StreamReader &Reader) const {
+    return consume_numeric(Reader, Item);
   }
 
   T &Item;
 };
 
 template <typename T, typename U>
 serialize_array_impl<T, U> serialize_array(ArrayRef<T> &Item, U Func) {
   return serialize_array_impl<T, U>(Item, Func);

 
 // This is an array that consumes null terminated strings until a double null
 // is encountered.
 #define CV_STRING_ARRAY_NULL_TERM(I) serialize_null_term_string_array(I)
 
 #define CV_NUMERIC_FIELD(I) serialize_numeric(I)
 
 template <typename T, typename U>
-Error consume(ArrayRef<uint8_t> &Data,
+Error consume(msf::StreamReader &Reader,
               const serialize_conditional_impl<T, U> &Item) {
-  return Item.deserialize(Data);
+  return Item.deserialize(Reader);
 }
 
 template <typename T, typename U>
-Error consume(ArrayRef<uint8_t> &Data, const serialize_array_impl<T, U> &Item) {
-  return Item.deserialize(Data);
+Error consume(msf::StreamReader &Reader,
+              const serialize_array_impl<T, U> &Item) {
+  return Item.deserialize(Reader);
 }
 
-inline Error consume(ArrayRef<uint8_t> &Data,
+inline Error consume(msf::StreamReader &Reader,
                      const serialize_null_term_string_array_impl &Item) {
-  return Item.deserialize(Data);
+  return Item.deserialize(Reader);
 }
 
 template <typename T>
-Error consume(ArrayRef<uint8_t> &Data,
+Error consume(msf::StreamReader &Reader,
               const serialize_vector_tail_impl<T> &Item) {
-  return Item.deserialize(Data);
+  return Item.deserialize(Reader);
 }
 
 template <typename T>
-Error consume(ArrayRef<uint8_t> &Data,
+Error consume(msf::StreamReader &Reader,
               const serialize_arrayref_tail_impl<T> &Item) {
-  return Item.deserialize(Data);
+  return Item.deserialize(Reader);
 }
 
 template <typename T>
-Error consume(ArrayRef<uint8_t> &Data, const serialize_numeric_impl<T> &Item) {
-  return Item.deserialize(Data);
+Error consume(msf::StreamReader &Reader,
+              const serialize_numeric_impl<T> &Item) {
+  return Item.deserialize(Reader);
 }
 
 template <typename T, typename U, typename... Args>
-Error consume(ArrayRef<uint8_t> &Data, T &&X, U &&Y, Args &&... Rest) {
-  if (auto EC = consume(Data, X))
+Error consume(msf::StreamReader &Reader, T &&X, U &&Y, Args &&... Rest) {
+  if (auto EC = consume(Reader, X))
     return EC;
-  return consume(Data, Y, std::forward<Args>(Rest)...);
+  return consume(Reader, Y, std::forward<Args>(Rest)...);
 }
 
 #define CV_DESERIALIZE(...)                                                    \
   if (auto EC = consume(__VA_ARGS__))                                          \
     return std::move(EC);
 }
 }
 
 #endif

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

 //===- SymbolDeserializer.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_SYMBOLDESERIALIZER_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLDESERIALIZER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h"
+#include "llvm/DebugInfo/MSF/ByteStream.h"
+#include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 class SymbolVisitorDelegate;
 class SymbolDeserializer : public SymbolVisitorCallbacks {
 public:
   explicit SymbolDeserializer(SymbolVisitorDelegate *Delegate)
       : Delegate(Delegate) {}
 
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
   Error visitKnownRecord(CVSymbol &CVR, Name &Record) override {               \
     return defaultVisitKnownRecord(CVR, Record);                               \
   }
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "CVSymbolTypes.def"
 
 protected:
   template <typename T>
-  Error deserializeRecord(ArrayRef<uint8_t> &Data, SymbolKind Kind,
+  Error deserializeRecord(msf::StreamReader &Reader, SymbolKind Kind,
                           T &Record) const {
-    uint32_t RecordOffset = Delegate ? Delegate->getRecordOffset(Data) : 0;
+    uint32_t RecordOffset = Delegate ? Delegate->getRecordOffset(Reader) : 0;
     SymbolRecordKind RK = static_cast<SymbolRecordKind>(Kind);
-    auto ExpectedRecord = T::deserialize(RK, RecordOffset, Data);
+    auto ExpectedRecord = T::deserialize(RK, RecordOffset, Reader);
     if (!ExpectedRecord)
       return ExpectedRecord.takeError();
     Record = std::move(*ExpectedRecord);
     return Error::success();
   }
 
 private:
   template <typename T>
   Error defaultVisitKnownRecord(CVSymbol &CVR, T &Record) {
-    ArrayRef<uint8_t> RD = CVR.content();
-    if (auto EC = deserializeRecord(RD, CVR.Type, Record))
+    msf::ByteStream S(CVR.content());
+    msf::StreamReader SR(S);
+    if (auto EC = deserializeRecord(SR, CVR.Type, Record))
       return EC;
     return Error::success();
   }
 
   SymbolVisitorDelegate *Delegate;
 };
 }
 }
 
 #endif

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

public:
   explicit ProcSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ProcSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H,
           StringRef Name)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name) {
   }
 
   static Expected<ProcSym> deserialize(SymbolRecordKind Kind,
                                        uint32_t RecordOffset,
-                                       ArrayRef<uint8_t> &Data) {
+                                       msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return ProcSym(Kind, RecordOffset, H, Name);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
public:
   explicit Thunk32Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   Thunk32Sym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H,
              StringRef Name, ArrayRef<uint8_t> VariantData)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name),
         VariantData(VariantData) {}
 
   static Expected<Thunk32Sym> deserialize(SymbolRecordKind Kind,
                                           uint32_t RecordOffset,
-                                          ArrayRef<uint8_t> &Data) {
+                                          msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
     ArrayRef<uint8_t> VariantData;
 
-    CV_DESERIALIZE(Data, H, Name, CV_ARRAY_FIELD_TAIL(VariantData));
+    CV_DESERIALIZE(Reader, H, Name, CV_ARRAY_FIELD_TAIL(VariantData));
 
     return Thunk32Sym(Kind, RecordOffset, H, Name, VariantData);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
   ArrayRef<uint8_t> VariantData;
public:
   };
 
   explicit TrampolineSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   TrampolineSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<TrampolineSym> deserialize(SymbolRecordKind Kind,
                                              uint32_t RecordOffset,
-                                             ArrayRef<uint8_t> &Data) {
+                                             msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
 
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return TrampolineSym(Kind, RecordOffset, H);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
 };
 
public:
   explicit SectionSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   SectionSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H,
              StringRef Name)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name) {
   }
 
   static Expected<SectionSym> deserialize(SymbolRecordKind Kind,
                                           uint32_t RecordOffset,
-                                          ArrayRef<uint8_t> &Data) {
+                                          msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
 
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return SectionSym(Kind, RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
   explicit CoffGroupSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   CoffGroupSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H,
                StringRef Name)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name) {
   }
 
   static Expected<CoffGroupSym> deserialize(SymbolRecordKind Kind,
                                             uint32_t RecordOffset,
-                                            ArrayRef<uint8_t> &Data) {
+                                            msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
 
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return CoffGroupSym(Kind, RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
 
 class ScopeEndSym : public SymbolRecord {
 public:
   explicit ScopeEndSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ScopeEndSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   static Expected<ScopeEndSym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     return ScopeEndSym(Kind, RecordOffset);
   }
   uint32_t RecordOffset;
 };
 
 class CallerSym : public SymbolRecord {
 public:
   struct Hdr {
     ulittle32_t Count;
   };
 
   explicit CallerSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   CallerSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *Header,
             ArrayRef<TypeIndex> Indices)
       : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*Header),
         Indices(Indices) {}
 
   static Expected<CallerSym> deserialize(SymbolRecordKind Kind,
                                          uint32_t RecordOffset,
-                                         ArrayRef<uint8_t> &Data) {
+                                         msf::StreamReader &Reader) {
     const Hdr *Header;
     ArrayRef<TypeIndex> Indices;
 
-    CV_DESERIALIZE(Data, Header, CV_ARRAY_FIELD_N(Indices, Header->Count));
+    CV_DESERIALIZE(Reader, Header, CV_ARRAY_FIELD_N(Indices, Header->Count));
 
     return CallerSym(Kind, RecordOffset, Header, Indices);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   ArrayRef<TypeIndex> Indices;
 };
public:
   explicit InlineSiteSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   InlineSiteSym(uint32_t RecordOffset, const Hdr *H,
                 ArrayRef<uint8_t> Annotations)
       : SymbolRecord(SymbolRecordKind::InlineSiteSym),
         RecordOffset(RecordOffset), Header(*H), Annotations(Annotations) {}
 
   static Expected<InlineSiteSym> deserialize(SymbolRecordKind Kind,
                                              uint32_t RecordOffset,
-                                             ArrayRef<uint8_t> &Data) {
+                                             msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<uint8_t> Annotations;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Annotations));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Annotations));
 
     return InlineSiteSym(RecordOffset, H, Annotations);
   }
 
   llvm::iterator_range<BinaryAnnotationIterator> annotations() const {
     return llvm::make_range(BinaryAnnotationIterator(Annotations),
                             BinaryAnnotationIterator());
   }
public:
 
   explicit PublicSym32(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   PublicSym32(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::PublicSym32), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<PublicSym32> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return PublicSym32(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit RegisterSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   RegisterSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::RegisterSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<RegisterSym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return RegisterSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit ProcRefSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ProcRefSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::ProcRefSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<ProcRefSym> deserialize(SymbolRecordKind Kind,
                                           uint32_t RecordOffset,
-                                          ArrayRef<uint8_t> &Data) {
+                                          msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return ProcRefSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit LocalSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   LocalSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::LocalSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<LocalSym> deserialize(SymbolRecordKind Kind,
                                         uint32_t RecordOffset,
-                                        ArrayRef<uint8_t> &Data) {
+                                        msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return LocalSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
   explicit DefRangeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   DefRangeSym(uint32_t RecordOffset, const Hdr *H,
               ArrayRef<LocalVariableAddrGap> Gaps)
       : SymbolRecord(SymbolRecordKind::DefRangeSym), RecordOffset(RecordOffset),
         Header(*H), Gaps(Gaps) {}
 
   static Expected<DefRangeSym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeSym(RecordOffset, H, Gaps);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, Range);
   }
 
public:
   explicit DefRangeSubfieldSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   DefRangeSubfieldSym(uint32_t RecordOffset, const Hdr *H,
                       ArrayRef<LocalVariableAddrGap> Gaps)
       : SymbolRecord(SymbolRecordKind::DefRangeSubfieldSym),
         RecordOffset(RecordOffset), Header(*H), Gaps(Gaps) {}
 
   static Expected<DefRangeSubfieldSym> deserialize(SymbolRecordKind Kind,
                                                    uint32_t RecordOffset,
-                                                   ArrayRef<uint8_t> &Data) {
+                                                   msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeSubfieldSym(RecordOffset, H, Gaps);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, Range);
   }
 
DefRangeRegisterSym(uint16_t Register, uint16_t MayHaveNoName,
         Gaps(Gaps) {
     Header.Register = Register;
     Header.MayHaveNoName = MayHaveNoName;
     Header.Range = {};
   }
 
   static Expected<DefRangeRegisterSym> deserialize(SymbolRecordKind Kind,
                                                    uint32_t RecordOffset,
-                                                   ArrayRef<uint8_t> &Data) {
+                                                   msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeRegisterSym(RecordOffset, H, Gaps);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, Range);
   }
 
DefRangeSubfieldRegisterSym(uint16_t Register, uint16_t MayHaveNoName,
     Header.Register = Register;
     Header.MayHaveNoName = MayHaveNoName;
     Header.OffsetInParent = OffsetInParent;
     Header.Range = {};
   }
 
   static Expected<DefRangeSubfieldRegisterSym>
   deserialize(SymbolRecordKind Kind, uint32_t RecordOffset,
-              ArrayRef<uint8_t> &Data) {
+              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeSubfieldRegisterSym(RecordOffset, H, Gaps);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, Range);
   }
 
explicit DefRangeFramePointerRelSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   DefRangeFramePointerRelSym(uint32_t RecordOffset, const Hdr *H,
                              ArrayRef<LocalVariableAddrGap> Gaps)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelSym),
         RecordOffset(RecordOffset), Header(*H), Gaps(Gaps) {}
 
   static Expected<DefRangeFramePointerRelSym>
   deserialize(SymbolRecordKind Kind, uint32_t RecordOffset,
-              ArrayRef<uint8_t> &Data) {
+              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeFramePointerRelSym(RecordOffset, H, Gaps);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, Range);
   }
 
DefRangeRegisterRelSym(uint16_t BaseRegister, uint16_t Flags,
       : SymbolRecord(SymbolRecordKind::DefRangeRegisterRelSym), RecordOffset(0),
         Gaps(Gaps) {
     Header.BaseRegister = BaseRegister;
     Header.Flags = Flags;
     Header.BasePointerOffset = BasePointerOffset;
     Header.Range = {};
   }
 
-  static Expected<DefRangeRegisterRelSym> deserialize(SymbolRecordKind Kind,
-                                                      uint32_t RecordOffset,
-                                                      ArrayRef<uint8_t> &Data) {
+  static Expected<DefRangeRegisterRelSym>
+  deserialize(SymbolRecordKind Kind, uint32_t RecordOffset,
+              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     ArrayRef<LocalVariableAddrGap> Gaps;
-    CV_DESERIALIZE(Data, H, CV_ARRAY_FIELD_TAIL(Gaps));
+    CV_DESERIALIZE(Reader, H, CV_ARRAY_FIELD_TAIL(Gaps));
 
     return DefRangeRegisterRelSym(RecordOffset, H, Gaps);
   }
 
   // The flags implement this notional bitfield:
   //   uint16_t IsSubfield : 1;
   //   uint16_t Padding : 3;
   //   uint16_t OffsetInParent : 12;
public:
   explicit DefRangeFramePointerRelFullScopeSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   DefRangeFramePointerRelFullScopeSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelFullScopeSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<DefRangeFramePointerRelFullScopeSym>
   deserialize(SymbolRecordKind Kind, uint32_t RecordOffset,
-              ArrayRef<uint8_t> &Data) {
+              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return DefRangeFramePointerRelFullScopeSym(RecordOffset, H);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
 };
 
public:
 
   explicit BlockSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   BlockSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::BlockSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<BlockSym> deserialize(SymbolRecordKind Kind,
                                         uint32_t RecordOffset,
-                                        ArrayRef<uint8_t> &Data) {
+                                        msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return BlockSym(RecordOffset, H, Name);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
public:
 
   explicit LabelSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   LabelSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::LabelSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<LabelSym> deserialize(SymbolRecordKind Kind,
                                         uint32_t RecordOffset,
-                                        ArrayRef<uint8_t> &Data) {
+                                        msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return LabelSym(RecordOffset, H, Name);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
public:
 
   explicit ObjNameSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ObjNameSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::ObjNameSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<ObjNameSym> deserialize(SymbolRecordKind Kind,
                                           uint32_t RecordOffset,
-                                          ArrayRef<uint8_t> &Data) {
+                                          msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return ObjNameSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
   explicit EnvBlockSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   EnvBlockSym(uint32_t RecordOffset, const Hdr *H,
               const std::vector<StringRef> &Fields)
       : SymbolRecord(SymbolRecordKind::EnvBlockSym), RecordOffset(RecordOffset),
         Header(*H), Fields(Fields) {}
 
   static Expected<EnvBlockSym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     std::vector<StringRef> Fields;
-    CV_DESERIALIZE(Data, H, CV_STRING_ARRAY_NULL_TERM(Fields));
+    CV_DESERIALIZE(Reader, H, CV_STRING_ARRAY_NULL_TERM(Fields));
 
     return EnvBlockSym(RecordOffset, H, Fields);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   std::vector<StringRef> Fields;
 };
public:
 
   explicit ExportSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ExportSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::ExportSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<ExportSym> deserialize(SymbolRecordKind Kind,
                                          uint32_t RecordOffset,
-                                         ArrayRef<uint8_t> &Data) {
+                                         msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return ExportSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit FileStaticSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   FileStaticSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::FileStaticSym),
         RecordOffset(RecordOffset), Header(*H), Name(Name) {}
 
   static Expected<FileStaticSym> deserialize(SymbolRecordKind Kind,
                                              uint32_t RecordOffset,
-                                             ArrayRef<uint8_t> &Data) {
+                                             msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return FileStaticSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit Compile2Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   Compile2Sym(uint32_t RecordOffset, const Hdr *H, StringRef Version)
       : SymbolRecord(SymbolRecordKind::Compile2Sym), RecordOffset(RecordOffset),
         Header(*H), Version(Version) {}
 
   static Expected<Compile2Sym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Version;
-    CV_DESERIALIZE(Data, H, Version);
+    CV_DESERIALIZE(Reader, H, Version);
 
     return Compile2Sym(RecordOffset, H, Version);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Version;
 };
public:
 
   explicit Compile3Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   Compile3Sym(uint32_t RecordOffset, const Hdr *H, StringRef Version)
       : SymbolRecord(SymbolRecordKind::Compile3Sym), RecordOffset(RecordOffset),
         Header(*H), Version(Version) {}
 
   static Expected<Compile3Sym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Version;
-    CV_DESERIALIZE(Data, H, Version);
+    CV_DESERIALIZE(Reader, H, Version);
 
     return Compile3Sym(RecordOffset, H, Version);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Version;
 };
public:
 
   explicit FrameProcSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   FrameProcSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::FrameProcSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<FrameProcSym> deserialize(SymbolRecordKind Kind,
                                             uint32_t RecordOffset,
-                                            ArrayRef<uint8_t> &Data) {
+                                            msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return FrameProcSym(RecordOffset, H);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
 };
 
public:
 
   explicit CallSiteInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   CallSiteInfoSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::CallSiteInfoSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<CallSiteInfoSym> deserialize(SymbolRecordKind Kind,
                                                uint32_t RecordOffset,
-                                               ArrayRef<uint8_t> &Data) {
+                                               msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return CallSiteInfoSym(RecordOffset, H);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
struct Hdr {
     TypeIndex Type;
   };
 
   explicit HeapAllocationSiteSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   HeapAllocationSiteSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::HeapAllocationSiteSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
-  static Expected<HeapAllocationSiteSym> deserialize(SymbolRecordKind Kind,
-                                                     uint32_t RecordOffset,
-                                                     ArrayRef<uint8_t> &Data) {
+  static Expected<HeapAllocationSiteSym>
+  deserialize(SymbolRecordKind Kind, uint32_t RecordOffset,
+              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return HeapAllocationSiteSym(RecordOffset, H);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
public:
 
   explicit FrameCookieSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   FrameCookieSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::FrameCookieSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<FrameCookieSym> deserialize(SymbolRecordKind Kind,
                                               uint32_t RecordOffset,
-                                              ArrayRef<uint8_t> &Data) {
+                                              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return FrameCookieSym(RecordOffset, H);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, CodeOffset);
   }
 
public:
 
   explicit UDTSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   UDTSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::UDTSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<UDTSym> deserialize(SymbolRecordKind Kind,
                                       uint32_t RecordOffset,
-                                      ArrayRef<uint8_t> &Data) {
+                                      msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return UDTSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
 
 // S_BUILDINFO
 class BuildInfoSym : public SymbolRecord {
 public:
   struct Hdr {
     ulittle32_t BuildId;
   };
 
   explicit BuildInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   BuildInfoSym(uint32_t RecordOffset, const Hdr *H)
       : SymbolRecord(SymbolRecordKind::BuildInfoSym),
         RecordOffset(RecordOffset), Header(*H) {}
 
   static Expected<BuildInfoSym> deserialize(SymbolRecordKind Kind,
                                             uint32_t RecordOffset,
-                                            ArrayRef<uint8_t> &Data) {
+                                            msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
-    CV_DESERIALIZE(Data, H);
+    CV_DESERIALIZE(Reader, H);
 
     return BuildInfoSym(RecordOffset, H);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
 };
 
 // S_BPREL32
 class BPRelativeSym : public SymbolRecord {
 public:
   struct Hdr {
     little32_t Offset; // Offset from the base pointer register
     TypeIndex Type;    // Type of the variable
                        // Name: The null-terminated name follows.
   };
 
   explicit BPRelativeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   BPRelativeSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::BPRelativeSym),
         RecordOffset(RecordOffset), Header(*H), Name(Name) {}
 
   static Expected<BPRelativeSym> deserialize(SymbolRecordKind Kind,
                                              uint32_t RecordOffset,
-                                             ArrayRef<uint8_t> &Data) {
+                                             msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return BPRelativeSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
 
   explicit RegRelativeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   RegRelativeSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::RegRelativeSym),
         RecordOffset(RecordOffset), Header(*H), Name(Name) {}
 
   static Expected<RegRelativeSym> deserialize(SymbolRecordKind Kind,
                                               uint32_t RecordOffset,
-                                              ArrayRef<uint8_t> &Data) {
+                                              msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return RegRelativeSym(RecordOffset, H, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   StringRef Name;
 };
public:
   explicit ConstantSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ConstantSym(uint32_t RecordOffset, const Hdr *H, const APSInt &Value,
               StringRef Name)
       : SymbolRecord(SymbolRecordKind::ConstantSym), RecordOffset(RecordOffset),
         Header(*H), Value(Value), Name(Name) {}
 
   static Expected<ConstantSym> deserialize(SymbolRecordKind Kind,
                                            uint32_t RecordOffset,
-                                           ArrayRef<uint8_t> &Data) {
+                                           msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     APSInt Value;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Value, Name);
+    CV_DESERIALIZE(Reader, H, Value, Name);
 
     return ConstantSym(RecordOffset, H, Value, Name);
   }
 
   uint32_t RecordOffset;
   Hdr Header;
   APSInt Value;
   StringRef Name;
public:
 
   explicit DataSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   DataSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::DataSym), RecordOffset(RecordOffset),
         Header(*H), Name(Name) {}
 
   static Expected<DataSym> deserialize(SymbolRecordKind Kind,
                                        uint32_t RecordOffset,
-                                       ArrayRef<uint8_t> &Data) {
+                                       msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return DataSym(RecordOffset, H, Name);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, DataOffset);
   }
 
public:
 
   explicit ThreadLocalDataSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ThreadLocalDataSym(uint32_t RecordOffset, const Hdr *H, StringRef Name)
       : SymbolRecord(SymbolRecordKind::ThreadLocalDataSym),
         RecordOffset(RecordOffset), Header(*H), Name(Name) {}
 
   static Expected<ThreadLocalDataSym> deserialize(SymbolRecordKind Kind,
                                                   uint32_t RecordOffset,
-                                                  ArrayRef<uint8_t> &Data) {
+                                                  msf::StreamReader &Reader) {
     const Hdr *H = nullptr;
     StringRef Name;
-    CV_DESERIALIZE(Data, H, Name);
+    CV_DESERIALIZE(Reader, H, Name);
 
     return ThreadLocalDataSym(RecordOffset, H, Name);
   }
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + offsetof(Hdr, DataOffset);
   }
 

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

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <stdint.h>
 
 namespace llvm {
 
+namespace msf {
+class StreamReader;
+}
+
 namespace codeview {
 
 class SymbolVisitorDelegate {
 public:
   virtual ~SymbolVisitorDelegate() {}
 
-  virtual uint32_t getRecordOffset(ArrayRef<uint8_t> Record) = 0;
+  virtual uint32_t getRecordOffset(msf::StreamReader Reader) = 0;
   virtual StringRef getFileNameForFileOffset(uint32_t FileOffset) = 0;
   virtual StringRef getStringTable() = 0;
 };
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLVISITORDELEGATE_H

llvm/trunk/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/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/DebugInfo/Msf/ByteStream.h"
+#include "llvm/DebugInfo/Msf/StreamReader.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 class TypeDeserializer : public TypeVisitorCallbacks {
 public:
   TypeDeserializer() {}
 
 #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);                               \
   }
 #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(ArrayRef<uint8_t> &Data, TypeLeafKind Kind,
+  Error deserializeRecord(msf::StreamReader &Reader, TypeLeafKind Kind,
                           T &Record) const {
     TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
-    auto ExpectedRecord = T::deserialize(RK, Data);
+    auto ExpectedRecord = T::deserialize(RK, Reader);
     if (!ExpectedRecord)
       return ExpectedRecord.takeError();
     Record = std::move(*ExpectedRecord);
     return Error::success();
   }
 
 private:
   template <typename T> Error defaultVisitKnownRecord(CVType &CVR, T &Record) {
-    ArrayRef<uint8_t> RD = CVR.content();
-    if (auto EC = deserializeRecord(RD, CVR.Type, Record))
+    msf::ByteStream S(CVR.content());
+    msf::StreamReader SR(S);
+    if (auto EC = deserializeRecord(SR, CVR.Type, Record))
       return EC;
     return Error::success();
   }
   template <typename T>
   Error defaultVisitKnownMember(CVMemberRecord &CVMR, T &Record) {
-    ArrayRef<uint8_t> RD = CVMR.Data;
-    if (auto EC = deserializeRecord(RD, CVMR.Kind, Record))
+    msf::ByteStream S(CVMR.Data);
+    msf::StreamReader SR(S);
+    if (auto EC = deserializeRecord(SR, CVMR.Kind, Record))
       return EC;
     return Error::success();
   }
 };
 }
 }
 
 #endif

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

 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Error.h"
 #include <cinttypes>
 #include <utility>
 
 namespace llvm {
+
+namespace msf {
+class StreamReader;
+}
+
 namespace codeview {
 
 using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
 typedef CVRecord<TypeLeafKind> CVType;
 
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(ArrayRef<uint8_t> &Data);
+  static Expected<MemberPointerInfo> deserialize(msf::StreamReader &Reader);
 
   TypeIndex getContainingType() const { return ContainingType; }
   PointerToMemberRepresentation getRepresentation() const {
     return Representation;
   }
 
   TypeIndex ContainingType;
   PointerToMemberRepresentation Representation;
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,
-                                              ArrayRef<uint8_t> &Data);
+                                              msf::StreamReader &Reader);
 
   TypeIndex getModifiedType() const { return ModifiedType; }
   ModifierOptions getModifiers() const { return Modifiers; }
 
   TypeIndex ModifiedType;
   ModifierOptions Modifiers;
 
 private:
ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
         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,
-                                               ArrayRef<uint8_t> &Data);
+                                               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; }
MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
         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,
-                                                    ArrayRef<uint8_t> &Data);
+                                                    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; }
MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
       : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
         FunctionType(FunctionType), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<MemberFuncIdRecord> deserialize(TypeRecordKind Kind,
-                                                  ArrayRef<uint8_t> &Data);
+                                                  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:
public:
   ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
       : TypeRecord(Kind), StringIndices(Indices) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<ArgListRecord> deserialize(TypeRecordKind Kind,
-                                             ArrayRef<uint8_t> &Data);
+                                             msf::StreamReader &Reader);
 
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
   std::vector<TypeIndex> StringIndices;
 
 private:
PointerRecord(TypeIndex ReferentType, PointerKind Kind, PointerMode Mode,
         PtrKind(Kind), Mode(Mode), Options(Options), Size(Size),
         MemberInfo(Member) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<PointerRecord> deserialize(TypeRecordKind Kind,
-                                             ArrayRef<uint8_t> &Data);
+                                             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; }
   MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
 
public:
   NestedTypeRecord(TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<NestedTypeRecord> deserialize(TypeRecordKind Kind,
-                                                ArrayRef<uint8_t> &Data);
+                                                msf::StreamReader &Reader);
 
   TypeIndex getNestedType() const { return Type; }
   StringRef getName() const { return Name; }
 
   TypeIndex Type;
   StringRef Name;
 
 private:
public:
   explicit FieldListRecord(ArrayRef<uint8_t> Data)
       : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap) { return false; }
 
   static Expected<FieldListRecord> deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data);
+                                               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,
-                                           ArrayRef<uint8_t> &Data);
+                                           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;
ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
         Hfa(Hfa), WinRTKind(WinRTKind), DerivationList(DerivationList),
         VTableShape(VTableShape), Size(Size) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<ClassRecord> deserialize(TypeRecordKind Kind,
-                                           ArrayRef<uint8_t> &Data);
+                                           msf::StreamReader &Reader);
 
   HfaKind getHfa() const { return Hfa; }
   WindowsRTClassKind getWinRTKind() const { return WinRTKind; }
   TypeIndex getDerivationList() const { return DerivationList; }
   TypeIndex getVTableShape() const { return VTableShape; }
   uint64_t getSize() const { return Size; }
 
   HfaKind Hfa;
struct UnionRecord : public TagRecord {
   UnionRecord(uint16_t MemberCount, ClassOptions Options, HfaKind Hfa,
               TypeIndex FieldList, uint64_t Size, StringRef Name,
               StringRef UniqueName)
       : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
                   UniqueName),
         Hfa(Hfa), Size(Size) {}
 
   static Expected<UnionRecord> deserialize(TypeRecordKind Kind,
-                                           ArrayRef<uint8_t> &Data);
+                                           msf::StreamReader &Reader);
 
   HfaKind getHfa() const { return Hfa; }
   uint64_t getSize() const { return Size; }
 
   HfaKind Hfa;
   uint64_t Size;
 
 private:
EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
       : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
                   UniqueName),
         UnderlyingType(UnderlyingType) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<EnumRecord> deserialize(TypeRecordKind Kind,
-                                          ArrayRef<uint8_t> &Data);
+                                          msf::StreamReader &Reader);
 
   TypeIndex getUnderlyingType() const { return UnderlyingType; }
   TypeIndex UnderlyingType;
 
 private:
   struct Layout {
     ulittle16_t NumEnumerators; // Number of enumerators
     ulittle16_t Properties;
BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
       : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),
         BitOffset(BitOffset) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<BitFieldRecord> deserialize(TypeRecordKind Kind,
-                                              ArrayRef<uint8_t> &Data);
+                                              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;
 
public:
   explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<VFTableShapeRecord> deserialize(TypeRecordKind Kind,
-                                                  ArrayRef<uint8_t> &Data);
+                                                  msf::StreamReader &Reader);
 
   ArrayRef<VFTableSlotKind> getSlots() const {
     if (!SlotsRef.empty())
       return SlotsRef;
     return Slots;
   }
   uint32_t getEntryCount() const { return getSlots().size(); }
   ArrayRef<VFTableSlotKind> SlotsRef;
TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
       : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
         Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<TypeServer2Record> deserialize(TypeRecordKind Kind,
-                                                 ArrayRef<uint8_t> &Data);
+                                                 msf::StreamReader &Reader);
 
   StringRef getGuid() const { return Guid; }
 
   uint32_t getAge() const { return Age; }
 
   StringRef getName() const { return Name; }
   StringRef Guid;
   uint32_t Age;
public:
   StringIdRecord(TypeIndex Id, StringRef String)
       : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<StringIdRecord> deserialize(TypeRecordKind Kind,
-                                              ArrayRef<uint8_t> &Data);
+                                              msf::StreamReader &Reader);
 
   TypeIndex getId() const { return Id; }
 
   StringRef getString() const { return String; }
   TypeIndex Id;
   StringRef String;
 
 private:
FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
       : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
         FunctionType(FunctionType), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<FuncIdRecord> deserialize(TypeRecordKind Kind,
-                                            ArrayRef<uint8_t> &Data);
+                                            msf::StreamReader &Reader);
 
   TypeIndex getParentScope() const { return ParentScope; }
 
   TypeIndex getFunctionType() const { return FunctionType; }
 
   StringRef getName() const { return Name; }
   TypeIndex ParentScope;
   TypeIndex FunctionType;
UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<UdtSourceLineRecord> deserialize(TypeRecordKind Kind,
-                                                   ArrayRef<uint8_t> &Data);
+                                                   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;
 
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,
-                                                      ArrayRef<uint8_t> &Data) {
+  static Expected<UdtModSourceLineRecord>
+  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
     const Layout *L = nullptr;
-    CV_DESERIALIZE(Data, L);
+    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; }
BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
       : TypeRecord(TypeRecordKind::BuildInfo),
         ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<BuildInfoRecord> deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data);
+                                               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
VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNames(Methods) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<VFTableRecord> deserialize(TypeRecordKind Kind,
-                                             ArrayRef<uint8_t> &Data);
+                                             msf::StreamReader &Reader);
 
   TypeIndex getCompleteClass() const { return CompleteClass; }
   TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
   uint32_t getVFPtrOffset() const { return VFPtrOffset; }
   StringRef getName() const { return Name; }
   ArrayRef<StringRef> getMethodNames() const {
     if (!MethodNamesRef.empty())
       return MethodNamesRef;
OneMethodRecord(TypeIndex Type, MethodKind Kind, MethodOptions Options,
         Options(Options), Access(Access), VFTableOffset(VFTableOffset),
         Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<OneMethodRecord> deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data);
+                                               msf::StreamReader &Reader);
 
   TypeIndex getType() const { return Type; }
   MethodKind getKind() const { return Kind; }
   MethodOptions getOptions() const { return Options; }
   MemberAccess getAccess() const { return Access; }
   int32_t getVFTableOffset() const { return VFTableOffset; }
   StringRef getName() const { return Name; }
 
public:
   MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
       : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<MethodOverloadListRecord>
-  deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data);
+  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader);
 
   ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
   std::vector<OneMethodRecord> Methods;
 
 private:
   struct Layout {
     MemberAttributes Attrs;
     ulittle16_t Padding;
OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
                          StringRef Name)
       : TypeRecord(TypeRecordKind::OverloadedMethod),
         NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<OverloadedMethodRecord> deserialize(TypeRecordKind Kind,
-                                                      ArrayRef<uint8_t> &Data);
+  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;
 
DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
       : TypeRecord(TypeRecordKind::DataMember), Access(Access), Type(Type),
         FieldOffset(Offset), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<DataMemberRecord> deserialize(TypeRecordKind Kind,
-                                                ArrayRef<uint8_t> &Data);
+                                                msf::StreamReader &Reader);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   uint64_t getFieldOffset() const { return FieldOffset; }
   StringRef getName() const { return Name; }
   MemberAccess Access;
   TypeIndex Type;
   uint64_t FieldOffset;
public:
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::StaticDataMember), Access(Access),
         Type(Type), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<StaticDataMemberRecord> deserialize(TypeRecordKind Kind,
-                                                      ArrayRef<uint8_t> &Data);
+  static Expected<StaticDataMemberRecord>
+  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   StringRef getName() const { return Name; }
   MemberAccess Access;
   TypeIndex Type;
   StringRef Name;
 
EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerator), Access(Access),
         Value(std::move(Value)), Name(Name) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<EnumeratorRecord> deserialize(TypeRecordKind Kind,
-                                                ArrayRef<uint8_t> &Data);
+                                                msf::StreamReader &Reader);
 
   MemberAccess getAccess() const { return Access; }
   APSInt getValue() const { return Value; }
   StringRef getName() const { return Name; }
   MemberAccess Access;
   APSInt Value;
   StringRef Name;
 
public:
   VFPtrRecord(TypeIndex Type)
       : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<VFPtrRecord> deserialize(TypeRecordKind Kind,
-                                           ArrayRef<uint8_t> &Data);
+                                           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(MemberAccess Access, TypeIndex Type, uint64_t Offset)
       : TypeRecord(TypeRecordKind::BaseClass), Access(Access), Type(Type),
         Offset(Offset) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static Expected<BaseClassRecord> deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data);
+                                               msf::StreamReader &Reader);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return Type; }
   uint64_t getBaseOffset() const { return Offset; }
   MemberAccess Access;
   TypeIndex Type;
   uint64_t Offset;
 
VirtualBaseClassRecord(MemberAccess Access, TypeIndex BaseType,
       : TypeRecord(TypeRecordKind::VirtualBaseClass), Access(Access),
         BaseType(BaseType), VBPtrType(VBPtrType), VBPtrOffset(Offset),
         VTableIndex(Index) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<VirtualBaseClassRecord> deserialize(TypeRecordKind Kind,
-                                                      ArrayRef<uint8_t> &Data);
+  static Expected<VirtualBaseClassRecord>
+  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader);
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }
   uint64_t getVBPtrOffset() const { return VBPtrOffset; }
   uint64_t getVTableIndex() const { return VTableIndex; }
   MemberAccess Access;
   TypeIndex BaseType;
public:
   ListContinuationRecord(TypeIndex ContinuationIndex)
       : TypeRecord(TypeRecordKind::ListContinuation),
         ContinuationIndex(ContinuationIndex) {}
 
   TypeIndex getContinuationIndex() const { return ContinuationIndex; }
 
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
-  static Expected<ListContinuationRecord> deserialize(TypeRecordKind Kind,
-                                                      ArrayRef<uint8_t> &Data);
+  static Expected<ListContinuationRecord>
+  deserialize(TypeRecordKind Kind, msf::StreamReader &Reader);
   TypeIndex ContinuationIndex;
 
 private:
   struct Layout {
     ulittle16_t Pad0;
     TypeIndex ContinuationIndex;
   };
 };
 
 }
 }
 
 #endif

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

 
 namespace llvm {
 namespace msf {
 
 class ByteStream : public ReadableStream {
 public:
   ByteStream() {}
   explicit ByteStream(ArrayRef<uint8_t> Data) : Data(Data) {}
+  explicit ByteStream(StringRef Data)
+      : Data(Data.bytes_begin(), Data.bytes_end()) {}
 
   Error readBytes(uint32_t Offset, uint32_t Size,
                   ArrayRef<uint8_t> &Buffer) const override {
     if (Offset > Data.size())
       return make_error<MSFError>(msf_error_code::insufficient_buffer);
     if (Data.size() < Size + Offset)
       return make_error<MSFError>(msf_error_code::insufficient_buffer);
     Buffer = Data.slice(Offset, Size);

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

 namespace msf {
 
 class StreamReader {
 public:
   StreamReader(ReadableStreamRef Stream);
 
   Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);
   Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
+  Error readInteger(uint8_t &Dest);
   Error readInteger(uint16_t &Dest);
   Error readInteger(uint32_t &Dest);
+  Error readInteger(uint64_t &Dest);
+  Error readInteger(int8_t &Dest);
+  Error readInteger(int16_t &Dest);
+  Error readInteger(int32_t &Dest);
+  Error readInteger(int64_t &Dest);
   Error readZeroString(StringRef &Dest);
   Error readFixedString(StringRef &Dest, uint32_t Length);
   Error readStreamRef(ReadableStreamRef &Ref);
   Error readStreamRef(ReadableStreamRef &Ref, uint32_t Length);
 
   template <typename T> Error readEnum(T &Dest) {
     typename std::underlying_type<T>::type N;
     if (auto EC = readInteger(N))
public:
   }
 
   bool empty() const { return bytesRemaining() == 0; }
   void setOffset(uint32_t Off) { Offset = Off; }
   uint32_t getOffset() const { return Offset; }
   uint32_t getLength() const { return Stream.getLength(); }
   uint32_t bytesRemaining() const { return getLength() - getOffset(); }
 
+  Error skip(uint32_t Amount);
+
+  uint8_t peek() const;
+
 private:
   ReadableStreamRef Stream;
   uint32_t Offset;
 };
 } // namespace msf
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_MSF_STREAMREADER_H

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

 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
-template <typename T>
-static Error takeObject(ArrayRef<uint8_t> &Data, const T *&Res) {
-  if (Data.size() < sizeof(*Res))
-    return llvm::make_error<CodeViewError>(cv_error_code::insufficient_buffer);
-  Res = reinterpret_cast<const T *>(Data.data());
-  Data = Data.drop_front(sizeof(*Res));
+static Error skipPadding(msf::StreamReader &Reader) {
+  if (Reader.empty())
     return Error::success();
-}
 
-static Error skipPadding(ArrayRef<uint8_t> &Data) {
-  if (Data.empty())
-    return Error::success();
-  uint8_t Leaf = Data.front();
+  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;
-  if (Data.size() < BytesToAdvance) {
-    return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                           "Invalid padding bytes!");
-  }
-  Data = Data.drop_front(BytesToAdvance);
-  return Error::success();
+  return Reader.skip(BytesToAdvance);
 }
 
 template <typename T>
-static Expected<CVMemberRecord> deserializeMemberRecord(ArrayRef<uint8_t> &Data,
-                                                        TypeLeafKind Kind) {
-  ArrayRef<uint8_t> OldData = Data;
+static Expected<CVMemberRecord>
+deserializeMemberRecord(msf::StreamReader &Reader, TypeLeafKind Kind) {
+  msf::StreamReader OldReader = Reader;
   TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
-  auto ExpectedRecord = T::deserialize(RK, Data);
+  auto ExpectedRecord = T::deserialize(RK, Reader);
   if (!ExpectedRecord)
     return ExpectedRecord.takeError();
-  assert(Data.size() < OldData.size());
-  if (auto EC = skipPadding(Data))
+  assert(Reader.bytesRemaining() < OldReader.bytesRemaining());
+  if (auto EC = skipPadding(Reader))
     return std::move(EC);
 
   CVMemberRecord CVMR;
   CVMR.Kind = Kind;
-  CVMR.Data = OldData.drop_back(Data.size());
+
+  uint32_t RecordLength = OldReader.bytesRemaining() - Reader.bytesRemaining();
+  if (auto EC = OldReader.readBytes(CVMR.Data, RecordLength))
+    return std::move(EC);
+
   return CVMR;
 }
 
 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
     : Callbacks(Callbacks) {}
 
 template <typename T>
 static Error visitKnownRecord(CVType &Record, TypeVisitorCallbacks &Callbacks) {
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(ArrayRef<uint8_t> &Data, TypeLeafKind Leaf,
+static Error visitKnownMember(msf::StreamReader &Reader, TypeLeafKind Leaf,
                               TypeVisitorCallbacks &Callbacks) {
-  auto ExpectedRecord = deserializeMemberRecord<MR>(Data, Leaf);
+  auto ExpectedRecord = deserializeMemberRecord<MR>(Reader, Leaf);
   if (!ExpectedRecord)
     return ExpectedRecord.takeError();
   CVMemberRecord &Record = *ExpectedRecord;
   if (auto EC = Callbacks.visitMemberBegin(Record))
     return EC;
   if (auto EC = visitKnownMember<MR>(Record, Callbacks))
     return EC;
   if (auto EC = Callbacks.visitMemberEnd(Record))
     return EC;
   return Error::success();
 }
 
-Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef<uint8_t> Data) {
-  while (!Data.empty()) {
-    const support::ulittle16_t *LeafValue;
-    if (auto EC = takeObject(Data, LeafValue))
+Error CVTypeVisitor::visitFieldListMemberStream(msf::StreamReader Reader) {
+  TypeLeafKind Leaf;
+  while (!Reader.empty()) {
+    if (auto EC = Reader.readEnum(Leaf))
       return EC;
 
-    TypeLeafKind Leaf = static_cast<TypeLeafKind>(uint16_t(*LeafValue));
     CVType Record;
     switch (Leaf) {
     default:
       // Field list records do not describe their own length, so we cannot
       // continue parsing past a type that we don't know how to deserialize.
       return llvm::make_error<CodeViewError>(
           cv_error_code::unknown_member_record);
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
-    if (auto EC = visitKnownMember<Name##Record>(Data, Leaf, Callbacks))       \
+    if (auto EC = visitKnownMember<Name##Record>(Reader, Leaf, Callbacks))     \
       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);
+}

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/MSF/ByteStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::support;
 
 /// 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.
 StringRef llvm::codeview::getBytesAsCharacters(ArrayRef<uint8_t> LeafData) {
   return StringRef(reinterpret_cast<const char *>(LeafData.data()),
                    LeafData.size());
 }
 
 StringRef llvm::codeview::getBytesAsCString(ArrayRef<uint8_t> LeafData) {
   return getBytesAsCharacters(LeafData).split('\0').first;
 }
 
-Error llvm::codeview::consume(ArrayRef<uint8_t> &Data, APSInt &Num) {
+Error llvm::codeview::consume(msf::StreamReader &Reader, APSInt &Num) {
   // Used to avoid overload ambiguity on APInt construtor.
   bool FalseVal = false;
-  if (Data.size() < 2)
-    return make_error<CodeViewError>(
-        cv_error_code::insufficient_buffer,
-        "Buffer does not contain enough data for an APSInt");
-  uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
-  Data = Data.drop_front(2);
+  uint16_t Short;
+  if (auto EC = Reader.readInteger(Short))
+    return EC;
+
   if (Short < LF_NUMERIC) {
     Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
                  /*isUnsigned=*/true);
     return Error::success();
   }
+
   switch (Short) {
-  case LF_CHAR:
-    if (Data.size() < 1)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_CHAR");
-    Num = APSInt(APInt(/*numBits=*/8,
-                       *reinterpret_cast<const int8_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(1);
-    return Error::success();
-  case LF_SHORT:
-    if (Data.size() < 2)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_SHORT");
-    Num = APSInt(APInt(/*numBits=*/16,
-                       *reinterpret_cast<const little16_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(2);
-    return Error::success();
-  case LF_USHORT:
-    if (Data.size() < 2)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_USHORT");
-    Num = APSInt(APInt(/*numBits=*/16,
-                       *reinterpret_cast<const ulittle16_t *>(Data.data()),
-                       /*isSigned=*/false),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(2);
+  case LF_CHAR: {
+    int8_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(8, N, true), false);
     return Error::success();
-  case LF_LONG:
-    if (Data.size() < 4)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_LONG");
-    Num = APSInt(APInt(/*numBits=*/32,
-                       *reinterpret_cast<const little32_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(4);
-    return Error::success();
-  case LF_ULONG:
-    if (Data.size() < 4)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_ULONG");
-    Num = APSInt(APInt(/*numBits=*/32,
-                       *reinterpret_cast<const ulittle32_t *>(Data.data()),
-                       /*isSigned=*/FalseVal),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(4);
+  }
+  case LF_SHORT: {
+    int16_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(16, N, true), false);
     return Error::success();
-  case LF_QUADWORD:
-    if (Data.size() < 8)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_QUADWORD");
-    Num = APSInt(APInt(/*numBits=*/64,
-                       *reinterpret_cast<const little64_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(8);
-    return Error::success();
-  case LF_UQUADWORD:
-    if (Data.size() < 8)
-      return make_error<CodeViewError>(
-          cv_error_code::insufficient_buffer,
-          "Buffer does not contain enough data for an LF_UQUADWORD");
-    Num = APSInt(APInt(/*numBits=*/64,
-                       *reinterpret_cast<const ulittle64_t *>(Data.data()),
-                       /*isSigned=*/false),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(8);
+  }
+  case LF_USHORT: {
+    uint16_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(16, N, false), true);
+    return Error::success();
+  }
+  case LF_LONG: {
+    int32_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(32, N, true), false);
     return Error::success();
   }
+  case LF_ULONG: {
+    uint32_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(32, N, FalseVal), true);
+    return Error::success();
+  }
+  case LF_QUADWORD: {
+    int64_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(64, N, true), false);
+    return Error::success();
+  }
+  case LF_UQUADWORD: {
+    uint64_t N;
+    if (auto EC = Reader.readInteger(N))
+      return EC;
+    Num = APSInt(APInt(64, N, false), true);
+    return Error::success();
+  }
+  }
   return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                    "Buffer contains invalid APSInt type");
 }
 
 Error llvm::codeview::consume(StringRef &Data, APSInt &Num) {
   ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end());
-  auto EC = consume(Bytes, Num);
-  Data = StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size());
+  msf::ByteStream S(Bytes);
+  msf::StreamReader SR(S);
+  auto EC = consume(SR, Num);
+  Data = Data.take_back(SR.bytesRemaining());
   return EC;
 }
 
 /// Decode a numeric leaf value that is known to be a uint64_t.
-Error llvm::codeview::consume_numeric(ArrayRef<uint8_t> &Data, uint64_t &Num) {
+Error llvm::codeview::consume_numeric(msf::StreamReader &Reader,
+                                      uint64_t &Num) {
   APSInt N;
-  if (auto EC = consume(Data, N))
+  if (auto EC = consume(Reader, N))
     return EC;
   if (N.isSigned() || !N.isIntN(64))
     return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                      "Data is not a numeric value!");
   Num = N.getLimitedValue();
   return Error::success();
 }
 
-Error llvm::codeview::consume(ArrayRef<uint8_t> &Data, uint32_t &Item) {
-  const support::ulittle32_t *IntPtr;
-  if (auto EC = consumeObject(Data, IntPtr))
-    return EC;
-  Item = *IntPtr;
-  return Error::success();
+Error llvm::codeview::consume(msf::StreamReader &Reader, uint32_t &Item) {
+  return Reader.readInteger(Item);
 }
 
 Error llvm::codeview::consume(StringRef &Data, uint32_t &Item) {
   ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end());
-  auto EC = consume(Bytes, Item);
-  Data = StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size());
+  msf::ByteStream S(Bytes);
+  msf::StreamReader SR(S);
+  auto EC = consume(SR, Item);
+  Data = Data.take_back(SR.bytesRemaining());
   return EC;
 }
 
-Error llvm::codeview::consume(ArrayRef<uint8_t> &Data, int32_t &Item) {
-  const support::little32_t *IntPtr;
-  if (auto EC = consumeObject(Data, IntPtr))
-    return EC;
-  Item = *IntPtr;
-  return Error::success();
+Error llvm::codeview::consume(msf::StreamReader &Reader, int32_t &Item) {
+  return Reader.readInteger(Item);
 }
 
-Error llvm::codeview::consume(ArrayRef<uint8_t> &Data, StringRef &Item) {
-  if (Data.empty())
+Error llvm::codeview::consume(msf::StreamReader &Reader, StringRef &Item) {
+  if (Reader.empty())
     return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                      "Null terminated string buffer is empty!");
 
-  StringRef Rest;
-  std::tie(Item, Rest) = getBytesAsCharacters(Data).split('\0');
-  // We expect this to be null terminated.  If it was not, it is an error.
-  if (Data.size() == Item.size())
-    return make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                     "Expected null terminator!");
-
-  Data = ArrayRef<uint8_t>(Rest.bytes_begin(), Rest.bytes_end());
-  return Error::success();
+  return Reader.readZeroString(Item);
 }

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

 //===-- TypeRecord.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #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(ArrayRef<uint8_t> &Data) {
+MemberPointerInfo::deserialize(msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  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,
-                                                     ArrayRef<uint8_t> &Data) {
+Expected<ModifierRecord>
+ModifierRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  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, ArrayRef<uint8_t> &Data) {
+ProcedureRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  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,
-                                  ArrayRef<uint8_t> &Data) {
+                                  msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  CV_DESERIALIZE(Data, L);
+  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, ArrayRef<uint8_t> &Data) {
+MemberFuncIdRecord::deserialize(TypeRecordKind Kind,
+                                msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return MemberFuncIdRecord(L->ClassType, L->FunctionType, Name);
 }
 
 Expected<ArgListRecord> ArgListRecord::deserialize(TypeRecordKind Kind,
-                                                   ArrayRef<uint8_t> &Data) {
+                                                   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(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
+  CV_DESERIALIZE(Reader, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
   return ArgListRecord(Kind, Indices);
 }
 
 Expected<PointerRecord> PointerRecord::deserialize(TypeRecordKind Kind,
-                                                   ArrayRef<uint8_t> &Data) {
+                                                   msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  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(Data))
+    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, ArrayRef<uint8_t> &Data) {
+NestedTypeRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return NestedTypeRecord(L->Type, Name);
 }
 
 Expected<FieldListRecord>
-FieldListRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
-  auto FieldListData = Data;
-  Data = ArrayRef<uint8_t>();
-  return FieldListRecord(FieldListData);
+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,
-                                               ArrayRef<uint8_t> &Data) {
+                                               msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   uint64_t Size;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Size), Name);
+  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Size), Name);
   return ArrayRecord(L->ElementType, L->IndexType, Size, Name);
 }
 
 Expected<ClassRecord> ClassRecord::deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data) {
+                                               msf::StreamReader &Reader) {
   uint64_t Size = 0;
   StringRef Name;
   StringRef UniqueName;
   uint16_t Props;
   const Layout *L = nullptr;
 
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Size), Name,
+  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,
-                                               ArrayRef<uint8_t> &Data) {
+                                               msf::StreamReader &Reader) {
   uint64_t Size = 0;
   StringRef Name;
   StringRef UniqueName;
   uint16_t Props;
 
   const Layout *L = nullptr;
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Size), Name,
+  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,
-                                             ArrayRef<uint8_t> &Data) {
+                                             msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
   StringRef UniqueName;
-  CV_DESERIALIZE(Data, L, Name,
+  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,
-                                                     ArrayRef<uint8_t> &Data) {
+Expected<BitFieldRecord>
+BitFieldRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  CV_DESERIALIZE(Data, L);
+  CV_DESERIALIZE(Reader, L);
   return BitFieldRecord(L->Type, L->BitSize, L->BitOffset);
 }
 
 Expected<VFTableShapeRecord>
-VFTableShapeRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+VFTableShapeRecord::deserialize(TypeRecordKind Kind,
+                                msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  if (auto EC = Reader.readObject(L))
     return std::move(EC);
 
   std::vector<VFTableSlotKind> Slots;
   uint16_t Count = L->VFEntryCount;
   while (Count > 0) {
-    if (Data.empty())
-      return make_error<CodeViewError>(cv_error_code::corrupt_record,
-                                       "VTableShapeRecord contains no entries");
-
     // Process up to 2 nibbles at a time (if there are at least 2 remaining)
-    uint8_t Value = Data[0] & 0x0F;
+    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[0] & 0xF0) >> 4;
+      Value = (Data & 0xF0) >> 4;
       Slots.push_back(static_cast<VFTableSlotKind>(Value));
       --Count;
     }
-    Data = Data.slice(1);
   }
 
   return VFTableShapeRecord(Slots);
 }
 
 Expected<TypeServer2Record>
-TypeServer2Record::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+TypeServer2Record::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return TypeServer2Record(StringRef(L->Guid, 16), L->Age, Name);
 }
 
-Expected<StringIdRecord> StringIdRecord::deserialize(TypeRecordKind Kind,
-                                                     ArrayRef<uint8_t> &Data) {
+Expected<StringIdRecord>
+StringIdRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return StringIdRecord(L->id, Name);
 }
 
 Expected<FuncIdRecord> FuncIdRecord::deserialize(TypeRecordKind Kind,
-                                                 ArrayRef<uint8_t> &Data) {
+                                                 msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return FuncIdRecord(L->ParentScope, L->FunctionType, Name);
 }
 
 Expected<UdtSourceLineRecord>
-UdtSourceLineRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+UdtSourceLineRecord::deserialize(TypeRecordKind Kind,
+                                 msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  CV_DESERIALIZE(Data, L);
+  CV_DESERIALIZE(Reader, L);
   return UdtSourceLineRecord(L->UDT, L->SourceFile, L->LineNumber);
 }
 
 Expected<BuildInfoRecord>
-BuildInfoRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+BuildInfoRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   ArrayRef<TypeIndex> Indices;
-  CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
+  CV_DESERIALIZE(Reader, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
   return BuildInfoRecord(Indices);
 }
 
 Expected<VFTableRecord> VFTableRecord::deserialize(TypeRecordKind Kind,
-                                                   ArrayRef<uint8_t> &Data) {
+                                                   msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
   std::vector<StringRef> Names;
-  CV_DESERIALIZE(Data, L, Name, CV_ARRAY_FIELD_TAIL(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, ArrayRef<uint8_t> &Data) {
+OneMethodRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
   int32_t VFTableOffset = -1;
 
-  CV_DESERIALIZE(Data, L, CV_CONDITIONAL_FIELD(VFTableOffset,
-                                               L->Attrs.isIntroducedVirtual()),
+  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,
-                                      ArrayRef<uint8_t> &Data) {
+                                      msf::StreamReader &Reader) {
   std::vector<OneMethodRecord> Methods;
-  while (!Data.empty()) {
+  while (!Reader.empty()) {
     const Layout *L = nullptr;
     int32_t VFTableOffset = -1;
-    CV_DESERIALIZE(Data, L, CV_CONDITIONAL_FIELD(
-                                VFTableOffset, L->Attrs.isIntroducedVirtual()));
+    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,
-                                    ArrayRef<uint8_t> &Data) {
+                                    msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return OverloadedMethodRecord(L->MethodCount, L->MethList, Name);
 }
 
 Expected<DataMemberRecord>
-DataMemberRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+DataMemberRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   uint64_t Offset;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), 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,
-                                    ArrayRef<uint8_t> &Data) {
+                                    msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Name);
+  CV_DESERIALIZE(Reader, L, Name);
   return StaticDataMemberRecord(L->Attrs.getAccess(), L->Type, Name);
 }
 
 Expected<EnumeratorRecord>
-EnumeratorRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+EnumeratorRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   APSInt Value;
   StringRef Name;
-  CV_DESERIALIZE(Data, L, Value, Name);
+  CV_DESERIALIZE(Reader, L, Value, Name);
   return EnumeratorRecord(L->Attrs.getAccess(), Value, Name);
 }
 
 Expected<VFPtrRecord> VFPtrRecord::deserialize(TypeRecordKind Kind,
-                                               ArrayRef<uint8_t> &Data) {
+                                               msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  if (auto EC = consumeObject(Data, L))
+  if (auto EC = Reader.readObject(L))
     return std::move(EC);
   return VFPtrRecord(L->Type);
 }
 
 Expected<BaseClassRecord>
-BaseClassRecord::deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
+BaseClassRecord::deserialize(TypeRecordKind Kind, msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   uint64_t Offset;
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset));
+  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Offset));
   return BaseClassRecord(L->Attrs.getAccess(), L->BaseType, Offset);
 }
 
 Expected<VirtualBaseClassRecord>
 VirtualBaseClassRecord::deserialize(TypeRecordKind Kind,
-                                    ArrayRef<uint8_t> &Data) {
+                                    msf::StreamReader &Reader) {
   const Layout *L = nullptr;
   uint64_t Offset;
   uint64_t Index;
-  CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
+  CV_DESERIALIZE(Reader, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
   return VirtualBaseClassRecord(L->Attrs.getAccess(), L->BaseType, L->VBPtrType,
                                 Offset, Index);
 }
 
 Expected<ListContinuationRecord>
 ListContinuationRecord::deserialize(TypeRecordKind Kind,
-                                    ArrayRef<uint8_t> &Data) {
+                                    msf::StreamReader &Reader) {
   const Layout *L = nullptr;
-  CV_DESERIALIZE(Data, L);
+  CV_DESERIALIZE(Reader, L);
   return ListContinuationRecord(L->ContinuationIndex);
 }
 
 //===----------------------------------------------------------------------===//
 // Type index remapping
 //===----------------------------------------------------------------------===//
 
 static bool remapIndex(ArrayRef<TypeIndex> IndexMap, TypeIndex &Idx) {

llvm/trunk/lib/DebugInfo/MSF/StreamReader.cpp

 
 Error StreamReader::readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size) {
   if (auto EC = Stream.readBytes(Offset, Size, Buffer))
     return EC;
   Offset += Size;
   return Error::success();
 }
 
+Error StreamReader::readInteger(uint8_t &Dest) {
+  const uint8_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
 Error StreamReader::readInteger(uint16_t &Dest) {
   const support::ulittle16_t *P;
   if (auto EC = readObject(P))
     return EC;
   Dest = *P;
   return Error::success();
 }
 
 Error StreamReader::readInteger(uint32_t &Dest) {
   const support::ulittle32_t *P;
   if (auto EC = readObject(P))
     return EC;
   Dest = *P;
   return Error::success();
 }
 
+Error StreamReader::readInteger(uint64_t &Dest) {
+  const support::ulittle64_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
+Error StreamReader::readInteger(int8_t &Dest) {
+  const int8_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
+Error StreamReader::readInteger(int16_t &Dest) {
+  const support::little16_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
+Error StreamReader::readInteger(int32_t &Dest) {
+  const support::little32_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
+Error StreamReader::readInteger(int64_t &Dest) {
+  const support::little64_t *P;
+  if (auto EC = readObject(P))
+    return EC;
+  Dest = *P;
+  return Error::success();
+}
+
 Error StreamReader::readZeroString(StringRef &Dest) {
   uint32_t Length = 0;
   // First compute the length of the string by reading 1 byte at a time.
   uint32_t OriginalOffset = getOffset();
   const char *C;
   do {
     if (auto EC = readObject(C))
       return EC;

 
 Error StreamReader::readStreamRef(ReadableStreamRef &Ref, uint32_t Length) {
   if (bytesRemaining() < Length)
     return make_error<MSFError>(msf_error_code::insufficient_buffer);
   Ref = Stream.slice(Offset, Length);
   Offset += Length;
   return Error::success();
 }
+
+Error StreamReader::skip(uint32_t Amount) {
+  if (Amount > bytesRemaining())
+    return make_error<MSFError>(msf_error_code::insufficient_buffer);
+  Offset += Amount;
+  return Error::success();
+}
+
+uint8_t StreamReader::peek() const {
+  ArrayRef<uint8_t> Buffer;
+  auto EC = Stream.readBytes(Offset, 1, Buffer);
+  assert(!EC && "Cannot peek an empty buffer!");
+  llvm::consumeError(std::move(EC));
+  return Buffer[0];
+}

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

 class COFFObjectDumpDelegate : public SymbolDumpDelegate {
 public:
   COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR,
                          const COFFObjectFile *Obj, StringRef SectionContents)
       : CD(CD), SR(SR), SectionContents(SectionContents) {
     Sec = Obj->getCOFFSection(SR);
   }
 
-  uint32_t getRecordOffset(ArrayRef<uint8_t> Record) override {
-    return Record.data() - SectionContents.bytes_begin();
+  uint32_t getRecordOffset(msf::StreamReader Reader) override {
+    ArrayRef<uint8_t> Data;
+    if (auto EC = Reader.readLongestContiguousChunk(Data)) {
+      llvm::consumeError(std::move(EC));
+      return 0;
+    }
+    return Data.data() - SectionContents.bytes_begin();
   }
 
   void printRelocatedField(StringRef Label, uint32_t RelocOffset,
                            uint32_t Offset, StringRef *RelocSym) override {
     CD.printRelocatedField(Label, Sec, RelocOffset, Offset, RelocSym);
   }
 
   void printBinaryBlockWithRelocs(StringRef Label,
case ModuleSubstreamKind::Lines: {
       }
 
       FunctionLineTables[LinkageName] = Contents;
       FunctionNames.push_back(LinkageName);
       break;
     }
     case ModuleSubstreamKind::FrameData: {
       // First four bytes is a relocation against the function.
+      msf::ByteStream S(Contents);
+      msf::StreamReader SR(S);
       const uint32_t *CodePtr;
-      error(consumeObject(Contents, CodePtr));
+      error(SR.readObject(CodePtr));
       StringRef LinkageName;
       error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents,
                               CodePtr, LinkageName));
       W.printString("LinkageName", LinkageName);
 
       // To find the active frame description, search this array for the
       // smallest PC range that includes the current PC.
-      while (!Contents.empty()) {
+      while (!SR.empty()) {
         const FrameData *FD;
-        error(consumeObject(Contents, FD));
+        error(SR.readObject(FD));
 
         if (FD->FrameFunc >= CVStringTable.size())
           error(object_error::parse_failed);
 
         StringRef FrameFunc =
             CVStringTable.drop_front(FD->FrameFunc).split('\0').first;
 
         DictScope S(W, "FrameData");
void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
   if (auto EC = CVSD.dump(Symbols)) {
     W.flush();
     error(std::move(EC));
   }
   W.flush();
 }
 
 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
-  StringRef Data = Subsection;
-  while (!Data.empty()) {
+  msf::ByteStream S(Subsection);
+  msf::StreamReader SR(S);
+  while (!SR.empty()) {
     DictScope S(W, "FileChecksum");
     const FileChecksum *FC;
-    error(consumeObject(Data, FC));
+    error(SR.readObject(FC));
     if (FC->FileNameOffset >= CVStringTable.size())
       error(object_error::parse_failed);
     StringRef Filename =
         CVStringTable.drop_front(FC->FileNameOffset).split('\0').first;
     W.printHex("Filename", Filename, FC->FileNameOffset);
     W.printHex("ChecksumSize", FC->ChecksumSize);
     W.printEnum("ChecksumKind", uint8_t(FC->ChecksumKind),
                 makeArrayRef(FileChecksumKindNames));
-    if (FC->ChecksumSize >= Data.size())
+    if (FC->ChecksumSize >= SR.bytesRemaining())
       error(object_error::parse_failed);
-    StringRef ChecksumBytes = Data.substr(0, FC->ChecksumSize);
+    ArrayRef<uint8_t> ChecksumBytes;
+    error(SR.readBytes(ChecksumBytes, FC->ChecksumSize));
     W.printBinary("ChecksumBytes", ChecksumBytes);
     unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) -
                           sizeof(FileChecksum);
-    if (PaddedSize > Data.size())
+    PaddedSize -= ChecksumBytes.size();
+    if (PaddedSize > SR.bytesRemaining())
       error(object_error::parse_failed);
-    Data = Data.drop_front(PaddedSize);
+    error(SR.skip(PaddedSize));
   }
 }
 
 void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) {
-  StringRef Data = Subsection;
+  msf::ByteStream S(Subsection);
+  msf::StreamReader SR(S);
   uint32_t Signature;
-  error(consume(Data, Signature));
+  error(SR.readInteger(Signature));
   bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles);
 
-  while (!Data.empty()) {
+  while (!SR.empty()) {
     const InlineeSourceLine *ISL;
-    error(consumeObject(Data, ISL));
+    error(SR.readObject(ISL));
     DictScope S(W, "InlineeSourceLine");
     printTypeIndex("Inlinee", ISL->Inlinee);
     printFileNameForOffset("FileID", ISL->FileID);
     W.printNumber("SourceLineNum", ISL->SourceLineNum);
 
     if (HasExtraFiles) {
       uint32_t ExtraFileCount;
-      error(consume(Data, ExtraFileCount));
+      error(SR.readInteger(ExtraFileCount));
       W.printNumber("ExtraFileCount", ExtraFileCount);
       ListScope ExtraFiles(W, "ExtraFiles");
       for (unsigned I = 0; I < ExtraFileCount; ++I) {
         uint32_t FileID;
-        error(consume(Data, FileID));
+        error(SR.readInteger(FileID));
         printFileNameForOffset("FileID", FileID);
       }
     }
   }
 }
 
 StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
   // The file checksum subsection should precede all references to it.