Enhance CodeView record deserialization with some template metaprogramming

[zturner]

Summary

The general idea is to introduce a variadic template function which can deserialize arbitrary sequences of items from a byte stream. For example, if you write:

const Layout *L;
StringRef S;
uint64_t N;
consume(Data, L, S, N);

it will deserialize each of these in sequence, returning an error at any point if there is a problem.

There are a few cases where things get more complicated.

1. Sometimes fields might only be present if a particular condition is true. For example, if a function is an introducing pure virtual function, then a VFTableOffset will be present, otherwise it won't. To handle this we introduce the notion of conditional fields, specified with the CONDITIONAL_FIELD macro.
2. There might be a field which represents a number N of elements, and then an N element array might follow. To handle this we introduce the ARRAY_FIELD_N macro.
3. There are occasions where what follows is an array whose length is not encoded, but which runs until the end of the buffer. To handle this we introduce the ARRAY_FIELD_TAIL macro.

These macros work by constructing a lambda function with the given conditional, so that it is evaluated lazily, meaning that if you write

const uint64_t Count;
ArrayRef<uint32_t> Items;
consume(Data, Count, ARRAY_FIELD_N(Items, Count));

it will work, because Count in the macro is not evaluated until it processes that item, at which point it has already been deserialized.

There are 2 remaining instances where I was not able to come up with a good solution that allows us to use this variadic template. One involves a nested "sub field" which must be deserialized, and another involves a complex nibble decoding algorithm.

In any case, this should handle 90% of cases, and greatly reduces the amount of boilerplate needed to deserialize records.

[rnk]

include/llvm/DebugInfo/CodeView/RecordSerialization.h

55–59

Seems kind of awkward that uint64_t is a leaf numeric, but uint32_t is fixed length.

142

These macros have fairly generic names. We can prefix them with LLVM_, or we could hide them in TypeRecord.cpp along with all the deserialize method implementations.

[zturner]

include/llvm/DebugInfo/CodeView/RecordSerialization.h

55–59

Yea, I thought of this too, but I'm not sure what a good solution is. Could make another macro like LEAF_64_FIELD and use a similar pattern to the other ones to select a different overload.

142

Rather prefix with CV_ than LLVM_, since at least that indicates what they're used for.

[zturner]

Fix review suggestions. Made it clear that uint64's use a different decoding algorithm, and added a CV_ prefix to the macros.

[rnk]

lgtm

[Eugene.Zelenko]

Committed in r269315.

include/llvm/DebugInfo/CodeView/RecordSerialization.h

+//===- RecordSerialization.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_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/Support/Endian.h"
+#include <cinttypes>
+#include <tuple>
+
+namespace llvm {
+namespace codeview {
+using llvm::support::little32_t;
+using llvm::support::ulittle16_t;
+using llvm::support::ulittle32_t;
+
+/// 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 std::error_code consumeObject(U &Data, const T *&Res) {
+  if (Data.size() < sizeof(*Res))
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+  Res = reinterpret_cast<const T *>(Data.data());
+  Data = Data.drop_front(sizeof(*Res));
+  return std::error_code();
+}
+
+inline std::error_code consume(ArrayRef<uint8_t> &Data) {
+  return std::error_code();
+}
+
+/// 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.
+std::error_code consume(ArrayRef<uint8_t> &Data, APSInt &Num);
+std::error_code consume(StringRef &Data, APSInt &Num);
+
+/// Decodes a numeric leaf value that is known to be a particular type.
+std::error_code consume_numeric(ArrayRef<uint8_t> &Data, uint64_t &Value);
+
+/// Decodes signed and unsigned fixed-length integers.
+std::error_code consume(ArrayRef<uint8_t> &Data, uint32_t &Item);
+std::error_code consume(StringRef &Data, uint32_t &Item);
+std::error_code consume(ArrayRef<uint8_t> &Data, int32_t &Item);
+
+/// Decodes a null terminated string.
+std::error_code consume(ArrayRef<uint8_t> &Data, StringRef &Item);
+
+/// Decodes an arbitrary object whose layout matches that of the underlying
+/// byte sequence, and returns a pointer to the object.
+template <typename T>
+std::error_code consume(ArrayRef<uint8_t> &Data, T *&Item) {
+  return consumeObject(Data, Item);
+}
+
+template <typename T, typename U> struct serialize_conditional_impl {
+  serialize_conditional_impl(T &Item, U Func) : Item(Item), Func(Func) {}
+
+  std::error_code deserialize(ArrayRef<uint8_t> &Data) const {
+    if (!Func())
+      return std::error_code();
+    return consume(Data, 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) {}
+
+  std::error_code deserialize(ArrayRef<uint8_t> &Data) const {
+    uint32_t N = Func();
+    if (N == 0)
+      return std::error_code();
+
+    uint32_t Size = sizeof(T) * N;
+    if (Data.size() < Size)
+      return std::make_error_code(std::errc::illegal_byte_sequence);
+
+    Item = ArrayRef<T>(reinterpret_cast<const T *>(Data.data()), N);
+    Data = Data.drop_front(Size);
+    return std::error_code();
+  }
+
+  ArrayRef<T> &Item;
+  U Func;
+};
+
+template <typename T> struct serialize_array_tail_impl {
+  serialize_array_tail_impl(std::vector<T> &Item) : Item(Item) {}
+
+  std::error_code deserialize(ArrayRef<uint8_t> &Data) const {
+    T Field;
+    while (!Data.empty()) {
+      if (auto EC = consume(Data, Field))
+        return EC;
+      Item.push_back(Field);
+    }
+    return std::error_code();
+  }
+
+  std::vector<T> &Item;
+};
+
+template <typename T> struct serialize_numeric_impl {
+  serialize_numeric_impl(T &Item) : Item(Item) {}
+
+  std::error_code deserialize(ArrayRef<uint8_t> &Data) const {
+    return consume_numeric(Data, 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);
+}
+
+template <typename T>
+serialize_array_tail_impl<T> serialize_array_tail(std::vector<T> &Item) {
+  return serialize_array_tail_impl<T>(Item);
+}
+
+template <typename T> serialize_numeric_impl<T> serialize_numeric(T &Item) {
+  return serialize_numeric_impl<T>(Item);
+}
+
+// This field is only present in the byte record if the condition is true.  The
+// condition is evaluated lazily, so it can depend on items that were
+// deserialized
+// earlier.
+#define CV_CONDITIONAL_FIELD(I, C)                                             \
+  serialize_conditional(I, [&]() { return !!(C); })
+
+// This is an array of N items, where N is evaluated lazily, so it can refer
+// to a field deserialized earlier.
+#define CV_ARRAY_FIELD_N(I, N) serialize_array(I, [&]() { return N; })
+
+// This is an array that exhausts the remainder of the input buffer.
+#define CV_ARRAY_FIELD_TAIL(I) serialize_array_tail(I)
+
+#define CV_NUMERIC_FIELD(I) serialize_numeric(I)
+
+template <typename T, typename U>
+std::error_code consume(ArrayRef<uint8_t> &Data,
+                        const serialize_conditional_impl<T, U> &Item) {
+  return Item.deserialize(Data);
+}
+
+template <typename T, typename U>
+std::error_code consume(ArrayRef<uint8_t> &Data,
+                        const serialize_array_impl<T, U> &Item) {
+  return Item.deserialize(Data);
+}
+
+template <typename T>
+std::error_code consume(ArrayRef<uint8_t> &Data,
+                        const serialize_array_tail_impl<T> &Item) {
+  return Item.deserialize(Data);
+}
+
+template <typename T>
+std::error_code consume(ArrayRef<uint8_t> &Data,
+                        const serialize_numeric_impl<T> &Item) {
+  return Item.deserialize(Data);
+}
+
+template <typename T, typename U, typename... Args>
+std::error_code consume(ArrayRef<uint8_t> &Data, T &&X, U &&Y,
+                        Args &&... Rest) {
+  if (auto EC = consume(Data, X))
+    return EC;
+  return consume(Data, Y, std::forward<Args>(Rest)...);
+}
+
+#define CV_DESERIALIZE(...)                                                    \
+  if (auto EC = consume(__VA_ARGS__))                                          \
+    return EC;
+}
+}
+
+#endif

include/llvm/DebugInfo/CodeView/TypeRecord.h

 //===- TypeRecord.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/ErrorOr.h"
 #include <cinttypes>
-#include <tuple>
 
 namespace llvm {
 namespace codeview {
 
 using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
-/// 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.
-bool decodeNumericLeaf(ArrayRef<uint8_t> &Data, APSInt &Num);
-
-inline bool decodeNumericLeaf(StringRef &Data, APSInt &Num) {
-  ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()),
-                          Data.size());
-  bool Success = decodeNumericLeaf(Bytes, Num);
-  Data = StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size());
-  return Success;
-}
-
-/// Decode a numeric leaf value that is known to be a uint32_t.
-bool decodeUIntLeaf(ArrayRef<uint8_t> &Data, uint64_t &Num);
-
-/// 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.
-inline StringRef getBytesAsCharacters(ArrayRef<uint8_t> LeafData) {
-  return StringRef(reinterpret_cast<const char *>(LeafData.data()),
-                   LeafData.size());
-}
-
-inline StringRef getBytesAsCString(ArrayRef<uint8_t> LeafData) {
-  return getBytesAsCharacters(LeafData).split('\0').first;
-}
-
-/// 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 std::error_code consumeObject(U &Data, const T *&Res) {
-  if (Data.size() < sizeof(*Res))
-    return std::make_error_code(std::errc::illegal_byte_sequence);
-  Res = reinterpret_cast<const T *>(Data.data());
-  Data = Data.drop_front(sizeof(*Res));
-  return std::error_code();
-}
-
-inline std::error_code consumeCString(ArrayRef<uint8_t> &Data, StringRef &Str) {
-  if (Data.empty())
-    return std::make_error_code(std::errc::illegal_byte_sequence);
-
-  StringRef Rest;
-  std::tie(Str, Rest) = getBytesAsCharacters(Data).split('\0');
-  // We expect this to be null terminated.  If it was not, it is an error.
-  if (Data.size() == Str.size())
-    return std::make_error_code(std::errc::illegal_byte_sequence);
-
-  Data = ArrayRef<uint8_t>(Rest.bytes_begin(), Rest.bytes_end());
-  return std::error_code();
-}
-
-template <typename T>
-inline std::error_code consumeArray(ArrayRef<uint8_t> &Data,
-                                    ArrayRef<T> &Result, uint32_t N) {
-  uint32_t Size = sizeof(T) * N;
-  if (Data.size() < Size)
-    return std::make_error_code(std::errc::illegal_byte_sequence);
-
-  Result = ArrayRef<T>(reinterpret_cast<const T *>(Data.data()), N);
-  Data = Data.drop_front(Size);
-  return std::error_code();
-}
-
-inline std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
-  const support::ulittle32_t *IntPtr;
-  if (auto EC = consumeObject(Data, IntPtr))
-    return EC;
-  Res = *IntPtr;
-  return std::error_code();
-}
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
   ulittle16_t Attrs;
 
   /// Get the access specifier. Valid for any kind of member.
   MemberAccess getAccess() const {
     return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
         ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
         Options(Options), ParameterCount(ParameterCount),
         ArgumentList(ArgumentList),
         ThisPointerAdjustment(ThisPointerAdjustment) {}
 
   static ErrorOr<MemberFunctionRecord> deserialize(TypeRecordKind Kind,
                                                    ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    CV_DESERIALIZE(Data, L);
 
     return MemberFunctionRecord(L->ReturnType, L->ClassType, L->ThisType,
                                 L->CallConv, L->Options, L->NumParameters,
                                 L->ArgListType, L->ThisAdjustment);
   }
 
   TypeIndex getReturnType() const { return ReturnType; }
   TypeIndex getClassType() const { return ClassType; }
public:
   MemberFunctionIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
                          StringRef Name)
       : TypeRecord(TypeRecordKind::MemberFunctionId), ClassType(ClassType),
         FunctionType(FunctionType), Name(Name) {}
 
   static ErrorOr<MemberFunctionIdRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
+
     return MemberFunctionIdRecord(L->ClassType, L->FunctionType, Name);
   }
 
   TypeIndex getClassType() const { return ClassType; }
   TypeIndex getFunctionType() const { return FunctionType; }
   StringRef getName() const { return Name; }
 
 private:
public:
 
   static ErrorOr<StringListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     if (Kind != TypeRecordKind::SubstringList &&
         Kind != TypeRecordKind::ArgumentList)
       return std::make_error_code(std::errc::illegal_byte_sequence);
 
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     ArrayRef<TypeIndex> Indices;
-    if (auto EC = consumeArray(Data, Indices, L->NumArgs))
-      return EC;
+    CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
+
     return StringListRecord(Kind, Indices);
   }
 
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
 private:

 class NestedTypeRecord : public TypeRecord {
 public:
   NestedTypeRecord(TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
 
   static ErrorOr<NestedTypeRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
+
     return NestedTypeRecord(L->Type, Name);
   }
 
   TypeIndex getNestedType() const { return Type; }
   StringRef getName() const { return Name; }
 
 private:
   struct Layout {
public:
   ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
               StringRef Name)
       : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),
         IndexType(IndexType), Size(Size), Name(Name) {}
 
   static ErrorOr<ArrayRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     uint64_t Size;
-    if (!decodeUIntLeaf(Data, Size))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Size), Name);
+
     return ArrayRecord(L->ElementType, L->IndexType, Size, Name);
   }
 
   TypeIndex getElementType() const { return ElementType; }
   TypeIndex getIndexType() const { return IndexType; }
   uint64_t getSize() const { return Size; }
   llvm::StringRef getName() const { return Name; }
 
ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
         VTableShape(VTableShape), Size(Size) {}
 
   static ErrorOr<ClassRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data) {
     uint64_t Size = 0;
     StringRef Name;
     StringRef UniqueName;
     uint16_t Props;
-
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+
+    CV_DESERIALIZE(Data, 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);
 
-    if (!decodeUIntLeaf(Data, Size))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
-    if (Props & uint16_t(ClassOptions::HasUniqueName)) {
-      if (auto EC = consumeCString(Data, UniqueName))
-        return EC;
-    }
-
     ClassOptions Options = static_cast<ClassOptions>(Props);
     return ClassRecord(Kind, L->MemberCount, Options, Hfa, WRT, L->FieldList,
                        L->DerivedFrom, L->VShape, Size, Name, UniqueName);
   }
 
   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; }
 
 private:
   struct Layout {
     ulittle16_t MemberCount; // Number of members in FieldList.
     ulittle16_t Properties;  // ClassOptions bitset
     TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
     TypeIndex DerivedFrom;   // LF_DERIVED: List of known derived classes
     TypeIndex VShape;        // LF_VTSHAPE: Shape of the vftable
     // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC
     // integer.
     // Name: The null-terminated name follows.
+
+    bool hasUniqueName() const {
+      return Properties & uint16_t(ClassOptions::HasUniqueName);
+    }
   };
 
   HfaKind Hfa;
   WindowsRTClassKind WinRTKind;
   TypeIndex DerivationList;
   TypeIndex VTableShape;
   uint64_t Size;
 };
struct UnionRecord : public TagRecord {
   static ErrorOr<UnionRecord> deserialize(TypeRecordKind Kind,
                                           ArrayRef<uint8_t> &Data) {
     uint64_t Size = 0;
     StringRef Name;
     StringRef UniqueName;
     uint16_t Props;
 
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    CV_DESERIALIZE(Data, 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);
-
-    if (!decodeUIntLeaf(Data, Size))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
-    if (Props & uint16_t(ClassOptions::HasUniqueName)) {
-      if (auto EC = consumeCString(Data, UniqueName))
-        return EC;
-    }
-
     ClassOptions Options = static_cast<ClassOptions>(Props);
     return UnionRecord(L->MemberCount, Options, Hfa, L->FieldList, Size, Name,
                        UniqueName);
   }
 
   HfaKind getHfa() const { return Hfa; }
   uint64_t getSize() const { return Size; }
 
 private:
   struct Layout {
     ulittle16_t MemberCount; // Number of members in FieldList.
     ulittle16_t Properties;  // ClassOptions bitset
     TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
     // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC
     // integer.
     // Name: The null-terminated name follows.
+
+    bool hasUniqueName() const {
+      return Properties & uint16_t(ClassOptions::HasUniqueName);
+    }
   };
 
   HfaKind Hfa;
   uint64_t Size;
 };
 
 // LF_ENUM
 class EnumRecord : public TagRecord {
 public:
   EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
              StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
       : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
                   UniqueName),
         UnderlyingType(UnderlyingType) {}
 
   static ErrorOr<EnumRecord> deserialize(TypeRecordKind Kind,
                                          ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    StringRef Name;
+    CV_DESERIALIZE(Data, L, Name);
 
     uint16_t P = L->Properties;
     ClassOptions Options = static_cast<ClassOptions>(P);
-    StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
     return EnumRecord(L->NumEnumerators, Options, L->FieldListType, Name, Name,
                       L->UnderlyingType);
   }
 
   TypeIndex getUnderlyingType() const { return UnderlyingType; }
 
 private:
   struct Layout {

 public:
   TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
       : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
         Name(Name) {}
 
   static ErrorOr<TypeServer2Record> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
+
     return TypeServer2Record(StringRef(L->Guid, 16), L->Age, Name);
   }
 
   StringRef getGuid() const { return Guid; }
 
   uint32_t getAge() const { return Age; }
 
   StringRef getName() const { return Name; }

 class StringIdRecord : public TypeRecord {
 public:
   StringIdRecord(TypeIndex Id, StringRef String)
       : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
 
   static ErrorOr<StringIdRecord> deserialize(TypeRecordKind Kind,
                                              ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
+
     return StringIdRecord(L->id, Name);
   }
 
   TypeIndex getId() const { return Id; }
 
   StringRef getString() const { return String; }
 
 private:

 public:
   FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
       : TypeRecord(TypeRecordKind::FunctionId), ParentScope(ParentScope),
         FunctionType(FunctionType), Name(Name) {}
 
   static ErrorOr<FuncIdRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
 
     return FuncIdRecord(L->ParentScope, L->FunctionType, Name);
   }
 
   TypeIndex getParentScope() const { return ParentScope; }
 
   TypeIndex getFunctionType() const { return FunctionType; }
 

 public:
   UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
       : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
         SourceFile(SourceFile), LineNumber(LineNumber) {}
 
   static ErrorOr<UdtSourceLineRecord> deserialize(TypeRecordKind Kind,
                                                   ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    CV_DESERIALIZE(Data, L);
 
     return UdtSourceLineRecord(L->UDT, L->SourceFile, L->LineNumber);
   }
 
   TypeIndex getUDT() const { return UDT; }
   TypeIndex getSourceFile() const { return SourceFile; }
   uint32_t getLineNumber() const { return LineNumber; }
 

 class BuildInfoRecord : public TypeRecord {
 public:
   BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
       : TypeRecord(TypeRecordKind::Modifier), ArgIndices(ArgIndices) {}
 
   static ErrorOr<BuildInfoRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     ArrayRef<TypeIndex> Indices;
-    if (auto EC = consumeArray(Data, Indices, L->NumArgs))
-      return EC;
+    CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
+
     return BuildInfoRecord(Indices);
   }
 
   ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
 
 private:
   struct Layout {
     ulittle16_t NumArgs; // Number of arguments
VirtualTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
                      const std::vector<StringRef> &Methods)
       : TypeRecord(TypeRecordKind::VirtualFunctionTable),
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNames(Methods) {}
 
   static ErrorOr<VirtualTableRecord> deserialize(TypeRecordKind Kind,
                                                  ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
-
     std::vector<StringRef> Names;
-    while (!Data.empty()) {
-      if (auto EC = consumeCString(Data, Name))
-        return EC;
-      Names.push_back(Name);
-    }
+    CV_DESERIALIZE(Data, L, Name, CV_ARRAY_FIELD_TAIL(Names));
+
     return VirtualTableRecord(L->CompleteClass, L->OverriddenVFTable,
                               L->VFPtrOffset, Name, Names);
   }
 
   TypeIndex getCompleteClass() const { return CompleteClass; }
   TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
   uint32_t getVFPtrOffset() const { return VFPtrOffset; }
   StringRef getName() const { return Name; }
OneMethodRecord(TypeIndex Type, MethodKind Kind, MethodOptions Options,
                   MemberAccess Access, int32_t VFTableOffset, StringRef Name)
       : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Kind(Kind),
         Options(Options), Access(Access), VFTableOffset(VFTableOffset),
         Name(Name) {}
 
   static ErrorOr<OneMethodRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    StringRef Name;
+    int32_t VFTableOffset = 0;
+
+    CV_DESERIALIZE(Data, L, CV_CONDITIONAL_FIELD(
+                                VFTableOffset, L->Attrs.isIntroducedVirtual()),
+                   Name);
 
     MethodOptions Options = L->Attrs.getFlags();
     MethodKind MethKind = L->Attrs.getMethodKind();
     MemberAccess Access = L->Attrs.getAccess();
-    int32_t VFTableOffset = 0;
-    if (L->Attrs.isIntroducedVirtual()) {
-      const little32_t *L;
-      if (consumeObject(Data, L))
-        return std::make_error_code(std::errc::illegal_byte_sequence);
-      VFTableOffset = *L;
-    }
-    StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
-
     return OneMethodRecord(L->Type, MethKind, Options, Access, VFTableOffset,
                            Name);
   }
 
   TypeIndex getType() const { return Type; }
   MethodKind getKind() const { return Kind; }
   MethodOptions getOptions() const { return Options; }
   MemberAccess getAccess() const { return Access; }
public:
   MethodListRecord(TypeIndex Type, MethodKind Kind, MethodOptions Options,
                    MemberAccess Access, int32_t VFTableOffset)
       : TypeRecord(TypeRecordKind::MethodList), Type(Type), Kind(Kind),
         Options(Options), Access(Access), VFTableOffset(VFTableOffset) {}
 
   static ErrorOr<MethodListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
+    int32_t VFTableOffset = 0;
+    CV_DESERIALIZE(Data, L, CV_CONDITIONAL_FIELD(
+                                VFTableOffset, L->Attrs.isIntroducedVirtual()));
 
     MethodOptions Options = L->Attrs.getFlags();
     MethodKind MethKind = L->Attrs.getMethodKind();
     MemberAccess Access = L->Attrs.getAccess();
-    int32_t VFTableOffset = 0;
-    if (L->Attrs.isIntroducedVirtual()) {
-      const little32_t *L;
-      if (consumeObject(Data, L))
-        return std::make_error_code(std::errc::illegal_byte_sequence);
-      VFTableOffset = *L;
-    }
 
     return MethodListRecord(L->Type, MethKind, Options, Access, VFTableOffset);
   }
 
   TypeIndex getType() const { return Type; }
   MethodKind getMethodKind() const { return Kind; }
   MethodOptions getOptions() const { return Options; }
   MemberAccess getAccess() const { return Access; }
public:
   OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
                          StringRef Name)
       : TypeRecord(TypeRecordKind::OverloadedMethod),
         NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
 
   static ErrorOr<OverloadedMethodRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
 
     return OverloadedMethodRecord(L->MethodCount, L->MethList, Name);
   }
 
   uint16_t getNumOverloads() const { return NumOverloads; }
   TypeIndex getMethodList() const { return MethodList; }
   StringRef getName() const { return Name; }
 
public:
   DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
                    StringRef Name)
       : TypeRecord(TypeRecordKind::Member), Access(Access), Type(Type),
         FieldOffset(Offset), Name(Name) {}
 
   static ErrorOr<DataMemberRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     uint64_t Offset;
-    if (!decodeUIntLeaf(Data, Offset))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), Name);
 
     return DataMemberRecord(L->Attrs.getAccess(), L->Type, Offset, Name);
   }
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   uint64_t getFieldOffset() const { return FieldOffset; }
   StringRef getName() const { return Name; }

 public:
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
       : TypeRecord(TypeRecordKind::StaticMember), Access(Access), Type(Type),
         Name(Name) {}
 
   static ErrorOr<StaticDataMemberRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Name);
 
     return StaticDataMemberRecord(L->Attrs.getAccess(), L->Type, Name);
   }
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getType() const { return Type; }
   StringRef getName() const { return Name; }
 

 public:
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
       : TypeRecord(TypeRecordKind::Enumerate), Access(Access), Value(Value),
         Name(Name) {}
 
   static ErrorOr<EnumeratorRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
-    if (Data.empty())
-      return std::make_error_code(std::errc::illegal_byte_sequence);
     APSInt Value;
-    if (!decodeNumericLeaf(Data, Value))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
-
     StringRef Name;
-    if (auto EC = consumeCString(Data, Name))
-      return EC;
+    CV_DESERIALIZE(Data, L, Value, Name);
 
     return EnumeratorRecord(L->Attrs.getAccess(), Value, Name);
   }
 
   MemberAccess getAccess() const { return Access; }
   APSInt getValue() const { return Value; }
   StringRef getName() const { return Name; }
 

 public:
   BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
       : TypeRecord(TypeRecordKind::BaseClass), Access(Access), Type(Type),
         Offset(Offset) {}
 
   static ErrorOr<BaseClassRecord> deserialize(TypeRecordKind Kind,
                                               ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     uint64_t Offset;
-    if (!decodeUIntLeaf(Data, Offset))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
+    CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset));
 
     return BaseClassRecord(L->Attrs.getAccess(), L->BaseType, Offset);
   }
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return Type; }
   uint64_t getBaseOffset() const { return Offset; }
 
VirtualBaseClassRecord(MemberAccess Access, TypeIndex BaseType,
                          TypeIndex VBPtrType, uint64_t Offset, uint64_t Index)
       : TypeRecord(TypeRecordKind::VirtualBaseClass), Access(Access),
         BaseType(BaseType), VBPtrType(VBPtrType), VBPtrOffset(Offset),
         VTableIndex(Index) {}
 
   static ErrorOr<VirtualBaseClassRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
-    if (auto EC = consumeObject(Data, L))
-      return EC;
-
     uint64_t Offset;
     uint64_t Index;
-    if (!decodeUIntLeaf(Data, Offset))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
-    if (!decodeUIntLeaf(Data, Index))
-      return std::make_error_code(std::errc::illegal_byte_sequence);
+    CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
 
     return VirtualBaseClassRecord(L->Attrs.getAccess(), L->BaseType,
                                   L->VBPtrType, Offset, Index);
   }
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }

lib/DebugInfo/CodeView/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoCodeView
   FieldListRecordBuilder.cpp
   Line.cpp
   ListRecordBuilder.cpp
   MemoryTypeTableBuilder.cpp
   MethodListRecordBuilder.cpp
+  RecordSerialization.cpp
   TypeDumper.cpp
   TypeRecordBuilder.cpp
   TypeTableBuilder.cpp
-  TypeStream.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/CodeView
   )

lib/DebugInfo/CodeView/RecordSerialization.cpp

+//===-- RecordSerialization.cpp -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for serializing and deserializing CodeView records.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/RecordSerialization.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.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;
+}
+
+std::error_code llvm::codeview::consume(ArrayRef<uint8_t> &Data, APSInt &Num) {
+  // Used to avoid overload ambiguity on APInt construtor.
+  bool FalseVal = false;
+  if (Data.size() < 2)
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+  uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
+  Data = Data.drop_front(2);
+  if (Short < LF_NUMERIC) {
+    Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
+                 /*isUnsigned=*/true);
+    return std::error_code();
+  }
+  switch (Short) {
+  case LF_CHAR:
+    Num = APSInt(APInt(/*numBits=*/8,
+                       *reinterpret_cast<const int8_t *>(Data.data()),
+                       /*isSigned=*/true),
+                 /*isUnsigned=*/false);
+    Data = Data.drop_front(1);
+    return std::error_code();
+  case LF_SHORT:
+    Num = APSInt(APInt(/*numBits=*/16,
+                       *reinterpret_cast<const little16_t *>(Data.data()),
+                       /*isSigned=*/true),
+                 /*isUnsigned=*/false);
+    Data = Data.drop_front(2);
+    return std::error_code();
+  case LF_USHORT:
+    Num = APSInt(APInt(/*numBits=*/16,
+                       *reinterpret_cast<const ulittle16_t *>(Data.data()),
+                       /*isSigned=*/false),
+                 /*isUnsigned=*/true);
+    Data = Data.drop_front(2);
+    return std::error_code();
+  case LF_LONG:
+    Num = APSInt(APInt(/*numBits=*/32,
+                       *reinterpret_cast<const little32_t *>(Data.data()),
+                       /*isSigned=*/true),
+                 /*isUnsigned=*/false);
+    Data = Data.drop_front(4);
+    return std::error_code();
+  case LF_ULONG:
+    Num = APSInt(APInt(/*numBits=*/32,
+                       *reinterpret_cast<const ulittle32_t *>(Data.data()),
+                       /*isSigned=*/FalseVal),
+                 /*isUnsigned=*/true);
+    Data = Data.drop_front(4);
+    return std::error_code();
+  case LF_QUADWORD:
+    Num = APSInt(APInt(/*numBits=*/64,
+                       *reinterpret_cast<const little64_t *>(Data.data()),
+                       /*isSigned=*/true),
+                 /*isUnsigned=*/false);
+    Data = Data.drop_front(8);
+    return std::error_code();
+  case LF_UQUADWORD:
+    Num = APSInt(APInt(/*numBits=*/64,
+                       *reinterpret_cast<const ulittle64_t *>(Data.data()),
+                       /*isSigned=*/false),
+                 /*isUnsigned=*/true);
+    Data = Data.drop_front(8);
+    return std::error_code();
+  }
+  return std::make_error_code(std::errc::illegal_byte_sequence);
+}
+
+std::error_code 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());
+  return EC;
+}
+
+/// Decode a numeric leaf value that is known to be a uint64_t.
+std::error_code llvm::codeview::consume_numeric(ArrayRef<uint8_t> &Data,
+                                                uint64_t &Num) {
+  APSInt N;
+  if (auto EC = consume(Data, N))
+    return EC;
+  if (N.isSigned() || !N.isIntN(64))
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+  Num = N.getLimitedValue();
+  return std::error_code();
+}
+
+std::error_code 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 std::error_code();
+}
+
+std::error_code 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());
+  return EC;
+}
+
+std::error_code 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 std::error_code();
+}
+
+std::error_code llvm::codeview::consume(ArrayRef<uint8_t> &Data,
+                                        StringRef &Item) {
+  if (Data.empty())
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+
+  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 std::make_error_code(std::errc::illegal_byte_sequence);
+
+  Data = ArrayRef<uint8_t>(Rest.bytes_begin(), Rest.bytes_end());
+  return std::error_code();
+}

lib/DebugInfo/CodeView/TypeStream.cpp

-//===-- TypeStream.cpp ----------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Utilities for parsing CodeView type streams.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/APSInt.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-using namespace llvm::support;
-
-bool llvm::codeview::decodeNumericLeaf(ArrayRef<uint8_t> &Data, APSInt &Num) {
-  // Used to avoid overload ambiguity on APInt construtor.
-  bool FalseVal = false;
-  if (Data.size() < 2)
-    return false;
-  uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
-  Data = Data.drop_front(2);
-  if (Short < LF_NUMERIC) {
-    Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
-                 /*isUnsigned=*/true);
-    return true;
-  }
-  switch (Short) {
-  case LF_CHAR:
-    Num = APSInt(APInt(/*numBits=*/8,
-                       *reinterpret_cast<const int8_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(1);
-    return true;
-  case LF_SHORT:
-    Num = APSInt(APInt(/*numBits=*/16,
-                       *reinterpret_cast<const little16_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(2);
-    return true;
-  case LF_USHORT:
-    Num = APSInt(APInt(/*numBits=*/16,
-                       *reinterpret_cast<const ulittle16_t *>(Data.data()),
-                       /*isSigned=*/false),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(2);
-    return true;
-  case LF_LONG:
-    Num = APSInt(APInt(/*numBits=*/32,
-                       *reinterpret_cast<const little32_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(4);
-    return true;
-  case LF_ULONG:
-    Num = APSInt(APInt(/*numBits=*/32,
-                       *reinterpret_cast<const ulittle32_t *>(Data.data()),
-                       /*isSigned=*/FalseVal),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(4);
-    return true;
-  case LF_QUADWORD:
-    Num = APSInt(APInt(/*numBits=*/64,
-                       *reinterpret_cast<const little64_t *>(Data.data()),
-                       /*isSigned=*/true),
-                 /*isUnsigned=*/false);
-    Data = Data.drop_front(8);
-    return true;
-  case LF_UQUADWORD:
-    Num = APSInt(APInt(/*numBits=*/64,
-                       *reinterpret_cast<const ulittle64_t *>(Data.data()),
-                       /*isSigned=*/false),
-                 /*isUnsigned=*/true);
-    Data = Data.drop_front(8);
-    return true;
-  }
-  return false;
-}
-
-/// Decode a numeric leaf value that is known to be a uint32_t.
-bool llvm::codeview::decodeUIntLeaf(ArrayRef<uint8_t> &Data, uint64_t &Num) {
-  APSInt N;
-  if (!decodeNumericLeaf(Data, N))
-    return false;
-  if (N.isSigned() || !N.isIntN(64))
-    return false;
-  Num = N.getLimitedValue();
-  return true;
-}

tools/llvm-readobj/COFFDumper.cpp

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

 }
 
 void COFFDumper::initializeFileAndStringTables(StringRef Data) {
   while (!Data.empty() && (CVFileChecksumTable.data() == nullptr ||
                            CVStringTable.data() == nullptr)) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
-    error(consumeUInt32(Data, SubType));
-    error(consumeUInt32(Data, SubSectionSize));
+    error(consume(Data, SubType));
+    error(consume(Data, SubSectionSize));
     if (SubSectionSize > Data.size())
       return error(object_error::parse_failed);
     switch (ModuleSubstreamKind(SubType)) {
     case ModuleSubstreamKind::FileChecksums:
       CVFileChecksumTable = Data.substr(0, SubSectionSize);
       break;
     case ModuleSubstreamKind::StringTable:
       CVStringTable = Data.substr(0, SubSectionSize);
void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   SmallVector<StringRef, 10> FunctionNames;
   StringMap<StringRef> FunctionLineTables;
 
   ListScope D(W, "CodeViewDebugInfo");
   // Print the section to allow correlation with printSections.
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   uint32_t Magic;
-  error(consumeUInt32(Data, Magic));
+  error(consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
   initializeFileAndStringTables(Data);
 
   while (!Data.empty()) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
-    error(consumeUInt32(Data, SubType));
-    error(consumeUInt32(Data, SubSectionSize));
+    error(consume(Data, SubType));
+    error(consume(Data, SubSectionSize));
 
     ListScope S(W, "Subsection");
     W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes));
     W.printHex("SubSectionSize", SubSectionSize);
 
     // Get the contents of the subsection.
     if (SubSectionSize > Data.size())
       return error(object_error::parse_failed);
case S_INLINESITE_END: {
       DictScope S(W, "InlineSiteEnd");
       break;
     }
 
     case S_CALLERS:
     case S_CALLEES: {
       ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers");
       uint32_t Count;
-      error(consumeUInt32(SymData, Count));
+      error(consume(SymData, Count));
       for (uint32_t I = 0; I < Count; ++I) {
         const TypeIndex *FuncID;
         error(consumeObject(SymData, FuncID));
         printTypeIndex("FuncID", *FuncID);
       }
       break;
     }
 
while (!Data.empty()) {
 
     case S_CONSTANT:
     case S_MANCONSTANT: {
       DictScope S(W, "Constant");
       const ConstantSym *Constant;
       error(consumeObject(SymData, Constant));
       printTypeIndex("Type", Constant->Type);
       APSInt Value;
-      if (!decodeNumericLeaf(SymData, Value))
+      if (auto EC = consume(SymData, Value))
         error(object_error::parse_failed);
       W.printNumber("Value", Value);
       StringRef Name = SymData.split('\0').first;
       W.printString("Name", Name);
       break;
     }
 
     default: {
unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) -
                           sizeof(FileChecksum);
     Data = Data.drop_front(PaddedSize);
   }
 }
 
 void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) {
   StringRef Data = Subsection;
   uint32_t Signature;
-  error(consumeUInt32(Data, Signature));
+  error(consume(Data, Signature));
   bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles);
 
   while (!Data.empty()) {
     const InlineeSourceLine *ISL;
     error(consumeObject(Data, ISL));
     DictScope S(W, "InlineeSourceLine");
     printTypeIndex("Inlinee", ISL->Inlinee);
     printFileNameForOffset("FileID", ISL->FileID);
     W.printNumber("SourceLineNum", ISL->SourceLineNum);
 
     if (HasExtraFiles) {
       uint32_t ExtraFileCount;
-      error(consumeUInt32(Data, ExtraFileCount));
+      error(consume(Data, ExtraFileCount));
       W.printNumber("ExtraFileCount", ExtraFileCount);
       ListScope ExtraFiles(W, "ExtraFiles");
       for (unsigned I = 0; I < ExtraFileCount; ++I) {
         uint32_t FileID;
-        error(consumeUInt32(Data, FileID));
+        error(consume(Data, FileID));
         printFileNameForOffset("FileID", FileID);
       }
     }
   }
 }
 
 void COFFDumper::printLocalVariableAddrRange(
     const LocalVariableAddrRange &Range, const coff_section *Sec,
if (!CVFileChecksumTable.data() || !CVStringTable.data())
     error(object_error::parse_failed);
   // Check if the file checksum table offset is valid.
   if (FileOffset >= CVFileChecksumTable.size())
     error(object_error::parse_failed);
 
   // The string table offset comes first before the file checksum.
   StringRef Data = CVFileChecksumTable.drop_front(FileOffset);
   uint32_t StringOffset;
-  error(consumeUInt32(Data, StringOffset));
+  error(consume(Data, StringOffset));
 
   // Check if the string table offset is valid.
   if (StringOffset >= CVStringTable.size())
     error(object_error::parse_failed);
 
   // Return the null-terminated string.
   return CVStringTable.drop_front(StringOffset).split('\0').first;
 }
 
 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   StringRef Data;
   error(Section.getContents(Data));
   if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
 
   uint32_t Magic;
-  error(consumeUInt32(Data, Magic));
+  error(consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
   ArrayRef<uint8_t> BinaryData(reinterpret_cast<const uint8_t *>(Data.data()),
                                Data.size());
   if (!CVTD.dump(BinaryData)) {
     W.flush();