[codeview] Test serialization of all known type records

This just checks that we emit all type records once, and then after
merging the type stream with no other type streams, we still emit every
kind of type record.

We could test the dumper output more closely, but that would make the
test very brittle. Currently we're just getting coverage.

llvm-svn: 269778

include/llvm/DebugInfo/CodeView/FieldListRecordBuilder.h

@@ -47,6 +47,8 @@ private:
 public:
   FieldListRecordBuilder();
 
+  void reset() { ListRecordBuilder::reset(TypeRecordKind::FieldList); }
+
   void writeBaseClass(const BaseClassRecord &Record);
   void writeEnumerator(const EnumeratorRecord &Record);
   void writeDataMember(const DataMemberRecord &Record);

include/llvm/DebugInfo/CodeView/ListRecordBuilder.h

@@ -28,7 +28,7 @@ protected:
 public:
   llvm::StringRef str() { return Builder.str(); }
 
-  void reset() { Builder.reset(); }
+  void reset(TypeRecordKind K) { Builder.reset(K); }
 
 protected:
   void finishSubRecord();

include/llvm/DebugInfo/CodeView/TypeRecordBuilder.h

@@ -47,7 +47,10 @@ public:
 
   uint64_t size() const { return Stream.tell(); }
 
-  void reset() { Buffer.clear(); }
+  void reset(TypeRecordKind K) {
+    Buffer.clear();
+    writeTypeRecordKind(K);
+  }
 
 private:
   llvm::SmallVector<char, 256> Buffer;

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

@@ -111,14 +111,14 @@ void TypeStreamMerger::visitFieldList(TypeLeafKind Leaf,
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
                                      Name##Record &Record) {                   \
-    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);              \
+    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     IndexMap.push_back(DestStream.write##Name(Record));                        \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
                                      Name##Record &Record) {                   \
-    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);              \
+    FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     FieldBuilder.write##Name(Record);                                          \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)

test/tools/llvm-readobj/codeview-types.test

@@ -0,0 +1,95 @@
+// This tests that we can deserialize and reserialize every known type record.
+// If you need to update the object file, enable the RUNX line below using MSVC
+// from VS 2012. Newer versions of MSVC emit tons of internal types for
+// attributes that pollute the test output. When Clang fully supports all these
+// type records, we can regenerate the test using it instead.
+
+// RUNX: cl -GR- -Z7 -c -TP %s -Fo%S/Inputs/codeview-types.obj
+// RUN: llvm-readobj -codeview %S/Inputs/codeview-types.obj | FileCheck %s
+// RUN: llvm-readobj -codeview-merged-types %S/Inputs/codeview-types.obj | FileCheck %s
+
+// TYPE_RECORD
+// CHECK-DAG: {{^ *Pointer (.*) {$}}
+// CHECK-DAG: {{^ *Modifier (.*) {$}}
+// CHECK-DAG: {{^ *Procedure (.*) {$}}
+// CHECK-DAG: {{^ *MemberFunction (.*) {$}}
+// CHECK-DAG: {{^ *ArgList (.*) {$}}
+// CHECK-DAG: {{^ *Array (.*) {$}}
+// CHECK-DAG: {{^ *Class (.*) {$}}
+// CHECK-DAG: {{^ *Union (.*) {$}}
+// CHECK-DAG: {{^ *Enum (.*) {$}}
+// CHECK-DAG: {{^ *VFTable (.*) {$}}
+// CHECK-DAG: {{^ *VFTableShape (.*) {$}}
+// CHECK-DAG: {{^ *FuncId (.*) {$}}
+// CHECK-DAG: {{^ *MemberFuncId (.*) {$}}
+// CHECK-DAG: {{^ *BuildInfo (.*) {$}}
+// CHECK-DAG: {{^ *StringId (.*) {$}}
+// CHECK-DAG: {{^ *UdtSourceLine (.*) {$}}
+// CHECK-DAG: {{^ *MethodOverloadList (.*) {$}}
+// No TypeServer2, since that is used with /Zi
+
+// MEMBER_RECORD
+// CHECK-DAG: {{^ *BaseClass {$}}
+// CHECK-DAG: {{^ *VirtualBaseClass {$}}
+// CHECK-DAG: {{^ *VFPtr {$}}
+// CHECK-DAG: {{^ *StaticDataMember {$}}
+// CHECK-DAG: {{^ *OverloadedMethod {$}}
+// CHECK-DAG: {{^ *DataMember {$}}
+// CHECK-DAG: {{^ *NestedType {$}}
+// CHECK-DAG: {{^ *OneMethod {$}}
+// CHECK-DAG: {{^ *Enumerator {$}}
+
+#if !defined(__clang__) && _MSC_VER >= 1800
+#error "use clang or MSVC 2012 to regenerate the test"
+#endif
+
+struct VBaseA;
+void FriendFunc();
+
+class Class {
+public:
+  const Class *DataMember;
+private:
+  static int StaticDataMember;
+protected:
+  virtual void MemberFunction();
+public:
+  struct Nested;
+  friend ::VBaseA;
+  friend void FriendFunc() { }
+  void OverloadedMethod();
+  void OverloadedMethod(int);
+};
+
+enum Enum {
+  E1 = 0,
+  E2 = 1
+};
+
+int array[4] = {1, 2, 3, 4};
+
+struct Class::Nested {};
+
+struct ClassWithBase : Class {
+  virtual void MemberFunction();
+  virtual void NewVirtual();
+};
+struct VBaseA { int x; };
+struct VBaseB : virtual VBaseA { int x; };
+struct VBaseC : virtual VBaseA { int x; };
+struct VBaseD : VBaseB, VBaseC { int x; };
+
+union Union {
+  float f;
+  int i;
+};
+
+void UseAllTypes() {
+  Class a;
+  Class::Nested b;
+  ClassWithBase c;
+  VBaseD d;
+  Union e;
+  Enum f;
+  FriendFunc();
+}