Fallback implementation of Q_ALIGNOF

For all practical purposes, the fallback introduced here returns the
desired value. Having a fallback enables unconditional use of Q_ALIGNOF.

For compilers that provide native support for it, Q_ALIGNOF is otherwise
 #defined in qcompilerdetection.h.

Change-Id: Ie148ca8936cbbf8b80fe87771a14797c39a9d30c
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

2 files changed, 115 insertions, 30 deletions

diff --git a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
index b3d76bef8a..529bafaa7a 100644
--- a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
+++ b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
@@ -56,6 +56,7 @@ private slots:
     void qstaticassert();
     void qConstructorFunction();
     void isEnum();
+    void qAlignOf();
 };
 
 void tst_QGlobal::qIsNull()
@@ -415,5 +416,115 @@ void tst_QGlobal::isEnum()
 #undef IS_ENUM_FALSE
 }
 
+struct Empty {};
+template <class T> struct AlignmentInStruct { T dummy; };
+
+typedef int (*fun) ();
+typedef int (Empty::*memFun) ();
+
+#define TEST_AlignOf(type, alignment)                                       \
+    do {                                                                    \
+        TEST_AlignOf_impl(type, alignment);                                 \
+                                                                            \
+        TEST_AlignOf_impl(type &, alignment);                               \
+        TEST_AlignOf_RValueRef(type &&, alignment);                         \
+                                                                            \
+        TEST_AlignOf_impl(type [5], alignment);                             \
+        TEST_AlignOf_impl(type (&) [5], alignment);                         \
+                                                                            \
+        TEST_AlignOf_impl(AlignmentInStruct<type>, alignment);              \
+                                                                            \
+        /* Some internal sanity validation, just for fun */                 \
+        TEST_AlignOf_impl(AlignmentInStruct<type [5]>, alignment);          \
+        TEST_AlignOf_impl(AlignmentInStruct<type &>, Q_ALIGNOF(void *));    \
+        TEST_AlignOf_impl(AlignmentInStruct<type (&) [5]>,                  \
+                Q_ALIGNOF(void *));                                         \
+        TEST_AlignOf_RValueRef(AlignmentInStruct<type &&>,                  \
+                Q_ALIGNOF(void *));                                         \
+    } while (false)                                                         \
+    /**/
+
+#ifdef Q_COMPILER_RVALUE_REFS
+#define TEST_AlignOf_RValueRef(type, alignment) \
+        TEST_AlignOf_impl(type, alignment)
+#else
+#define TEST_AlignOf_RValueRef(type, alignment) do {} while (false)
+#endif
+
+#define TEST_AlignOf_impl(type, alignment) \
+    do { \
+        QCOMPARE(Q_ALIGNOF(type), size_t(alignment)); \
+        /* Compare to native operator for compilers that support it,
+           otherwise...  erm... check consistency! :-) */ \
+        QCOMPARE(QT_EMULATED_ALIGNOF(type), Q_ALIGNOF(type)); \
+    } while (false)
+    /**/
+
+void tst_QGlobal::qAlignOf()
+{
+    // Built-in types, except 64-bit integers and double
+    TEST_AlignOf(char, 1);
+    TEST_AlignOf(signed char, 1);
+    TEST_AlignOf(unsigned char, 1);
+    TEST_AlignOf(qint8, 1);
+    TEST_AlignOf(quint8, 1);
+    TEST_AlignOf(qint16, 2);
+    TEST_AlignOf(quint16, 2);
+    TEST_AlignOf(qint32, 4);
+    TEST_AlignOf(quint32, 4);
+    TEST_AlignOf(void *, sizeof(void *));
+
+    // Depends on platform and compiler, disabling test for now
+    // TEST_AlignOf(long double, 16);
+
+    // Empty struct
+    TEST_AlignOf(Empty, 1);
+
+    // Function pointers
+    TEST_AlignOf(fun, Q_ALIGNOF(void *));
+    TEST_AlignOf(memFun, Q_ALIGNOF(void *));
+
+
+    // 64-bit integers and double
+    TEST_AlignOf_impl(qint64, 8);
+    TEST_AlignOf_impl(quint64, 8);
+    TEST_AlignOf_impl(double, 8);
+
+    TEST_AlignOf_impl(qint64 &, 8);
+    TEST_AlignOf_impl(quint64 &, 8);
+    TEST_AlignOf_impl(double &, 8);
+
+    TEST_AlignOf_RValueRef(qint64 &&, 8);
+    TEST_AlignOf_RValueRef(quint64 &&, 8);
+    TEST_AlignOf_RValueRef(double &&, 8);
+
+    // 32-bit x86 ABI idiosyncrasies
+#if defined(Q_PROCESSOR_X86_32) && !defined(Q_OS_WIN)
+    TEST_AlignOf_impl(AlignmentInStruct<qint64>, 4);
+#else
+    TEST_AlignOf_impl(AlignmentInStruct<qint64>, 8);
+#endif
+
+    TEST_AlignOf_impl(AlignmentInStruct<quint64>, Q_ALIGNOF(AlignmentInStruct<qint64>));
+    TEST_AlignOf_impl(AlignmentInStruct<double>, Q_ALIGNOF(AlignmentInStruct<qint64>));
+
+    // 32-bit x86 ABI, Clang disagrees with gcc
+#if !defined(Q_PROCESSOR_X86_32) || !defined(Q_CC_CLANG)
+    TEST_AlignOf_impl(qint64 [5],       Q_ALIGNOF(qint64));
+#else
+    TEST_AlignOf_impl(qint64 [5],       Q_ALIGNOF(AlignmentInStruct<qint64>));
+#endif
+
+    TEST_AlignOf_impl(qint64 (&) [5],   Q_ALIGNOF(qint64 [5]));
+    TEST_AlignOf_impl(quint64 [5],      Q_ALIGNOF(quint64 [5]));
+    TEST_AlignOf_impl(quint64 (&) [5],  Q_ALIGNOF(quint64 [5]));
+    TEST_AlignOf_impl(double [5],       Q_ALIGNOF(double [5]));
+    TEST_AlignOf_impl(double (&) [5],   Q_ALIGNOF(double [5]));
+}
+
+#undef TEST_AlignOf
+#undef TEST_AlignOf_RValueRef
+#undef TEST_AlignOf_impl
+
 QTEST_MAIN(tst_QGlobal)
 #include "tst_qglobal.moc"
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 72ad3080d6..9f4944b44b 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -868,41 +868,15 @@ void tst_QMetaType::construct_data()
     create_data();
 }
 
-#ifndef Q_ALIGNOF
-template<uint N>
-struct RoundToNextHighestPowerOfTwo
-{
-private:
-    enum { V1 = N-1 };
-    enum { V2 = V1 | (V1 >> 1) };
-    enum { V3 = V2 | (V2 >> 2) };
-    enum { V4 = V3 | (V3 >> 4) };
-    enum { V5 = V4 | (V4 >> 8) };
-    enum { V6 = V5 | (V5 >> 16) };
-public:
-    enum { Value = V6 + 1 };
-};
-#endif
-
-template<class T>
-struct TypeAlignment
-{
-#ifdef Q_ALIGNOF
-    enum { Value = Q_ALIGNOF(T) };
-#else
-    enum { Value = RoundToNextHighestPowerOfTwo<sizeof(T)>::Value };
-#endif
-};
-
 template<int ID>
 static void testConstructHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
     QMetaType info(ID);
     int size = info.sizeOf();
-    void *storage1 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage1 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/0);
-    void *storage2 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage2 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual2 = info.construct(storage2, /*copy=*/0);
     QCOMPARE(actual1, storage1);
     QCOMPARE(actual2, storage2);
@@ -971,9 +945,9 @@ static void testConstructCopyHelper()
     QMetaType info(ID);
     int size = QMetaType::sizeOf(ID);
     QCOMPARE(info.sizeOf(), size);
-    void *storage1 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage1 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual1 = QMetaType::construct(ID, storage1, expected);
-    void *storage2 = qMallocAligned(size, TypeAlignment<Type>::Value);
+    void *storage2 = qMallocAligned(size, Q_ALIGNOF(Type));
     void *actual2 = info.construct(storage2, expected);
     QCOMPARE(actual1, storage1);
     QCOMPARE(actual2, storage2);