vendor/clang/clang-release_350-r216957

16 files changed, 4927 insertions, 2917 deletions

diff --git a/test/Layout/ms-x86-alias-avoidance-padding.cpp b/test/Layout/ms-x86-alias-avoidance-padding.cpp
new file mode 100644
index 000000000000..e51bab387115
--- /dev/null
+++ b/test/Layout/ms-x86-alias-avoidance-padding.cpp
@@ -0,0 +1,599 @@
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
+// RUN:            | FileCheck %s
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
+// RUN:            | FileCheck %s -check-prefix CHECK-X64
+
+extern "C" int printf(const char *fmt, ...);
+__declspec(align(4096)) char buffer[4096];
+
+struct AT {};
+
+struct V : AT {
+	char c;
+	V() {
+		printf("V   - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+struct AT0 {
+	union { struct { int a; AT t; } y; int b; } x;
+	char c;
+	AT0() {
+		printf("AT0 - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+struct AT1 : V {
+	int a;
+	AT1() {
+		printf("AT1 - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+struct AT2 {
+	AT0 t;
+	char AT2FieldName0;
+	AT2() {
+		printf("AT2 - this: %d\n", (int)((char*)this - buffer));
+		printf("AT2 - Fiel: %d\n", (int)((char*)&AT2FieldName0 - buffer));
+	}
+};
+
+struct AT3 : AT2, AT1 {
+	AT3() {
+		printf("AT3 - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AT3
+// CHECK-NEXT:    0 |   struct AT2 (base)
+// CHECK-NEXT:    0 |     struct AT0 t
+// CHECK-NEXT:    0 |       union AT0::(anonymous at {{.*}} x
+// CHECK-NEXT:    0 |         struct AT0::(anonymous at {{.*}} y
+// CHECK-NEXT:    0 |           int a
+// CHECK-NEXT:    4 |           struct AT t (empty)
+// CHECK:         0 |         int b
+// CHECK:         8 |       char c
+// CHECK:        12 |     char AT2FieldName0
+// CHECK-NEXT:   20 |   struct AT1 (base)
+// CHECK-NEXT:   20 |     struct V (base)
+// CHECK-NEXT:   20 |       struct AT (base) (empty)
+// CHECK-NEXT:   20 |       char c
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:      | [sizeof=28, align=4
+// CHECK-NEXT:      |  nvsize=28, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AT3
+// CHECK-X64-NEXT:    0 |   struct AT2 (base)
+// CHECK-X64-NEXT:    0 |     struct AT0 t
+// CHECK-X64-NEXT:    0 |       union AT0::(anonymous at {{.*}} x
+// CHECK-X64-NEXT:    0 |         struct AT0::(anonymous at {{.*}} y
+// CHECK-X64-NEXT:    0 |           int a
+// CHECK-X64-NEXT:    4 |           struct AT t (empty)
+// CHECK-X64:         0 |         int b
+// CHECK-X64:         8 |       char c
+// CHECK-X64:        12 |     char AT2FieldName0
+// CHECK-X64-NEXT:   20 |   struct AT1 (base)
+// CHECK-X64-NEXT:   20 |     struct V (base)
+// CHECK-X64-NEXT:   20 |       struct AT (base) (empty)
+// CHECK-X64-NEXT:   20 |       char c
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:      | [sizeof=28, align=4
+// CHECK-X64-NEXT:      |  nvsize=28, nvalign=4]
+
+struct BT0 {
+	BT0() {
+		printf("BT0 - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+struct BT2 : BT0 {
+	char BT2FieldName0;
+	BT2() {
+		printf("BT2 - this: %d\n", (int)((char*)this - buffer));
+		printf("BT2 - Fiel: %d\n", (int)((char*)&BT2FieldName0 - buffer));
+	}
+};
+
+struct BT3 : BT0, BT2 {
+	BT3() {
+		printf("BT3 - this: %d\n", (int)((char*)this - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct BT3
+// CHECK-NEXT:    0 |   struct BT0 (base) (empty)
+// CHECK-NEXT:    1 |   struct BT2 (base)
+// CHECK-NEXT:    1 |     struct BT0 (base) (empty)
+// CHECK-NEXT:    1 |     char BT2FieldName0
+// CHECK-NEXT:      | [sizeof=2, align=1
+// CHECK-NEXT:      |  nvsize=2, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct BT3
+// CHECK-X64-NEXT:    0 |   struct BT0 (base) (empty)
+// CHECK-X64-NEXT:    1 |   struct BT2 (base)
+// CHECK-X64-NEXT:    1 |     struct BT0 (base) (empty)
+// CHECK-X64-NEXT:    1 |     char BT2FieldName0
+// CHECK-X64-NEXT:      | [sizeof=2, align=1
+// CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
+
+struct T0 : AT {
+	T0() {
+		printf("T0 (this) : %d\n", (int)((char*)this - buffer));
+	}
+};
+
+struct T1 : T0 {
+	char a;
+	T1() {
+		printf("T1 (this) : %d\n", (int)((char*)this - buffer));
+		printf("T1 (fiel) : %d\n", (int)((char*)&a - buffer));
+	}
+};
+
+struct T2 : AT {
+	char a;
+	T2() {
+		printf("T2 (this) : %d\n", (int)((char*)this - buffer));
+		printf("T2 (fiel) : %d\n", (int)((char*)&a - buffer));
+	}
+};
+
+struct __declspec(align(1)) T3 : virtual T1, virtual T2 {
+	T3() {
+		printf("T3 (this) : %d\n", (int)((char*)this - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct T3
+// CHECK-NEXT:    0 |   (T3 vbtable pointer)
+// CHECK-NEXT:    4 |   struct T1 (virtual base)
+// CHECK-NEXT:    4 |     struct T0 (base) (empty)
+// CHECK-NEXT:    4 |       struct AT (base) (empty)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:   12 |   struct T2 (virtual base)
+// CHECK-NEXT:   12 |     struct AT (base) (empty)
+// CHECK-NEXT:   12 |     char a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct T3
+// CHECK-X64-NEXT:    0 |   (T3 vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct T1 (virtual base)
+// CHECK-X64-NEXT:    8 |     struct T0 (base) (empty)
+// CHECK-X64-NEXT:    8 |       struct AT (base) (empty)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   16 |   struct T2 (virtual base)
+// CHECK-X64-NEXT:   16 |     struct AT (base) (empty)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+struct B {};
+struct C { int a; };
+struct D : B, virtual C { B b; };
+struct E : D, B {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct D (base)
+// CHECK-NEXT:    4 |     struct B (base) (empty)
+// CHECK-NEXT:    0 |     (D vbtable pointer)
+// CHECK-NEXT:    4 |     struct B b (empty)
+// CHECK:         8 |   struct B (base) (empty)
+// CHECK-NEXT:    8 |   struct C (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:   0 | struct E
+// CHECK-X64-NEXT:   0 |   struct D (base)
+// CHECK-X64-NEXT:   8 |     struct B (base) (empty)
+// CHECK-X64-NEXT:   0 |     (D vbtable pointer)
+// CHECK-X64-NEXT:   8 |     struct B b (empty)
+// CHECK-X64:       16 |   struct B (base) (empty)
+// CHECK-X64-NEXT:  16 |   struct C (virtual base)
+// CHECK-X64-NEXT:  16 |     int a
+// CHECK-X64-NEXT:     | [sizeof=24, align=8
+// CHECK-X64-NEXT:     |  nvsize=16, nvalign=8]
+
+struct F : virtual D, virtual B {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   (F vbtable pointer)
+// CHECK-NEXT:    4 |   struct C (virtual base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct D (virtual base)
+// CHECK-NEXT:   12 |     struct B (base) (empty)
+// CHECK-NEXT:    8 |     (D vbtable pointer)
+// CHECK-NEXT:   12 |     struct B b (empty)
+// CHECK:        16 |   struct B (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   (F vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct C (virtual base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct D (virtual base)
+// CHECK-X64-NEXT:   24 |     struct B (base) (empty)
+// CHECK-X64-NEXT:   16 |     (D vbtable pointer)
+// CHECK-X64-NEXT:   24 |     struct B b (empty)
+// CHECK-X64:        32 |   struct B (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+struct JC0 {
+	JC0() { printf("JC0 : %d\n", (int)((char*)this - buffer)); }
+};
+struct JC1 : JC0 {
+	virtual void f() {}
+	JC1() { printf("JC1 : %d\n", (int)((char*)this - buffer)); }
+};
+struct JC2 : JC1 {
+	JC2() { printf("JC2 : %d\n", (int)((char*)this - buffer)); }
+};
+struct JC4 : JC1, JC2 {
+	JC4() { printf("JC4 : %d\n", (int)((char*)this - buffer)); }
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct JC4
+// CHECK-NEXT:    0 |   struct JC1 (primary base)
+// CHECK-NEXT:    0 |     (JC1 vftable pointer)
+// CHECK-NEXT:    4 |     struct JC0 (base) (empty)
+// CHECK-NEXT:    8 |   struct JC2 (base)
+// CHECK-NEXT:    8 |     struct JC1 (primary base)
+// CHECK-NEXT:    8 |       (JC1 vftable pointer)
+// CHECK-NEXT:   12 |       struct JC0 (base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct JC4
+// CHECK-X64-NEXT:    0 |   struct JC1 (primary base)
+// CHECK-X64-NEXT:    0 |     (JC1 vftable pointer)
+// CHECK-X64-NEXT:    8 |     struct JC0 (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct JC2 (base)
+// CHECK-X64-NEXT:   16 |     struct JC1 (primary base)
+// CHECK-X64-NEXT:   16 |       (JC1 vftable pointer)
+// CHECK-X64-NEXT:   24 |       struct JC0 (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
+
+struct RA {};
+struct RB { char c; };
+struct RV {};
+struct RW { char c; };
+struct RY { RY() { printf("%Id\n", (char*)this - buffer); } };
+struct RX0 : RB, RA {};
+struct RX1 : RA, RB {};
+struct RX2 : RA { char a; };
+struct RX3 : RA { RB a; };
+struct RX4 { RA a; char b; };
+struct RX5 { RA a; RB b; };
+struct RX6 : virtual RV { RB a; };
+struct RX7 : virtual RW { RA a; };
+struct RX8 : RA, virtual RW {};
+
+struct RZ0 : RX0, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ0
+// CHECK-NEXT:    0 |   struct RX0 (base)
+// CHECK-NEXT:    0 |     struct RB (base)
+// CHECK-NEXT:    0 |       char c
+// CHECK-NEXT:    1 |     struct RA (base) (empty)
+// CHECK-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=2, align=1
+// CHECK-NEXT:      |  nvsize=2, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ0
+// CHECK-X64-NEXT:    0 |   struct RX0 (base)
+// CHECK-X64-NEXT:    0 |     struct RB (base)
+// CHECK-X64-NEXT:    0 |       char c
+// CHECK-X64-NEXT:    1 |     struct RA (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=2, align=1
+// CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
+
+struct RZ1 : RX1, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ1
+// CHECK-NEXT:    0 |   struct RX1 (base)
+// CHECK-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-NEXT:    0 |     struct RB (base)
+// CHECK-NEXT:    0 |       char c
+// CHECK-NEXT:    1 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=1, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ1
+// CHECK-X64-NEXT:    0 |   struct RX1 (base)
+// CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-X64-NEXT:    0 |     struct RB (base)
+// CHECK-X64-NEXT:    0 |       char c
+// CHECK-X64-NEXT:    1 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=1, nvalign=1]
+
+struct RZ2 : RX2, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ2
+// CHECK-NEXT:    0 |   struct RX2 (base)
+// CHECK-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-NEXT:    0 |     char a
+// CHECK-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=2, align=1
+// CHECK-NEXT:      |  nvsize=2, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ2
+// CHECK-X64-NEXT:    0 |   struct RX2 (base)
+// CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-X64-NEXT:    0 |     char a
+// CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=2, align=1
+// CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
+
+struct RZ3 : RX3, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ3
+// CHECK-NEXT:    0 |   struct RX3 (base)
+// CHECK-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-NEXT:    0 |     struct RB a
+// CHECK-NEXT:    0 |       char c
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-NEXT:    1 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=1, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ3
+// CHECK-X64-NEXT:    0 |   struct RX3 (base)
+// CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
+// CHECK-X64-NEXT:    0 |     struct RB a
+// CHECK-X64-NEXT:    0 |       char c
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-X64-NEXT:    1 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=1, nvalign=1]
+
+struct RZ4 : RX4, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ4
+// CHECK-NEXT:    0 |   struct RX4 (base)
+// CHECK-NEXT:    0 |     struct RA a (empty)
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-NEXT:    1 |     char b
+// CHECK-NEXT:    3 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=3, align=1
+// CHECK-NEXT:      |  nvsize=3, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ4
+// CHECK-X64-NEXT:    0 |   struct RX4 (base)
+// CHECK-X64-NEXT:    0 |     struct RA a (empty)
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-X64-NEXT:    1 |     char b
+// CHECK-X64-NEXT:    3 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=3, align=1
+// CHECK-X64-NEXT:      |  nvsize=3, nvalign=1]
+
+struct RZ5 : RX5, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ5
+// CHECK-NEXT:    0 |   struct RX5 (base)
+// CHECK-NEXT:    0 |     struct RA a (empty)
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-NEXT:    1 |     struct RB b
+// CHECK-NEXT:    1 |       char c
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-NEXT:      | [sizeof=2, align=1
+// CHECK-NEXT:      |  nvsize=2, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ5
+// CHECK-X64-NEXT:    0 |   struct RX5 (base)
+// CHECK-X64-NEXT:    0 |     struct RA a (empty)
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-X64-NEXT:    1 |     struct RB b
+// CHECK-X64-NEXT:    1 |       char c
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=2, align=1
+// CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
+
+struct RZ6 : RX6, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ6
+// CHECK-NEXT:    0 |   struct RX6 (base)
+// CHECK-NEXT:    0 |     (RX6 vbtable pointer)
+// CHECK-NEXT:    4 |     struct RB a
+// CHECK-NEXT:    4 |       char c
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-NEXT:    9 |   struct RY (base) (empty)
+// CHECK-NEXT:   12 |   struct RV (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ6
+// CHECK-X64-NEXT:    0 |   struct RX6 (base)
+// CHECK-X64-NEXT:    0 |     (RX6 vbtable pointer)
+// CHECK-X64-NEXT:    8 |     struct RB a
+// CHECK-X64-NEXT:    8 |       char c
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=1, nvalign=1]
+// CHECK-X64-NEXT:   17 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:   24 |   struct RV (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
+
+struct RZ7 : RX7, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ7
+// CHECK-NEXT:    0 |   struct RX7 (base)
+// CHECK-NEXT:    0 |     (RX7 vbtable pointer)
+// CHECK-NEXT:    4 |     struct RA a (empty)
+// CHECK-NEXT:      |     [sizeof=1, align=1
+// CHECK-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-NEXT:    8 |   struct RY (base) (empty)
+// CHECK-NEXT:    8 |   struct RW (virtual base)
+// CHECK-NEXT:    8 |     char c
+// CHECK-NEXT:      | [sizeof=9, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ7
+// CHECK-X64-NEXT:    0 |   struct RX7 (base)
+// CHECK-X64-NEXT:    0 |     (RX7 vbtable pointer)
+// CHECK-X64-NEXT:    8 |     struct RA a (empty)
+// CHECK-X64-NEXT:      |     [sizeof=1, align=1
+// CHECK-X64-NEXT:      |      nvsize=0, nvalign=1]
+// CHECK-X64-NEXT:   16 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct RW (virtual base)
+// CHECK-X64-NEXT:   16 |     char c
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
+
+struct RZ8 : RX8, RY {};
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RZ8
+// CHECK-NEXT:    0 |   struct RX8 (base)
+// CHECK-NEXT:    4 |     struct RA (base) (empty)
+// CHECK-NEXT:    0 |     (RX8 vbtable pointer)
+// CHECK-NEXT:    4 |   struct RY (base) (empty)
+// CHECK-NEXT:    4 |   struct RW (virtual base)
+// CHECK-NEXT:    4 |     char c
+// CHECK-NEXT:      | [sizeof=5, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RZ8
+// CHECK-X64-NEXT:    0 |   struct RX8 (base)
+// CHECK-X64-NEXT:    8 |     struct RA (base) (empty)
+// CHECK-X64-NEXT:    0 |     (RX8 vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct RY (base) (empty)
+// CHECK-X64-NEXT:    8 |   struct RW (virtual base)
+// CHECK-X64-NEXT:    8 |     char c
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+struct JA {};
+struct JB {};
+struct JC : JA { virtual void f() {} };
+struct JD : virtual JB, virtual JC { virtual void f() {} JD() {} };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct JD
+// CHECK-NEXT:    0 |   (JD vbtable pointer)
+// CHECK-NEXT:    4 |   struct JB (virtual base) (empty)
+// CHECK-NEXT:    4 |   (vtordisp for vbase JC)
+// CHECK-NEXT:    8 |   struct JC (virtual base)
+// CHECK-NEXT:    8 |     (JC vftable pointer)
+// CHECK-NEXT:   12 |     struct JA (base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct JD
+// CHECK-X64-NEXT:    0 |   (JD vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct JB (virtual base) (empty)
+// CHECK-X64-NEXT:   12 |   (vtordisp for vbase JC)
+// CHECK-X64-NEXT:   16 |   struct JC (virtual base)
+// CHECK-X64-NEXT:   16 |     (JC vftable pointer)
+// CHECK-X64-NEXT:   24 |     struct JA (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+int a[
+sizeof(AT3) +
+sizeof(BT3) +
+sizeof(T3) +
+sizeof(E) +
+sizeof(F) +
+sizeof(JC4) +
+sizeof(RZ0) +
+sizeof(RZ1) +
+sizeof(RZ2) +
+sizeof(RZ3) +
+sizeof(RZ4) +
+sizeof(RZ5) +
+sizeof(RZ6) +
+sizeof(RZ7) +
+sizeof(RZ8) +
+sizeof(JD) +
+0];
diff --git a/test/Layout/ms-x86-aligned-tail-padding.cpp b/test/Layout/ms-x86-aligned-tail-padding.cpp
index b9020f386c03..f919766546e4 100644
--- a/test/Layout/ms-x86-aligned-tail-padding.cpp
+++ b/test/Layout/ms-x86-aligned-tail-padding.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -75,33 +75,41 @@ struct A : B1, B0, B2, virtual V {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   struct B1 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   struct B0 (base)
-// CHECK:    4 |     int a
-// CHECK:   16 |   struct B2 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   (A vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct V (virtual base)
-// CHECK:   64 |     char a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   struct B1 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   struct B0 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:   16 |   struct B2 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (A vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct V (virtual base)
+// CHECK-NEXT:   64 |     char a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   struct B1 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    4 |   struct B0 (base)
-// CHECK-X64:    4 |     int a
-// CHECK-X64:   16 |   struct B2 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   (A vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   48 |   struct V (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   struct B1 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    4 |   struct B0 (base)
+// CHECK-X64-NEXT:    4 |     int a
+// CHECK-X64-NEXT:   16 |   struct B2 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (A vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct V (virtual base)
+// CHECK-X64-NEXT:   64 |     char a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct B : B2, B0, B1, virtual V {
 	int a;
@@ -109,33 +117,33 @@ struct B : B2, B0, B1, virtual V {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct B2 (base)
-// CHECK:    0 |     int a
-// CHECK:   16 |   struct B0 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   struct B1 (base)
-// CHECK:   32 |     int a
-// CHECK:   36 |   (B vbtable pointer)
-// CHECK:   52 |   int a
-// CHECK:   64 |   struct V (virtual base)
-// CHECK:   64 |     char a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct B2 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:   16 |   struct B0 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   struct B1 (base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:   36 |   (B vbtable pointer)
+// CHECK-NEXT:   52 |   int a
+// CHECK-NEXT:   64 |   struct V (virtual base)
+// CHECK-NEXT:   64 |     char a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   struct B2 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:   16 |   struct B0 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   struct B1 (base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   40 |   (B vbtable pointer)
-// CHECK-X64:   48 |   int a
-// CHECK-X64:   64 |   struct V (virtual base)
-// CHECK-X64:   64 |     char a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   struct B2 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   struct B1 (base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:   40 |   (B vbtable pointer)
+// CHECK-X64-NEXT:   52 |   int a
+// CHECK-X64-NEXT:   64 |   struct V (virtual base)
+// CHECK-X64-NEXT:   64 |     char a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct C : B1, B0, virtual V {
 	int a;
@@ -144,31 +152,31 @@ struct C : B1, B0, virtual V {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   struct B1 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   struct B0 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (C vbtable pointer)
-// CHECK:   24 |   int a
-// CHECK:   32 |   long long a1
-// CHECK:   48 |   struct V (virtual base)
-// CHECK:   48 |     char a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   struct B1 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   struct B0 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (C vbtable pointer)
+// CHECK-NEXT:   24 |   int a
+// CHECK-NEXT:   32 |   long long a1
+// CHECK-NEXT:   48 |   struct V (virtual base)
+// CHECK-NEXT:   48 |     char a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   struct B1 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    4 |   struct B0 (base)
-// CHECK-X64:    4 |     int a
-// CHECK-X64:    8 |   (C vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   long long a1
-// CHECK-X64:   32 |   struct V (virtual base)
-// CHECK-X64:   32 |     char a
-// CHECK-X64:      | [sizeof=48, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   struct B1 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    4 |   struct B0 (base)
+// CHECK-X64-NEXT:    4 |     int a
+// CHECK-X64-NEXT:    8 |   (C vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   long long a1
+// CHECK-X64-NEXT:   48 |   struct V (virtual base)
+// CHECK-X64-NEXT:   48 |     char a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct D : B2, B0, virtual V {
 	int a;
@@ -176,29 +184,29 @@ struct D : B2, B0, virtual V {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct B2 (base)
-// CHECK:    0 |     int a
-// CHECK:   16 |   struct B0 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   (D vbtable pointer)
-// CHECK:   36 |   int a
-// CHECK:   48 |   struct V (virtual base)
-// CHECK:   48 |     char a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct B2 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:   16 |   struct B0 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   (D vbtable pointer)
+// CHECK-NEXT:   36 |   int a
+// CHECK-NEXT:   48 |   struct V (virtual base)
+// CHECK-NEXT:   48 |     char a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   struct B2 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:   16 |   struct B0 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   (D vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct V (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct B2 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   (D vbtable pointer)
+// CHECK-X64-NEXT:   36 |   int a
+// CHECK-X64-NEXT:   48 |   struct V (virtual base)
+// CHECK-X64-NEXT:   48 |     char a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct E : B3, B0, virtual V {
 	int a;
@@ -206,31 +214,33 @@ struct E : B3, B0, virtual V {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   struct B3 (base)
-// CHECK:    0 |     long long a1
-// CHECK:    8 |     int a
-// CHECK:   16 |   struct B0 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   (E vbtable pointer)
-// CHECK:   36 |   int a
-// CHECK:   48 |   struct V (virtual base)
-// CHECK:   48 |     char a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct B3 (base)
+// CHECK-NEXT:    0 |     long long a1
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   16 |   struct B0 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   (E vbtable pointer)
+// CHECK-NEXT:   36 |   int a
+// CHECK-NEXT:   48 |   struct V (virtual base)
+// CHECK-NEXT:   48 |     char a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   struct B3 (base)
-// CHECK-X64:    0 |     long long a1
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   struct B0 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   (E vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct V (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   struct B3 (base)
+// CHECK-X64-NEXT:    0 |     long long a1
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   (E vbtable pointer)
+// CHECK-X64-NEXT:   36 |   int a
+// CHECK-X64-NEXT:   48 |   struct V (virtual base)
+// CHECK-X64-NEXT:   48 |     char a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct F : B0, virtual V1 {
 	__declspec(align(16)) int a;
@@ -239,29 +249,33 @@ struct F : B0, virtual V1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   struct B0 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (F vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   92 |   (vtordisp for vbase V1)
-// CHECK:   96 |   struct V1 (virtual base)
-// CHECK:   96 |     (V1 vftable pointer)
-// CHECK:  128 |     struct A16 (base) (empty)
-// CHECK:      | [sizeof=128, align=32
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   struct B0 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (F vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   92 |   (vtordisp for vbase V1)
+// CHECK-NEXT:   96 |   struct V1 (virtual base)
+// CHECK-NEXT:   96 |     (V1 vftable pointer)
+// CHECK-NEXT:  128 |     struct A16 (base) (empty)
+// CHECK-NEXT:      | [sizeof=128, align=32
+// CHECK-NEXT:      |  nvsize=48, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   struct B0 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (F vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   60 |   (vtordisp for vbase V1)
-// CHECK-X64:   64 |   struct V1 (virtual base)
-// CHECK-X64:   64 |     (V1 vftable pointer)
-// CHECK-X64:   96 |     struct A16 (base) (empty)
-// CHECK-X64:      | [sizeof=96, align=32
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   struct B0 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (F vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   92 |   (vtordisp for vbase V1)
+// CHECK-X64-NEXT:   96 |   struct V1 (virtual base)
+// CHECK-X64-NEXT:   96 |     (V1 vftable pointer)
+// CHECK-X64-NEXT:  128 |     struct A16 (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=128, align=32
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=32]
 
 struct G : virtual V2, virtual V3 {
 	int a;
@@ -269,27 +283,31 @@ struct G : virtual V2, virtual V3 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    0 |   (G vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct V2 (virtual base)
-// CHECK:    8 |     long long a
-// CHECK:   16 |     int a1
-// CHECK:   24 |   struct V3 (virtual base)
-// CHECK:   24 |     int a
-// CHECK:      | [sizeof=28, align=8
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   (G vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct V2 (virtual base)
+// CHECK-NEXT:    8 |     long long a
+// CHECK-NEXT:   16 |     int a1
+// CHECK-NEXT:   24 |   struct V3 (virtual base)
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:      | [sizeof=28, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct G
-// CHECK-X64:    0 |   (G vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct V2 (virtual base)
-// CHECK-X64:   16 |     long long a
-// CHECK-X64:   24 |     int a1
-// CHECK-X64:   32 |   struct V3 (virtual base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-NEXT:    0 |   (G vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct V2 (virtual base)
+// CHECK-X64-NEXT:   16 |     long long a
+// CHECK-X64-NEXT:   24 |     int a1
+// CHECK-X64-NEXT:   32 |   struct V3 (virtual base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct H {
 	__declspec(align(16)) int a;
@@ -298,17 +316,17 @@ struct H {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct H
-// CHECK:    0 |   int a
-// CHECK:    4 |   int b
-// CHECK:      | [sizeof=16, align=16
-// CHECK:      |  nvsize=16, nvalign=16]
+// CHECK-NEXT:    0 | struct H
+// CHECK-NEXT:    0 |   int a
+// CHECK-NEXT:    4 |   int b
+// CHECK-NEXT:      | [sizeof=16, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct H
-// CHECK-X64:    0 |   int a
-// CHECK-X64:    4 |   int b
-// CHECK-X64:      | [sizeof=16, align=16
-// CHECK-X64:      |  nvsize=16, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-NEXT:    0 |   int a
+// CHECK-X64-NEXT:    4 |   int b
+// CHECK-X64-NEXT:      | [sizeof=16, align=16
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct I {
 	B2 a;
@@ -317,19 +335,19 @@ struct I {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct I
-// CHECK:    0 |   struct B2 a
-// CHECK:    0 |     int a
-// CHECK:   16 |   int b
-// CHECK:      | [sizeof=32, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct I
+// CHECK-NEXT:    0 |   struct B2 a
+// CHECK-NEXT:    0 |     int a
+// CHECK:        16 |   int b
+// CHECK-NEXT:      | [sizeof=32, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct I
-// CHECK-X64:    0 |   struct B2 a
-// CHECK-X64:    0 |     int a
-// CHECK-X64:   16 |   int b
-// CHECK-X64:      | [sizeof=32, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-NEXT:    0 |   struct B2 a
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64:        16 |   int b
+// CHECK-X64-NEXT:      | [sizeof=32, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct AX : B0X, virtual B2X, virtual B6X, virtual B3X {
 	int a;
@@ -339,41 +357,49 @@ struct AX : B0X, virtual B2X, virtual B6X, virtual B3X {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AX
-// CHECK:    0 |   (AX vftable pointer)
-// CHECK:   16 |   struct B0X (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |     int a1
-// CHECK:   24 |   (AX vbtable pointer)
-// CHECK:   40 |   int a
-// CHECK:   48 |   struct B2X (virtual base)
-// CHECK:   48 |     int a
-// CHECK:   52 |   struct B6X (virtual base)
-// CHECK:   52 |     int a
-// CHECK:   76 |   (vtordisp for vbase B3X)
-// CHECK:   80 |   struct B3X (virtual base)
-// CHECK:   80 |     (B3X vftable pointer)
-// CHECK:   84 |     int a
-// CHECK:      | [sizeof=96, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AX
+// CHECK-NEXT:    0 |   (AX vftable pointer)
+// CHECK-NEXT:   16 |   struct B0X (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |     int a1
+// CHECK-NEXT:   24 |   (AX vbtable pointer)
+// CHECK-NEXT:   40 |   int a
+// CHECK-NEXT:   48 |   struct B2X (virtual base)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:   52 |   struct B6X (virtual base)
+// CHECK-NEXT:   52 |     int a
+// CHECK-NEXT:   76 |   (vtordisp for vbase B3X)
+// CHECK-NEXT:   80 |   struct B3X (virtual base)
+// CHECK-NEXT:   80 |     (B3X vftable pointer)
+// CHECK-NEXT:   84 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AX
-// CHECK-X64:    0 |   (AX vftable pointer)
-// CHECK-X64:   16 |   struct B0X (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   20 |     int a1
-// CHECK-X64:   24 |   (AX vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B2X (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   52 |   struct B6X (virtual base)
-// CHECK-X64:   52 |     int a
-// CHECK-X64:   76 |   (vtordisp for vbase B3X)
-// CHECK-X64:   80 |   struct B3X (virtual base)
-// CHECK-X64:   80 |     (B3X vftable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-NEXT:    0 |   (AX vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0X (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |     int a1
+// CHECK-X64-NEXT:   24 |   (AX vbtable pointer)
+// CHECK-X64-NEXT:   40 |   int a
+// CHECK-X64-NEXT:   48 |   struct B2X (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   52 |   struct B6X (virtual base)
+// CHECK-X64-NEXT:   52 |     int a
+// CHECK-X64-NEXT:   76 |   (vtordisp for vbase B3X)
+// CHECK-X64-NEXT:   80 |   struct B3X (virtual base)
+// CHECK-X64-NEXT:   80 |     (B3X vftable pointer)
+// CHECK-X64-NEXT:   88 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct BX : B4X, virtual B2X, virtual B6X, virtual B3X {
 	int a;
@@ -383,43 +409,47 @@ struct BX : B4X, virtual B2X, virtual B6X, virtual B3X {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct BX
-// CHECK:    0 |   (BX vftable pointer)
-// CHECK:   16 |   struct B4X (base)
-// CHECK:   16 |     struct A16X (base) (empty)
-// CHECK:   16 |     int a
-// CHECK:   20 |     int a1
-// CHECK:   32 |   (BX vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct B2X (virtual base)
-// CHECK:   64 |     int a
-// CHECK:   68 |   struct B6X (virtual base)
-// CHECK:   68 |     int a
-// CHECK:   92 |   (vtordisp for vbase B3X)
-// CHECK:   96 |   struct B3X (virtual base)
-// CHECK:   96 |     (B3X vftable pointer)
-// CHECK:  100 |     int a
-// CHECK:      | [sizeof=112, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct BX
+// CHECK-NEXT:    0 |   (BX vftable pointer)
+// CHECK-NEXT:   16 |   struct B4X (base)
+// CHECK-NEXT:   16 |     struct A16X (base) (empty)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |     int a1
+// CHECK-NEXT:   32 |   (BX vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct B2X (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   68 |   struct B6X (virtual base)
+// CHECK-NEXT:   68 |     int a
+// CHECK-NEXT:   92 |   (vtordisp for vbase B3X)
+// CHECK-NEXT:   96 |   struct B3X (virtual base)
+// CHECK-NEXT:   96 |     (B3X vftable pointer)
+// CHECK-NEXT:  100 |     int a
+// CHECK-NEXT:      | [sizeof=112, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct BX
-// CHECK-X64:    0 |   (BX vftable pointer)
-// CHECK-X64:   16 |   struct B4X (base)
-// CHECK-X64:   16 |     struct A16X (base) (empty)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   20 |     int a1
-// CHECK-X64:   32 |   (BX vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   48 |   struct B2X (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   52 |   struct B6X (virtual base)
-// CHECK-X64:   52 |     int a
-// CHECK-X64:   76 |   (vtordisp for vbase B3X)
-// CHECK-X64:   80 |   struct B3X (virtual base)
-// CHECK-X64:   80 |     (B3X vftable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-NEXT:    0 |   (BX vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B4X (base)
+// CHECK-X64-NEXT:   16 |     struct A16X (base) (empty)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |     int a1
+// CHECK-X64-NEXT:   32 |   (BX vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct B2X (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   68 |   struct B6X (virtual base)
+// CHECK-X64-NEXT:   68 |     int a
+// CHECK-X64-NEXT:   92 |   (vtordisp for vbase B3X)
+// CHECK-X64-NEXT:   96 |   struct B3X (virtual base)
+// CHECK-X64-NEXT:   96 |     (B3X vftable pointer)
+// CHECK-X64-NEXT:  104 |     int a
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct CX : B5X, virtual B2X, virtual B6X, virtual B3X {
 	int a;
@@ -429,43 +459,45 @@ struct CX : B5X, virtual B2X, virtual B6X, virtual B3X {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct CX
-// CHECK:    0 |   (CX vftable pointer)
-// CHECK:   16 |   struct B5X (base)
-// CHECK:   16 |     (B5X vbtable pointer)
-// CHECK:   20 |     int a
-// CHECK:   24 |     int a1
-// CHECK:   28 |   int a
-// CHECK:   32 |   struct A16X (virtual base) (empty)
-// CHECK:   32 |   struct B2X (virtual base)
-// CHECK:   32 |     int a
-// CHECK:   36 |   struct B6X (virtual base)
-// CHECK:   36 |     int a
-// CHECK:   60 |   (vtordisp for vbase B3X)
-// CHECK:   64 |   struct B3X (virtual base)
-// CHECK:   64 |     (B3X vftable pointer)
-// CHECK:   68 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct CX
+// CHECK-NEXT:    0 |   (CX vftable pointer)
+// CHECK-NEXT:   16 |   struct B5X (base)
+// CHECK-NEXT:   16 |     (B5X vbtable pointer)
+// CHECK-NEXT:   20 |     int a
+// CHECK-NEXT:   24 |     int a1
+// CHECK-NEXT:   28 |   int a
+// CHECK-NEXT:   32 |   struct A16X (virtual base) (empty)
+// CHECK-NEXT:   32 |   struct B2X (virtual base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:   36 |   struct B6X (virtual base)
+// CHECK-NEXT:   36 |     int a
+// CHECK-NEXT:   60 |   (vtordisp for vbase B3X)
+// CHECK-NEXT:   64 |   struct B3X (virtual base)
+// CHECK-NEXT:   64 |     (B3X vftable pointer)
+// CHECK-NEXT:   68 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct CX
-// CHECK-X64:    0 |   (CX vftable pointer)
-// CHECK-X64:   16 |   struct B5X (base)
-// CHECK-X64:   16 |     (B5X vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   28 |     int a1
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct A16X (virtual base) (empty)
-// CHECK-X64:   48 |   struct B2X (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   52 |   struct B6X (virtual base)
-// CHECK-X64:   52 |     int a
-// CHECK-X64:   76 |   (vtordisp for vbase B3X)
-// CHECK-X64:   80 |   struct B3X (virtual base)
-// CHECK-X64:   80 |     (B3X vftable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-NEXT:    0 |   (CX vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B5X (base)
+// CHECK-X64-NEXT:   16 |     (B5X vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   28 |     int a1
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct A16X (virtual base) (empty)
+// CHECK-X64-NEXT:   48 |   struct B2X (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   52 |   struct B6X (virtual base)
+// CHECK-X64-NEXT:   52 |     int a
+// CHECK-X64-NEXT:   76 |   (vtordisp for vbase B3X)
+// CHECK-X64-NEXT:   80 |   struct B3X (virtual base)
+// CHECK-X64-NEXT:   80 |     (B3X vftable pointer)
+// CHECK-X64-NEXT:   88 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct __declspec(align(16)) DX {
 	int a;
@@ -474,17 +506,17 @@ struct __declspec(align(16)) DX {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct DX
-// CHECK:    0 |   (DX vftable pointer)
-// CHECK:    4 |   int a
-// CHECK:      | [sizeof=16, align=16
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct DX
+// CHECK-NEXT:    0 |   (DX vftable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:      | [sizeof=16, align=16
+// CHECK-NEXT:      |  nvsize=8, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct DX
-// CHECK-X64:    0 |   (DX vftable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:      | [sizeof=16, align=16
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-NEXT:    0 |   (DX vftable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:      | [sizeof=16, align=16
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-basic-layout.cpp b/test/Layout/ms-x86-basic-layout.cpp
index 86b3553b0ba0..b6ffeee7114a 100644
--- a/test/Layout/ms-x86-basic-layout.cpp
+++ b/test/Layout/ms-x86-basic-layout.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -38,25 +38,29 @@ struct TestF0 : A4, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF0
-// CHECK:    0 |   struct A4 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (TestF0 vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   12 |   struct B4 (virtual base)
-// CHECK:   12 |     int a
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct TestF0
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF0 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   12 |   struct B4 (virtual base)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF0
-// CHECK-X64:    0 |   struct A4 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (TestF0 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B4 (virtual base)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:      | [sizeof=32, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct TestF0
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF0 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B4 (virtual base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct TestF1 : A4, virtual A16 {
 	int a;
@@ -64,25 +68,27 @@ struct TestF1 : A4, virtual A16 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF1
-// CHECK:    0 |   struct A4 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (TestF1 vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   16 |   struct A16 (virtual base)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=32, align=16
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct TestF1
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF1 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   16 |   struct A16 (virtual base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=32, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF1
-// CHECK-X64:    0 |   struct A4 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (TestF1 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   32 |   struct A16 (virtual base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=48, align=16
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct TestF1
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF1 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   32 |   struct A16 (virtual base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=48, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct TestF2 : A4, virtual C4 {
 	int a;
@@ -90,27 +96,29 @@ struct TestF2 : A4, virtual C4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF2
-// CHECK:    0 |   struct A4 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (TestF2 vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   12 |   struct C4 (virtual base)
-// CHECK:   12 |     (C4 vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct TestF2
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF2 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   12 |   struct C4 (virtual base)
+// CHECK-NEXT:   12 |     (C4 vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF2
-// CHECK-X64:    0 |   struct A4 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (TestF2 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct C4 (virtual base)
-// CHECK-X64:   24 |     (C4 vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct TestF2
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF2 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct C4 (virtual base)
+// CHECK-X64-NEXT:   24 |     (C4 vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct TestF3 : A4, virtual C16 {
 	int a;
@@ -118,27 +126,29 @@ struct TestF3 : A4, virtual C16 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF3
-// CHECK:    0 |   struct A4 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (TestF3 vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   16 |   struct C16 (virtual base)
-// CHECK:   16 |     (C16 vftable pointer)
-// CHECK:   32 |     int a
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct TestF3
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF3 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   16 |   struct C16 (virtual base)
+// CHECK-NEXT:   16 |     (C16 vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF3
-// CHECK-X64:    0 |   struct A4 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (TestF3 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   32 |   struct C16 (virtual base)
-// CHECK-X64:   32 |     (C16 vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct TestF3
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct TestF4 : TestF3, A4 {
 	int a;
@@ -146,35 +156,35 @@ struct TestF4 : TestF3, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF4
-// CHECK:    0 |   struct TestF3 (base)
-// CHECK:    0 |     struct A4 (base)
-// CHECK:    0 |       int a
-// CHECK:    4 |     (TestF3 vbtable pointer)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct A4 (base)
-// CHECK:   12 |     int a
-// CHECK:   16 |   int a
-// CHECK:   32 |   struct C16 (virtual base)
-// CHECK:   32 |     (C16 vftable pointer)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct TestF4
+// CHECK-NEXT:    0 |   struct TestF3 (base)
+// CHECK-NEXT:    0 |     struct A4 (base)
+// CHECK-NEXT:    0 |       int a
+// CHECK-NEXT:    4 |     (TestF3 vbtable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct A4 (base)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF4
-// CHECK-X64:    0 |   struct TestF3 (base)
-// CHECK-X64:    0 |     struct A4 (base)
-// CHECK-X64:    0 |       int a
-// CHECK-X64:    8 |     (TestF3 vbtable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct A4 (base)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   28 |   int a
-// CHECK-X64:   32 |   struct C16 (virtual base)
-// CHECK-X64:   32 |     (C16 vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestF4
+// CHECK-X64-NEXT:    0 |   struct TestF3 (base)
+// CHECK-X64-NEXT:    0 |     struct A4 (base)
+// CHECK-X64-NEXT:    0 |       int a
+// CHECK-X64-NEXT:    8 |     (TestF3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct A4 (base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   28 |   int a
+// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct TestF5 : TestF3, A4 {
 	int a;
@@ -183,37 +193,37 @@ struct TestF5 : TestF3, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF5
-// CHECK:    0 |   (TestF5 vftable pointer)
-// CHECK:   16 |   struct TestF3 (base)
-// CHECK:   16 |     struct A4 (base)
-// CHECK:   16 |       int a
-// CHECK:   20 |     (TestF3 vbtable pointer)
-// CHECK:   24 |     int a
-// CHECK:   28 |   struct A4 (base)
-// CHECK:   28 |     int a
-// CHECK:   32 |   int a
-// CHECK:   48 |   struct C16 (virtual base)
-// CHECK:   48 |     (C16 vftable pointer)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct TestF5
+// CHECK-NEXT:    0 |   (TestF5 vftable pointer)
+// CHECK-NEXT:   16 |   struct TestF3 (base)
+// CHECK-NEXT:   16 |     struct A4 (base)
+// CHECK-NEXT:   16 |       int a
+// CHECK-NEXT:   20 |     (TestF3 vbtable pointer)
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:   28 |   struct A4 (base)
+// CHECK-NEXT:   28 |     int a
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF5
-// CHECK-X64:    0 |   (TestF5 vftable pointer)
-// CHECK-X64:   16 |   struct TestF3 (base)
-// CHECK-X64:   16 |     struct A4 (base)
-// CHECK-X64:   16 |       int a
-// CHECK-X64:   24 |     (TestF3 vbtable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   40 |   struct A4 (base)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   44 |   int a
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestF5
+// CHECK-X64-NEXT:    0 |   (TestF5 vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct TestF3 (base)
+// CHECK-X64-NEXT:   16 |     struct A4 (base)
+// CHECK-X64-NEXT:   16 |       int a
+// CHECK-X64-NEXT:   24 |     (TestF3 vbtable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:   40 |   struct A4 (base)
+// CHECK-X64-NEXT:   40 |     int a
+// CHECK-X64-NEXT:   44 |   int a
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct TestF6 : TestF3, A4 {
 	int a;
@@ -222,37 +232,37 @@ struct TestF6 : TestF3, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF6
-// CHECK:    0 |   struct TestF3 (base)
-// CHECK:    0 |     struct A4 (base)
-// CHECK:    0 |       int a
-// CHECK:    4 |     (TestF3 vbtable pointer)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct A4 (base)
-// CHECK:   12 |     int a
-// CHECK:   16 |   int a
-// CHECK:   44 |   (vtordisp for vbase C16)
-// CHECK:   48 |   struct C16 (virtual base)
-// CHECK:   48 |     (C16 vftable pointer)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct TestF6
+// CHECK-NEXT:    0 |   struct TestF3 (base)
+// CHECK-NEXT:    0 |     struct A4 (base)
+// CHECK-NEXT:    0 |       int a
+// CHECK-NEXT:    4 |     (TestF3 vbtable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct A4 (base)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF6
-// CHECK-X64:    0 |   struct TestF3 (base)
-// CHECK-X64:    0 |     struct A4 (base)
-// CHECK-X64:    0 |       int a
-// CHECK-X64:    8 |     (TestF3 vbtable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct A4 (base)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   28 |   int a
-// CHECK-X64:   44 |   (vtordisp for vbase C16)
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestF6
+// CHECK-X64-NEXT:    0 |   struct TestF3 (base)
+// CHECK-X64-NEXT:    0 |     struct A4 (base)
+// CHECK-X64-NEXT:    0 |       int a
+// CHECK-X64-NEXT:    8 |     (TestF3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct A4 (base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   28 |   int a
+// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct TestF7 : A4, virtual C16 {
 	int a;
@@ -261,29 +271,29 @@ struct TestF7 : A4, virtual C16 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF7
-// CHECK:    0 |   struct A4 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (TestF7 vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   28 |   (vtordisp for vbase C16)
-// CHECK:   32 |   struct C16 (virtual base)
-// CHECK:   32 |     (C16 vftable pointer)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct TestF7
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF7 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   28 |   (vtordisp for vbase C16)
+// CHECK-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF7
-// CHECK-X64:    0 |   struct A4 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (TestF7 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   44 |   (vtordisp for vbase C16)
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct TestF7
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF7 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct TestF8 : TestF7, A4 {
 	int a;
@@ -292,37 +302,37 @@ struct TestF8 : TestF7, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF8
-// CHECK:    0 |   struct TestF7 (base)
-// CHECK:    0 |     struct A4 (base)
-// CHECK:    0 |       int a
-// CHECK:    4 |     (TestF7 vbtable pointer)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct A4 (base)
-// CHECK:   12 |     int a
-// CHECK:   16 |   int a
-// CHECK:   44 |   (vtordisp for vbase C16)
-// CHECK:   48 |   struct C16 (virtual base)
-// CHECK:   48 |     (C16 vftable pointer)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct TestF8
+// CHECK-NEXT:    0 |   struct TestF7 (base)
+// CHECK-NEXT:    0 |     struct A4 (base)
+// CHECK-NEXT:    0 |       int a
+// CHECK-NEXT:    4 |     (TestF7 vbtable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct A4 (base)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF8
-// CHECK-X64:    0 |   struct TestF7 (base)
-// CHECK-X64:    0 |     struct A4 (base)
-// CHECK-X64:    0 |       int a
-// CHECK-X64:    8 |     (TestF7 vbtable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct A4 (base)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   28 |   int a
-// CHECK-X64:   44 |   (vtordisp for vbase C16)
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestF8
+// CHECK-X64-NEXT:    0 |   struct TestF7 (base)
+// CHECK-X64-NEXT:    0 |     struct A4 (base)
+// CHECK-X64-NEXT:    0 |       int a
+// CHECK-X64-NEXT:    8 |     (TestF7 vbtable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct A4 (base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   28 |   int a
+// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct TestF9 : A4, virtual C16 {
 	int a;
@@ -331,29 +341,29 @@ struct TestF9 : A4, virtual C16 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestF9
-// CHECK:    0 |   (TestF9 vftable pointer)
-// CHECK:    4 |   struct A4 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (TestF9 vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct C16 (virtual base)
-// CHECK:   16 |     (C16 vftable pointer)
-// CHECK:   32 |     int a
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct TestF9
+// CHECK-NEXT:    0 |   (TestF9 vftable pointer)
+// CHECK-NEXT:    4 |   struct A4 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (TestF9 vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct C16 (virtual base)
+// CHECK-NEXT:   16 |     (C16 vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestF9
-// CHECK-X64:    0 |   (TestF9 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (TestF9 vbtable pointer)
-// CHECK-X64:   24 |   int a
-// CHECK-X64:   32 |   struct C16 (virtual base)
-// CHECK-X64:   32 |     (C16 vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct TestF9
+// CHECK-X64-NEXT:    0 |   (TestF9 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct A4 (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (TestF9 vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct TestFA : TestF9, A4 {
 	int a;
@@ -362,37 +372,37 @@ struct TestFA : TestF9, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestFA
-// CHECK:    0 |   struct TestF9 (primary base)
-// CHECK:    0 |     (TestF9 vftable pointer)
-// CHECK:    4 |     struct A4 (base)
-// CHECK:    4 |       int a
-// CHECK:    8 |     (TestF9 vbtable pointer)
-// CHECK:   12 |     int a
-// CHECK:   16 |   struct A4 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   int a
-// CHECK:   32 |   struct C16 (virtual base)
-// CHECK:   32 |     (C16 vftable pointer)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct TestFA
+// CHECK-NEXT:    0 |   struct TestF9 (primary base)
+// CHECK-NEXT:    0 |     (TestF9 vftable pointer)
+// CHECK-NEXT:    4 |     struct A4 (base)
+// CHECK-NEXT:    4 |       int a
+// CHECK-NEXT:    8 |     (TestF9 vbtable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   struct A4 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   int a
+// CHECK-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestFA
-// CHECK-X64:    0 |   struct TestF9 (primary base)
-// CHECK-X64:    0 |     (TestF9 vftable pointer)
-// CHECK-X64:    8 |     struct A4 (base)
-// CHECK-X64:    8 |       int a
-// CHECK-X64:   16 |     (TestF9 vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   32 |   struct A4 (base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   36 |   int a
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestFA
+// CHECK-X64-NEXT:    0 |   struct TestF9 (primary base)
+// CHECK-X64-NEXT:    0 |     (TestF9 vftable pointer)
+// CHECK-X64-NEXT:    8 |     struct A4 (base)
+// CHECK-X64-NEXT:    8 |       int a
+// CHECK-X64-NEXT:   16 |     (TestF9 vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   struct A4 (base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:   36 |   int a
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct TestFB : A16, virtual C16 {
 	int a;
@@ -401,29 +411,29 @@ struct TestFB : A16, virtual C16 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestFB
-// CHECK:    0 |   (TestFB vftable pointer)
-// CHECK:   16 |   struct A16 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   (TestFB vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct C16 (virtual base)
-// CHECK:   64 |     (C16 vftable pointer)
-// CHECK:   80 |     int a
-// CHECK:      | [sizeof=96, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct TestFB
+// CHECK-NEXT:    0 |   (TestFB vftable pointer)
+// CHECK-NEXT:   16 |   struct A16 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (TestFB vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct C16 (virtual base)
+// CHECK-NEXT:   64 |     (C16 vftable pointer)
+// CHECK-NEXT:   80 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestFB
-// CHECK-X64:    0 |   (TestFB vftable pointer)
-// CHECK-X64:   16 |   struct A16 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   (TestFB vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   48 |   struct C16 (virtual base)
-// CHECK-X64:   48 |     (C16 vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestFB
+// CHECK-X64-NEXT:    0 |   (TestFB vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct A16 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (TestFB vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   64 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct TestFC : TestFB, A4 {
 	int a;
@@ -432,37 +442,37 @@ struct TestFC : TestFB, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct TestFC
-// CHECK:    0 |   struct TestFB (primary base)
-// CHECK:    0 |     (TestFB vftable pointer)
-// CHECK:   16 |     struct A16 (base)
-// CHECK:   16 |       int a
-// CHECK:   32 |     (TestFB vbtable pointer)
-// CHECK:   48 |     int a
-// CHECK:   64 |   struct A4 (base)
-// CHECK:   64 |     int a
-// CHECK:   68 |   int a
-// CHECK:   80 |   struct C16 (virtual base)
-// CHECK:   80 |     (C16 vftable pointer)
-// CHECK:   96 |     int a
-// CHECK:      | [sizeof=112, align=16
-// CHECK:      |  nvsize=80, nvalign=16]
+// CHECK-NEXT:    0 | struct TestFC
+// CHECK-NEXT:    0 |   struct TestFB (primary base)
+// CHECK-NEXT:    0 |     (TestFB vftable pointer)
+// CHECK-NEXT:   16 |     struct A16 (base)
+// CHECK-NEXT:   16 |       int a
+// CHECK-NEXT:   32 |     (TestFB vbtable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:   64 |   struct A4 (base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   68 |   int a
+// CHECK-NEXT:   80 |   struct C16 (virtual base)
+// CHECK-NEXT:   80 |     (C16 vftable pointer)
+// CHECK-NEXT:   96 |     int a
+// CHECK-NEXT:      | [sizeof=112, align=16
+// CHECK-NEXT:      |  nvsize=80, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct TestFC
-// CHECK-X64:    0 |   struct TestFB (primary base)
-// CHECK-X64:    0 |     (TestFB vftable pointer)
-// CHECK-X64:   16 |     struct A16 (base)
-// CHECK-X64:   16 |       int a
-// CHECK-X64:   32 |     (TestFB vbtable pointer)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   48 |   struct A4 (base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   52 |   int a
-// CHECK-X64:   64 |   struct C16 (virtual base)
-// CHECK-X64:   64 |     (C16 vftable pointer)
-// CHECK-X64:   80 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct TestFC
+// CHECK-X64-NEXT:    0 |   struct TestFB (primary base)
+// CHECK-X64-NEXT:    0 |     (TestFB vftable pointer)
+// CHECK-X64-NEXT:   16 |     struct A16 (base)
+// CHECK-X64-NEXT:   16 |       int a
+// CHECK-X64-NEXT:   32 |     (TestFB vbtable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   64 |   struct A4 (base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   68 |   int a
+// CHECK-X64-NEXT:   80 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   80 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   96 |     int a
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
 
 struct A16f {
@@ -486,43 +496,51 @@ struct F0 : A4, B {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F0
-// CHECK:    0 |   (F0 vftable pointer)
-// CHECK:   16 |   struct A4 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   struct B (base)
-// CHECK:   32 |     struct A4 (base)
-// CHECK:   32 |       int a
-// CHECK:   36 |     struct Y (base)
-// CHECK:   36 |       char y
-// CHECK:   48 |     struct X (base)
-// CHECK:   48 |       (X vbtable pointer)
-// CHECK:   52 |     int a
-// CHECK:   64 |   int a
-// CHECK:   80 |   struct A16f (virtual base)
-// CHECK:   80 |     (A16f vftable pointer)
-// CHECK:   96 |     int a
-// CHECK:      | [sizeof=112, align=16
-// CHECK:      |  nvsize=80, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct F0
+// CHECK-NEXT:    0 |   (F0 vftable pointer)
+// CHECK-NEXT:   16 |   struct A4 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   struct B (base)
+// CHECK-NEXT:   32 |     struct A4 (base)
+// CHECK-NEXT:   32 |       int a
+// CHECK-NEXT:   36 |     struct Y (base)
+// CHECK-NEXT:   36 |       char y
+// CHECK-NEXT:   48 |     struct X (base)
+// CHECK-NEXT:   48 |       (X vbtable pointer)
+// CHECK-NEXT:   52 |     int a
+// CHECK-NEXT:   64 |   int a
+// CHECK-NEXT:   80 |   struct A16f (virtual base)
+// CHECK-NEXT:   80 |     (A16f vftable pointer)
+// CHECK-NEXT:   96 |     int a
+// CHECK-NEXT:      | [sizeof=112, align=16
+// CHECK-NEXT:      |  nvsize=80, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F0
-// CHECK-X64:    0 |   (F0 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   struct B (base)
-// CHECK-X64:   16 |     struct A4 (base)
-// CHECK-X64:   16 |       int a
-// CHECK-X64:   20 |     struct Y (base)
-// CHECK-X64:   20 |       char y
-// CHECK-X64:   32 |     struct X (base)
-// CHECK-X64:   32 |       (X vbtable pointer)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   48 |   int a
-// CHECK-X64:   64 |   struct A16f (virtual base)
-// CHECK-X64:   64 |     (A16f vftable pointer)
-// CHECK-X64:   80 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct F0
+// CHECK-X64-NEXT:    0 |   (F0 vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct A4 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   struct B (base)
+// CHECK-X64-NEXT:   32 |     struct A4 (base)
+// CHECK-X64-NEXT:   32 |       int a
+// CHECK-X64-NEXT:   36 |     struct Y (base)
+// CHECK-X64-NEXT:   36 |       char y
+// CHECK-X64-NEXT:   48 |     struct X (base)
+// CHECK-X64-NEXT:   48 |       (X vbtable pointer)
+// CHECK-X64-NEXT:   56 |     int a
+// CHECK-X64-NEXT:   64 |   int a
+// CHECK-X64-NEXT:   80 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   80 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   96 |     int a
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
 struct F1 : B, A4 {
 	int a;
@@ -531,43 +549,43 @@ struct F1 : B, A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F1
-// CHECK:    0 |   (F1 vftable pointer)
-// CHECK:   16 |   struct B (base)
-// CHECK:   16 |     struct A4 (base)
-// CHECK:   16 |       int a
-// CHECK:   20 |     struct Y (base)
-// CHECK:   20 |       char y
-// CHECK:   32 |     struct X (base)
-// CHECK:   32 |       (X vbtable pointer)
-// CHECK:   36 |     int a
-// CHECK:   48 |   struct A4 (base)
-// CHECK:   48 |     int a
-// CHECK:   52 |   int a
-// CHECK:   64 |   struct A16f (virtual base)
-// CHECK:   64 |     (A16f vftable pointer)
-// CHECK:   80 |     int a
-// CHECK:      | [sizeof=96, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct F1
+// CHECK-NEXT:    0 |   (F1 vftable pointer)
+// CHECK-NEXT:   16 |   struct B (base)
+// CHECK-NEXT:   16 |     struct A4 (base)
+// CHECK-NEXT:   16 |       int a
+// CHECK-NEXT:   20 |     struct Y (base)
+// CHECK-NEXT:   20 |       char y
+// CHECK-NEXT:   32 |     struct X (base)
+// CHECK-NEXT:   32 |       (X vbtable pointer)
+// CHECK-NEXT:   36 |     int a
+// CHECK-NEXT:   48 |   struct A4 (base)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:   52 |   int a
+// CHECK-NEXT:   64 |   struct A16f (virtual base)
+// CHECK-NEXT:   64 |     (A16f vftable pointer)
+// CHECK-NEXT:   80 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F1
-// CHECK-X64:    0 |   (F1 vftable pointer)
-// CHECK-X64:   16 |   struct B (base)
-// CHECK-X64:   16 |     struct A4 (base)
-// CHECK-X64:   16 |       int a
-// CHECK-X64:   20 |     struct Y (base)
-// CHECK-X64:   20 |       char y
-// CHECK-X64:   32 |     struct X (base)
-// CHECK-X64:   32 |       (X vbtable pointer)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   48 |   struct A4 (base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   52 |   int a
-// CHECK-X64:   64 |   struct A16f (virtual base)
-// CHECK-X64:   64 |     (A16f vftable pointer)
-// CHECK-X64:   80 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct F1
+// CHECK-X64-NEXT:    0 |   (F1 vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B (base)
+// CHECK-X64-NEXT:   16 |     struct A4 (base)
+// CHECK-X64-NEXT:   16 |       int a
+// CHECK-X64-NEXT:   20 |     struct Y (base)
+// CHECK-X64-NEXT:   20 |       char y
+// CHECK-X64-NEXT:   32 |     struct X (base)
+// CHECK-X64-NEXT:   32 |       (X vbtable pointer)
+// CHECK-X64-NEXT:   40 |     int a
+// CHECK-X64-NEXT:   48 |   struct A4 (base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   52 |   int a
+// CHECK-X64-NEXT:   64 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   64 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F2 : A4, virtual A16f {
 	int a;
@@ -576,29 +594,29 @@ struct F2 : A4, virtual A16f {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F2
-// CHECK:    0 |   (F2 vftable pointer)
-// CHECK:    4 |   struct A4 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (F2 vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct A16f (virtual base)
-// CHECK:   16 |     (A16f vftable pointer)
-// CHECK:   32 |     int a
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct F2
+// CHECK-NEXT:    0 |   (F2 vftable pointer)
+// CHECK-NEXT:    4 |   struct A4 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (F2 vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct A16f (virtual base)
+// CHECK-NEXT:   16 |     (A16f vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F2
-// CHECK-X64:    0 |   (F2 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (F2 vbtable pointer)
-// CHECK-X64:   24 |   int a
-// CHECK-X64:   32 |   struct A16f (virtual base)
-// CHECK-X64:   32 |     (A16f vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F2
+// CHECK-X64-NEXT:    0 |   (F2 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct A4 (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (F2 vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   32 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct F3 : A4, virtual A16f {
 	__declspec(align(16)) int a;
@@ -607,29 +625,29 @@ struct F3 : A4, virtual A16f {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F3
-// CHECK:    0 |   (F3 vftable pointer)
-// CHECK:   16 |   struct A4 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   (F3 vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct A16f (virtual base)
-// CHECK:   64 |     (A16f vftable pointer)
-// CHECK:   80 |     int a
-// CHECK:      | [sizeof=96, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct F3
+// CHECK-NEXT:    0 |   (F3 vftable pointer)
+// CHECK-NEXT:   16 |   struct A4 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   (F3 vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct A16f (virtual base)
+// CHECK-NEXT:   64 |     (A16f vftable pointer)
+// CHECK-NEXT:   80 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F3
-// CHECK-X64:    0 |   (F3 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (F3 vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct A16f (virtual base)
-// CHECK-X64:   48 |     (A16f vftable pointer)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct F3
+// CHECK-X64-NEXT:    0 |   (F3 vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct A4 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   (F3 vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   64 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F4 : A4, B {
 	__declspec(align(16)) int a;
@@ -638,43 +656,43 @@ struct F4 : A4, B {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F4
-// CHECK:    0 |   (F4 vftable pointer)
-// CHECK:   16 |   struct A4 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   struct B (base)
-// CHECK:   32 |     struct A4 (base)
-// CHECK:   32 |       int a
-// CHECK:   36 |     struct Y (base)
-// CHECK:   36 |       char y
-// CHECK:   48 |     struct X (base)
-// CHECK:   48 |       (X vbtable pointer)
-// CHECK:   52 |     int a
-// CHECK:   64 |   int a
-// CHECK:   80 |   struct A16f (virtual base)
-// CHECK:   80 |     (A16f vftable pointer)
-// CHECK:   96 |     int a
-// CHECK:      | [sizeof=112, align=16
-// CHECK:      |  nvsize=80, nvalign=16]
+// CHECK-NEXT:    0 | struct F4
+// CHECK-NEXT:    0 |   (F4 vftable pointer)
+// CHECK-NEXT:   16 |   struct A4 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   struct B (base)
+// CHECK-NEXT:   32 |     struct A4 (base)
+// CHECK-NEXT:   32 |       int a
+// CHECK-NEXT:   36 |     struct Y (base)
+// CHECK-NEXT:   36 |       char y
+// CHECK-NEXT:   48 |     struct X (base)
+// CHECK-NEXT:   48 |       (X vbtable pointer)
+// CHECK-NEXT:   52 |     int a
+// CHECK-NEXT:   64 |   int a
+// CHECK-NEXT:   80 |   struct A16f (virtual base)
+// CHECK-NEXT:   80 |     (A16f vftable pointer)
+// CHECK-NEXT:   96 |     int a
+// CHECK-NEXT:      | [sizeof=112, align=16
+// CHECK-NEXT:      |  nvsize=80, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F4
-// CHECK-X64:    0 |   (F4 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   struct B (base)
-// CHECK-X64:   16 |     struct A4 (base)
-// CHECK-X64:   16 |       int a
-// CHECK-X64:   20 |     struct Y (base)
-// CHECK-X64:   20 |       char y
-// CHECK-X64:   32 |     struct X (base)
-// CHECK-X64:   32 |       (X vbtable pointer)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   48 |   int a
-// CHECK-X64:   64 |   struct A16f (virtual base)
-// CHECK-X64:   64 |     (A16f vftable pointer)
-// CHECK-X64:   80 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct F4
+// CHECK-X64-NEXT:    0 |   (F4 vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct A4 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   struct B (base)
+// CHECK-X64-NEXT:   32 |     struct A4 (base)
+// CHECK-X64-NEXT:   32 |       int a
+// CHECK-X64-NEXT:   36 |     struct Y (base)
+// CHECK-X64-NEXT:   36 |       char y
+// CHECK-X64-NEXT:   48 |     struct X (base)
+// CHECK-X64-NEXT:   48 |       (X vbtable pointer)
+// CHECK-X64-NEXT:   56 |     int a
+// CHECK-X64-NEXT:   64 |   int a
+// CHECK-X64-NEXT:   80 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   80 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   96 |     int a
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
 struct F5 : A16f, virtual A4 {
 	int a;
@@ -683,27 +701,27 @@ struct F5 : A16f, virtual A4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F5
-// CHECK:    0 |   struct A16f (primary base)
-// CHECK:    0 |     (A16f vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:   32 |   (F5 vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct A4 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct F5
+// CHECK-NEXT:    0 |   struct A16f (primary base)
+// CHECK-NEXT:    0 |     (A16f vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (F5 vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct A4 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F5
-// CHECK-X64:    0 |   struct A16f (primary base)
-// CHECK-X64:    0 |     (A16f vftable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   (F5 vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   48 |   struct A4 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct F5
+// CHECK-X64-NEXT:    0 |   struct A16f (primary base)
+// CHECK-X64-NEXT:    0 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (F5 vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct A4 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F6 : virtual A16f, A4, virtual B {
 	int a;
@@ -712,45 +730,91 @@ struct F6 : virtual A16f, A4, virtual B {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F6
-// CHECK:    0 |   (F6 vftable pointer)
-// CHECK:    4 |   struct A4 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (F6 vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct A16f (virtual base)
-// CHECK:   16 |     (A16f vftable pointer)
-// CHECK:   32 |     int a
-// CHECK:   48 |   struct B (virtual base)
-// CHECK:   48 |     struct A4 (base)
-// CHECK:   48 |       int a
-// CHECK:   52 |     struct Y (base)
-// CHECK:   52 |       char y
-// CHECK:   64 |     struct X (base)
-// CHECK:   64 |       (X vbtable pointer)
-// CHECK:   68 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct F6
+// CHECK-NEXT:    0 |   (F6 vftable pointer)
+// CHECK-NEXT:    4 |   struct A4 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (F6 vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct A16f (virtual base)
+// CHECK-NEXT:   16 |     (A16f vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:   48 |   struct B (virtual base)
+// CHECK-NEXT:   48 |     struct A4 (base)
+// CHECK-NEXT:   48 |       int a
+// CHECK-NEXT:   52 |     struct Y (base)
+// CHECK-NEXT:   52 |       char y
+// CHECK-NEXT:   64 |     struct X (base)
+// CHECK-NEXT:   64 |       (X vbtable pointer)
+// CHECK-NEXT:   68 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct F6
+// CHECK-X64-NEXT:    0 |   (F6 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct A4 (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (F6 vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   struct A16f (virtual base)
+// CHECK-X64-NEXT:   32 |     (A16f vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   64 |   struct B (virtual base)
+// CHECK-X64-NEXT:   64 |     struct A4 (base)
+// CHECK-X64-NEXT:   64 |       int a
+// CHECK-X64-NEXT:   68 |     struct Y (base)
+// CHECK-X64-NEXT:   68 |       char y
+// CHECK-X64-NEXT:   80 |     struct X (base)
+// CHECK-X64-NEXT:   80 |       (X vbtable pointer)
+// CHECK-X64-NEXT:   88 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
+
+struct ArrayFieldOfRecords {
+  A4 InlineElts[2];
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct ArrayFieldOfRecords
+// CHECK-NEXT:    0 |   struct A4 [2] InlineElts
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct ArrayFieldOfRecords
+// CHECK-X64-NEXT:    0 |   struct A4 [2] InlineElts
+// CHECK-X64-NEXT:      | [sizeof=8, align=4
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
+
+struct ArrayOfArrayFieldOfRecords {
+  A4 InlineElts[2][2];
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct ArrayOfArrayFieldOfRecords
+// CHECK-NEXT:    0 |   struct A4 [2][2] InlineElts
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct ArrayOfArrayFieldOfRecords
+// CHECK-X64-NEXT:    0 |   struct A4 [2][2] InlineElts
+// CHECK-X64-NEXT:      | [sizeof=16, align=4
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=4]
+
+struct RecordArrayTypedef {
+  typedef A4 ArrayTy[2];
+  ArrayTy InlineElts[2];
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RecordArrayTypedef
+// CHECK-NEXT:    0 |   ArrayTy [2] InlineElts
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F6
-// CHECK-X64:    0 |   (F6 vftable pointer)
-// CHECK-X64:    8 |   struct A4 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (F6 vbtable pointer)
-// CHECK-X64:   24 |   int a
-// CHECK-X64:   32 |   struct A16f (virtual base)
-// CHECK-X64:   32 |     (A16f vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   64 |   struct B (virtual base)
-// CHECK-X64:   64 |     struct A4 (base)
-// CHECK-X64:   64 |       int a
-// CHECK-X64:   68 |     struct Y (base)
-// CHECK-X64:   68 |       char y
-// CHECK-X64:   80 |     struct X (base)
-// CHECK-X64:   80 |       (X vbtable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct RecordArrayTypedef
+// CHECK-X64-NEXT:    0 |   ArrayTy [2] InlineElts
+// CHECK-X64-NEXT:      | [sizeof=16, align=4
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=4]
 
 int a[
 sizeof(TestF0)+
@@ -772,4 +836,8 @@ sizeof(F2)+
 sizeof(F3)+
 sizeof(F4)+
 sizeof(F5)+
-sizeof(F6)];
+sizeof(F6)+
+sizeof(ArrayFieldOfRecords)+
+sizeof(ArrayOfArrayFieldOfRecords)+
+sizeof(RecordArrayTypedef)+
+0];
diff --git a/test/Layout/ms-x86-bitfields-vbases.cpp b/test/Layout/ms-x86-bitfields-vbases.cpp
index e11ef67a6347..5b54596bbb83 100644
--- a/test/Layout/ms-x86-bitfields-vbases.cpp
+++ b/test/Layout/ms-x86-bitfields-vbases.cpp
@@ -1,84 +1,120 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
-struct B0 { };

-

-struct A : virtual B0 { char a : 1; };

+struct B0 { int a; };
+struct B1 { int a; };
 
-// CHECK: *** Dumping AST Record Layout

-// CHECK:    0 | struct A

-// CHECK:    0 |   (A vbtable pointer)

-// CHECK:    4 |   char a

-// CHECK:    9 |   struct B0 (virtual base) (empty)

-// CHECK:      | [sizeof=9, align=4

-// CHECK:      |  nvsize=8, nvalign=4]

+struct A : virtual B0 { char a : 1; };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vbtable pointer)
+// CHECK-NEXT:    4 |   char a
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A

-// CHECK-X64:    0 |   (A vbtable pointer)

-// CHECK-X64:    8 |   char a

-// CHECK-X64:   17 |   struct B0 (virtual base) (empty)

-// CHECK-X64:      | [sizeof=24, align=8

-// CHECK-X64:      |  nvsize=16, nvalign=8]

+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vbtable pointer)
+// CHECK-X64-NEXT:    8 |   char a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
-struct B : virtual B0 { short a : 1; };

+struct B : virtual B0 { short a : 1; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B

-// CHECK:    0 |   (B vbtable pointer)

-// CHECK:    4 |   short a

-// CHECK:   10 |   struct B0 (virtual base) (empty)

-// CHECK:      | [sizeof=10, align=4

-// CHECK:      |  nvsize=8, nvalign=4]

+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   (B vbtable pointer)
+// CHECK-NEXT:    4 |   short a
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B

-// CHECK-X64:    0 |   (B vbtable pointer)

-// CHECK-X64:    8 |   short a

-// CHECK-X64:   18 |   struct B0 (virtual base) (empty)

-// CHECK-X64:      | [sizeof=24, align=8

-// CHECK-X64:      |  nvsize=16, nvalign=8]

+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   (B vbtable pointer)
+// CHECK-X64-NEXT:    8 |   short a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
-struct C : virtual B0 { char a : 1; char : 0; };

+struct C : virtual B0 { char a : 1; char : 0; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C

-// CHECK:    0 |   (C vbtable pointer)

-// CHECK:    4 |   char a

-// CHECK:    5 |   char

-// CHECK:    8 |   struct B0 (virtual base) (empty)

-// CHECK:      | [sizeof=8, align=4

-// CHECK:      |  nvsize=8, nvalign=4]

+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   char a
+// CHECK-NEXT:    5 |   char
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C

-// CHECK-X64:    0 |   (C vbtable pointer)

-// CHECK-X64:    8 |   char a

-// CHECK-X64:    9 |   char

-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)

-// CHECK-X64:      | [sizeof=16, align=8

-// CHECK-X64:      |  nvsize=16, nvalign=8]

+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vbtable pointer)
+// CHECK-X64-NEXT:    8 |   char a
+// CHECK-X64-NEXT:    9 |   char
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
-struct D : virtual B0 { char a : 1; char b; };

+struct D : virtual B0 { char a : 1; char b; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D

-// CHECK:    0 |   (D vbtable pointer)

-// CHECK:    4 |   char a

-// CHECK:    5 |   char b

-// CHECK:    8 |   struct B0 (virtual base) (empty)

-// CHECK:      | [sizeof=8, align=4

-// CHECK:      |  nvsize=8, nvalign=4]

+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   (D vbtable pointer)
+// CHECK-NEXT:    4 |   char a
+// CHECK-NEXT:    5 |   char b
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   (D vbtable pointer)
+// CHECK-X64-NEXT:    8 |   char a
+// CHECK-X64-NEXT:    9 |   char b
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
+
+struct E : virtual B0, virtual B1 { long long : 1; };
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   (E vbtable pointer)
+// CHECK-NEXT:    8 |   long long
+// CHECK-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   struct B1 (virtual base)
+// CHECK-NEXT:   20 |     int a
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=16, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D

-// CHECK-X64:    0 |   (D vbtable pointer)

-// CHECK-X64:    8 |   char a

-// CHECK-X64:    9 |   char b

-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)

-// CHECK-X64:      | [sizeof=16, align=8

-// CHECK-X64:      |  nvsize=16, nvalign=8]

+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   (E vbtable pointer)
+// CHECK-X64-NEXT:    8 |   long long
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   20 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 int a[
 sizeof(A)+
 sizeof(B)+
 sizeof(C)+
-sizeof(D)];
+sizeof(D)+
+sizeof(E)];
diff --git a/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp b/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp
index 293a61b96e64..224594ead408 100644
--- a/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp
+++ b/test/Layout/ms-x86-empty-base-after-base-with-vbptr.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 
@@ -14,197 +14,209 @@ struct Z : Y { };
 struct A : X, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    9 |   struct W (base) (empty)
-// CHECK:    9 |   char a
-// CHECK:   12 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    9 |   struct W (base) (empty)
+// CHECK-NEXT:    9 |   char a
+// CHECK-NEXT:   12 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   17 |   struct W (base) (empty)
-// CHECK-X64:   17 |   char a
-// CHECK-X64:   24 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   17 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   17 |   char a
+// CHECK-X64-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct B : X, U, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    8 |   struct U (base)
-// CHECK:    8 |     char a
-// CHECK:    9 |   struct W (base) (empty)
-// CHECK:    9 |   char a
-// CHECK:   12 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    8 |   struct U (base)
+// CHECK-NEXT:    8 |     char a
+// CHECK-NEXT:    9 |   struct W (base) (empty)
+// CHECK-NEXT:    9 |   char a
+// CHECK-NEXT:   12 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   16 |   struct U (base)
-// CHECK-X64:   16 |     char a
-// CHECK-X64:   17 |   struct W (base) (empty)
-// CHECK-X64:   17 |   char a
-// CHECK-X64:   24 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   16 |   struct U (base)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:   17 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   17 |   char a
+// CHECK-X64-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct C : X, V, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    9 |   struct V (base) (empty)
-// CHECK:   10 |   struct W (base) (empty)
-// CHECK:   10 |   char a
-// CHECK:   12 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    9 |   struct V (base) (empty)
+// CHECK-NEXT:   10 |   struct W (base) (empty)
+// CHECK-NEXT:   10 |   char a
+// CHECK-NEXT:   12 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   17 |   struct V (base) (empty)
-// CHECK-X64:   18 |   struct W (base) (empty)
-// CHECK-X64:   18 |   char a
-// CHECK-X64:   24 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   17 |   struct V (base) (empty)
+// CHECK-X64-NEXT:   18 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   18 |   char a
+// CHECK-X64-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct D : X, U, V, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    8 |   struct U (base)
-// CHECK:    8 |     char a
-// CHECK:    9 |   struct V (base) (empty)
-// CHECK:   10 |   struct W (base) (empty)
-// CHECK:   10 |   char a
-// CHECK:   12 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    8 |   struct U (base)
+// CHECK-NEXT:    8 |     char a
+// CHECK-NEXT:    9 |   struct V (base) (empty)
+// CHECK-NEXT:   10 |   struct W (base) (empty)
+// CHECK-NEXT:   10 |   char a
+// CHECK-NEXT:   12 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   16 |   struct U (base)
-// CHECK-X64:   16 |     char a
-// CHECK-X64:   17 |   struct V (base) (empty)
-// CHECK-X64:   18 |   struct W (base) (empty)
-// CHECK-X64:   18 |   char a
-// CHECK-X64:   24 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   16 |   struct U (base)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:   17 |   struct V (base) (empty)
+// CHECK-X64-NEXT:   18 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   18 |   char a
+// CHECK-X64-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct E : X, U, Y, V, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    8 |   struct U (base)
-// CHECK:    8 |     char a
-// CHECK:   12 |   struct Y (base)
-// CHECK:   12 |     (Y vbtable pointer)
-// CHECK:   16 |     char a
-// CHECK:   21 |   struct V (base) (empty)
-// CHECK:   22 |   struct W (base) (empty)
-// CHECK:   22 |   char a
-// CHECK:   24 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=24, align=4
-// CHECK:      |  nvsize=24, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    8 |   struct U (base)
+// CHECK-NEXT:    8 |     char a
+// CHECK-NEXT:   12 |   struct Y (base)
+// CHECK-NEXT:   12 |     (Y vbtable pointer)
+// CHECK-NEXT:   16 |     char a
+// CHECK-NEXT:   21 |   struct V (base) (empty)
+// CHECK-NEXT:   22 |   struct W (base) (empty)
+// CHECK-NEXT:   22 |   char a
+// CHECK-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=24, align=4
+// CHECK-NEXT:      |  nvsize=24, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   16 |   struct U (base)
-// CHECK-X64:   16 |     char a
-// CHECK-X64:   24 |   struct Y (base)
-// CHECK-X64:   24 |     (Y vbtable pointer)
-// CHECK-X64:   32 |     char a
-// CHECK-X64:   41 |   struct V (base) (empty)
-// CHECK-X64:   42 |   struct W (base) (empty)
-// CHECK-X64:   42 |   char a
-// CHECK-X64:   48 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=8
-// CHECK-X64:      |  nvsize=48, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   16 |   struct U (base)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:   24 |   struct Y (base)
+// CHECK-X64-NEXT:   24 |     (Y vbtable pointer)
+// CHECK-X64-NEXT:   32 |     char a
+// CHECK-X64-NEXT:   41 |   struct V (base) (empty)
+// CHECK-X64-NEXT:   42 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   42 |   char a
+// CHECK-X64-NEXT:   48 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=8
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=8]
 
 struct F : Z, W  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   struct Z (base)
-// CHECK:    0 |     struct Y (base)
-// CHECK:    0 |       (Y vbtable pointer)
-// CHECK:    4 |       char a
-// CHECK:    9 |   struct W (base) (empty)
-// CHECK:    9 |   char a
-// CHECK:   12 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   struct Z (base)
+// CHECK-NEXT:    0 |     struct Y (base)
+// CHECK-NEXT:    0 |       (Y vbtable pointer)
+// CHECK-NEXT:    4 |       char a
+// CHECK-NEXT:    9 |   struct W (base) (empty)
+// CHECK-NEXT:    9 |   char a
+// CHECK-NEXT:   12 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   struct Z (base)
-// CHECK-X64:    0 |     struct Y (base)
-// CHECK-X64:    0 |       (Y vbtable pointer)
-// CHECK-X64:    8 |       char a
-// CHECK-X64:   17 |   struct W (base) (empty)
-// CHECK-X64:   17 |   char a
-// CHECK-X64:   24 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   struct Z (base)
+// CHECK-X64-NEXT:    0 |     struct Y (base)
+// CHECK-X64-NEXT:    0 |       (Y vbtable pointer)
+// CHECK-X64-NEXT:    8 |       char a
+// CHECK-X64-NEXT:   17 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   17 |   char a
+// CHECK-X64-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct G : X, W, Y, V  { char a; };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    0 |   struct X (base)
-// CHECK:    0 |     (X vbtable pointer)
-// CHECK:    4 |     char a
-// CHECK:    9 |   struct W (base) (empty)
-// CHECK:   12 |   struct Y (base)
-// CHECK:   12 |     (Y vbtable pointer)
-// CHECK:   16 |     char a
-// CHECK:   21 |   struct V (base) (empty)
-// CHECK:   21 |   char a
-// CHECK:   24 |   struct V (virtual base) (empty)
-// CHECK:      | [sizeof=24, align=4
-// CHECK:      |  nvsize=24, nvalign=4]
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   struct X (base)
+// CHECK-NEXT:    0 |     (X vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    9 |   struct W (base) (empty)
+// CHECK-NEXT:   12 |   struct Y (base)
+// CHECK-NEXT:   12 |     (Y vbtable pointer)
+// CHECK-NEXT:   16 |     char a
+// CHECK-NEXT:   21 |   struct V (base) (empty)
+// CHECK-NEXT:   21 |   char a
+// CHECK-NEXT:   24 |   struct V (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=24, align=4
+// CHECK-NEXT:      |  nvsize=24, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct G
-// CHECK-X64:    0 |   struct X (base)
-// CHECK-X64:    0 |     (X vbtable pointer)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:   17 |   struct W (base) (empty)
-// CHECK-X64:   24 |   struct Y (base)
-// CHECK-X64:   24 |     (Y vbtable pointer)
-// CHECK-X64:   32 |     char a
-// CHECK-X64:   41 |   struct V (base) (empty)
-// CHECK-X64:   41 |   char a
-// CHECK-X64:   48 |   struct V (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=8
-// CHECK-X64:      |  nvsize=48, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-NEXT:    0 |   struct X (base)
+// CHECK-X64-NEXT:    0 |     (X vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   17 |   struct W (base) (empty)
+// CHECK-X64-NEXT:   24 |   struct Y (base)
+// CHECK-X64-NEXT:   24 |     (Y vbtable pointer)
+// CHECK-X64-NEXT:   32 |     char a
+// CHECK-X64-NEXT:   41 |   struct V (base) (empty)
+// CHECK-X64-NEXT:   41 |   char a
+// CHECK-X64-NEXT:   48 |   struct V (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=8
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=8]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-empty-nonvirtual-bases.cpp b/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
index 01d10c9994f6..6ef14948e346 100644
--- a/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
+++ b/test/Layout/ms-x86-empty-nonvirtual-bases.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
 
 extern "C" int printf(const char *fmt, ...);
@@ -23,11 +23,12 @@ struct A : B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    0 |   int a
-// CHECK:      | [sizeof=8, align=8
-// CHECK:      |  nvsize=8, nvalign=8]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    0 |   int a
+// CHECK-NEXT:      | [sizeof=8, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
 
 struct B : B0 {
 	B0 b0;
@@ -36,14 +37,14 @@ struct B : B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    0 |   struct B0 b0 (empty)
-// CHECK:      |   [sizeof=8, align=8
-// CHECK:      |    nvsize=0, nvalign=1]
-// CHECK:    8 |   int a
-// CHECK:      | [sizeof=16, align=8
-// CHECK:      |  nvsize=16, nvalign=8]
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    0 |   struct B0 b0 (empty)
+// CHECK-NEXT:      |   [sizeof=8, align=8
+// CHECK-NEXT:      |    nvsize=0, nvalign=8]
+// CHECK:         8 |   int a
+// CHECK-NEXT:      | [sizeof=16, align=8
+// CHECK-NEXT:      |  nvsize=16, nvalign=8]
 
 struct C : B0, B1, B2, B3, B4 {
 	int a;
@@ -51,15 +52,19 @@ struct C : B0, B1, B2, B3, B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    8 |   struct B1 (base) (empty)
-// CHECK:   16 |   struct B2 (base) (empty)
-// CHECK:   24 |   struct B3 (base) (empty)
-// CHECK:   32 |   struct B4 (base) (empty)
-// CHECK:   32 |   int a
-// CHECK:      | [sizeof=40, align=8
-// CHECK:      |  nvsize=40, nvalign=8]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    8 |   struct B1 (base) (empty)
+// CHECK-NEXT:   16 |   struct B2 (base) (empty)
+// CHECK-NEXT:   24 |   struct B3 (base) (empty)
+// CHECK-NEXT:   32 |   struct B4 (base) (empty)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:      | [sizeof=40, align=8
+// CHECK-NEXT:      |  nvsize=40, nvalign=8]
 
 struct D {
 	B0 b0;
@@ -72,28 +77,31 @@ struct D {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct B0 b0 (empty)
-// CHECK:      |   [sizeof=8, align=8
-// CHECK:      |    nvsize=0, nvalign=1]
-// CHECK:    8 |   struct C0 c0
-// CHECK:    8 |     int a
-// CHECK:      |   [sizeof=4, align=4
-// CHECK:      |    nvsize=4, nvalign=4]
-// CHECK:   12 |   struct C1 c1
-// CHECK:   12 |     int a
-// CHECK:      |   [sizeof=4, align=4
-// CHECK:      |    nvsize=4, nvalign=4]
-// CHECK:   16 |   struct C2 c2
-// CHECK:   16 |     int a
-// CHECK:      |   [sizeof=4, align=4
-// CHECK:      |    nvsize=4, nvalign=4]
-// CHECK:   24 |   struct B1 b1 (empty)
-// CHECK:      |   [sizeof=8, align=8
-// CHECK:      |    nvsize=0, nvalign=1]
-// CHECK:   32 |   int a
-// CHECK:      | [sizeof=40, align=8
-// CHECK:      |  nvsize=40, nvalign=8]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct B0 b0 (empty)
+// CHECK-NEXT:      |   [sizeof=8, align=8
+// CHECK-NEXT:      |    nvsize=0, nvalign=8]
+// CHECK:         8 |   struct C0 c0
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      |   [sizeof=4, align=4
+// CHECK-NEXT:      |    nvsize=4, nvalign=4]
+// CHECK:        12 |   struct C1 c1
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:      |   [sizeof=4, align=4
+// CHECK-NEXT:      |    nvsize=4, nvalign=4]
+// CHECK:        16 |   struct C2 c2
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      |   [sizeof=4, align=4
+// CHECK-NEXT:      |    nvsize=4, nvalign=4]
+// CHECK:        24 |   struct B1 b1 (empty)
+// CHECK-NEXT:      |   [sizeof=8, align=8
+// CHECK-NEXT:      |    nvsize=0, nvalign=8]
+// CHECK:        32 |   int a
+// CHECK-NEXT:      | [sizeof=40, align=8
+// CHECK-NEXT:      |  nvsize=40, nvalign=8]
 
 struct E : B0, C0, C1, C2, B1 {
 	int a;
@@ -101,18 +109,18 @@ struct E : B0, C0, C1, C2, B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    0 |   struct C0 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   struct C1 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   struct C2 (base)
-// CHECK:    8 |     int a
-// CHECK:   16 |   struct B1 (base) (empty)
-// CHECK:   16 |   int a
-// CHECK:      | [sizeof=24, align=8
-// CHECK:      |  nvsize=24, nvalign=8]
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    0 |   struct C0 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   struct C1 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct C2 (base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : C0, B0, B1, C1 {
 	int a;
@@ -120,16 +128,16 @@ struct F : C0, B0, B1, C1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   struct C0 (base)
-// CHECK:    0 |     int a
-// CHECK:    8 |   struct B0 (base) (empty)
-// CHECK:   16 |   struct B1 (base) (empty)
-// CHECK:   16 |   struct C1 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   int a
-// CHECK:      | [sizeof=24, align=8
-// CHECK:      |  nvsize=24, nvalign=8]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   struct C0 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    8 |   struct B0 (base) (empty)
+// CHECK-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-NEXT:   16 |   struct C1 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   int a
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
 
 struct G : B0, B1, B2, B3, B4 {
 	__declspec(align(32)) int a;
@@ -137,15 +145,15 @@ struct G : B0, B1, B2, B3, B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    8 |   struct B1 (base) (empty)
-// CHECK:   16 |   struct B2 (base) (empty)
-// CHECK:   24 |   struct B3 (base) (empty)
-// CHECK:   32 |   struct B4 (base) (empty)
-// CHECK:   32 |   int a
-// CHECK:      | [sizeof=64, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    8 |   struct B1 (base) (empty)
+// CHECK-NEXT:   16 |   struct B2 (base) (empty)
+// CHECK-NEXT:   24 |   struct B3 (base) (empty)
+// CHECK-NEXT:   32 |   struct B4 (base) (empty)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:      | [sizeof=64, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) H : B0, B1, B2, B3, B4 {
 	int a;
@@ -153,15 +161,15 @@ struct __declspec(align(32)) H : B0, B1, B2, B3, B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct H
-// CHECK:    0 |   struct B0 (base) (empty)
-// CHECK:    8 |   struct B1 (base) (empty)
-// CHECK:   16 |   struct B2 (base) (empty)
-// CHECK:   24 |   struct B3 (base) (empty)
-// CHECK:   32 |   struct B4 (base) (empty)
-// CHECK:   32 |   int a
-// CHECK:      | [sizeof=64, align=32
-// CHECK:      |  nvsize=40, nvalign=8]
+// CHECK-NEXT:    0 | struct H
+// CHECK-NEXT:    0 |   struct B0 (base) (empty)
+// CHECK-NEXT:    8 |   struct B1 (base) (empty)
+// CHECK-NEXT:   16 |   struct B2 (base) (empty)
+// CHECK-NEXT:   24 |   struct B3 (base) (empty)
+// CHECK-NEXT:   32 |   struct B4 (base) (empty)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:      | [sizeof=64, align=32
+// CHECK-NEXT:      |  nvsize=40, nvalign=32]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-empty-virtual-base.cpp b/test/Layout/ms-x86-empty-virtual-base.cpp
index ef6f08175e7a..23e287acf93b 100644
--- a/test/Layout/ms-x86-empty-virtual-base.cpp
+++ b/test/Layout/ms-x86-empty-virtual-base.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -27,19 +27,21 @@ struct A : virtual B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=8, align=8
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct B : virtual B0 {
 	B0 b0;
@@ -48,25 +50,25 @@ struct B : virtual B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   (B vbtable pointer)
-// CHECK:    8 |   struct B0 b0 (empty)
-// CHECK:      |   [sizeof=8, align=8
-// CHECK:      |    nvsize=0, nvalign=1]
-// CHECK:   16 |   int a
-// CHECK:   24 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=24, align=8
-// CHECK:      |  nvsize=24, nvalign=8]
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   (B vbtable pointer)
+// CHECK-NEXT:    8 |   struct B0 b0 (empty)
+// CHECK-NEXT:      |   [sizeof=8, align=8
+// CHECK-NEXT:      |    nvsize=0, nvalign=8]
+// CHECK:        16 |   int a
+// CHECK-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   (B vbtable pointer)
-// CHECK-X64:    8 |   struct B0 b0 (empty)
-// CHECK-X64:      |   [sizeof=8, align=8
-// CHECK-X64:      |    nvsize=0, nvalign=1]
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   (B vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 b0 (empty)
+// CHECK-X64-NEXT:      |   [sizeof=8, align=8
+// CHECK-X64-NEXT:      |    nvsize=0, nvalign=8]
+// CHECK-X64:        16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct C : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
 	int a;
@@ -74,27 +76,35 @@ struct C : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:   16 |   struct B1 (virtual base) (empty)
-// CHECK:   24 |   struct B2 (virtual base) (empty)
-// CHECK:   32 |   struct B3 (virtual base) (empty)
-// CHECK:   40 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=40, align=8
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   16 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   24 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:   32 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:   40 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=40, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   24 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   32 |   struct B2 (virtual base) (empty)
-// CHECK-X64:   40 |   struct B3 (virtual base) (empty)
-// CHECK-X64:   48 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   24 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   32 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:   48 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct D {
 	B0 b0;
@@ -107,31 +117,37 @@ struct D {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct B0 b0 (empty)
-// CHECK:    8 |   struct C0 c0
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct C1 c1
-// CHECK:   12 |     int a
-// CHECK:   16 |   struct C2 c2
-// CHECK:   16 |     int a
-// CHECK:   24 |   struct B1 b1 (empty)
-// CHECK:   32 |   int a
-// CHECK:      | [sizeof=40, align=8
-// CHECK:      |  nvsize=40, nvalign=8]
-// CHECK-64: *** Dumping AST Record Layout
-// CHECK-64:    0 | struct D
-// CHECK-64:    0 |   struct B0 b0 (empty)
-// CHECK-64:    8 |   struct C0 c0
-// CHECK-64:    8 |     int a
-// CHECK-64:   12 |   struct C1 c1
-// CHECK-64:   12 |     int a
-// CHECK-64:   16 |   struct C2 c2
-// CHECK-64:   16 |     int a
-// CHECK-64:   24 |   struct B1 b1 (empty)
-// CHECK-64:   32 |   int a
-// CHECK-64:      | [sizeof=40, align=8
-// CHECK-64:      |  nvsize=40, nvalign=8]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct B0 b0 (empty)
+// CHECK:         8 |   struct C0 c0
+// CHECK-NEXT:    8 |     int a
+// CHECK:        12 |   struct C1 c1
+// CHECK-NEXT:   12 |     int a
+// CHECK:        16 |   struct C2 c2
+// CHECK-NEXT:   16 |     int a
+// CHECK:        24 |   struct B1 b1 (empty)
+// CHECK:        32 |   int a
+// CHECK-NEXT:      | [sizeof=40, align=8
+// CHECK-NEXT:      |  nvsize=40, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct B0 b0 (empty)
+// CHECK-X64:         8 |   struct C0 c0
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64:        12 |   struct C1 c1
+// CHECK-X64-NEXT:   12 |     int a
+// CHECK-X64:        16 |   struct C2 c2
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64:        24 |   struct B1 b1 (empty)
+// CHECK-X64:        32 |   int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct E : virtual B0, virtual C0, virtual C1, virtual C2, virtual B1 {
 	int a;
@@ -139,33 +155,33 @@ struct E : virtual B0, virtual C0, virtual C1, virtual C2, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   (E vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:    8 |   struct C0 (virtual base)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct C1 (virtual base)
-// CHECK:   12 |     int a
-// CHECK:   16 |   struct C2 (virtual base)
-// CHECK:   16 |     int a
-// CHECK:   24 |   struct B1 (virtual base) (empty)
-// CHECK:      | [sizeof=24, align=8
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   (E vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct C0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct C1 (virtual base)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   struct C2 (virtual base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   (E vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   16 |   struct C0 (virtual base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   20 |   struct C1 (virtual base)
-// CHECK-X64:   20 |     int a
-// CHECK-X64:   24 |   struct C2 (virtual base)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   32 |   struct B1 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=32, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   (E vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |   struct C1 (virtual base)
+// CHECK-X64-NEXT:   20 |     int a
+// CHECK-X64-NEXT:   24 |   struct C2 (virtual base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct F : virtual C0, virtual B0, virtual B1, virtual C1 {
 	int a;
@@ -173,29 +189,29 @@ struct F : virtual C0, virtual B0, virtual B1, virtual C1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   (F vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct C0 (virtual base)
-// CHECK:    8 |     int a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:   24 |   struct B1 (virtual base) (empty)
-// CHECK:   24 |   struct C1 (virtual base)
-// CHECK:   24 |     int a
-// CHECK:      | [sizeof=32, align=8
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   (F vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct C0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   24 |   struct C1 (virtual base)
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:      | [sizeof=32, align=8
+// CHECK-NEXT:      |  nvsize=8, nvalign=8]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   (F vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct C0 (virtual base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   32 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   32 |   struct C1 (virtual base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   (F vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   32 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   32 |   struct C1 (virtual base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct G : virtual C0, virtual B0, virtual B1, D0, virtual C1 {
 	int a;
@@ -204,33 +220,35 @@ struct G : virtual C0, virtual B0, virtual B1, D0, virtual C1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    0 |   struct D0 (primary base)
-// CHECK:    0 |     (D0 vftable pointer)
-// CHECK:    4 |   (G vbtable pointer)
-// CHECK:   20 |   int a
-// CHECK:   32 |   struct C0 (virtual base)
-// CHECK:   32 |     int a
-// CHECK:   40 |   struct B0 (virtual base) (empty)
-// CHECK:   56 |   struct B1 (virtual base) (empty)
-// CHECK:   56 |   struct C1 (virtual base)
-// CHECK:   56 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   struct D0 (primary base)
+// CHECK-NEXT:    0 |     (D0 vftable pointer)
+// CHECK-NEXT:    4 |   (G vbtable pointer)
+// CHECK-NEXT:   20 |   int a
+// CHECK-NEXT:   32 |   struct C0 (virtual base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:   40 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   56 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   56 |   struct C1 (virtual base)
+// CHECK-NEXT:   56 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct G
-// CHECK-X64:    0 |   struct D0 (primary base)
-// CHECK-X64:    0 |     (D0 vftable pointer)
-// CHECK-X64:    8 |   (G vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   32 |   struct C0 (virtual base)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   40 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   56 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   56 |   struct C1 (virtual base)
-// CHECK-X64:   56 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-NEXT:    0 |   struct D0 (primary base)
+// CHECK-X64-NEXT:    0 |     (D0 vftable pointer)
+// CHECK-X64-NEXT:    8 |   (G vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:   40 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   56 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   56 |   struct C1 (virtual base)
+// CHECK-X64-NEXT:   56 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct H : virtual C0, virtual B0, virtual B1, virtual D0, virtual C1 {
 	int a;
@@ -239,35 +257,35 @@ struct H : virtual C0, virtual B0, virtual B1, virtual D0, virtual C1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct H
-// CHECK:    0 |   (H vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct C0 (virtual base)
-// CHECK:    8 |     int a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:   24 |   struct B1 (virtual base) (empty)
-// CHECK:   44 |   (vtordisp for vbase D0)
-// CHECK:   48 |   struct D0 (virtual base)
-// CHECK:   48 |     (D0 vftable pointer)
-// CHECK:   52 |   struct C1 (virtual base)
-// CHECK:   52 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct H
+// CHECK-NEXT:    0 |   (H vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct C0 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   44 |   (vtordisp for vbase D0)
+// CHECK-NEXT:   48 |   struct D0 (virtual base)
+// CHECK-NEXT:   48 |     (D0 vftable pointer)
+// CHECK-NEXT:   52 |   struct C1 (virtual base)
+// CHECK-NEXT:   52 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=8, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct H
-// CHECK-X64:    0 |   (H vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct C0 (virtual base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   40 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   60 |   (vtordisp for vbase D0)
-// CHECK-X64:   64 |   struct D0 (virtual base)
-// CHECK-X64:   64 |     (D0 vftable pointer)
-// CHECK-X64:   72 |   struct C1 (virtual base)
-// CHECK-X64:   72 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-NEXT:    0 |   (H vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   60 |   (vtordisp for vbase D0)
+// CHECK-X64-NEXT:   64 |   struct D0 (virtual base)
+// CHECK-X64-NEXT:   64 |     (D0 vftable pointer)
+// CHECK-X64-NEXT:   72 |   struct C1 (virtual base)
+// CHECK-X64-NEXT:   72 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct I : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -275,27 +293,27 @@ struct I : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct I
-// CHECK:    0 |   (I vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B0 (virtual base) (empty)
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct I
+// CHECK-NEXT:    0 |   (I vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct I
-// CHECK-X64:    0 |   (I vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-NEXT:    0 |   (I vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) J : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
 	int a;
@@ -303,27 +321,27 @@ struct __declspec(align(32)) J : virtual B0, virtual B1, virtual B2, virtual B3,
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct J
-// CHECK:    0 |   (J vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:   40 |   struct B1 (virtual base) (empty)
-// CHECK:   72 |   struct B2 (virtual base) (empty)
-// CHECK:  104 |   struct B3 (virtual base) (empty)
-// CHECK:  136 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=160, align=32
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct J
+// CHECK-NEXT:    0 |   (J vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=160, align=32
+// CHECK-NEXT:      |  nvsize=8, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct J
-// CHECK-X64:    0 |   (J vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   40 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=160, align=32
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct J
+// CHECK-X64-NEXT:    0 |   (J vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=160, align=32
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
 
 struct K : virtual D1, virtual B1, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -331,27 +349,29 @@ struct K : virtual D1, virtual B1, virtual B2, virtual B3, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct K
-// CHECK:    0 |   (K vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct D1 (virtual base) (empty)
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct K
+// CHECK-NEXT:    0 |   (K vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct K
-// CHECK-X64:    0 |   (K vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct D1 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct K
+// CHECK-X64-NEXT:    0 |   (K vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct L : virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -359,27 +379,27 @@ struct L : virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct L
-// CHECK:    0 |   (L vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B1 (virtual base) (empty)
-// CHECK:   68 |   struct D1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct L
+// CHECK-NEXT:    0 |   (L vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   68 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct L
-// CHECK-X64:    0 |   (L vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   68 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-NEXT:    0 |   (L vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   68 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct M : virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -387,27 +407,27 @@ struct M : virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct M
-// CHECK:    0 |   (M vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B1 (virtual base) (empty)
-// CHECK:   72 |   struct B2 (virtual base) (empty)
-// CHECK:  100 |   struct D1 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct M
+// CHECK-NEXT:    0 |   (M vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct M
-// CHECK-X64:    0 |   (M vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  100 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct M
+// CHECK-X64-NEXT:    0 |   (M vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct N : virtual C0, virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -415,31 +435,31 @@ struct N : virtual C0, virtual B1, virtual D1, virtual B2, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct N
-// CHECK:    0 |   (N vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct C0 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:  100 |   struct D1 (virtual base) (empty)
-// CHECK:  136 |   struct B2 (virtual base) (empty)
-// CHECK:  168 |   struct B3 (virtual base) (empty)
-// CHECK:  200 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=224, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct N
+// CHECK-NEXT:    0 |   (N vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  200 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=224, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct N
-// CHECK-X64:    0 |   (N vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct C0 (virtual base)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:  100 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  200 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=224, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct N
+// CHECK-X64-NEXT:    0 |   (N vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  200 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=224, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct O : virtual C0, virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -447,31 +467,31 @@ struct O : virtual C0, virtual B1, virtual B2, virtual D1, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct O
-// CHECK:    0 |   (O vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct C0 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  132 |   struct D1 (virtual base) (empty)
-// CHECK:  168 |   struct B3 (virtual base) (empty)
-// CHECK:  200 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=224, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct O
+// CHECK-NEXT:    0 |   (O vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  132 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  200 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=224, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct O
-// CHECK-X64:    0 |   (O vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct C0 (virtual base)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  132 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  200 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=224, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct O
+// CHECK-X64-NEXT:    0 |   (O vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  132 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  200 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=224, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct P : virtual B1, virtual C0, virtual D1, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -479,31 +499,31 @@ struct P : virtual B1, virtual C0, virtual D1, virtual B2, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct P
-// CHECK:    0 |   (P vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B1 (virtual base) (empty)
-// CHECK:   64 |   struct C0 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:   68 |   struct D1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct P
+// CHECK-NEXT:    0 |   (P vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   68 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct P
-// CHECK-X64:    0 |   (P vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   64 |   struct C0 (virtual base)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:   68 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct P
+// CHECK-X64-NEXT:    0 |   (P vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   68 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct Q : virtual B1, virtual C0, virtual B2, virtual D1, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -511,31 +531,31 @@ struct Q : virtual B1, virtual C0, virtual B2, virtual D1, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct Q
-// CHECK:    0 |   (Q vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B1 (virtual base) (empty)
-// CHECK:   64 |   struct C0 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:   72 |   struct B2 (virtual base) (empty)
-// CHECK:  100 |   struct D1 (virtual base) (empty)
-// CHECK:  136 |   struct B3 (virtual base) (empty)
-// CHECK:  168 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=192, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct Q
+// CHECK-NEXT:    0 |   (Q vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=192, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct Q
-// CHECK-X64:    0 |   (Q vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   64 |   struct C0 (virtual base)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:   72 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  100 |   struct D1 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  168 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=192, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct Q
+// CHECK-X64-NEXT:    0 |   (Q vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=192, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct R : virtual B0, virtual B1, virtual B2, virtual C0, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -543,31 +563,31 @@ struct R : virtual B0, virtual B1, virtual B2, virtual C0, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct R
-// CHECK:    0 |   (R vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B0 (virtual base) (empty)
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:  104 |   struct B2 (virtual base) (empty)
-// CHECK:  104 |   struct C0 (virtual base)
-// CHECK:  104 |     int a
-// CHECK:  112 |   struct B3 (virtual base) (empty)
-// CHECK:  136 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=160, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct R
+// CHECK-NEXT:    0 |   (R vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct C0 (virtual base)
+// CHECK-NEXT:  104 |     int a
+// CHECK-NEXT:  112 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=160, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct R
-// CHECK-X64:    0 |   (R vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  104 |   struct C0 (virtual base)
-// CHECK-X64:  104 |     int a
-// CHECK-X64:  112 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=160, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct R
+// CHECK-X64-NEXT:    0 |   (R vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:  104 |     int a
+// CHECK-X64-NEXT:  112 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=160, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct S : virtual B0, virtual B1, virtual C0, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(32)) int a;
@@ -575,31 +595,31 @@ struct S : virtual B0, virtual B1, virtual C0, virtual B2, virtual B3, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct S
-// CHECK:    0 |   (S vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   64 |   struct B0 (virtual base) (empty)
-// CHECK:   72 |   struct B1 (virtual base) (empty)
-// CHECK:   72 |   struct C0 (virtual base)
-// CHECK:   72 |     int a
-// CHECK:   80 |   struct B2 (virtual base) (empty)
-// CHECK:  104 |   struct B3 (virtual base) (empty)
-// CHECK:  136 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=160, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK-NEXT:    0 | struct S
+// CHECK-NEXT:    0 |   (S vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   72 |   struct C0 (virtual base)
+// CHECK-NEXT:   72 |     int a
+// CHECK-NEXT:   80 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=160, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct S
-// CHECK-X64:    0 |   (S vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   64 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   72 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   72 |   struct C0 (virtual base)
-// CHECK-X64:   72 |     int a
-// CHECK-X64:   80 |   struct B2 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  136 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=160, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct S
+// CHECK-X64-NEXT:    0 |   (S vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   72 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   72 |     int a
+// CHECK-X64-NEXT:   80 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=160, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct T : virtual B0, virtual B1, virtual C0, virtual D2, virtual B2, virtual B3, virtual B4 {
 	__declspec(align(16)) int a;
@@ -607,35 +627,37 @@ struct T : virtual B0, virtual B1, virtual C0, virtual D2, virtual B2, virtual B
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct T
-// CHECK:    0 |   (T vbtable pointer)
-// CHECK:   16 |   int a
-// CHECK:   32 |   struct B0 (virtual base) (empty)
-// CHECK:   40 |   struct B1 (virtual base) (empty)
-// CHECK:   40 |   struct C0 (virtual base)
-// CHECK:   40 |     int a
-// CHECK:   44 |   struct D2 (virtual base)
-// CHECK:   44 |     int [8] a
-// CHECK:   80 |   struct B2 (virtual base) (empty)
-// CHECK:   88 |   struct B3 (virtual base) (empty)
-// CHECK:  104 |   struct B4 (virtual base) (empty)
-// CHECK:      | [sizeof=112, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct T
+// CHECK-NEXT:    0 |   (T vbtable pointer)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   32 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:   40 |   struct C0 (virtual base)
+// CHECK-NEXT:   40 |     int a
+// CHECK-NEXT:   44 |   struct D2 (virtual base)
+// CHECK-NEXT:   44 |     int [8] a
+// CHECK-NEXT:   80 |   struct B2 (virtual base) (empty)
+// CHECK-NEXT:   88 |   struct B3 (virtual base) (empty)
+// CHECK-NEXT:  104 |   struct B4 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=112, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct T
-// CHECK-X64:    0 |   (T vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   32 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   40 |   struct B1 (virtual base) (empty)
-// CHECK-X64:   40 |   struct C0 (virtual base)
-// CHECK-X64:   40 |     int a
-// CHECK-X64:   44 |   struct D2 (virtual base)
-// CHECK-X64:   44 |     int [8] a
-// CHECK-X64:   80 |   struct B2 (virtual base) (empty)
-// CHECK-X64:   88 |   struct B3 (virtual base) (empty)
-// CHECK-X64:  104 |   struct B4 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=112, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct T
+// CHECK-X64-NEXT:    0 |   (T vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   32 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct C0 (virtual base)
+// CHECK-X64-NEXT:   40 |     int a
+// CHECK-X64-NEXT:   44 |   struct D2 (virtual base)
+// CHECK-X64-NEXT:   44 |     int [8] a
+// CHECK-X64-NEXT:   80 |   struct B2 (virtual base) (empty)
+// CHECK-X64-NEXT:   88 |   struct B3 (virtual base) (empty)
+// CHECK-X64-NEXT:  104 |   struct B4 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct __declspec(align(32)) U : virtual B0, virtual B1 {
 	int a;
@@ -643,21 +665,21 @@ struct __declspec(align(32)) U : virtual B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct U
-// CHECK:    0 |   (U vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:   40 |   struct B1 (virtual base) (empty)
-// CHECK:      | [sizeof=64, align=32
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct U
+// CHECK-NEXT:    0 |   (U vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=64, align=32
+// CHECK-NEXT:      |  nvsize=8, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct U
-// CHECK-X64:    0 |   (U vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:   40 |   struct B1 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=64, align=32
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct U
+// CHECK-X64-NEXT:    0 |   (U vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=64, align=32
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
 
 struct __declspec(align(32)) V : virtual D1 {
 	int a;
@@ -665,19 +687,82 @@ struct __declspec(align(32)) V : virtual D1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct V
-// CHECK:    0 |   (V vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct D1 (virtual base) (empty)
-// CHECK:      | [sizeof=32, align=32
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct V
+// CHECK-NEXT:    0 |   (V vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct D1 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=32, align=32
+// CHECK-NEXT:      |  nvsize=8, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct V
+// CHECK-X64-NEXT:    0 |   (V vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct D1 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=32, align=32
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
+
+struct T0 {};
+struct T1 : T0 { char a; };
+struct T3 : virtual T1, virtual T0 { long long a; };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct T3
+// CHECK-NEXT:    0 |   (T3 vbtable pointer)
+// CHECK-NEXT:    8 |   long long a
+// CHECK-NEXT:   16 |   struct T1 (virtual base)
+// CHECK-NEXT:   16 |     struct T0 (base) (empty)
+// CHECK-NEXT:   16 |     char a
+// CHECK-NEXT:   24 |   struct T0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=16, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct T3
+// CHECK-X64-NEXT:    0 |   (T3 vbtable pointer)
+// CHECK-X64-NEXT:    8 |   long long a
+// CHECK-X64-NEXT:   16 |   struct T1 (virtual base)
+// CHECK-X64-NEXT:   16 |     struct T0 (base) (empty)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:   24 |   struct T0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
+
+struct Q0A {};
+struct Q0B { char Q0BField; };
+struct Q0C : virtual Q0A, virtual Q0B { char Q0CField; };
+struct Q0D : Q0C, Q0A {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct Q0D
+// CHECK-NEXT:    0 |   struct Q0C (base)
+// CHECK-NEXT:    0 |     (Q0C vbtable pointer)
+// CHECK-NEXT:    4 |     char Q0CField
+// CHECK-NEXT:    8 |   struct Q0A (base) (empty)
+// CHECK-NEXT:    8 |   struct Q0A (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct Q0B (virtual base)
+// CHECK-NEXT:    8 |     char Q0BField
+// CHECK-NEXT:      | [sizeof=9, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct V
-// CHECK-X64:    0 |   (V vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct D1 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=32, align=32
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct Q0D
+// CHECK-X64-NEXT:    0 |   struct Q0C (base)
+// CHECK-X64-NEXT:    0 |     (Q0C vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char Q0CField
+// CHECK-X64-NEXT:   16 |   struct Q0A (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct Q0A (virtual base) (empty)
+// CHECK-X64-NEXT:   16 |   struct Q0B (virtual base)
+// CHECK-X64-NEXT:   16 |     char Q0BField
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 int a[
 sizeof(A)+
@@ -701,4 +786,6 @@ sizeof(R)+
 sizeof(S)+
 sizeof(T)+
 sizeof(U)+
-sizeof(V)];
\ No newline at end of file
+sizeof(V)+
+sizeof(T3)+
+sizeof(Q0D)];
diff --git a/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp b/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
index 7dd3fad5bf45..34ae0cf9dde8 100644
--- a/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
+++ b/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -24,687 +24,786 @@ struct __declspec(align(2)) B3X { B3X() { printf("B3 = %p\n", this); } };
 struct B4X { B4X() { printf("B4 = %p\n", this); } };
 struct B5X { B5X() { printf("B5 = %p\n", this); } };
 struct B6X { B6X() { printf("B6 = %p\n", this); } };
-struct B8X { short a; B8X() : a(0xf00000B8) { printf("B8 = %p\n", this); } };
+struct B8X { short a; B8X() : a(0x000000B8) { printf("B8 = %p\n", this); } };
 
 struct AA : B8, B1, virtual B0 {
 	int a;
-	AA() : a(0xf00000AA) { printf("AA = %p\n", this); }
+	AA() : a(0x000000AA) { printf("AA = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AA
-// CHECK:    0 |   struct B8 (base)
-// CHECK:    0 |     char [5] c
-// CHECK:   13 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AA vbtable pointer)
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AA
+// CHECK-NEXT:    0 |   struct B8 (base)
+// CHECK-NEXT:    0 |     char [5] c
+// CHECK-NEXT:   13 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AA vbtable pointer)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AA
-// CHECK-X64:    0 |   struct B8 (base)
-// CHECK-X64:    0 |     char [5] c
-// CHECK-X64:   17 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AA vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AA
+// CHECK-X64-NEXT:    0 |   struct B8 (base)
+// CHECK-X64-NEXT:    0 |     char [5] c
+// CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AA vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB : B8, B1, virtual B0 {
 	short a;
-	AB() : a(0xf00000AB) { printf("AB = %p\n", this); }
+	AB() : a(0x000000AB) { printf("AB = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AB
-// CHECK:    0 |   struct B8 (base)
-// CHECK:    0 |     char [5] c
-// CHECK:   13 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AB vbtable pointer)
-// CHECK:   14 |   short a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AB
+// CHECK-NEXT:    0 |   struct B8 (base)
+// CHECK-NEXT:    0 |     char [5] c
+// CHECK-NEXT:   13 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AB vbtable pointer)
+// CHECK-NEXT:   14 |   short a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AB
-// CHECK-X64:    0 |   struct B8 (base)
-// CHECK-X64:    0 |     char [5] c
-// CHECK-X64:   17 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AB vbtable pointer)
-// CHECK-X64:   18 |   short a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AB
+// CHECK-X64-NEXT:    0 |   struct B8 (base)
+// CHECK-X64-NEXT:    0 |     char [5] c
+// CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AB vbtable pointer)
+// CHECK-X64-NEXT:   18 |   short a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC : B8, B1, virtual B0 {
 	char a;
-	AC() : a(0xf00000AC) { printf("AC = %p\n", this); }
+	AC() : a(0x000000AC) { printf("AC = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AC
-// CHECK:    0 |   struct B8 (base)
-// CHECK:    0 |     char [5] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AC vbtable pointer)
-// CHECK:   12 |   char a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AC
+// CHECK-NEXT:    0 |   struct B8 (base)
+// CHECK-NEXT:    0 |     char [5] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AC vbtable pointer)
+// CHECK-NEXT:   12 |   char a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AC
-// CHECK-X64:    0 |   struct B8 (base)
-// CHECK-X64:    0 |     char [5] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AC vbtable pointer)
-// CHECK-X64:   16 |   char a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AC
+// CHECK-X64-NEXT:    0 |   struct B8 (base)
+// CHECK-X64-NEXT:    0 |     char [5] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AC vbtable pointer)
+// CHECK-X64-NEXT:   16 |   char a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD : B8, B1, virtual B0 {
 	AD() { printf("AD = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AD
-// CHECK:    0 |   struct B8 (base)
-// CHECK:    0 |     char [5] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AD vbtable pointer)
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct AD
+// CHECK-NEXT:    0 |   struct B8 (base)
+// CHECK-NEXT:    0 |     char [5] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AD vbtable pointer)
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AD
-// CHECK-X64:    0 |   struct B8 (base)
-// CHECK-X64:    0 |     char [5] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AD vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AD
+// CHECK-X64-NEXT:    0 |   struct B8 (base)
+// CHECK-X64-NEXT:    0 |     char [5] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AD vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA1 : B9, B1, virtual B0 {
 	int a;
-	AA1() : a(0xf0000AA1) { printf("AA1 = %p\n", this); }
+	AA1() : a(0x00000AA1) { printf("AA1 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AA1
-// CHECK:    0 |   struct B9 (base)
-// CHECK:    0 |     char [6] c
-// CHECK:   14 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AA1 vbtable pointer)
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AA1
+// CHECK-NEXT:    0 |   struct B9 (base)
+// CHECK-NEXT:    0 |     char [6] c
+// CHECK-NEXT:   14 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AA1 vbtable pointer)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AA1
-// CHECK-X64:    0 |   struct B9 (base)
-// CHECK-X64:    0 |     char [6] c
-// CHECK-X64:   18 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AA1 vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AA1
+// CHECK-X64-NEXT:    0 |   struct B9 (base)
+// CHECK-X64-NEXT:    0 |     char [6] c
+// CHECK-X64-NEXT:   18 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AA1 vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB1 : B9, B1, virtual B0 {
 	short a;
-	AB1() : a(0xf0000AB1) { printf("AB1 = %p\n", this); }
+	AB1() : a(0x00000AB1) { printf("AB1 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AB1
-// CHECK:    0 |   struct B9 (base)
-// CHECK:    0 |     char [6] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AB1 vbtable pointer)
-// CHECK:   12 |   short a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AB1
+// CHECK-NEXT:    0 |   struct B9 (base)
+// CHECK-NEXT:    0 |     char [6] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AB1 vbtable pointer)
+// CHECK-NEXT:   12 |   short a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AB1
-// CHECK-X64:    0 |   struct B9 (base)
-// CHECK-X64:    0 |     char [6] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AB1 vbtable pointer)
-// CHECK-X64:   16 |   short a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AB1
+// CHECK-X64-NEXT:    0 |   struct B9 (base)
+// CHECK-X64-NEXT:    0 |     char [6] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AB1 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   short a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC1 : B9, B1, virtual B0 {
 	char a;
-	AC1() : a(0xf0000AC1) { printf("AC1 = %p\n", this); }
+	AC1() : a(0x000000C1) { printf("AC1 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AC1
-// CHECK:    0 |   struct B9 (base)
-// CHECK:    0 |     char [6] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AC1 vbtable pointer)
-// CHECK:   12 |   char a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AC1
+// CHECK-NEXT:    0 |   struct B9 (base)
+// CHECK-NEXT:    0 |     char [6] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AC1 vbtable pointer)
+// CHECK-NEXT:   12 |   char a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AC1
-// CHECK-X64:    0 |   struct B9 (base)
-// CHECK-X64:    0 |     char [6] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AC1 vbtable pointer)
-// CHECK-X64:   16 |   char a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AC1
+// CHECK-X64-NEXT:    0 |   struct B9 (base)
+// CHECK-X64-NEXT:    0 |     char [6] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AC1 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   char a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD1 : B9, B1, virtual B0 {
 	AD1() { printf("AD1 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AD1
-// CHECK:    0 |   struct B9 (base)
-// CHECK:    0 |     char [6] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AD1 vbtable pointer)
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct AD1
+// CHECK-NEXT:    0 |   struct B9 (base)
+// CHECK-NEXT:    0 |     char [6] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AD1 vbtable pointer)
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AD1
-// CHECK-X64:    0 |   struct B9 (base)
-// CHECK-X64:    0 |     char [6] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AD1 vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AD1
+// CHECK-X64-NEXT:    0 |   struct B9 (base)
+// CHECK-X64-NEXT:    0 |     char [6] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AD1 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA2 : B10, B1, virtual B0 {
 	int a;
-	AA2() : a(0xf0000AA2) { printf("AA2 = %p\n", this); }
+	AA2() : a(0x00000AA2) { printf("AA2 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AA2
-// CHECK:    0 |   struct B10 (base)
-// CHECK:    0 |     char [7] c
-// CHECK:   15 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AA2 vbtable pointer)
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AA2
+// CHECK-NEXT:    0 |   struct B10 (base)
+// CHECK-NEXT:    0 |     char [7] c
+// CHECK-NEXT:   15 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AA2 vbtable pointer)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AA2
-// CHECK-X64:    0 |   struct B10 (base)
-// CHECK-X64:    0 |     char [7] c
-// CHECK-X64:   19 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AA2 vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AA2
+// CHECK-X64-NEXT:    0 |   struct B10 (base)
+// CHECK-X64-NEXT:    0 |     char [7] c
+// CHECK-X64-NEXT:   19 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AA2 vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB2 : B10, B1, virtual B0 {
 	short a;
-	AB2() : a(0xf0000AB2) { printf("AB2 = %p\n", this); }
+	AB2() : a(0x00000AB2) { printf("AB2 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AB2
-// CHECK:    0 |   struct B10 (base)
-// CHECK:    0 |     char [7] c
-// CHECK:   13 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AB2 vbtable pointer)
-// CHECK:   14 |   short a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AB2
+// CHECK-NEXT:    0 |   struct B10 (base)
+// CHECK-NEXT:    0 |     char [7] c
+// CHECK-NEXT:   13 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AB2 vbtable pointer)
+// CHECK-NEXT:   14 |   short a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AB2
-// CHECK-X64:    0 |   struct B10 (base)
-// CHECK-X64:    0 |     char [7] c
-// CHECK-X64:   17 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AB2 vbtable pointer)
-// CHECK-X64:   18 |   short a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AB2
+// CHECK-X64-NEXT:    0 |   struct B10 (base)
+// CHECK-X64-NEXT:    0 |     char [7] c
+// CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AB2 vbtable pointer)
+// CHECK-X64-NEXT:   18 |   short a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC2 : B10, B1, virtual B0 {
 	char a;
-	AC2() : a(0xf0000AC2) { printf("AC2 = %p\n", this); }
+	AC2() : a(0x000000C2) { printf("AC2 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AC2
-// CHECK:    0 |   struct B10 (base)
-// CHECK:    0 |     char [7] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AC2 vbtable pointer)
-// CHECK:   12 |   char a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AC2
+// CHECK-NEXT:    0 |   struct B10 (base)
+// CHECK-NEXT:    0 |     char [7] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AC2 vbtable pointer)
+// CHECK-NEXT:   12 |   char a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AC2
-// CHECK-X64:    0 |   struct B10 (base)
-// CHECK-X64:    0 |     char [7] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AC2 vbtable pointer)
-// CHECK-X64:   16 |   char a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AC2
+// CHECK-X64-NEXT:    0 |   struct B10 (base)
+// CHECK-X64-NEXT:    0 |     char [7] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AC2 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   char a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD2 : B10, B1, virtual B0 {
 	AD2() { printf("AD2 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AD2
-// CHECK:    0 |   struct B10 (base)
-// CHECK:    0 |     char [7] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AD2 vbtable pointer)
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct AD2
+// CHECK-NEXT:    0 |   struct B10 (base)
+// CHECK-NEXT:    0 |     char [7] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AD2 vbtable pointer)
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AD2
-// CHECK-X64:    0 |   struct B10 (base)
-// CHECK-X64:    0 |     char [7] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AD2 vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AD2
+// CHECK-X64-NEXT:    0 |   struct B10 (base)
+// CHECK-X64-NEXT:    0 |     char [7] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AD2 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA3 : B11, B1, virtual B0 {
 	int a;
-	AA3() : a(0xf0000AA3) { printf("AA3 = %p\n", this); }
+	AA3() : a(0x00000AA3) { printf("AA3 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AA3
-// CHECK:    0 |   struct B11 (base)
-// CHECK:    0 |     char [8] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AA3 vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AA3
+// CHECK-NEXT:    0 |   struct B11 (base)
+// CHECK-NEXT:    0 |     char [8] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AA3 vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AA3
-// CHECK-X64:    0 |   struct B11 (base)
-// CHECK-X64:    0 |     char [8] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AA3 vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AA3
+// CHECK-X64-NEXT:    0 |   struct B11 (base)
+// CHECK-X64-NEXT:    0 |     char [8] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AA3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB3 : B11, B1, virtual B0 {
 	short a;
-	AB3() : a(0xf0000AB3) { printf("AB3 = %p\n", this); }
+	AB3() : a(0x00000AB3) { printf("AB3 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AB3
-// CHECK:    0 |   struct B11 (base)
-// CHECK:    0 |     char [8] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AB3 vbtable pointer)
-// CHECK:   12 |   short a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AB3
+// CHECK-NEXT:    0 |   struct B11 (base)
+// CHECK-NEXT:    0 |     char [8] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AB3 vbtable pointer)
+// CHECK-NEXT:   12 |   short a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AB3
-// CHECK-X64:    0 |   struct B11 (base)
-// CHECK-X64:    0 |     char [8] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AB3 vbtable pointer)
-// CHECK-X64:   16 |   short a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AB3
+// CHECK-X64-NEXT:    0 |   struct B11 (base)
+// CHECK-X64-NEXT:    0 |     char [8] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AB3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   short a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC3 : B11, B1, virtual B0 {
 	char a;
-	AC3() : a(0xf0000AC3) { printf("AC3 = %p\n", this); }
+	AC3() : a(0x000000C3) { printf("AC3 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AC3
-// CHECK:    0 |   struct B11 (base)
-// CHECK:    0 |     char [8] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AC3 vbtable pointer)
-// CHECK:   12 |   char a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct AC3
+// CHECK-NEXT:    0 |   struct B11 (base)
+// CHECK-NEXT:    0 |     char [8] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AC3 vbtable pointer)
+// CHECK-NEXT:   12 |   char a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AC3
-// CHECK-X64:    0 |   struct B11 (base)
-// CHECK-X64:    0 |     char [8] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AC3 vbtable pointer)
-// CHECK-X64:   16 |   char a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AC3
+// CHECK-X64-NEXT:    0 |   struct B11 (base)
+// CHECK-X64-NEXT:    0 |     char [8] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AC3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   char a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD3 : B11, B1, virtual B0 {
 	AD3() { printf("AD3 = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AD3
-// CHECK:    0 |   struct B11 (base)
-// CHECK:    0 |     char [8] c
-// CHECK:   12 |   struct B1 (base) (empty)
-// CHECK:    8 |   (AD3 vbtable pointer)
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct AD3
+// CHECK-NEXT:    0 |   struct B11 (base)
+// CHECK-NEXT:    0 |     char [8] c
+// CHECK-NEXT:   12 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (AD3 vbtable pointer)
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AD3
-// CHECK-X64:    0 |   struct B11 (base)
-// CHECK-X64:    0 |     char [8] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (AD3 vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AD3
+// CHECK-X64-NEXT:    0 |   struct B11 (base)
+// CHECK-X64-NEXT:    0 |     char [8] c
+// CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (AD3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct B : B1, B2, virtual B0 {
 	B() { printf("B = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct B1 (base) (empty)
-// CHECK:    8 |   struct B2 (base) (empty)
-// CHECK:    4 |   (B vbtable pointer)
-// CHECK:    8 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   struct B2 (base) (empty)
+// CHECK-NEXT:    4 |   (B vbtable pointer)
+// CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   struct B1 (base) (empty)
-// CHECK-X64:   16 |   struct B2 (base) (empty)
-// CHECK-X64:    8 |   (B vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct B2 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (B vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct C : B1, B2, B3, virtual B0 {
 	char a;
-	C() : a(0xf000000C) { printf("C = %p\n", this); }
+	C() : a(0x0000000C) { printf("C = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   struct B1 (base) (empty)
-// CHECK:    1 |   struct B2 (base) (empty)
-// CHECK:    8 |   struct B3 (base) (empty)
-// CHECK:    4 |   (C vbtable pointer)
-// CHECK:    8 |   char a
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-NEXT:    1 |   struct B2 (base) (empty)
+// CHECK-NEXT:    8 |   struct B3 (base) (empty)
+// CHECK-NEXT:    4 |   (C vbtable pointer)
+// CHECK-NEXT:    8 |   char a
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   struct B1 (base) (empty)
-// CHECK-X64:    1 |   struct B2 (base) (empty)
-// CHECK-X64:   16 |   struct B3 (base) (empty)
-// CHECK-X64:    8 |   (C vbtable pointer)
-// CHECK-X64:   16 |   char a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    1 |   struct B2 (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct B3 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (C vbtable pointer)
+// CHECK-X64-NEXT:   16 |   char a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct D : B1, B2, B3, B4, B5, virtual B0 {
 	int a;
-	D() : a(0xf000000D) { printf("D = %p\n", this); }
+	D() : a(0x0000000D) { printf("D = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct B1 (base) (empty)
-// CHECK:    1 |   struct B2 (base) (empty)
-// CHECK:    2 |   struct B3 (base) (empty)
-// CHECK:    3 |   struct B4 (base) (empty)
-// CHECK:    8 |   struct B5 (base) (empty)
-// CHECK:    4 |   (D vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   12 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-NEXT:    1 |   struct B2 (base) (empty)
+// CHECK-NEXT:    2 |   struct B3 (base) (empty)
+// CHECK-NEXT:    3 |   struct B4 (base) (empty)
+// CHECK-NEXT:    8 |   struct B5 (base) (empty)
+// CHECK-NEXT:    4 |   (D vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   struct B1 (base) (empty)
-// CHECK-X64:    1 |   struct B2 (base) (empty)
-// CHECK-X64:    2 |   struct B3 (base) (empty)
-// CHECK-X64:    3 |   struct B4 (base) (empty)
-// CHECK-X64:   16 |   struct B5 (base) (empty)
-// CHECK-X64:    8 |   (D vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    1 |   struct B2 (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct B3 (base) (empty)
+// CHECK-X64-NEXT:    3 |   struct B4 (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct B5 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (D vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct E : B1, B6, B3, B4, B5, virtual B0 {
 	int a;
-	E() : a(0xf000000E) { printf("E = %p\n", this); }
+	E() : a(0x0000000E) { printf("E = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   struct B1 (base) (empty)
-// CHECK:    2 |   struct B6 (base) (empty)
-// CHECK:    3 |   struct B3 (base) (empty)
-// CHECK:    4 |   struct B4 (base) (empty)
-// CHECK:   13 |   struct B5 (base) (empty)
-// CHECK:    8 |   (E vbtable pointer)
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-NEXT:    2 |   struct B6 (base) (empty)
+// CHECK-NEXT:    3 |   struct B3 (base) (empty)
+// CHECK-NEXT:    4 |   struct B4 (base) (empty)
+// CHECK-NEXT:   13 |   struct B5 (base) (empty)
+// CHECK-NEXT:    8 |   (E vbtable pointer)
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   struct B1 (base) (empty)
-// CHECK-X64:    2 |   struct B6 (base) (empty)
-// CHECK-X64:    3 |   struct B3 (base) (empty)
-// CHECK-X64:    4 |   struct B4 (base) (empty)
-// CHECK-X64:   17 |   struct B5 (base) (empty)
-// CHECK-X64:    8 |   (E vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct B6 (base) (empty)
+// CHECK-X64-NEXT:    3 |   struct B3 (base) (empty)
+// CHECK-X64-NEXT:    4 |   struct B4 (base) (empty)
+// CHECK-X64-NEXT:   17 |   struct B5 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (E vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : B1, B6, B4, B8, B5, virtual B0 {
 	int a;
-	F() : a(0xf000000F) { printf("&a = %p\n", &a); printf("F = %p\n", this); }
+	F() : a(0x0000000F) { printf("&a = %p\n", &a); printf("F = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   struct B1 (base) (empty)
-// CHECK:    2 |   struct B6 (base) (empty)
-// CHECK:    3 |   struct B4 (base) (empty)
-// CHECK:    3 |   struct B8 (base)
-// CHECK:    3 |     char [5] c
-// CHECK:   12 |   struct B5 (base) (empty)
-// CHECK:    8 |   (F vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-NEXT:    2 |   struct B6 (base) (empty)
+// CHECK-NEXT:    3 |   struct B4 (base) (empty)
+// CHECK-NEXT:    3 |   struct B8 (base)
+// CHECK-NEXT:    3 |     char [5] c
+// CHECK-NEXT:   12 |   struct B5 (base) (empty)
+// CHECK-NEXT:    8 |   (F vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   struct B1 (base) (empty)
-// CHECK-X64:    2 |   struct B6 (base) (empty)
-// CHECK-X64:    3 |   struct B4 (base) (empty)
-// CHECK-X64:    3 |   struct B8 (base)
-// CHECK-X64:    3 |     char [5] c
-// CHECK-X64:   16 |   struct B5 (base) (empty)
-// CHECK-X64:    8 |   (F vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct B6 (base) (empty)
+// CHECK-X64-NEXT:    3 |   struct B4 (base) (empty)
+// CHECK-X64-NEXT:    3 |   struct B8 (base)
+// CHECK-X64-NEXT:    3 |     char [5] c
+// CHECK-X64-NEXT:   16 |   struct B5 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (F vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct G : B8, B1, virtual B0 {
 	int a;
 	__declspec(align(16)) int a1;
-	G() : a(0xf0000010), a1(0xf0000010) { printf("G = %p\n", this); }
+	G() : a(0x00000010), a1(0xf0000010) { printf("G = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    0 |   struct B8 (base)
-// CHECK:    0 |     char [5] c
-// CHECK:   21 |   struct B1 (base) (empty)
-// CHECK:    8 |   (G vbtable pointer)
-// CHECK:   24 |   int a
-// CHECK:   32 |   int a1
-// CHECK:   48 |   struct B0 (virtual base) (empty)
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   struct B8 (base)
+// CHECK-NEXT:    0 |     char [5] c
+// CHECK-NEXT:   21 |   struct B1 (base) (empty)
+// CHECK-NEXT:    8 |   (G vbtable pointer)
+// CHECK-NEXT:   24 |   int a
+// CHECK-NEXT:   32 |   int a1
+// CHECK-NEXT:   48 |   struct B0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct G
-// CHECK-X64:    0 |   struct B8 (base)
-// CHECK-X64:    0 |     char [5] c
-// CHECK-X64:   16 |   struct B1 (base) (empty)
-// CHECK-X64:    8 |   (G vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   32 |   int a1
-// CHECK-X64:   48 |   struct B0 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-NEXT:    0 |   struct B8 (base)
+// CHECK-X64-NEXT:    0 |     char [5] c
+// CHECK-X64-NEXT:   21 |   struct B1 (base) (empty)
+// CHECK-X64-NEXT:    8 |   (G vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   int a1
+// CHECK-X64-NEXT:   48 |   struct B0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct AX : B1X, B2X, B3X, B4X, virtual B0X {
 	int a;
-	AX() : a(0xf000000A) { printf(" A = %p\n", this); }
+	AX() : a(0x0000000A) { printf(" A = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AX
-// CHECK:    0 |   struct B1X (base) (empty)
-// CHECK:   16 |   struct B2X (base) (empty)
-// CHECK:   18 |   struct B3X (base) (empty)
-// CHECK:   35 |   struct B4X (base) (empty)
-// CHECK:   20 |   (AX vbtable pointer)
-// CHECK:   36 |   int a
-// CHECK:   48 |   struct B0X (virtual base) (empty)
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AX
+// CHECK-NEXT:    0 |   struct B1X (base) (empty)
+// CHECK-NEXT:   16 |   struct B2X (base) (empty)
+// CHECK-NEXT:   18 |   struct B3X (base) (empty)
+// CHECK-NEXT:   35 |   struct B4X (base) (empty)
+// CHECK-NEXT:   20 |   (AX vbtable pointer)
+// CHECK-NEXT:   36 |   int a
+// CHECK-NEXT:   48 |   struct B0X (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AX
-// CHECK-X64:    0 |   struct B1X (base) (empty)
-// CHECK-X64:   16 |   struct B2X (base) (empty)
-// CHECK-X64:   18 |   struct B3X (base) (empty)
-// CHECK-X64:   33 |   struct B4X (base) (empty)
-// CHECK-X64:   24 |   (AX vbtable pointer)
-// CHECK-X64:   36 |   int a
-// CHECK-X64:   48 |   struct B0X (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-NEXT:    0 |   struct B1X (base) (empty)
+// CHECK-X64-NEXT:   16 |   struct B2X (base) (empty)
+// CHECK-X64-NEXT:   18 |   struct B3X (base) (empty)
+// CHECK-X64-NEXT:   35 |   struct B4X (base) (empty)
+// CHECK-X64-NEXT:   24 |   (AX vbtable pointer)
+// CHECK-X64-NEXT:   36 |   int a
+// CHECK-X64-NEXT:   48 |   struct B0X (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct BX : B2X, B1X, B3X, B4X, virtual B0X {
 	int a;
-	BX() : a(0xf000000B) { printf(" B = %p\n", this); }
+	BX() : a(0x0000000B) { printf(" B = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct BX
-// CHECK:    0 |   struct B2X (base) (empty)
-// CHECK:    1 |   struct B1X (base) (empty)
-// CHECK:    2 |   struct B3X (base) (empty)
-// CHECK:   19 |   struct B4X (base) (empty)
-// CHECK:    4 |   (BX vbtable pointer)
-// CHECK:   20 |   int a
-// CHECK:   32 |   struct B0X (virtual base) (empty)
-// CHECK:      | [sizeof=32, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK-NEXT:    0 | struct BX
+// CHECK-NEXT:    0 |   struct B2X (base) (empty)
+// CHECK-NEXT:    1 |   struct B1X (base) (empty)
+// CHECK-NEXT:    2 |   struct B3X (base) (empty)
+// CHECK-NEXT:   19 |   struct B4X (base) (empty)
+// CHECK-NEXT:    4 |   (BX vbtable pointer)
+// CHECK-NEXT:   20 |   int a
+// CHECK-NEXT:   32 |   struct B0X (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=32, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct BX
-// CHECK-X64:    0 |   struct B2X (base) (empty)
-// CHECK-X64:    1 |   struct B1X (base) (empty)
-// CHECK-X64:    2 |   struct B3X (base) (empty)
-// CHECK-X64:   17 |   struct B4X (base) (empty)
-// CHECK-X64:    8 |   (BX vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   32 |   struct B0X (virtual base) (empty)
-// CHECK-X64:      | [sizeof=32, align=16
-// CHECK-X64:      |  nvsize=32, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-NEXT:    0 |   struct B2X (base) (empty)
+// CHECK-X64-NEXT:    1 |   struct B1X (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct B3X (base) (empty)
+// CHECK-X64-NEXT:   19 |   struct B4X (base) (empty)
+// CHECK-X64-NEXT:    8 |   (BX vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   32 |   struct B0X (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=32, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct CX : B1X, B3X, B2X, virtual B0X {
 	int a;
-	CX() : a(0xf000000C) { printf(" C = %p\n", this); }
+	CX() : a(0x0000000C) { printf(" C = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct CX
-// CHECK:    0 |   struct B1X (base) (empty)
-// CHECK:    2 |   struct B3X (base) (empty)
-// CHECK:   32 |   struct B2X (base) (empty)
-// CHECK:    4 |   (CX vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   48 |   struct B0X (virtual base) (empty)
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct CX
+// CHECK-NEXT:    0 |   struct B1X (base) (empty)
+// CHECK-NEXT:    2 |   struct B3X (base) (empty)
+// CHECK-NEXT:   32 |   struct B2X (base) (empty)
+// CHECK-NEXT:   16 |   (CX vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   48 |   struct B0X (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct CX
-// CHECK-X64:    0 |   struct B1X (base) (empty)
-// CHECK-X64:    2 |   struct B3X (base) (empty)
-// CHECK-X64:   32 |   struct B2X (base) (empty)
-// CHECK-X64:    8 |   (CX vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B0X (virtual base) (empty)
-// CHECK-X64:      | [sizeof=48, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-NEXT:    0 |   struct B1X (base) (empty)
+// CHECK-X64-NEXT:    2 |   struct B3X (base) (empty)
+// CHECK-X64-NEXT:   32 |   struct B2X (base) (empty)
+// CHECK-X64-NEXT:   16 |   (CX vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B0X (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=48, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct DX : B8X, B1X, virtual B0X {
 	int a;
-	DX() : a(0xf000000D) { printf(" D = %p\n", this); }
+	DX() : a(0x0000000D) { printf(" D = %p\n", this); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct DX
-// CHECK:    0 |   struct B8X (base)
-// CHECK:    0 |     short a
-// CHECK:   10 |   struct B1X (base) (empty)
-// CHECK:    4 |   (DX vbtable pointer)
-// CHECK:   12 |   int a
-// CHECK:   16 |   struct B0X (virtual base) (empty)
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct DX
+// CHECK-NEXT:    0 |   struct B8X (base)
+// CHECK-NEXT:    0 |     short a
+// CHECK-NEXT:   10 |   struct B1X (base) (empty)
+// CHECK-NEXT:    4 |   (DX vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct B0X (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-NEXT:    0 |   struct B8X (base)
+// CHECK-X64-NEXT:    0 |     short a
+// CHECK-X64-NEXT:   18 |   struct B1X (base) (empty)
+// CHECK-X64-NEXT:    8 |   (DX vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   struct B0X (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
+
+
+struct C0 {};
+struct C1 : public C0 { int C1F0; };
+struct C2 : public C1, public C0 {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C2
+// CHECK-NEXT:    0 |   struct C1 (base)
+// CHECK-NEXT:    0 |     struct C0 (base) (empty)
+// CHECK-NEXT:    0 |     int C1F0
+// CHECK-NEXT:    5 |   struct C0 (base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct C2
+// CHECK-X64-NEXT:    0 |   struct C1 (base)
+// CHECK-X64-NEXT:    0 |     struct C0 (base) (empty)
+// CHECK-X64-NEXT:    0 |     int C1F0
+// CHECK-X64-NEXT:    5 |   struct C0 (base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=8, align=4
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
+
+struct JA { char a; };
+struct JB {
+  char a;
+  virtual void f() {}
+};
+struct JC { char a; };
+struct JD : JA, JB, virtual JC {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct JD
+// CHECK-NEXT:    0 |   struct JB (primary base)
+// CHECK-NEXT:    0 |     (JB vftable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:   12 |   struct JA (base)
+// CHECK-NEXT:   12 |     char a
+// CHECK-NEXT:    8 |   (JD vbtable pointer)
+// CHECK-NEXT:   16 |   struct JC (virtual base)
+// CHECK-NEXT:   16 |     char a
+// CHECK-NEXT:      | [sizeof=17, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct DX
-// CHECK-X64:    0 |   struct B8X (base)
-// CHECK-X64:    0 |     short a
-// CHECK-X64:   18 |   struct B1X (base) (empty)
-// CHECK-X64:    8 |   (DX vbtable pointer)
-// CHECK-X64:   20 |   int a
-// CHECK-X64:   24 |   struct B0X (virtual base) (empty)
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct JD
+// CHECK-X64-NEXT:    0 |   struct JB (primary base)
+// CHECK-X64-NEXT:    0 |     (JB vftable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   24 |   struct JA (base)
+// CHECK-X64-NEXT:   24 |     char a
+// CHECK-X64-NEXT:   16 |   (JD vbtable pointer)
+// CHECK-X64-NEXT:   32 |   struct JC (virtual base)
+// CHECK-X64-NEXT:   32 |     char a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=8]
 
 int a[
 sizeof(AA)+
@@ -732,4 +831,7 @@ sizeof(G)+
 sizeof(AX)+
 sizeof(BX)+
 sizeof(CX)+
-sizeof(DX)];
+sizeof(DX)+
+sizeof(C2)+
+sizeof(JD)+
+0];
diff --git a/test/Layout/ms-x86-member-pointers.cpp b/test/Layout/ms-x86-member-pointers.cpp
new file mode 100644
index 000000000000..89dd211a3515
--- /dev/null
+++ b/test/Layout/ms-x86-member-pointers.cpp
@@ -0,0 +1,80 @@
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fms-extensions -fsyntax-only %s 2>&1 | FileCheck %s
+
+struct __single_inheritance S;
+struct __multiple_inheritance M;
+struct __virtual_inheritance V;
+struct U;
+
+struct SD { char a; int S::*mp; };
+struct MD { char a; int M::*mp; };
+struct VD { char a; int V::*mp; };
+struct UD { char a; int U::*mp; };
+struct SF { char a; int (S::*mp)(); };
+struct MF { char a; int (M::*mp)(); };
+struct VF { char a; int (V::*mp)(); };
+struct UF { char a; int (U::*mp)(); };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct SD
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    4 |   int struct S::* mp
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct MD
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    4 |   int struct M::* mp
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct VD
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    8 |   int struct V::* mp
+// CHECK-NEXT:      | [sizeof=16, align=8
+// CHECK-NEXT:      |  nvsize=16, nvalign=8]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct UD
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    8 |   int struct U::* mp
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct SF
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    4 |   int (struct S::*)(void) __attribute__((thiscall)) mp
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct MF
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    8 |   int (struct M::*)(void) __attribute__((thiscall)) mp
+// CHECK-NEXT:      | [sizeof=16, align=8
+// CHECK-NEXT:      |  nvsize=16, nvalign=8]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct VF
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    8 |   int (struct V::*)(void) __attribute__((thiscall)) mp
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct UF
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    8 |   int (struct U::*)(void) __attribute__((thiscall)) mp
+// CHECK-NEXT:      | [sizeof=24, align=8
+// CHECK-NEXT:      |  nvsize=24, nvalign=8]
+
+char a[sizeof(SD) +
+       sizeof(MD) +
+       sizeof(VD) +
+       sizeof(UD) +
+       sizeof(SF) +
+       sizeof(MF) +
+       sizeof(VF) +
+       sizeof(UF)];
diff --git a/test/Layout/ms-x86-misalignedarray.cpp b/test/Layout/ms-x86-misalignedarray.cpp
index f6887daf15b6..de5bcc7c35c2 100644
--- a/test/Layout/ms-x86-misalignedarray.cpp
+++ b/test/Layout/ms-x86-misalignedarray.cpp
@@ -1,23 +1,27 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
-struct T0 { char c; };

-struct T2 : virtual T0 { };

-struct T3 { T2 a[1]; char c; };

+struct T0 { char c; };
+struct T2 : virtual T0 { };
+struct T3 { T2 a[1]; char c; };
 
-// CHECK: *** Dumping AST Record Layout

-// CHECK:    0 | struct T3

-// CHECK:    0 |   struct T2 [1] a

-// CHECK:    5 |   char c

-// CHECK:      | [sizeof=8, align=4

-// CHECK:      |  nvsize=8, nvalign=4]

-// CHECK-X64: *** Dumping AST Record Layout

-// CHECK-X64:    0 | struct T3

-// CHECK-X64:    0 |   struct T2 [1] a

-// CHECK-X64:   16 |   char c

-// CHECK-X64:      | [sizeof=24, align=8

-// CHECK-X64:      |  nvsize=24, nvalign=8]

+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct T3
+// CHECK-NEXT:    0 |   struct T2 [1] a
+// CHECK-NEXT:    5 |   char c
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct T3
+// CHECK-X64-NEXT:    0 |   struct T2 [1] a
+// CHECK-X64-NEXT:   16 |   char c
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 int a[sizeof(T3)];
diff --git a/test/Layout/ms-x86-pack-and-align.cpp b/test/Layout/ms-x86-pack-and-align.cpp
new file mode 100644
index 000000000000..5e1aae1ca757
--- /dev/null
+++ b/test/Layout/ms-x86-pack-and-align.cpp
@@ -0,0 +1,683 @@
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
+// RUN:            | FileCheck %s
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
+// RUN:            | FileCheck %s -check-prefix CHECK-X64
+
+extern "C" int printf(const char *fmt, ...);
+char buffer[419430400];
+
+struct A {
+	char a;
+	A() {
+		printf("A   = %d\n", (int)((char*)this - buffer));
+		printf("A.a = %d\n", (int)((char*)&a - buffer));
+	}
+};
+
+struct B {
+	__declspec(align(4)) long long a;
+	B() {
+		printf("B   = %d\n", (int)((char*)this - buffer));
+		printf("B.a = %d\n", (int)((char*)&a - buffer));
+	}
+};
+
+#pragma pack(push, 2)
+struct X {
+	B a;
+	char b;
+	int c;
+	X() {
+		printf("X   = %d\n", (int)((char*)this - buffer));
+		printf("X.a = %d\n", (int)((char*)&a - buffer));
+		printf("X.b = %d\n", (int)((char*)&b - buffer));
+		printf("X.c = %d\n", (int)((char*)&c - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct X
+// CHECK-NEXT:    0 |   struct B a
+// CHECK-NEXT:    0 |     long long a
+// CHECK-NEXT:      |   [sizeof=8, align=8
+// CHECK-NEXT:      |    nvsize=8, nvalign=8]
+// CHECK-NEXT:    8 |   char b
+// CHECK-NEXT:   10 |   int c
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=14, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct X
+// CHECK-X64-NEXT:    0 |   struct B a
+// CHECK-X64-NEXT:    0 |     long long a
+// CHECK-X64-NEXT:      |   [sizeof=8, align=8
+// CHECK-X64-NEXT:      |    nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    8 |   char b
+// CHECK-X64-NEXT:   10 |   int c
+// CHECK-X64-NEXT:      | [sizeof=16, align=4
+// CHECK-X64-NEXT:      |  nvsize=14, nvalign=4]
+
+struct Y : A, B {
+	char a;
+	int b;
+	Y() {
+		printf("Y   = %d\n", (int)((char*)this - buffer));
+		printf("Y.a = %d\n", (int)((char*)&a - buffer));
+		printf("Y.b = %d\n", (int)((char*)&b - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct Y
+// CHECK-NEXT:    0 |   struct A (base)
+// CHECK-NEXT:    0 |     char a
+// CHECK-NEXT:    4 |   struct B (base)
+// CHECK-NEXT:    4 |     long long a
+// CHECK-NEXT:   12 |   char a
+// CHECK-NEXT:   14 |   int b
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=18, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct Y
+// CHECK-X64-NEXT:    0 |   struct A (base)
+// CHECK-X64-NEXT:    0 |     char a
+// CHECK-X64-NEXT:    4 |   struct B (base)
+// CHECK-X64-NEXT:    4 |     long long a
+// CHECK-X64-NEXT:   12 |   char a
+// CHECK-X64-NEXT:   14 |   int b
+// CHECK-X64-NEXT:      | [sizeof=20, align=4
+// CHECK-X64-NEXT:      |  nvsize=18, nvalign=4]
+
+struct Z : virtual B {
+	char a;
+	int b;
+	Z() {
+		printf("Z   = %d\n", (int)((char*)this - buffer));
+		printf("Z.a = %d\n", (int)((char*)&a - buffer));
+		printf("Z.b = %d\n", (int)((char*)&b - buffer));
+	}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct Z
+// CHECK-NEXT:    0 |   (Z vbtable pointer)
+// CHECK-NEXT:    4 |   char a
+// CHECK-NEXT:    6 |   int b
+// CHECK-NEXT:   12 |   struct B (virtual base)
+// CHECK-NEXT:   12 |     long long a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=10, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct Z
+// CHECK-X64-NEXT:    0 |   (Z vbtable pointer)
+// CHECK-X64-NEXT:    8 |   char a
+// CHECK-X64-NEXT:   10 |   int b
+// CHECK-X64-NEXT:   16 |   struct B (virtual base)
+// CHECK-X64-NEXT:   16 |     long long a
+// CHECK-X64-NEXT:      | [sizeof=24, align=4
+// CHECK-X64-NEXT:      |  nvsize=14, nvalign=4]
+
+#pragma pack(pop)
+
+struct A1 { long long a; };
+#pragma pack(push, 1)
+struct B1 : virtual A1 { char a; };
+#pragma pack(pop)
+struct C1 : B1 {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C1
+// CHECK-NEXT:    0 |   struct B1 (base)
+// CHECK-NEXT:    0 |     (B1 vbtable pointer)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    8 |   struct A1 (virtual base)
+// CHECK-NEXT:    8 |     long long a
+// CHECK-NEXT:      | [sizeof=16, align=8
+// CHECK-NEXT:      |  nvsize=5, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct C1
+// CHECK-X64-NEXT:    0 |   struct B1 (base)
+// CHECK-X64-NEXT:    0 |     (B1 vbtable pointer)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:   16 |   struct A1 (virtual base)
+// CHECK-X64-NEXT:   16 |     long long a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=9, nvalign=8]
+
+struct CA0 {
+	CA0() {}
+};
+struct CA1 : virtual CA0 {
+	CA1() {}
+};
+#pragma pack(push, 1)
+struct CA2 : public CA1, public CA0 {
+	virtual void CA2Method() {}
+	CA2() {}
+};
+#pragma pack(pop)
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct CA2
+// CHECK-NEXT:    0 |   (CA2 vftable pointer)
+// CHECK-NEXT:    4 |   struct CA1 (base)
+// CHECK-NEXT:    4 |     (CA1 vbtable pointer)
+// CHECK-NEXT:    9 |   struct CA0 (base) (empty)
+// CHECK-NEXT:    9 |   struct CA0 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=9, align=1
+// CHECK-NEXT:      |  nvsize=9, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct CA2
+// CHECK-X64-NEXT:    0 |   (CA2 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct CA1 (base)
+// CHECK-X64-NEXT:    8 |     (CA1 vbtable pointer)
+// CHECK-X64-NEXT:   17 |   struct CA0 (base) (empty)
+// CHECK-X64-NEXT:   17 |   struct CA0 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=17, align=1
+// CHECK-X64-NEXT:      |  nvsize=17, nvalign=1]
+
+#pragma pack(16)
+struct YA {
+	__declspec(align(32)) char : 1;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YA (empty)
+// CHECK-NEXT:    0 |   char
+// CHECK-NEXT:      | [sizeof=32, align=32
+// CHECK-NEXT:      |  nvsize=32, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YA (empty)
+// CHECK-X64-NEXT:    0 |   char
+// CHECK-X64-NEXT:      | [sizeof=32, align=32
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=32]
+
+#pragma pack(1)
+struct YB {
+	char a;
+	YA b;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YB
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    1 |   struct YA b (empty)
+// CHECK-NEXT:    1 |     char
+// CHECK-NEXT:      |   [sizeof=32, align=32
+// CHECK-NEXT:      |    nvsize=32, nvalign=32]
+// CHECK-NEXT:      | [sizeof=33, align=1
+// CHECK-NEXT:      |  nvsize=33, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YB
+// CHECK-X64-NEXT:    0 |   char a
+// CHECK-X64-NEXT:    1 |   struct YA b (empty)
+// CHECK-X64-NEXT:    1 |     char
+// CHECK-X64-NEXT:      |   [sizeof=32, align=32
+// CHECK-X64-NEXT:      |    nvsize=32, nvalign=32]
+// CHECK-X64-NEXT:      | [sizeof=33, align=1
+// CHECK-X64-NEXT:      |  nvsize=33, nvalign=1]
+
+#pragma pack(8)
+struct YC {
+	__declspec(align(32)) char : 1;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YC (empty)
+// CHECK-NEXT:    0 |   char
+// CHECK-NEXT:      | [sizeof=32, align=32
+// CHECK-NEXT:      |  nvsize=32, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YC (empty)
+// CHECK-X64-NEXT:    0 |   char
+// CHECK-X64-NEXT:      | [sizeof=8, align=32
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=32]
+
+#pragma pack(1)
+struct YD {
+	char a;
+	YC b;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YD
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    1 |   struct YC b (empty)
+// CHECK-NEXT:    1 |     char
+// CHECK-NEXT:      |   [sizeof=32, align=32
+// CHECK-NEXT:      |    nvsize=32, nvalign=32]
+// CHECK-NEXT:      | [sizeof=33, align=1
+// CHECK-NEXT:      |  nvsize=33, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YD
+// CHECK-X64-NEXT:    0 |   char a
+// CHECK-X64-NEXT:    1 |   struct YC b (empty)
+// CHECK-X64-NEXT:    1 |     char
+// CHECK-X64-NEXT:      |   [sizeof=8, align=32
+// CHECK-X64-NEXT:      |    nvsize=8, nvalign=32]
+// CHECK-X64-NEXT:      | [sizeof=9, align=1
+// CHECK-X64-NEXT:      |  nvsize=9, nvalign=1]
+
+#pragma pack(4)
+struct YE {
+	__declspec(align(32)) char : 1;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YE (empty)
+// CHECK-NEXT:    0 |   char
+// CHECK-NEXT:      | [sizeof=4, align=32
+// CHECK-NEXT:      |  nvsize=4, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YE (empty)
+// CHECK-X64-NEXT:    0 |   char
+// CHECK-X64-NEXT:      | [sizeof=4, align=32
+// CHECK-X64-NEXT:      |  nvsize=4, nvalign=32]
+
+#pragma pack(1)
+struct YF {
+	char a;
+	YE b;
+};
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct YF
+// CHECK-NEXT:    0 |   char a
+// CHECK-NEXT:    1 |   struct YE b (empty)
+// CHECK-NEXT:    1 |     char
+// CHECK-NEXT:      |   [sizeof=4, align=32
+// CHECK-NEXT:      |    nvsize=4, nvalign=32]
+// CHECK-NEXT:      | [sizeof=5, align=1
+// CHECK-NEXT:      |  nvsize=5, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct YF
+// CHECK-X64-NEXT:    0 |   char a
+// CHECK-X64-NEXT:    1 |   struct YE b (empty)
+// CHECK-X64-NEXT:    1 |     char
+// CHECK-X64-NEXT:      |   [sizeof=4, align=32
+// CHECK-X64-NEXT:      |    nvsize=4, nvalign=32]
+// CHECK-X64-NEXT:      | [sizeof=5, align=1
+// CHECK-X64-NEXT:      |  nvsize=5, nvalign=1]
+
+#pragma pack(16)
+struct __declspec(align(16)) D0 { char a; };
+#pragma pack(1)
+struct D1 : public D0 { char a; };
+#pragma pack(16)
+struct D2 : D1 { char a; };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D2
+// CHECK-NEXT:    0 |   struct D1 (base)
+// CHECK-NEXT:    0 |     struct D0 (base)
+// CHECK-NEXT:    0 |       char a
+// CHECK-NEXT:    1 |     char a
+// CHECK-NEXT:    2 |   char a
+// CHECK-NEXT:      | [sizeof=16, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct D2
+// CHECK-X64-NEXT:    0 |   struct D1 (base)
+// CHECK-X64-NEXT:    0 |     struct D0 (base)
+// CHECK-X64-NEXT:    0 |       char a
+// CHECK-X64-NEXT:    1 |     char a
+// CHECK-X64-NEXT:    2 |   char a
+// CHECK-X64-NEXT:      | [sizeof=16, align=16
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
+
+#pragma pack()
+struct JA { char a; };
+#pragma pack(1)
+struct JB { __declspec(align(4)) char a; };
+#pragma pack()
+struct JC : JB, JA { };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct JC
+// CHECK-NEXT:    0 |   struct JB (base)
+// CHECK-NEXT:    0 |     char a
+// CHECK-NEXT:    1 |   struct JA (base)
+// CHECK-NEXT:    1 |     char a
+// CHECK-NEXT:      | [sizeof=4, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct JC
+// CHECK-X64-NEXT:    0 |   struct JB (base)
+// CHECK-X64-NEXT:    0 |     char a
+// CHECK-X64-NEXT:    1 |   struct JA (base)
+// CHECK-X64-NEXT:    1 |     char a
+// CHECK-X64-NEXT:      | [sizeof=4, align=4
+// CHECK-X64-NEXT:      |  nvsize=4, nvalign=4]
+
+#pragma pack()
+struct KA { char a; };
+#pragma pack(1)
+struct KB : KA { __declspec(align(2)) char a; };
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct KB
+// CHECK-NEXT:    0 |   struct KA (base)
+// CHECK-NEXT:    0 |     char a
+// CHECK-NEXT:    2 |   char a
+// CHECK-NEXT:      | [sizeof=4, align=2
+// CHECK-NEXT:      |  nvsize=3, nvalign=2]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct KB
+// CHECK-X64-NEXT:    0 |   struct KA (base)
+// CHECK-X64-NEXT:    0 |     char a
+// CHECK-X64-NEXT:    2 |   char a
+// CHECK-X64-NEXT:      | [sizeof=4, align=2
+// CHECK-X64-NEXT:      |  nvsize=3, nvalign=2]
+
+#pragma pack(1)
+struct L {
+  virtual void fun() {}
+  __declspec(align(256)) int Field;
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct L
+// CHECK-NEXT:    0 |   (L vftable pointer)
+// CHECK-NEXT:  256 |   int Field
+// CHECK-NEXT:      | [sizeof=512, align=256
+// CHECK-NEXT:      |  nvsize=260, nvalign=256]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-NEXT:    0 |   (L vftable pointer)
+// CHECK-X64-NEXT:  256 |   int Field
+// CHECK-X64-NEXT:      | [sizeof=512, align=256
+// CHECK-X64-NEXT:      |  nvsize=260, nvalign=256]
+
+#pragma pack()
+struct MA {};
+#pragma pack(1)
+struct MB : virtual MA {
+  __declspec(align(256)) int Field;
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct MB
+// CHECK-NEXT:    0 |   (MB vbtable pointer)
+// CHECK-NEXT:  256 |   int Field
+// CHECK-NEXT:  260 |   struct MA (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=512, align=256
+// CHECK-NEXT:      |  nvsize=260, nvalign=256]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct MB
+// CHECK-X64-NEXT:    0 |   (MB vbtable pointer)
+// CHECK-X64-NEXT:  256 |   int Field
+// CHECK-X64-NEXT:  260 |   struct MA (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=512, align=256
+// CHECK-X64-NEXT:      |  nvsize=260, nvalign=256]
+
+struct RA {};
+#pragma pack(1)
+struct __declspec(align(8)) RB0 { 
+	__declspec(align(1024)) int b : 3;
+};
+
+struct __declspec(align(8)) RB1 { 
+	__declspec(align(1024)) int b : 3;
+	virtual void f() {}
+};
+
+struct __declspec(align(8)) RB2 : virtual RA { 
+	__declspec(align(1024)) int b : 3;
+};
+
+struct __declspec(align(8)) RB3 : virtual RA { 
+	__declspec(align(1024)) int b : 3;
+	virtual void f() {}
+};
+
+struct RC {
+	char _;
+	__declspec(align(1024)) int c : 3;
+};
+struct RE {
+	char _;
+	RC c;
+};
+#pragma pack()
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RB0
+// CHECK-NEXT:    0 |   int b
+// CHECK-NEXT:      | [sizeof=8, align=1024
+// CHECK-NEXT:      |  nvsize=4, nvalign=1024]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RB1
+// CHECK-NEXT:    0 |   (RB1 vftable pointer)
+// CHECK-NEXT: 1024 |   int b
+// CHECK-NEXT:      | [sizeof=1032, align=1024
+// CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RB2
+// CHECK-NEXT:    0 |   (RB2 vbtable pointer)
+// CHECK-NEXT: 1024 |   int b
+// CHECK-NEXT: 1028 |   struct RA (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=1032, align=1024
+// CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RB3
+// CHECK-NEXT:    0 |   (RB3 vftable pointer)
+// CHECK-NEXT: 1024 |   (RB3 vbtable pointer)
+// CHECK-NEXT: 2048 |   int b
+// CHECK-NEXT: 2052 |   struct RA (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=2056, align=1024
+// CHECK-NEXT:      |  nvsize=2052, nvalign=1024]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RC
+// CHECK-NEXT:    0 |   char _
+// CHECK-NEXT: 1024 |   int c
+// CHECK-NEXT:      | [sizeof=1028, align=1024
+// CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct RE
+// CHECK-NEXT:    0 |   char _
+// CHECK-NEXT:    1 |   struct RC c
+// CHECK-NEXT:    1 |     char _
+// CHECK-NEXT: 1025 |     int c
+// CHECK-NEXT:      |   [sizeof=1028, align=1024
+// CHECK-NEXT:      |    nvsize=1028, nvalign=1024]
+// CHECK-NEXT:      | [sizeof=1029, align=1
+// CHECK-NEXT:      |  nvsize=1029, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RB0
+// CHECK-X64-NEXT:    0 |   int b
+// CHECK-X64-NEXT:      | [sizeof=8, align=1024
+// CHECK-X64-NEXT:      |  nvsize=4, nvalign=1024]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RB1
+// CHECK-X64-NEXT:    0 |   (RB1 vftable pointer)
+// CHECK-X64-NEXT: 1024 |   int b
+// CHECK-X64-NEXT:      | [sizeof=1032, align=1024
+// CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RB2
+// CHECK-X64-NEXT:    0 |   (RB2 vbtable pointer)
+// CHECK-X64-NEXT: 1024 |   int b
+// CHECK-X64-NEXT: 1028 |   struct RA (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=1032, align=1024
+// CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RB3
+// CHECK-X64-NEXT:    0 |   (RB3 vftable pointer)
+// CHECK-X64-NEXT: 1024 |   (RB3 vbtable pointer)
+// CHECK-X64-NEXT: 2048 |   int b
+// CHECK-X64-NEXT: 2052 |   struct RA (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=2056, align=1024
+// CHECK-X64-NEXT:      |  nvsize=2052, nvalign=1024]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RC
+// CHECK-X64-NEXT:    0 |   char _
+// CHECK-X64-NEXT: 1024 |   int c
+// CHECK-X64-NEXT:      | [sizeof=1028, align=1024
+// CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct RE
+// CHECK-X64-NEXT:    0 |   char _
+// CHECK-X64-NEXT:    1 |   struct RC c
+// CHECK-X64-NEXT:    1 |     char _
+// CHECK-X64-NEXT: 1025 |     int c
+// CHECK-X64-NEXT:      |   [sizeof=1028, align=1024
+// CHECK-X64-NEXT:      |    nvsize=1028, nvalign=1024]
+// CHECK-X64-NEXT:      | [sizeof=1029, align=1
+// CHECK-X64-NEXT:      |  nvsize=1029, nvalign=1]
+
+struct NA {};
+struct NB {};
+#pragma pack(push, 1)
+struct NC : virtual NA, virtual NB {};
+#pragma pack(pop)
+struct ND : NC {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct NA (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct NB (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct NC
+// CHECK-NEXT:    0 |   (NC vbtable pointer)
+// CHECK-NEXT:    4 |   struct NA (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct NB (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=1
+// CHECK-NEXT:      |  nvsize=4, nvalign=1]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct ND
+// CHECK-NEXT:    0 |   struct NC (base)
+// CHECK-NEXT:    0 |     (NC vbtable pointer)
+// CHECK-NEXT:    4 |   struct NA (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct NB (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct NA (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct NB (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct NC
+// CHECK-X64-NEXT:    0 |   (NC vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct NA (virtual base) (empty)
+// CHECK-X64-NEXT:   12 |   struct NB (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=12, align=1
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct ND
+// CHECK-X64-NEXT:    0 |   struct NC (base)
+// CHECK-X64-NEXT:    0 |     (NC vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct NA (virtual base) (empty)
+// CHECK-X64-NEXT:   12 |   struct NB (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=12, align=4
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
+
+struct OA {};
+struct OB {};
+struct OC : virtual OA, virtual OB {};
+#pragma pack(push, 1)
+struct OD : OC {};
+#pragma pack(pop)
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct OA (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct OB (empty)
+// CHECK-NEXT:      | [sizeof=1, align=1
+// CHECK-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct OC
+// CHECK-NEXT:    0 |   (OC vbtable pointer)
+// CHECK-NEXT:    4 |   struct OA (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct OB (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct OD
+// CHECK-NEXT:    0 |   struct OC (base)
+// CHECK-NEXT:    0 |     (OC vbtable pointer)
+// CHECK-NEXT:    4 |   struct OA (virtual base) (empty)
+// CHECK-NEXT:    8 |   struct OB (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=1
+// CHECK-NEXT:      |  nvsize=4, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct OA (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct OB (empty)
+// CHECK-X64-NEXT:      | [sizeof=1, align=1
+// CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct OC
+// CHECK-X64-NEXT:    0 |   (OC vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct OA (virtual base) (empty)
+// CHECK-X64-NEXT:   12 |   struct OB (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct OD
+// CHECK-X64-NEXT:    0 |   struct OC (base)
+// CHECK-X64-NEXT:    0 |     (OC vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct OA (virtual base) (empty)
+// CHECK-X64-NEXT:   12 |   struct OB (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=12, align=1
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=1]
+
+
+
+int a[
+sizeof(X)+
+sizeof(Y)+
+sizeof(Z)+
+sizeof(C1)+
+sizeof(CA2)+
+sizeof(YA)+
+sizeof(YB)+
+sizeof(YC)+
+sizeof(YD)+
+sizeof(YE)+
+sizeof(YF)+
+sizeof(YF)+
+sizeof(D2)+
+sizeof(JC)+
+sizeof(KB)+
+sizeof(L)+
+sizeof(MB)+
+sizeof(RB0)+
+sizeof(RB1)+
+sizeof(RB2)+
+sizeof(RB3)+
+sizeof(RC)+
+sizeof(RE)+
+sizeof(ND)+
+sizeof(OD)+
+0];
diff --git a/test/Layout/ms-x86-primary-bases.cpp b/test/Layout/ms-x86-primary-bases.cpp
index bc9b801d99c8..b5bd041fa116 100644
--- a/test/Layout/ms-x86-primary-bases.cpp
+++ b/test/Layout/ms-x86-primary-bases.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -16,65 +16,67 @@ struct A : virtual B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     (B0 vftable pointer)
-// CHECK:    8 |     int a
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     (B0 vftable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     (B0 vftable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct B : virtual B0 {
 	virtual void f() { printf("B"); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   (B vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     (B0 vftable pointer)
-// CHECK:    8 |     int a
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   (B vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     (B0 vftable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   (B vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     (B0 vftable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   (B vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct C : virtual B0 {
 	virtual void g() { printf("A"); }
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vftable pointer)
-// CHECK:    4 |   (C vbtable pointer)
-// CHECK:    8 |   struct B0 (virtual base)
-// CHECK:    8 |     (B0 vftable pointer)
-// CHECK:   12 |     int a
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vftable pointer)
+// CHECK-NEXT:    4 |   (C vbtable pointer)
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     (B0 vftable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vftable pointer)
-// CHECK-X64:    8 |   (C vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (virtual base)
-// CHECK-X64:   16 |     (B0 vftable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:      | [sizeof=32, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vftable pointer)
+// CHECK-X64-NEXT:    8 |   (C vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct D : virtual B2, virtual B0 {
 	virtual void f() { printf("D"); }
@@ -82,27 +84,29 @@ struct D : virtual B2, virtual B0 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   (D vftable pointer)
-// CHECK:    4 |   (D vbtable pointer)
-// CHECK:    8 |   struct B2 (virtual base)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct B0 (virtual base)
-// CHECK:   12 |     (B0 vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   (D vftable pointer)
+// CHECK-NEXT:    4 |   (D vbtable pointer)
+// CHECK-NEXT:    8 |   struct B2 (virtual base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct B0 (virtual base)
+// CHECK-NEXT:   12 |     (B0 vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   (D vftable pointer)
-// CHECK-X64:    8 |   (D vbtable pointer)
-// CHECK-X64:   16 |   struct B2 (virtual base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct B0 (virtual base)
-// CHECK-X64:   24 |     (B0 vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   (D vftable pointer)
+// CHECK-X64-NEXT:    8 |   (D vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B2 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   24 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct E : B0, virtual B1 {
 	virtual void f() { printf("E"); }
@@ -110,197 +114,205 @@ struct E : B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   struct B0 (primary base)
-// CHECK:    0 |     (B0 vftable pointer)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (E vbtable pointer)
-// CHECK:   12 |   struct B1 (virtual base)
-// CHECK:   12 |     (B1 vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   struct B0 (primary base)
+// CHECK-NEXT:    0 |     (B0 vftable pointer)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (E vbtable pointer)
+// CHECK-NEXT:   12 |   struct B1 (virtual base)
+// CHECK-NEXT:   12 |     (B1 vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   struct B0 (primary base)
-// CHECK-X64:    0 |     (B0 vftable pointer)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (E vbtable pointer)
-// CHECK-X64:   24 |   struct B1 (virtual base)
-// CHECK-X64:   24 |     (B1 vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   struct B0 (primary base)
+// CHECK-X64-NEXT:    0 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (E vbtable pointer)
+// CHECK-X64-NEXT:   24 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   24 |     (B1 vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : virtual B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   (F vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     (B0 vftable pointer)
-// CHECK:    8 |     int a
-// CHECK:   12 |   struct B1 (virtual base)
-// CHECK:   12 |     (B1 vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   (F vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     (B0 vftable pointer)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   struct B1 (virtual base)
+// CHECK-NEXT:   12 |     (B1 vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   (F vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     (B0 vftable pointer)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   24 |   struct B1 (virtual base)
-// CHECK-X64:   24 |     (B1 vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   (F vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   24 |     (B1 vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct AX : B0X, B1X { int a; AX() : a(0xf000000A) {} virtual void f() { printf("A"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct AX
-// CHECK:    8 |   struct B0X (base)
-// CHECK:    8 |     int a
-// CHECK:    0 |   struct B1X (primary base)
-// CHECK:    0 |     (B1X vftable pointer)
-// CHECK:    4 |     int a
-// CHECK:   12 |   int a
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct AX
+// CHECK-NEXT:    0 |   struct B1X (primary base)
+// CHECK-NEXT:    0 |     (B1X vftable pointer)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct B0X (base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct AX
-// CHECK-X64:   16 |   struct B0X (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:    0 |   struct B1X (primary base)
-// CHECK-X64:    0 |     (B1X vftable pointer)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   20 |   int a
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-NEXT:    0 |   struct B1X (primary base)
+// CHECK-X64-NEXT:    0 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B0X (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct BX : B0X, B1X { int a; BX() : a(0xf000000B) {} virtual void g() { printf("B"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct BX
-// CHECK:    8 |   struct B0X (base)
-// CHECK:    8 |     int a
-// CHECK:    0 |   struct B1X (primary base)
-// CHECK:    0 |     (B1X vftable pointer)
-// CHECK:    4 |     int a
-// CHECK:   12 |   int a
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=16, nvalign=4]
-// CHECK-x64: *** Dumping AST Record Layout
-// CHECK-x64:    0 | struct BX
-// CHECK-x64:   16 |   struct B0X (base)
-// CHECK-x64:   16 |     int a
-// CHECK-x64:    0 |   struct B1X (primary base)
-// CHECK-x64:    0 |     (B1X vftable pointer)
-// CHECK-x64:    8 |     int a
-// CHECK-x64:   24 |   int a
-// CHECK-x64:      | [sizeof=24, align=8
-// CHECK-x64:      |  nvsize=24, nvalign=8]
+// CHECK-NEXT:    0 | struct BX
+// CHECK-NEXT:    0 |   struct B1X (primary base)
+// CHECK-NEXT:    0 |     (B1X vftable pointer)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct B0X (base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=16, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-NEXT:    0 |   struct B1X (primary base)
+// CHECK-X64-NEXT:    0 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B0X (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct CX : B0X, B2X { int a; CX() : a(0xf000000C) {} virtual void g() { printf("C"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct CX
-// CHECK:    0 |   (CX vftable pointer)
-// CHECK:    4 |   struct B0X (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   struct B2X (base)
-// CHECK:    8 |     (B2X vbtable pointer)
-// CHECK:   12 |     int a
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B1X (virtual base)
-// CHECK:   20 |     (B1X vftable pointer)
-// CHECK:   24 |     int a
-// CHECK:      | [sizeof=28, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct CX
+// CHECK-NEXT:    0 |   (CX vftable pointer)
+// CHECK-NEXT:    4 |   struct B0X (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct B2X (base)
+// CHECK-NEXT:    8 |     (B2X vbtable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B1X (virtual base)
+// CHECK-NEXT:   20 |     (B1X vftable pointer)
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:      | [sizeof=28, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct CX
-// CHECK-X64:    0 |   (CX vftable pointer)
-// CHECK-X64:    8 |   struct B0X (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   struct B2X (base)
-// CHECK-X64:   16 |     (B2X vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   40 |   struct B1X (virtual base)
-// CHECK-X64:   40 |     (B1X vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=56, align=8
-// CHECK-X64:      |  nvsize=40, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-NEXT:    0 |   (CX vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0X (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B2X (base)
+// CHECK-X64-NEXT:   16 |     (B2X vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   40 |   struct B1X (virtual base)
+// CHECK-X64-NEXT:   40 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=56, align=8
+// CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct DX : virtual B1X { int a; DX() : a(0xf000000D) {} virtual void f() { printf("D"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct DX
-// CHECK:    0 |   (DX vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   (vtordisp for vbase B1X)
-// CHECK:   12 |   struct B1X (virtual base)
-// CHECK:   12 |     (B1X vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct DX
+// CHECK-NEXT:    0 |   (DX vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   (vtordisp for vbase B1X)
+// CHECK-NEXT:   12 |   struct B1X (virtual base)
+// CHECK-NEXT:   12 |     (B1X vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct DX
-// CHECK-X64:    0 |   (DX vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   20 |   (vtordisp for vbase B1X)
-// CHECK-X64:   24 |   struct B1X (virtual base)
-// CHECK-X64:   24 |     (B1X vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-NEXT:    0 |   (DX vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   20 |   (vtordisp for vbase B1X)
+// CHECK-X64-NEXT:   24 |   struct B1X (virtual base)
+// CHECK-X64-NEXT:   24 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct EX : virtual B1X { int a; EX() : a(0xf000000E) {} virtual void g() { printf("E"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct EX
-// CHECK:    0 |   (EX vftable pointer)
-// CHECK:    4 |   (EX vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   12 |   struct B1X (virtual base)
-// CHECK:   12 |     (B1X vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct EX
+// CHECK-NEXT:    0 |   (EX vftable pointer)
+// CHECK-NEXT:    4 |   (EX vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   12 |   struct B1X (virtual base)
+// CHECK-NEXT:   12 |     (B1X vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct EX
-// CHECK-X64:    0 |   (EX vftable pointer)
-// CHECK-X64:    8 |   (EX vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct B1X (virtual base)
-// CHECK-X64:   24 |     (B1X vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct EX
+// CHECK-X64-NEXT:    0 |   (EX vftable pointer)
+// CHECK-X64-NEXT:    8 |   (EX vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct B1X (virtual base)
+// CHECK-X64-NEXT:   24 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct FX : virtual B1X { int a; FX() : a(0xf000000F) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct FX
-// CHECK:    0 |   (FX vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B1X (virtual base)
-// CHECK:    8 |     (B1X vftable pointer)
-// CHECK:   12 |     int a
-// CHECK:      | [sizeof=16, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct FX
+// CHECK-NEXT:    0 |   (FX vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B1X (virtual base)
+// CHECK-NEXT:    8 |     (B1X vftable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct FX
-// CHECK-X64:    0 |   (FX vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B1X (virtual base)
-// CHECK-X64:   16 |     (B1X vftable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:      | [sizeof=32, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct FX
+// CHECK-X64-NEXT:    0 |   (FX vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B1X (virtual base)
+// CHECK-X64-NEXT:   16 |     (B1X vftable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-size-alignment-fail.cpp b/test/Layout/ms-x86-size-alignment-fail.cpp
index f998ee12c8d1..7e975b0039e2 100644
--- a/test/Layout/ms-x86-size-alignment-fail.cpp
+++ b/test/Layout/ms-x86-size-alignment-fail.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -11,108 +11,112 @@ struct __declspec(align(1)) B1 {};
 struct A : virtual B0 {};
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     char a
-// CHECK:      | [sizeof=5, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:      | [sizeof=5, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct __declspec(align(1)) B : virtual B0 {};
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   (B vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     char a
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   (B vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   (B vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   (B vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct C : virtual B0 { int a; C() : a(0xC) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base)
-// CHECK:    8 |     char a
-// CHECK:      | [sizeof=9, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     char a
+// CHECK-NEXT:      | [sizeof=9, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base)
-// CHECK-X64:   16 |     char a
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct D : virtual B0 { __declspec(align(1)) int a; D() : a(0xD) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   (D vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   struct B0 (virtual base)
-// CHECK:    8 |     char a
-// CHECK:      | [sizeof=12, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   (D vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-NEXT:    8 |     char a
+// CHECK-NEXT:      | [sizeof=12, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   (D vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B0 (virtual base)
-// CHECK-X64:   16 |     char a
-// CHECK-X64:      | [sizeof=24, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   (D vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   16 |     char a
+// CHECK-X64-NEXT:      | [sizeof=24, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct E : virtual B0, virtual B1 {};
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   (E vbtable pointer)
-// CHECK:    4 |   struct B0 (virtual base)
-// CHECK:    4 |     char a
-// CHECK:    5 |   struct B1 (virtual base) (empty)
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   (E vbtable pointer)
+// CHECK-NEXT:    4 |   struct B0 (virtual base)
+// CHECK-NEXT:    4 |     char a
+// CHECK-NEXT:    5 |   struct B1 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   (E vbtable pointer)
-// CHECK-X64:    8 |   struct B0 (virtual base)
-// CHECK-X64:    8 |     char a
-// CHECK-X64:    9 |   struct B1 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   (E vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:    8 |     char a
+// CHECK-X64-NEXT:    9 |   struct B1 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct F { char a; virtual ~F(); };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   (F vftable pointer)
-// CHECK:    4 |   char a
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   (F vftable pointer)
+// CHECK-NEXT:    4 |   char a
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   (F vftable pointer)
-// CHECK-X64:    8 |   char a
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   (F vftable pointer)
+// CHECK-X64-NEXT:    8 |   char a
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-vfvb-alignment.cpp b/test/Layout/ms-x86-vfvb-alignment.cpp
index 8eea20959b0e..54f74ac16d10 100644
--- a/test/Layout/ms-x86-vfvb-alignment.cpp
+++ b/test/Layout/ms-x86-vfvb-alignment.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -16,349 +16,361 @@ struct B6 { int a; B6() : a(0xf00000B6) {} virtual void f() { printf("B6"); } };
 struct A : B0, virtual B1 { __declspec(align(16)) int a; A() : a(0xf000000A) {} virtual void f() { printf("A"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vftable pointer)
-// CHECK:   16 |   struct B0 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   (A vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct B1 (virtual base)
-// CHECK:   64 |     char a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vftable pointer)
+// CHECK-NEXT:   16 |   struct B0 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   (A vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-NEXT:   64 |     char a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vftable pointer)
-// CHECK-X64:    8 |   struct B0 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (A vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   (A vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   64 |     char a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct B : A, B2 { int a; B() : a(0xf000000B) {} virtual void f() { printf("B"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct A (primary base)
-// CHECK:    0 |     (A vftable pointer)
-// CHECK:   16 |     struct B0 (base)
-// CHECK:   16 |       int a
-// CHECK:   20 |     (A vbtable pointer)
-// CHECK:   48 |     int a
-// CHECK:   64 |   struct B2 (base)
-// CHECK:   64 |     (B2 vbtable pointer)
-// CHECK:   68 |     int a
-// CHECK:   72 |   int a
-// CHECK:   80 |   struct B1 (virtual base)
-// CHECK:   80 |     char a
-// CHECK:      | [sizeof=96, align=16
-// CHECK:      |  nvsize=80, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct A (primary base)
+// CHECK-NEXT:    0 |     (A vftable pointer)
+// CHECK-NEXT:   16 |     struct B0 (base)
+// CHECK-NEXT:   16 |       int a
+// CHECK-NEXT:   20 |     (A vbtable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:   64 |   struct B2 (base)
+// CHECK-NEXT:   64 |     (B2 vbtable pointer)
+// CHECK-NEXT:   68 |     int a
+// CHECK-NEXT:   72 |   int a
+// CHECK-NEXT:   80 |   struct B1 (virtual base)
+// CHECK-NEXT:   80 |     char a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=80, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   struct A (primary base)
-// CHECK-X64:    0 |     (A vftable pointer)
-// CHECK-X64:    8 |     struct B0 (base)
-// CHECK-X64:    8 |       int a
-// CHECK-X64:   16 |     (A vbtable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   48 |   struct B2 (base)
-// CHECK-X64:   48 |     (B2 vbtable pointer)
-// CHECK-X64:   56 |     int a
-// CHECK-X64:   64 |   int a
-// CHECK-X64:   80 |   struct B1 (virtual base)
-// CHECK-X64:   80 |     char a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=80, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   struct A (primary base)
+// CHECK-X64-NEXT:    0 |     (A vftable pointer)
+// CHECK-X64-NEXT:   16 |     struct B0 (base)
+// CHECK-X64-NEXT:   16 |       int a
+// CHECK-X64-NEXT:   24 |     (A vbtable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   64 |   struct B2 (base)
+// CHECK-X64-NEXT:   64 |     (B2 vbtable pointer)
+// CHECK-X64-NEXT:   72 |     int a
+// CHECK-X64-NEXT:   80 |   int a
+// CHECK-X64-NEXT:   96 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   96 |     char a
+// CHECK-X64-NEXT:      | [sizeof=112, align=16
+// CHECK-X64-NEXT:      |  nvsize=96, nvalign=16]
 
 struct C : B4 { int a; C() : a(0xf000000C) {} virtual void f() { printf("C"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vftable pointer)
-// CHECK:   16 |   struct B4 (base)
-// CHECK:   16 |     (B4 vbtable pointer)
-// CHECK:   20 |     int a
-// CHECK:   24 |   int a
-// CHECK:   32 |   struct B3 (virtual base)
-// CHECK:   32 |     int a
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vftable pointer)
+// CHECK-NEXT:   16 |   struct B4 (base)
+// CHECK-NEXT:   16 |     (B4 vbtable pointer)
+// CHECK-NEXT:   20 |     int a
+// CHECK-NEXT:   24 |   int a
+// CHECK-NEXT:   32 |   struct B3 (virtual base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vftable pointer)
-// CHECK-X64:   16 |   struct B4 (base)
-// CHECK-X64:   16 |     (B4 vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B3 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B4 (base)
+// CHECK-X64-NEXT:   16 |     (B4 vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B3 (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct D : C { int a; D() : a(0xf000000D) {} virtual void f() { printf("D"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct C (primary base)
-// CHECK:    0 |     (C vftable pointer)
-// CHECK:   16 |     struct B4 (base)
-// CHECK:   16 |       (B4 vbtable pointer)
-// CHECK:   20 |       int a
-// CHECK:   24 |     int a
-// CHECK:   32 |   int a
-// CHECK:   48 |   struct B3 (virtual base)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct C (primary base)
+// CHECK-NEXT:    0 |     (C vftable pointer)
+// CHECK-NEXT:   16 |     struct B4 (base)
+// CHECK-NEXT:   16 |       (B4 vbtable pointer)
+// CHECK-NEXT:   20 |       int a
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   48 |   struct B3 (virtual base)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   struct C (primary base)
-// CHECK-X64:    0 |     (C vftable pointer)
-// CHECK-X64:   16 |     struct B4 (base)
-// CHECK-X64:   16 |       (B4 vbtable pointer)
-// CHECK-X64:   24 |       int a
-// CHECK-X64:   32 |     int a
-// CHECK-X64:   48 |   int a
-// CHECK-X64:   64 |   struct B3 (virtual base)
-// CHECK-X64:   64 |     int a
-// CHECK-X64:      | [sizeof=80, align=16
-// CHECK-X64:      |  nvsize=64, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct C (primary base)
+// CHECK-X64-NEXT:    0 |     (C vftable pointer)
+// CHECK-X64-NEXT:   16 |     struct B4 (base)
+// CHECK-X64-NEXT:   16 |       (B4 vbtable pointer)
+// CHECK-X64-NEXT:   24 |       int a
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct B3 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct E : virtual C { int a; E() : a(0xf000000E) {} virtual void f() { printf("E"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct E
-// CHECK:    0 |   (E vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:   16 |   struct B3 (virtual base)
-// CHECK:   16 |     int a
-// CHECK:   44 |   (vtordisp for vbase C)
-// CHECK:   48 |   struct C (virtual base)
-// CHECK:   48 |     (C vftable pointer)
-// CHECK:   64 |     struct B4 (base)
-// CHECK:   64 |       (B4 vbtable pointer)
-// CHECK:   68 |       int a
-// CHECK:   72 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct E
+// CHECK-NEXT:    0 |   (E vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:   16 |   struct B3 (virtual base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   44 |   (vtordisp for vbase C)
+// CHECK-NEXT:   48 |   struct C (virtual base)
+// CHECK-NEXT:   48 |     (C vftable pointer)
+// CHECK-NEXT:   64 |     struct B4 (base)
+// CHECK-NEXT:   64 |       (B4 vbtable pointer)
+// CHECK-NEXT:   68 |       int a
+// CHECK-NEXT:   72 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=8, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct E
-// CHECK-X64:    0 |   (E vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   16 |   struct B3 (virtual base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   44 |   (vtordisp for vbase C)
-// CHECK-X64:   48 |   struct C (virtual base)
-// CHECK-X64:   48 |     (C vftable pointer)
-// CHECK-X64:   64 |     struct B4 (base)
-// CHECK-X64:   64 |       (B4 vbtable pointer)
-// CHECK-X64:   72 |       int a
-// CHECK-X64:   80 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-NEXT:    0 |   (E vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   16 |   struct B3 (virtual base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C)
+// CHECK-X64-NEXT:   48 |   struct C (virtual base)
+// CHECK-X64-NEXT:   48 |     (C vftable pointer)
+// CHECK-X64-NEXT:   64 |     struct B4 (base)
+// CHECK-X64-NEXT:   64 |       (B4 vbtable pointer)
+// CHECK-X64-NEXT:   72 |       int a
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct F : B3, virtual B0 { int a; F() : a(0xf000000F) {} virtual void f() { printf("F"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct F
-// CHECK:    0 |   (F vftable pointer)
-// CHECK:   16 |   struct B3 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   (F vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct B0 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct F
+// CHECK-NEXT:    0 |   (F vftable pointer)
+// CHECK-NEXT:   16 |   struct B3 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (F vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct B0 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct F
-// CHECK-X64:    0 |   (F vftable pointer)
-// CHECK-X64:   16 |   struct B3 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   (F vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   48 |   struct B0 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-NEXT:    0 |   (F vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B3 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (F vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct G : B2, B6, virtual B1 { int a; G() : a(0xf0000010) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct G
-// CHECK:    8 |   struct B2 (base)
-// CHECK:    8 |     (B2 vbtable pointer)
-// CHECK:   12 |     int a
-// CHECK:    0 |   struct B6 (primary base)
-// CHECK:    0 |     (B6 vftable pointer)
-// CHECK:    4 |     int a
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B1 (virtual base)
-// CHECK:   20 |     char a
-// CHECK:      | [sizeof=21, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct G
+// CHECK-NEXT:    0 |   struct B6 (primary base)
+// CHECK-NEXT:    0 |     (B6 vftable pointer)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct B2 (base)
+// CHECK-NEXT:    8 |     (B2 vbtable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B1 (virtual base)
+// CHECK-NEXT:   20 |     char a
+// CHECK-NEXT:      | [sizeof=21, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct G
-// CHECK-X64:   16 |   struct B2 (base)
-// CHECK-X64:   16 |     (B2 vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:    0 |   struct B6 (primary base)
-// CHECK-X64:    0 |     (B6 vftable pointer)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   40 |   struct B1 (virtual base)
-// CHECK-X64:   40 |     char a
-// CHECK-X64:      | [sizeof=48, align=8
-// CHECK-X64:      |  nvsize=40, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-NEXT:    0 |   struct B6 (primary base)
+// CHECK-X64-NEXT:    0 |     (B6 vftable pointer)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B2 (base)
+// CHECK-X64-NEXT:   16 |     (B2 vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   40 |     char a
+// CHECK-X64-NEXT:      | [sizeof=48, align=8
+// CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct H : B6, B2, virtual B1 { int a; H() : a(0xf0000011) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct H
-// CHECK:    0 |   struct B6 (primary base)
-// CHECK:    0 |     (B6 vftable pointer)
-// CHECK:    4 |     int a
-// CHECK:    8 |   struct B2 (base)
-// CHECK:    8 |     (B2 vbtable pointer)
-// CHECK:   12 |     int a
-// CHECK:   16 |   int a
-// CHECK:   20 |   struct B1 (virtual base)
-// CHECK:   20 |     char a
-// CHECK:      | [sizeof=21, align=4
-// CHECK:      |  nvsize=20, nvalign=4]
+// CHECK-NEXT:    0 | struct H
+// CHECK-NEXT:    0 |   struct B6 (primary base)
+// CHECK-NEXT:    0 |     (B6 vftable pointer)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   struct B2 (base)
+// CHECK-NEXT:    8 |     (B2 vbtable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   20 |   struct B1 (virtual base)
+// CHECK-NEXT:   20 |     char a
+// CHECK-NEXT:      | [sizeof=21, align=4
+// CHECK-NEXT:      |  nvsize=20, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct H
-// CHECK-X64:    0 |   struct B6 (primary base)
-// CHECK-X64:    0 |     (B6 vftable pointer)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   struct B2 (base)
-// CHECK-X64:   16 |     (B2 vbtable pointer)
-// CHECK-X64:   24 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   40 |   struct B1 (virtual base)
-// CHECK-X64:   40 |     char a
-// CHECK-X64:      | [sizeof=48, align=8
-// CHECK-X64:      |  nvsize=40, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-NEXT:    0 |   struct B6 (primary base)
+// CHECK-X64-NEXT:    0 |     (B6 vftable pointer)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   struct B2 (base)
+// CHECK-X64-NEXT:   16 |     (B2 vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   40 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   40 |     char a
+// CHECK-X64-NEXT:      | [sizeof=48, align=8
+// CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct I : B0, virtual B1 { int a; int a1; __declspec(align(16)) int a2; I() : a(0xf0000011), a1(0xf0000011), a2(0xf0000011) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct I
-// CHECK:    0 |   struct B0 (base)
-// CHECK:    0 |     int a
-// CHECK:    4 |   (I vbtable pointer)
-// CHECK:   20 |   int a
-// CHECK:   24 |   int a1
-// CHECK:   32 |   int a2
-// CHECK:   48 |   struct B1 (virtual base)
-// CHECK:   48 |     char a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK-NEXT:    0 | struct I
+// CHECK-NEXT:    0 |   struct B0 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (I vbtable pointer)
+// CHECK-NEXT:   20 |   int a
+// CHECK-NEXT:   24 |   int a1
+// CHECK-NEXT:   32 |   int a2
+// CHECK-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-NEXT:   48 |     char a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct I
-// CHECK-X64:    0 |   struct B0 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:    8 |   (I vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   20 |   int a1
-// CHECK-X64:   32 |   int a2
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-NEXT:    0 |   struct B0 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (I vbtable pointer)
+// CHECK-X64-NEXT:   20 |   int a
+// CHECK-X64-NEXT:   24 |   int a1
+// CHECK-X64-NEXT:   32 |   int a2
+// CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   48 |     char a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct J : B0, B3, virtual B1 { int a; int a1; J() : a(0xf0000012), a1(0xf0000012) {} };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct J
-// CHECK:    0 |   struct B0 (base)
-// CHECK:    0 |     int a
-// CHECK:   16 |   struct B3 (base)
-// CHECK:   16 |     int a
-// CHECK:   32 |   (J vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   52 |   int a1
-// CHECK:   64 |   struct B1 (virtual base)
-// CHECK:   64 |     char a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK-NEXT:    0 | struct J
+// CHECK-NEXT:    0 |   struct B0 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:   16 |   struct B3 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (J vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   52 |   int a1
+// CHECK-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-NEXT:   64 |     char a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct J
-// CHECK-X64:    0 |   struct B0 (base)
-// CHECK-X64:    0 |     int a
-// CHECK-X64:   16 |   struct B3 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   (J vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   44 |   int a1
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     char a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct J
+// CHECK-X64-NEXT:    0 |   struct B0 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:   16 |   struct B3 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (J vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   52 |   int a1
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   64 |     char a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct K { int a; K() : a(0xf0000013) {} virtual void f() { printf("K"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct K
-// CHECK:    0 |   (K vftable pointer)
-// CHECK:    4 |   int a
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct K
+// CHECK-NEXT:    0 |   (K vftable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct K
-// CHECK-X64:    0 |   (K vftable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct K
+// CHECK-X64-NEXT:    0 |   (K vftable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct L : virtual K { int a; L() : a(0xf0000014) {} virtual void g() { printf("L"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct L
-// CHECK:    0 |   (L vftable pointer)
-// CHECK:    4 |   (L vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   12 |   struct K (virtual base)
-// CHECK:   12 |     (K vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct L
+// CHECK-NEXT:    0 |   (L vftable pointer)
+// CHECK-NEXT:    4 |   (L vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   12 |   struct K (virtual base)
+// CHECK-NEXT:   12 |     (K vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=12, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct L
-// CHECK-X64:    0 |   (L vftable pointer)
-// CHECK-X64:    8 |   (L vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   24 |   struct K (virtual base)
-// CHECK-X64:   24 |     (K vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-NEXT:    0 |   (L vftable pointer)
+// CHECK-X64-NEXT:    8 |   (L vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   24 |   struct K (virtual base)
+// CHECK-X64-NEXT:   24 |     (K vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct M : virtual K { int a; M() : a(0xf0000015) {} virtual void f() { printf("M"); } };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct M
-// CHECK:    0 |   (M vbtable pointer)
-// CHECK:    4 |   int a
-// CHECK:    8 |   (vtordisp for vbase K)
-// CHECK:   12 |   struct K (virtual base)
-// CHECK:   12 |     (K vftable pointer)
-// CHECK:   16 |     int a
-// CHECK:      | [sizeof=20, align=4
-// CHECK:      |  nvsize=8, nvalign=4]
+// CHECK-NEXT:    0 | struct M
+// CHECK-NEXT:    0 |   (M vbtable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:    8 |   (vtordisp for vbase K)
+// CHECK-NEXT:   12 |   struct K (virtual base)
+// CHECK-NEXT:   12 |     (K vftable pointer)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct M
-// CHECK-X64:    0 |   (M vbtable pointer)
-// CHECK-X64:    8 |   int a
-// CHECK-X64:   20 |   (vtordisp for vbase K)
-// CHECK-X64:   24 |   struct K (virtual base)
-// CHECK-X64:   24 |     (K vftable pointer)
-// CHECK-X64:   32 |     int a
-// CHECK-X64:      | [sizeof=40, align=8
-// CHECK-X64:      |  nvsize=16, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct M
+// CHECK-X64-NEXT:    0 |   (M vbtable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:   20 |   (vtordisp for vbase K)
+// CHECK-X64-NEXT:   24 |   struct K (virtual base)
+// CHECK-X64-NEXT:   24 |     (K vftable pointer)
+// CHECK-X64-NEXT:   32 |     int a
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-vfvb-sharing.cpp b/test/Layout/ms-x86-vfvb-sharing.cpp
index 2b3d08e44c67..91f194f2a5e5 100644
--- a/test/Layout/ms-x86-vfvb-sharing.cpp
+++ b/test/Layout/ms-x86-vfvb-sharing.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -18,27 +18,31 @@ struct A : B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vftable pointer)
-// CHECK:   16 |   struct B0 (base)
-// CHECK:   16 |     int a
-// CHECK:   20 |   (A vbtable pointer)
-// CHECK:   48 |   int a
-// CHECK:   64 |   struct B1 (virtual base)
-// CHECK:   64 |     int a
-// CHECK:      | [sizeof=80, align=16
-// CHECK:      |  nvsize=64, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vftable pointer)
+// CHECK-NEXT:   16 |   struct B0 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   20 |   (A vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-NEXT:   64 |     int a
+// CHECK-NEXT:      | [sizeof=80, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vftable pointer)
-// CHECK-X64:    8 |   struct B0 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (A vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   24 |   (A vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct B : B2, B0, virtual B1 {
 	__declspec(align(16)) int a;
@@ -47,29 +51,31 @@ struct B : B2, B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct B
-// CHECK:    0 |   struct B2 (primary base)
-// CHECK:    0 |     (B2 vftable pointer)
-// CHECK:    4 |   struct B0 (base)
-// CHECK:    4 |     int a
-// CHECK:    8 |   (B vbtable pointer)
-// CHECK:   32 |   int a
-// CHECK:   48 |   struct B1 (virtual base)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct B
+// CHECK-NEXT:    0 |   struct B2 (primary base)
+// CHECK-NEXT:    0 |     (B2 vftable pointer)
+// CHECK-NEXT:    4 |   struct B0 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (B vbtable pointer)
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct B
-// CHECK-X64:    0 |   struct B2 (primary base)
-// CHECK-X64:    0 |     (B2 vftable pointer)
-// CHECK-X64:    8 |   struct B0 (base)
-// CHECK-X64:    8 |     int a
-// CHECK-X64:   16 |   (B vbtable pointer)
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-NEXT:    0 |   struct B2 (primary base)
+// CHECK-X64-NEXT:    0 |     (B2 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct B0 (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (B vbtable pointer)
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct C : B3, B0, virtual B1 {
 	__declspec(align(16)) int a;
@@ -78,29 +84,31 @@ struct C : B3, B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vftable pointer)
-// CHECK:   16 |   struct B3 (base)
-// CHECK:   16 |     (B3 vbtable pointer)
-// CHECK:   20 |   struct B0 (base)
-// CHECK:   20 |     int a
-// CHECK:   32 |   int a
-// CHECK:   48 |   struct B1 (virtual base)
-// CHECK:   48 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=48, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vftable pointer)
+// CHECK-NEXT:   16 |   struct B3 (base)
+// CHECK-NEXT:   16 |     (B3 vbtable pointer)
+// CHECK-NEXT:   20 |   struct B0 (base)
+// CHECK-NEXT:   20 |     int a
+// CHECK-NEXT:   32 |   int a
+// CHECK-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=48, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vftable pointer)
-// CHECK-X64:    8 |   struct B3 (base)
-// CHECK-X64:    8 |     (B3 vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B3 (base)
+// CHECK-X64-NEXT:   16 |     (B3 vbtable pointer)
+// CHECK-X64-NEXT:   24 |   struct B0 (base)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct D : B4, B0, virtual B1 {
 	__declspec(align(16)) int a;
@@ -109,29 +117,31 @@ struct D : B4, B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   struct B4 (primary base)
-// CHECK:    0 |     (B4 vftable pointer)
-// CHECK:    4 |     (B4 vbtable pointer)
-// CHECK:    8 |   struct B0 (base)
-// CHECK:    8 |     int a
-// CHECK:   16 |   int a
-// CHECK:   32 |   struct B1 (virtual base)
-// CHECK:   32 |     int a
-// CHECK:      | [sizeof=48, align=16
-// CHECK:      |  nvsize=32, nvalign=16]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   struct B4 (primary base)
+// CHECK-NEXT:    0 |     (B4 vftable pointer)
+// CHECK-NEXT:    4 |     (B4 vbtable pointer)
+// CHECK-NEXT:    8 |   struct B0 (base)
+// CHECK-NEXT:    8 |     int a
+// CHECK-NEXT:   16 |   int a
+// CHECK-NEXT:   32 |   struct B1 (virtual base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   struct B4 (primary base)
-// CHECK-X64:    0 |     (B4 vftable pointer)
-// CHECK-X64:    8 |     (B4 vbtable pointer)
-// CHECK-X64:   16 |   struct B0 (base)
-// CHECK-X64:   16 |     int a
-// CHECK-X64:   32 |   int a
-// CHECK-X64:   48 |   struct B1 (virtual base)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:      | [sizeof=64, align=16
-// CHECK-X64:      |  nvsize=48, nvalign=16]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   struct B4 (primary base)
+// CHECK-X64-NEXT:    0 |     (B4 vftable pointer)
+// CHECK-X64-NEXT:    8 |     (B4 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   struct B0 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 int a[
 sizeof(A)+
diff --git a/test/Layout/ms-x86-vtordisp.cpp b/test/Layout/ms-x86-vtordisp.cpp
index b16f09ed704c..60779fb1975b 100644
--- a/test/Layout/ms-x86-vtordisp.cpp
+++ b/test/Layout/ms-x86-vtordisp.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>&1 \
+// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only -cxx-abi microsoft %s 2>/dev/null \
+// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
@@ -30,35 +30,39 @@ struct A : virtual B0, virtual B1 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct A
-// CHECK:    0 |   (A vftable pointer)
-// CHECK:    4 |   (A vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   16 |   (vtordisp for vbase B0)
-// CHECK:   20 |   struct B0 (virtual base)
-// CHECK:   20 |     (B0 vftable pointer)
-// CHECK:   24 |     int a
-// CHECK:   44 |   (vtordisp for vbase B1)
-// CHECK:   48 |   struct B1 (virtual base)
-// CHECK:   48 |     (B1 vftable pointer)
-// CHECK:   52 |     int a
-// CHECK:      | [sizeof=64, align=16
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct A
+// CHECK-NEXT:    0 |   (A vftable pointer)
+// CHECK-NEXT:    4 |   (A vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   16 |   (vtordisp for vbase B0)
+// CHECK-NEXT:   20 |   struct B0 (virtual base)
+// CHECK-NEXT:   20 |     (B0 vftable pointer)
+// CHECK-NEXT:   24 |     int a
+// CHECK-NEXT:   44 |   (vtordisp for vbase B1)
+// CHECK-NEXT:   48 |   struct B1 (virtual base)
+// CHECK-NEXT:   48 |     (B1 vftable pointer)
+// CHECK-NEXT:   52 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct A
-// CHECK-X64:    0 |   (A vftable pointer)
-// CHECK-X64:    8 |   (A vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   36 |   (vtordisp for vbase B0)
-// CHECK-X64:   40 |   struct B0 (virtual base)
-// CHECK-X64:   40 |     (B0 vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   76 |   (vtordisp for vbase B1)
-// CHECK-X64:   80 |   struct B1 (virtual base)
-// CHECK-X64:   80 |     (B1 vftable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=16
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-NEXT:    0 |   (A vftable pointer)
+// CHECK-X64-NEXT:    8 |   (A vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
+// CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
+// CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
+// CHECK-X64-NEXT:   88 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct C : virtual B0, virtual B1, VAlign32 {
 	int a;
@@ -68,39 +72,43 @@ struct C : virtual B0, virtual B1, VAlign32 {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct C
-// CHECK:    0 |   (C vftable pointer)
-// CHECK:   32 |   struct VAlign32 (base)
-// CHECK:   32 |     (VAlign32 vbtable pointer)
-// CHECK:   36 |   int a
-// CHECK:   64 |   (vtordisp for vbase B0)
-// CHECK:   68 |   struct B0 (virtual base)
-// CHECK:   68 |     (B0 vftable pointer)
-// CHECK:   72 |     int a
-// CHECK:  108 |   (vtordisp for vbase B1)
-// CHECK:  112 |   struct B1 (virtual base)
-// CHECK:  112 |     (B1 vftable pointer)
-// CHECK:  116 |     int a
-// CHECK:  128 |   struct Align32 (virtual base) (empty)
-// CHECK:      | [sizeof=128, align=32
-// CHECK:      |  nvsize=64, nvalign=32]
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct C
+// CHECK-NEXT:    0 |   (C vftable pointer)
+// CHECK-NEXT:   32 |   struct VAlign32 (base)
+// CHECK-NEXT:   32 |     (VAlign32 vbtable pointer)
+// CHECK-NEXT:   36 |   int a
+// CHECK-NEXT:   64 |   (vtordisp for vbase B0)
+// CHECK-NEXT:   68 |   struct B0 (virtual base)
+// CHECK-NEXT:   68 |     (B0 vftable pointer)
+// CHECK-NEXT:   72 |     int a
+// CHECK-NEXT:  108 |   (vtordisp for vbase B1)
+// CHECK-NEXT:  112 |   struct B1 (virtual base)
+// CHECK-NEXT:  112 |     (B1 vftable pointer)
+// CHECK-NEXT:  116 |     int a
+// CHECK-NEXT:  128 |   struct Align32 (virtual base) (empty)
+// CHECK-NEXT:      | [sizeof=128, align=32
+// CHECK-NEXT:      |  nvsize=64, nvalign=32]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct C
-// CHECK-X64:    0 |   (C vftable pointer)
-// CHECK-X64:   32 |   struct VAlign32 (base)
-// CHECK-X64:   32 |     (VAlign32 vbtable pointer)
-// CHECK-X64:   40 |   int a
-// CHECK-X64:   68 |   (vtordisp for vbase B0)
-// CHECK-X64:   72 |   struct B0 (virtual base)
-// CHECK-X64:   72 |     (B0 vftable pointer)
-// CHECK-X64:   80 |     int a
-// CHECK-X64:  108 |   (vtordisp for vbase B1)
-// CHECK-X64:  112 |   struct B1 (virtual base)
-// CHECK-X64:  112 |     (B1 vftable pointer)
-// CHECK-X64:  120 |     int a
-// CHECK-X64:  128 |   struct Align32 (virtual base) (empty)
-// CHECK-X64:      | [sizeof=128, align=32
-// CHECK-X64:      |  nvsize=64, nvalign=32]
+// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vftable pointer)
+// CHECK-X64-NEXT:   32 |   struct VAlign32 (base)
+// CHECK-X64-NEXT:   32 |     (VAlign32 vbtable pointer)
+// CHECK-X64-NEXT:   40 |   int a
+// CHECK-X64-NEXT:   68 |   (vtordisp for vbase B0)
+// CHECK-X64-NEXT:   72 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   72 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:  108 |   (vtordisp for vbase B1)
+// CHECK-X64-NEXT:  112 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:  112 |     (B1 vftable pointer)
+// CHECK-X64-NEXT:  120 |     int a
+// CHECK-X64-NEXT:  128 |   struct Align32 (virtual base) (empty)
+// CHECK-X64-NEXT:      | [sizeof=128, align=32
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) D : virtual B0, virtual B1  {
 	int a;
@@ -110,35 +118,35 @@ struct __declspec(align(32)) D : virtual B0, virtual B1  {
 };
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct D
-// CHECK:    0 |   (D vftable pointer)
-// CHECK:    4 |   (D vbtable pointer)
-// CHECK:    8 |   int a
-// CHECK:   32 |   (vtordisp for vbase B0)
-// CHECK:   36 |   struct B0 (virtual base)
-// CHECK:   36 |     (B0 vftable pointer)
-// CHECK:   40 |     int a
-// CHECK:   76 |   (vtordisp for vbase B1)
-// CHECK:   80 |   struct B1 (virtual base)
-// CHECK:   80 |     (B1 vftable pointer)
-// CHECK:   84 |     int a
-// CHECK:      | [sizeof=96, align=32
-// CHECK:      |  nvsize=12, nvalign=4]
+// CHECK-NEXT:    0 | struct D
+// CHECK-NEXT:    0 |   (D vftable pointer)
+// CHECK-NEXT:    4 |   (D vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   32 |   (vtordisp for vbase B0)
+// CHECK-NEXT:   36 |   struct B0 (virtual base)
+// CHECK-NEXT:   36 |     (B0 vftable pointer)
+// CHECK-NEXT:   40 |     int a
+// CHECK-NEXT:   76 |   (vtordisp for vbase B1)
+// CHECK-NEXT:   80 |   struct B1 (virtual base)
+// CHECK-NEXT:   80 |     (B1 vftable pointer)
+// CHECK-NEXT:   84 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=32
+// CHECK-NEXT:      |  nvsize=12, nvalign=32]
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct D
-// CHECK-X64:    0 |   (D vftable pointer)
-// CHECK-X64:    8 |   (D vbtable pointer)
-// CHECK-X64:   16 |   int a
-// CHECK-X64:   36 |   (vtordisp for vbase B0)
-// CHECK-X64:   40 |   struct B0 (virtual base)
-// CHECK-X64:   40 |     (B0 vftable pointer)
-// CHECK-X64:   48 |     int a
-// CHECK-X64:   76 |   (vtordisp for vbase B1)
-// CHECK-X64:   80 |   struct B1 (virtual base)
-// CHECK-X64:   80 |     (B1 vftable pointer)
-// CHECK-X64:   88 |     int a
-// CHECK-X64:      | [sizeof=96, align=32
-// CHECK-X64:      |  nvsize=24, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-NEXT:    0 |   (D vftable pointer)
+// CHECK-X64-NEXT:    8 |   (D vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
+// CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
+// CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
+// CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
+// CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
+// CHECK-X64-NEXT:   88 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=32
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=32]
 
 struct AT {
 	virtual ~AT(){}
@@ -149,22 +157,275 @@ struct CT : virtual AT {
 CT::~CT(){}
 
 // CHECK: *** Dumping AST Record Layout
-// CHECK:    0 | struct CT
-// CHECK:    0 |   (CT vbtable pointer)
-// CHECK:    4 |   struct AT (virtual base)
-// CHECK:    4 |     (AT vftable pointer)
-// CHECK:      | [sizeof=8, align=4
-// CHECK:      |  nvsize=4, nvalign=4]
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct CT
+// CHECK-NEXT:    0 |   (CT vbtable pointer)
+// CHECK-NEXT:    4 |   struct AT (virtual base)
+// CHECK-NEXT:    4 |     (AT vftable pointer)
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct CT
+// CHECK-X64-NEXT:    0 |   (CT vbtable pointer)
+// CHECK-X64-NEXT:    8 |   struct AT (virtual base)
+// CHECK-X64-NEXT:    8 |     (AT vftable pointer)
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+struct XA {
+	XA() { printf("XA"); }
+	long long ll;
+};
+struct XB : XA {
+	XB() { printf("XB"); }
+	virtual void foo() {}
+	int b;
+};
+struct XC : virtual XB {
+	XC() { printf("XC"); }
+	virtual void foo() {}
+};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct XC
+// CHECK-NEXT:    0 |   (XC vbtable pointer)
+// CHECK-NEXT:    4 |   (vtordisp for vbase XB)
+// CHECK-NEXT:    8 |   struct XB (virtual base)
+// CHECK-NEXT:    8 |     (XB vftable pointer)
+// CHECK-NEXT:   16 |     struct XA (base)
+// CHECK-NEXT:   16 |       long long ll
+// CHECK-NEXT:   24 |     int b
+// CHECK-NEXT:      | [sizeof=32, align=8
+// CHECK-NEXT:      |  nvsize=4, nvalign=8]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct XC
+// CHECK-X64-NEXT:    0 |   (XC vbtable pointer)
+// CHECK-X64-NEXT:   12 |   (vtordisp for vbase XB)
+// CHECK-X64-NEXT:   16 |   struct XB (virtual base)
+// CHECK-X64-NEXT:   16 |     (XB vftable pointer)
+// CHECK-X64-NEXT:   24 |     struct XA (base)
+// CHECK-X64-NEXT:   24 |       long long ll
+// CHECK-X64-NEXT:   32 |     int b
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+namespace pragma_test1 {
+// No overrides means no vtordisps by default.
+struct A { virtual ~A(); virtual void foo(); int a; };
+struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
+struct C : virtual B { int c; };
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct pragma_test1::C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int c
+// CHECK-NEXT:    8 |   struct pragma_test1::A (virtual base)
+// CHECK-NEXT:    8 |     (A vftable pointer)
+// CHECK-NEXT:   12 |     int a
+// CHECK-NEXT:   16 |   struct pragma_test1::B (virtual base)
+// CHECK-NEXT:   16 |     (B vftable pointer)
+// CHECK-NEXT:   20 |     (B vbtable pointer)
+// CHECK-NEXT:   24 |     int b
+// CHECK-NEXT:      | [sizeof=28, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+}
+
+namespace pragma_test2 {
+struct A { virtual ~A(); virtual void foo(); int a; };
+#pragma vtordisp(push,2)
+struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
+struct C : virtual B { int c; };
+#pragma vtordisp(pop)
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct pragma_test2::C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int c
+// CHECK-NEXT:    8 |   (vtordisp for vbase A)
+// CHECK-NEXT:   12 |   struct pragma_test2::A (virtual base)
+// CHECK-NEXT:   12 |     (A vftable pointer)
+// CHECK-NEXT:   16 |     int a
+//   By adding a virtual method and vftable to B, now we need a vtordisp.
+// CHECK-NEXT:   20 |   (vtordisp for vbase B)
+// CHECK-NEXT:   24 |   struct pragma_test2::B (virtual base)
+// CHECK-NEXT:   24 |     (B vftable pointer)
+// CHECK-NEXT:   28 |     (B vbtable pointer)
+// CHECK-NEXT:   32 |     int b
+// CHECK-NEXT:      | [sizeof=36, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+}
+
+namespace pragma_test3 {
+struct A { virtual ~A(); virtual void foo(); int a; };
+#pragma vtordisp(push,2)
+struct B : virtual A { virtual ~B(); virtual void foo(); int b; };
+struct C : virtual B { int c; };
+#pragma vtordisp(pop)
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct pragma_test3::C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int c
+// CHECK-NEXT:    8 |   (vtordisp for vbase A)
+// CHECK-NEXT:   12 |   struct pragma_test3::A (virtual base)
+// CHECK-NEXT:   12 |     (A vftable pointer)
+// CHECK-NEXT:   16 |     int a
+//   No vtordisp before B!  It doesn't have its own vftable.
+// CHECK-NEXT:   20 |   struct pragma_test3::B (virtual base)
+// CHECK-NEXT:   20 |     (B vbtable pointer)
+// CHECK-NEXT:   24 |     int b
+// CHECK-NEXT:      | [sizeof=28, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+}
+
+namespace pragma_test4 {
+struct A {
+  A();
+  virtual void foo();
+  int a;
+};
+
+// Make sure the pragma applies to class template decls before they've been
+// instantiated.
+#pragma vtordisp(push,2)
+template <typename T>
+struct B : virtual A {
+  B();
+  virtual ~B();
+  virtual void bar();
+  T b;
+};
+#pragma vtordisp(pop)
+
+struct C : virtual B<int> { int c; };
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct pragma_test4::C
+// CHECK-NEXT:    0 |   (C vbtable pointer)
+// CHECK-NEXT:    4 |   int c
+//   Pragma applies to B, which has vbase A.
+// CHECK-NEXT:    8 |   (vtordisp for vbase A)
+// CHECK-NEXT:   12 |   struct pragma_test4::A (virtual base)
+// CHECK-NEXT:   12 |     (A vftable pointer)
+// CHECK-NEXT:   16 |     int a
+//   Pragma does not apply to C, and B doesn't usually need a vtordisp in C.
+// CHECK-NEXT:   20 |   struct pragma_test4::B<int> (virtual base)
+// CHECK-NEXT:   20 |     (B vftable pointer)
+// CHECK-NEXT:   24 |     (B vbtable pointer)
+// CHECK-NEXT:   28 |     int b
+// CHECK-NEXT:      | [sizeof=32, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+}
+
+struct GA {
+	virtual void fun() {}
+};
+struct GB: public GA {};
+struct GC: public virtual GA {
+	virtual void fun() {}
+	GC() {}
+};
+struct GD: public virtual GC, public virtual GB {};
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct GD
+// CHECK-NEXT:    0 |   (GD vbtable pointer)
+// CHECK-NEXT:    4 |   (vtordisp for vbase GA)
+// CHECK-NEXT:    8 |   struct GA (virtual base)
+// CHECK-NEXT:    8 |     (GA vftable pointer)
+// CHECK-NEXT:   12 |   struct GC (virtual base)
+// CHECK-NEXT:   12 |     (GC vbtable pointer)
+// CHECK-NEXT:   16 |   struct GB (virtual base)
+// CHECK-NEXT:   16 |     struct GA (primary base)
+// CHECK-NEXT:   16 |       (GA vftable pointer)
+// CHECK-NEXT:      | [sizeof=20, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64-NEXT:    0 | struct GD
+// CHECK-X64-NEXT:    0 |   (GD vbtable pointer)
+// CHECK-X64-NEXT:   12 |   (vtordisp for vbase GA)
+// CHECK-X64-NEXT:   16 |   struct GA (virtual base)
+// CHECK-X64-NEXT:   16 |     (GA vftable pointer)
+// CHECK-X64-NEXT:   24 |   struct GC (virtual base)
+// CHECK-X64-NEXT:   24 |     (GC vbtable pointer)
+// CHECK-X64-NEXT:   32 |   struct GB (virtual base)
+// CHECK-X64-NEXT:   32 |     struct GA (primary base)
+// CHECK-X64-NEXT:   32 |       (GA vftable pointer)
+// CHECK-X64-NEXT:      | [sizeof=40, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
+
+struct HA {
+  virtual void fun() {}
+};
+#pragma vtordisp(push, 2)
+struct HB : virtual HA {};
+#pragma vtordisp(pop)
+#pragma vtordisp(push, 0)
+struct HC : virtual HB {};
+#pragma vtordisp(pop)
+
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK: *** Dumping AST Record Layout
+// CHECK-NEXT:    0 | struct HC
+// CHECK-NEXT:    0 |   (HC vbtable pointer)
+// CHECK-NEXT:    4 |   (vtordisp for vbase HA)
+// CHECK-NEXT:    8 |   struct HA (virtual base)
+// CHECK-NEXT:    8 |     (HA vftable pointer)
+// CHECK-NEXT:   12 |   struct HB (virtual base)
+// CHECK-NEXT:   12 |     (HB vbtable pointer)
+// CHECK-NEXT:      | [sizeof=16, align=4
+// CHECK-NEXT:      |  nvsize=4, nvalign=4]
+// CHECK-X64: *** Dumping AST Record Layout
+// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64:    0 | struct CT
-// CHECK-X64:    0 |   (CT vbtable pointer)
-// CHECK-X64:    8 |   struct AT (virtual base)
-// CHECK-X64:    8 |     (AT vftable pointer)
-// CHECK-X64:      | [sizeof=16, align=8
-// CHECK-X64:      |  nvsize=8, nvalign=8]
+// CHECK-X64-NEXT:    0 | struct HC
+// CHECK-X64-NEXT:    0 |   (HC vbtable pointer)
+// CHECK-X64-NEXT:   12 |   (vtordisp for vbase HA)
+// CHECK-X64-NEXT:   16 |   struct HA (virtual base)
+// CHECK-X64-NEXT:   16 |     (HA vftable pointer)
+// CHECK-X64-NEXT:   24 |   struct HB (virtual base)
+// CHECK-X64-NEXT:   24 |     (HB vbtable pointer)
+// CHECK-X64-NEXT:      | [sizeof=32, align=8
+// CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 int a[
 sizeof(A)+
 sizeof(C)+
 sizeof(D)+
-sizeof(CT)];
+sizeof(CT)+
+sizeof(XC)+
+sizeof(pragma_test1::C)+
+sizeof(pragma_test2::C)+
+sizeof(pragma_test3::C)+
+sizeof(pragma_test4::C)+
+sizeof(GD)+
+sizeof(HC)+
+0];