[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

2 files changed, 95 insertions, 0 deletions

diff --git a/llvm/test/tools/llvm-readobj/Inputs/codeview-types.obj b/llvm/test/tools/llvm-readobj/Inputs/codeview-types.obj
new file mode 100644
index 00000000000..b00a7c6a3e1
--- /dev/null
+++ b/llvm/test/tools/llvm-readobj/Inputs/codeview-types.obj
diff --git a/llvm/test/tools/llvm-readobj/codeview-types.test b/llvm/test/tools/llvm-readobj/codeview-types.test
new file mode 100644
index 00000000000..4545b8e01dd
--- /dev/null
+++ b/llvm/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();
+}