Make TypeRecordBuilder usable for symbols

[zturner]

Summary

TypeRecordBuilder is overly specific to type records, even though 99% of it is re-usable for symbol records as well. Raise out the type specific stuff so that it can be used for writing symbols.

[rnk]

Do you think we'll ever want to merge the reading and writing code like the way we do it in yaml, or something else? This writing code is very redundant with the deserialize methods. I was holding out hope that we'd sort that out eventually.

[zturner]

In D25752#574352, @rnk wrote:

Do you think we'll ever want to merge the reading and writing code like the way we do it in yaml, or something else? This writing code is very redundant with the deserialize methods. I was holding out hope that we'd sort that out eventually.

I expect it will be hard to merge reading and writing code. The Yaml stuff does offer a nice pattern though, so maybe there's a way to do it elegantly. I guess I'm in the same boat as you. Still holding out hope? :)

[rnk]

lgtm

include/llvm/DebugInfo/CodeView/CodeViewRecordBuilder.h

73

Let's make this a bool member, and have TypeRecordBuilder do the Kind check in its constructor.

include/llvm/DebugInfo/CodeView/CodeViewRecordBuilder.h

+//===- CodeViewRecordBuilder.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_CODEVIEWRECORDBUILDER_H
+#define LLVM_DEBUGINFO_CODEVIEW_CODEVIEWRECORDBUILDER_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace codeview {
+
+class CodeViewRecordBuilder {
+private:
+  CodeViewRecordBuilder(const CodeViewRecordBuilder &) = delete;
+  CodeViewRecordBuilder &operator=(const CodeViewRecordBuilder &) = delete;
+
+public:
+  explicit CodeViewRecordBuilder(uint16_t RecordKind)
+      : Kind(RecordKind), Stream(Buffer), Writer(Stream) {
+    writeRecordKind(Kind);
+  }
+
+  void writeUInt8(uint8_t Value);
+  void writeInt16(int16_t Value);
+  void writeUInt16(uint16_t Value);
+  void writeInt32(int32_t Value);
+  void writeUInt32(uint32_t Value);
+  void writeInt64(int64_t Value);
+  void writeUInt64(uint64_t Value);
+  void writeTypeIndex(TypeIndex TypeInd);
+  void writeRecordKind(uint16_t Kind) { writeUInt16(Kind); }
+  void writeEncodedInteger(int64_t Value);
+  void writeEncodedSignedInteger(int64_t Value);
+  void writeEncodedUnsignedInteger(uint64_t Value);
+  void writeNullTerminatedString(StringRef Value);
+  void writeGuid(StringRef Guid);
+  void writeBytes(StringRef Value) { Stream << Value; }
+
+  llvm::StringRef str();
+
+  uint64_t size() const { return Stream.tell(); }
+  uint16_t kind() const { return Kind; }
+
+  /// Returns the number of bytes remaining before this record is larger than
+  /// the maximum record length. Accounts for the extra two byte size field in
+  /// the header.
+  size_t maxBytesRemaining() const { return MaxRecordLength - size() - 2; }
+
+  void truncate(uint64_t Size) {
+    // This works because raw_svector_ostream is not buffered.
+    assert(Size < Buffer.size());
+    Buffer.resize(Size);
+  }
+
+  void reset(uint16_t RecordKind) {
+    Buffer.clear();
+    Kind = RecordKind;
+    writeRecordKind(Kind);
+  }
+
+protected:
+  virtual bool canSplitRecord() const = 0;
+
+  uint16_t Kind;
+  llvm::SmallVector<char, 256> Buffer;
+  llvm::raw_svector_ostream Stream;
+  llvm::support::endian::Writer<llvm::support::endianness::little> Writer;
+};
+
+class TypeRecordBuilder : public CodeViewRecordBuilder {
+public:
+  explicit TypeRecordBuilder(TypeRecordKind RecordKind)
+      : CodeViewRecordBuilder(static_cast<uint16_t>(RecordKind)) {}
+
+  bool canSplitRecord() const override {
+    TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
+    return (RK != TypeRecordKind::FieldList &&
+            RK != TypeRecordKind::MethodOverloadList);
+  }
+
+  TypeRecordKind kind() const { return static_cast<TypeRecordKind>(Kind); }
+
+  void reset(TypeRecordKind K) {
+    CodeViewRecordBuilder::reset(static_cast<uint16_t>(K));
+  }
+
+  void writeRecordKind(TypeRecordKind K) {
+    CodeViewRecordBuilder::writeRecordKind(static_cast<uint16_t>(K));
+  }
+};
+}
+}
+
+#endif

include/llvm/DebugInfo/CodeView/ListRecordBuilder.h

 //===- ListRecordBuilder.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_LISTRECORDBUILDER_H
 #define LLVM_DEBUGINFO_CODEVIEW_LISTRECORDBUILDER_H
 
-#include "llvm/DebugInfo/CodeView/TypeRecordBuilder.h"
+#include "llvm/DebugInfo/CodeView/CodeViewRecordBuilder.h"
 
 namespace llvm {
 namespace codeview {
 class TypeTableBuilder;
 
 class ListRecordBuilder {
 private:
   ListRecordBuilder(const ListRecordBuilder &) = delete;

include/llvm/DebugInfo/CodeView/SymbolTableBuilder.h

+//===- SymbolTableBuilder.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_SYMBOLTABLEBUILDER_H
+#define LLVM_DEBUGINFO_CODEVIEW_SYMBOLTABLEBUILDER_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/Support/Compiler.h"
+
+namespace llvm {
+
+class StringRef;
+
+namespace codeview {
+
+class SymbolTableBuilder {
+private:
+  SymbolTableBuilder(const TypeTableBuilder &) = delete;
+  SymbolTableBuilder &operator=(const SymbolTableBuilder &) = delete;
+
+protected:
+  SymbolTableBuilder();
+
+public:
+  virtual ~SymbolTableBuilder();
+
+public:
+  void writeKnownRecord(const ProcSym &Record);
+  void writeKnownRecord(const Thunk32Sym &Record);
+  void writeKnownRecord(const TrampolineSym &Record);
+  void writeKnownRecord(const SectionSym &Record);
+  void writeKnownRecord(const CoffGroupSym &Record);
+  void writeKnownRecord(const ScopeEndSym &Record);
+  void writeKnownRecord(const CallerSym &Record);
+  void writeKnownRecord(const InlineSiteSym &Record);
+  void writeKnownRecord(const PublicSym32 &Record);
+  void writeKnownRecord(const RegisterSym &Record);
+  void writeKnownRecord(const ProcRefSym &Record);
+  void writeKnownRecord(const LocalSym &Record);
+  void writeKnownRecord(const DefRangeSym &Record);
+  void writeKnownRecord(const DefRangeSubfieldSym &Record);
+  void writeKnownRecord(const DefRangeRegisterSym &Record);
+  void writeKnownRecord(const DefRangeSubfieldRegisterSym &Record);
+  void writeKnownRecord(const DefRangeFramePointerRelSym &Record);
+  void writeKnownRecord(const DefRangeRegisterRelSym &Record);
+  void writeKnownRecord(const DefRangeFramePointerRelFullScopeSym &Record);
+  void writeKnownRecord(const BlockSym &Record);
+  void writeKnownRecord(const LabelSym &Record);
+  void writeKnownRecord(const ObjNameSym &Record);
+  void writeKnownRecord(const EnvBlockSym &Record);
+  void writeKnownRecord(const ExportSym &Record);
+  void writeKnownRecord(const FileStaticSym &Record);
+  void writeKnownRecord(const Compile2Sym &Record);
+  void writeKnownRecord(const Compile3Sym &Record);
+  void writeKnownRecord(const FrameProcSym &Record);
+  void writeKnownRecord(const CallSiteInfoSym &Record);
+  void writeKnownRecord(const HeapAllocationSiteSym &Record);
+  void writeKnownRecord(const FrameCookieSym &Record);
+  void writeKnownRecord(const UDTSym &Record);
+  void writeKnownRecord(const BuildInfoSym &Record);
+  void writeKnownRecord(const BPRelativeSym &Record);
+  void writeKnownRecord(const RegRelativeSym &Record);
+  void writeKnownRecord(const ConstantSym &Record);
+  void writeKnownRecord(const DataSym &Record);
+  void writeKnownRecord(const ThreadLocalDataSym &Record);
+
+  virtual void writeRecord(llvm::StringRef record) = 0;
+
+  ArrayRef<SymbolKind> getRecordKinds() const { return RecordKinds; }
+
+private:
+  std::vector<SymbolKind> RecordKinds;
+};
+}
+}
+
+#endif

include/llvm/DebugInfo/CodeView/TypeRecordBuilder.h

-//===- TypeRecordBuilder.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_TYPERECORDBUILDER_H
-#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORDBUILDER_H
-
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/Support/EndianStream.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-namespace codeview {
-
-class TypeRecordBuilder {
-private:
-  TypeRecordBuilder(const TypeRecordBuilder &) = delete;
-  TypeRecordBuilder &operator=(const TypeRecordBuilder &) = delete;
-
-public:
-  explicit TypeRecordBuilder(TypeRecordKind Kind);
-
-  void writeUInt8(uint8_t Value);
-  void writeInt16(int16_t Value);
-  void writeUInt16(uint16_t Value);
-  void writeInt32(int32_t Value);
-  void writeUInt32(uint32_t Value);
-  void writeInt64(int64_t Value);
-  void writeUInt64(uint64_t Value);
-  void writeTypeIndex(TypeIndex TypeInd);
-  void writeTypeRecordKind(TypeRecordKind Kind);
-  void writeEncodedInteger(int64_t Value);
-  void writeEncodedSignedInteger(int64_t Value);
-  void writeEncodedUnsignedInteger(uint64_t Value);
-  void writeNullTerminatedString(StringRef Value);
-  void writeGuid(StringRef Guid);
-  void writeBytes(StringRef Value) { Stream << Value; }
-
-  llvm::StringRef str();
-
-  uint64_t size() const { return Stream.tell(); }
-  TypeRecordKind kind() const { return Kind; }
-
-  /// Returns the number of bytes remaining before this record is larger than
-  /// the maximum record length. Accounts for the extra two byte size field in
-  /// the header.
-  size_t maxBytesRemaining() const { return MaxRecordLength - size() - 2; }
-
-  void truncate(uint64_t Size) {
-    // This works because raw_svector_ostream is not buffered.
-    assert(Size < Buffer.size());
-    Buffer.resize(Size);
-  }
-
-  void reset(TypeRecordKind K) {
-    Buffer.clear();
-    Kind = K;
-    writeTypeRecordKind(K);
-  }
-
-private:
-  TypeRecordKind Kind;
-  llvm::SmallVector<char, 256> Buffer;
-  llvm::raw_svector_ostream Stream;
-  llvm::support::endian::Writer<llvm::support::endianness::little> Writer;
-};
-}
-}
-
-#endif

lib/DebugInfo/CodeView/CMakeLists.txt

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

lib/DebugInfo/CodeView/CodeViewRecordBuilder.cpp

+//===-- CodeViewRecordBuilder.cpp
+//---------------------------------------------===//
+//
+//                     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/CodeViewRecordBuilder.h"
+
+using namespace llvm;
+using namespace codeview;
+
+StringRef CodeViewRecordBuilder::str() {
+  return StringRef(Buffer.data(), Buffer.size());
+}
+
+void CodeViewRecordBuilder::writeUInt8(uint8_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeInt16(int16_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeUInt16(uint16_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeInt32(int32_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeUInt32(uint32_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeInt64(int64_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeUInt64(uint64_t Value) { Writer.write(Value); }
+
+void CodeViewRecordBuilder::writeEncodedInteger(int64_t Value) {
+  if (Value >= 0) {
+    writeEncodedUnsignedInteger(static_cast<uint64_t>(Value));
+  } else {
+    writeEncodedSignedInteger(Value);
+  }
+}
+
+void CodeViewRecordBuilder::writeEncodedSignedInteger(int64_t Value) {
+  if (Value >= std::numeric_limits<int8_t>::min() &&
+      Value <= std::numeric_limits<int8_t>::max()) {
+    writeUInt16(LF_CHAR);
+    writeInt16(static_cast<int8_t>(Value));
+  } else if (Value >= std::numeric_limits<int16_t>::min() &&
+             Value <= std::numeric_limits<int16_t>::max()) {
+    writeUInt16(LF_SHORT);
+    writeInt16(static_cast<int16_t>(Value));
+  } else if (Value >= std::numeric_limits<int32_t>::min() &&
+             Value <= std::numeric_limits<int32_t>::max()) {
+    writeUInt16(LF_LONG);
+    writeInt32(static_cast<int32_t>(Value));
+  } else {
+    writeUInt16(LF_QUADWORD);
+    writeInt64(Value);
+  }
+}
+
+void CodeViewRecordBuilder::writeEncodedUnsignedInteger(uint64_t Value) {
+  if (Value < LF_CHAR) {
+    writeUInt16(static_cast<uint16_t>(Value));
+  } else if (Value <= std::numeric_limits<uint16_t>::max()) {
+    writeUInt16(LF_USHORT);
+    writeUInt16(static_cast<uint16_t>(Value));
+  } else if (Value <= std::numeric_limits<uint32_t>::max()) {
+    writeUInt16(LF_ULONG);
+    writeUInt32(static_cast<uint32_t>(Value));
+  } else {
+    writeUInt16(LF_UQUADWORD);
+    writeUInt64(Value);
+  }
+}
+
+void CodeViewRecordBuilder::writeNullTerminatedString(StringRef Value) {
+  // Usually the null terminated string comes last, so truncate it to avoid a
+  // record larger than MaxNameLength. Don't do this if this is a list record.
+  // Those have special handling to split the record.
+  unsigned MaxNameLength = MaxRecordLength;
+  if (canSplitRecord())
+    MaxNameLength = maxBytesRemaining();
+  assert(MaxNameLength > 0 && "need room for null terminator");
+  Value = Value.take_front(MaxNameLength - 1);
+  Stream.write(Value.data(), Value.size());
+  writeUInt8(0);
+}
+
+void CodeViewRecordBuilder::writeGuid(StringRef Guid) {
+  assert(Guid.size() == 16);
+  Stream.write(Guid.data(), 16);
+}
+
+void CodeViewRecordBuilder::writeTypeIndex(TypeIndex TypeInd) {
+  writeUInt32(TypeInd.getIndex());
+}

lib/DebugInfo/CodeView/FieldListRecordBuilder.cpp

 using namespace codeview;
 
 FieldListRecordBuilder::FieldListRecordBuilder()
     : ListRecordBuilder(TypeRecordKind::FieldList) {}
 
 void FieldListRecordBuilder::writeMemberType(const BaseClassRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::BaseClass);
+  Builder.writeRecordKind(TypeRecordKind::BaseClass);
   Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
   Builder.writeTypeIndex(Record.getBaseType());
   Builder.writeEncodedUnsignedInteger(Record.getBaseOffset());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(const EnumeratorRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::Enumerator);
+  Builder.writeRecordKind(TypeRecordKind::Enumerator);
   Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
   // FIXME: Handle full APInt such as __int128.
   Builder.writeEncodedUnsignedInteger(Record.getValue().getZExtValue());
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(const DataMemberRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeRecordKind(Record.getKind());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
   Builder.writeTypeIndex(Record.getType());
   Builder.writeEncodedUnsignedInteger(Record.getFieldOffset());
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(
     const OverloadedMethodRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::OverloadedMethod);
+  Builder.writeRecordKind(TypeRecordKind::OverloadedMethod);
   Builder.writeUInt16(Record.getNumOverloads());
   Builder.writeTypeIndex(Record.getMethodList());
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(const OneMethodRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
   uint16_t Flags = static_cast<uint16_t>(Record.getAccess());
   Flags |= static_cast<uint16_t>(Record.getKind()) << MethodKindShift;
   Flags |= static_cast<uint16_t>(Record.getOptions());
 
-  Builder.writeTypeRecordKind(TypeRecordKind::OneMethod);
+  Builder.writeRecordKind(TypeRecordKind::OneMethod);
   Builder.writeUInt16(Flags);
   Builder.writeTypeIndex(Record.getType());
   if (Record.isIntroducingVirtual()) {
     assert(Record.getVFTableOffset() >= 0);
     Builder.writeInt32(Record.getVFTableOffset());
   } else {
     assert(Record.getVFTableOffset() == -1);
   }
 
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(const NestedTypeRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeRecordKind(Record.getKind());
   Builder.writeUInt16(0);
   Builder.writeTypeIndex(Record.getNestedType());
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(
     const StaticDataMemberRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeRecordKind(Record.getKind());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
   Builder.writeTypeIndex(Record.getType());
   Builder.writeNullTerminatedString(Record.getName());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(
     const VirtualBaseClassRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(Record.getKind());
+  Builder.writeRecordKind(Record.getKind());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getAccess()));
   Builder.writeTypeIndex(Record.getBaseType());
   Builder.writeTypeIndex(Record.getVBPtrType());
   Builder.writeEncodedInteger(Record.getVBPtrOffset());
   Builder.writeEncodedUnsignedInteger(Record.getVTableIndex());
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMemberType(const VFPtrRecord &Record) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::VFPtr);
+  Builder.writeRecordKind(TypeRecordKind::VFPtr);
   Builder.writeUInt16(0);
   Builder.writeTypeIndex(Record.getType());
 
   finishSubRecord();
 }

lib/DebugInfo/CodeView/ListRecordBuilder.cpp

 ListRecordBuilder::ListRecordBuilder(TypeRecordKind Kind)
     : Kind(Kind), Builder(Kind) {}
 
 void ListRecordBuilder::writeMemberType(const ListContinuationRecord &R) {
   TypeRecordBuilder &Builder = getBuilder();
 
   assert(getLastContinuationSize() < MaxRecordLength - 8 && "continuation won't fit");
 
-  Builder.writeTypeRecordKind(TypeRecordKind::ListContinuation);
+  Builder.writeRecordKind(TypeRecordKind::ListContinuation);
   Builder.writeUInt16(0);
   Builder.writeTypeIndex(R.getContinuationIndex());
 
   // End the current segment manually so that nothing comes after the
   // continuation.
   ContinuationOffsets.push_back(Builder.size());
   SubrecordStart = Builder.size();
 }
if (getLastContinuationSize() > MaxRecordLength - 8) {
     assert(SubrecordStart != 0 && "can't slide from the start!");
     SmallString<128> SubrecordCopy(
         Builder.str().slice(SubrecordStart, Builder.size()));
     assert(SubrecordCopy.size() < MaxRecordLength - 8 &&
            "subrecord is too large to slide!");
     Builder.truncate(SubrecordStart);
 
     // Write a placeholder continuation record.
-    Builder.writeTypeRecordKind(TypeRecordKind::ListContinuation);
+    Builder.writeRecordKind(TypeRecordKind::ListContinuation);
     Builder.writeUInt16(0);
     Builder.writeUInt32(0);
     ContinuationOffsets.push_back(Builder.size());
     assert(Builder.size() == SubrecordStart + 8 && "wrong continuation size");
     assert(getLastContinuationSize() < MaxRecordLength && "segment too big");
 
     // Start a new list record of the appropriate kind, and copy the previous
     // subrecord into place.
-    Builder.writeTypeRecordKind(Kind);
+    Builder.writeRecordKind(Kind);
     Builder.writeBytes(SubrecordCopy);
   }
 
   SubrecordStart = Builder.size();
 }
 
 TypeIndex ListRecordBuilder::writeListRecord(TypeTableBuilder &Table) {
   // Get the continuation segments as a reversed vector of StringRefs for

lib/DebugInfo/CodeView/TypeRecordBuilder.cpp

-//===-- TypeRecordBuilder.cpp ---------------------------------------------===//
-//
-//                     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/TypeRecordBuilder.h"
-
-using namespace llvm;
-using namespace codeview;
-
-TypeRecordBuilder::TypeRecordBuilder(TypeRecordKind Kind)
-    : Kind(Kind), Stream(Buffer), Writer(Stream) {
-  writeTypeRecordKind(Kind);
-}
-
-StringRef TypeRecordBuilder::str() {
-  return StringRef(Buffer.data(), Buffer.size());
-}
-
-void TypeRecordBuilder::writeUInt8(uint8_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeInt16(int16_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeUInt16(uint16_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeInt32(int32_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeUInt32(uint32_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeInt64(int64_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeUInt64(uint64_t Value) {
-  Writer.write(Value);
-}
-
-void TypeRecordBuilder::writeEncodedInteger(int64_t Value) {
-  if (Value >= 0) {
-    writeEncodedUnsignedInteger(static_cast<uint64_t>(Value));
-  } else {
-    writeEncodedSignedInteger(Value);
-  }
-}
-
-void TypeRecordBuilder::writeEncodedSignedInteger(int64_t Value) {
-  if (Value >= std::numeric_limits<int8_t>::min() &&
-      Value <= std::numeric_limits<int8_t>::max()) {
-    writeUInt16(LF_CHAR);
-    writeInt16(static_cast<int8_t>(Value));
-  } else if (Value >= std::numeric_limits<int16_t>::min() &&
-             Value <= std::numeric_limits<int16_t>::max()) {
-    writeUInt16(LF_SHORT);
-    writeInt16(static_cast<int16_t>(Value));
-  } else if (Value >= std::numeric_limits<int32_t>::min() &&
-             Value <= std::numeric_limits<int32_t>::max()) {
-    writeUInt16(LF_LONG);
-    writeInt32(static_cast<int32_t>(Value));
-  } else {
-    writeUInt16(LF_QUADWORD);
-    writeInt64(Value);
-  }
-}
-
-void TypeRecordBuilder::writeEncodedUnsignedInteger(uint64_t Value) {
-  if (Value < LF_CHAR) {
-    writeUInt16(static_cast<uint16_t>(Value));
-  } else if (Value <= std::numeric_limits<uint16_t>::max()) {
-    writeUInt16(LF_USHORT);
-    writeUInt16(static_cast<uint16_t>(Value));
-  } else if (Value <= std::numeric_limits<uint32_t>::max()) {
-    writeUInt16(LF_ULONG);
-    writeUInt32(static_cast<uint32_t>(Value));
-  } else {
-    writeUInt16(LF_UQUADWORD);
-    writeUInt64(Value);
-  }
-}
-
-void TypeRecordBuilder::writeNullTerminatedString(StringRef Value) {
-  // Usually the null terminated string comes last, so truncate it to avoid a
-  // record larger than MaxNameLength. Don't do this if this is a list record.
-  // Those have special handling to split the record.
-  unsigned MaxNameLength = MaxRecordLength;
-  if (Kind != TypeRecordKind::FieldList &&
-      Kind != TypeRecordKind::MethodOverloadList)
-    MaxNameLength = maxBytesRemaining();
-  assert(MaxNameLength > 0 && "need room for null terminator");
-  Value = Value.take_front(MaxNameLength - 1);
-  Stream.write(Value.data(), Value.size());
-  writeUInt8(0);
-}
-
-void TypeRecordBuilder::writeGuid(StringRef Guid) {
-  assert(Guid.size() == 16);
-  Stream.write(Guid.data(), 16);
-}
-
-void TypeRecordBuilder::writeTypeIndex(TypeIndex TypeInd) {
-  writeUInt32(TypeInd.getIndex());
-}
-
-void TypeRecordBuilder::writeTypeRecordKind(TypeRecordKind Kind) {
-  writeUInt16(static_cast<uint16_t>(Kind));
-}

lib/DebugInfo/CodeView/TypeTableBuilder.cpp

 //===-- TypeTableBuilder.cpp ----------------------------------------------===//
 //
 //                     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/TypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/CodeViewRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/MethodListRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecordBuilder.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace codeview;
 
 TypeTableBuilder::TypeTableBuilder() {}
 
 TypeTableBuilder::~TypeTableBuilder() {}