[ms-cxxabi] Raise aggregate memptr alignment to 8 for x86_32

With this change, we give different results for __alignof than MSVC, but
our record layout is compatible.

Some data member pointers also now have a size that is not a multiple of
their alignment.

Fixes PR18618.

Reviewers: majnemer

Differential Revision: http://llvm-reviews.chandlerc.com/D2669

llvm-svn: 200585

1 files changed, 24 insertions, 3 deletions

diff --git a/clang/test/SemaCXX/member-pointer-ms.cpp b/clang/test/SemaCXX/member-pointer-ms.cpp
index ca37e07496a..aa3caa74285 100644
--- a/clang/test/SemaCXX/member-pointer-ms.cpp
+++ b/clang/test/SemaCXX/member-pointer-ms.cpp
@@ -19,15 +19,29 @@ struct Foo {
 };
 
 enum {
+  kSingleDataAlign             = 1 * sizeof(int),
+  kSingleFunctionAlign         = 1 * sizeof(void *),
+  kMultipleDataAlign           = 1 * sizeof(int),
+  // Everything with more than 1 field is 8 byte aligned, except virtual data
+  // member pointers on x64 (ugh).
+  kMultipleFunctionAlign       = 8,
+#ifdef _M_X64
+  kVirtualDataAlign            = 4,
+#else
+  kVirtualDataAlign            = 8,
+#endif
+  kVirtualFunctionAlign        = 8,
+  kUnspecifiedDataAlign        = 8,
+  kUnspecifiedFunctionAlign    = 8,
+
   kSingleDataSize             = 1 * sizeof(int),
   kSingleFunctionSize         = 1 * sizeof(void *),
   kMultipleDataSize           = 1 * sizeof(int),
   kMultipleFunctionSize       = 2 * sizeof(void *),
   kVirtualDataSize            = 2 * sizeof(int),
   kVirtualFunctionSize        = 2 * sizeof(int) + 1 * sizeof(void *),
-  // Unspecified is weird, it's 1 more slot than virtual.
-  kUnspecifiedDataSize        = kVirtualDataSize + 1 * sizeof(int),
-  kUnspecifiedFunctionSize    = kVirtualFunctionSize + 1 * sizeof(void *),
+  kUnspecifiedDataSize        = 3 * sizeof(int),
+  kUnspecifiedFunctionSize    = 2 * sizeof(int) + 2 * sizeof(void *),
 };
 
 // incomplete types
@@ -41,6 +55,13 @@ static_assert(sizeof(void (IncSingle::*)())   == kSingleFunctionSize, "");
 static_assert(sizeof(void (IncMultiple::*)()) == kMultipleFunctionSize, "");
 static_assert(sizeof(void (IncVirtual::*)())  == kVirtualFunctionSize, "");
 
+static_assert(__alignof(int IncSingle::*)        == kSingleDataAlign, "");
+static_assert(__alignof(int IncMultiple::*)      == kMultipleDataAlign, "");
+static_assert(__alignof(int IncVirtual::*)       == kVirtualDataAlign, "");
+static_assert(__alignof(void (IncSingle::*)())   == kSingleFunctionAlign, "");
+static_assert(__alignof(void (IncMultiple::*)()) == kMultipleFunctionAlign, "");
+static_assert(__alignof(void (IncVirtual::*)())  == kVirtualFunctionAlign, "");
+
 // An incomplete type with an unspecified inheritance model seems to take one
 // more slot than virtual.  It's not clear what it's used for yet.
 class IncUnspecified;