From 540978288ea0f6ed0b166bb9207f427a4c825ab6 Mon Sep 17 00:00:00 2001
From: Thiago Macieira <thiago.macieira@intel.com>
Date: Tue, 15 Mar 2016 10:10:12 -0700
Subject: Replace qUnaligned{Load,Store} with the existing q{To,From}Unaligned

Move the Q_ALWAYS_INLINE and forcing of __builtin_memcpy to the existing
functions.

Change-Id: Icaa7fb2a490246bda156ffff143c137e520eea79
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
---
 src/corelib/global/qendian.h    | 30 ++++++++++++++++++++----------
 src/corelib/global/qendian.qdoc | 23 +++++++++++++++++++++++
 2 files changed, 43 insertions(+), 10 deletions(-)

(limited to 'src/corelib/global')

diff --git a/src/corelib/global/qendian.h b/src/corelib/global/qendian.h
index 2ddefaec8b..23dda270e3 100644
--- a/src/corelib/global/qendian.h
+++ b/src/corelib/global/qendian.h
@@ -42,6 +42,11 @@
 
 QT_BEGIN_NAMESPACE
 
+#ifdef __has_builtin
+#  define QT_HAS_BUILTIN(x)     __has_builtin(x)
+#else
+#  define QT_HAS_BUILTIN(x)     0
+#endif
 
 /*
  * ENDIAN FUNCTIONS
@@ -64,18 +69,29 @@ template <typename T> inline void qbswap(const T src, uchar *dest)
 
 // Used to implement a type-safe and alignment-safe copy operation
 // If you want to avoid the memcpy, you must write specializations for these functions
-template <typename T> inline void qToUnaligned(const T src, uchar *dest)
+template <typename T> Q_ALWAYS_INLINE void qToUnaligned(const T src, uchar *dest)
 {
     // Using sizeof(T) inside memcpy function produces internal compiler error with
     // MSVC2008/ARM in tst_endian -> use extra indirection to resolve size of T.
     const size_t size = sizeof(T);
-    memcpy(dest, &src, size);
+#if QT_HAS_BUILTIN(__builtin_memcpy)
+    __builtin_memcpy
+#else
+    memcpy
+#endif
+            (dest, &src, size);
 }
-template <typename T> inline T qFromUnaligned(const uchar *src)
+
+template <typename T> Q_ALWAYS_INLINE T qFromUnaligned(const uchar *src)
 {
     T dest;
     const size_t size = sizeof(T);
-    memcpy(&dest, src, size);
+#if QT_HAS_BUILTIN(__builtin_memcpy)
+    __builtin_memcpy
+#else
+    memcpy
+#endif
+            (&dest, src, size);
     return dest;
 }
 
@@ -87,12 +103,6 @@ template <typename T> inline T qFromUnaligned(const uchar *src)
 */
 template <typename T> T qbswap(T source);
 
-#ifdef __has_builtin
-#  define QT_HAS_BUILTIN(x)     __has_builtin(x)
-#else
-#  define QT_HAS_BUILTIN(x)     0
-#endif
-
 // GCC 4.3 implemented all the intrinsics, but the 16-bit one only got implemented in 4.8;
 // Clang 2.6 implemented the 32- and 64-bit but waited until 3.2 to implement the 16-bit one
 #if (defined(Q_CC_GNU) && Q_CC_GNU >= 403) || QT_HAS_BUILTIN(__builtin_bswap32)
diff --git a/src/corelib/global/qendian.qdoc b/src/corelib/global/qendian.qdoc
index e110461f8b..b7494c9a21 100644
--- a/src/corelib/global/qendian.qdoc
+++ b/src/corelib/global/qendian.qdoc
@@ -33,6 +33,29 @@
     little and big endian representations of numbers.
 */
 
+/*!
+    \internal
+    \fn T qFromUnaligned(const uchar *ptr)
+    \since 5.5
+
+    Loads a \c{T} from address \a ptr, which may be misaligned.
+
+    Use of this function avoids the undefined behavior that the C++ standard
+    otherwise attributes to unaligned loads.
+*/
+
+/*!
+    \internal
+    \fn void qToUnaligned(T t, uchar *ptr)
+    \since 4.5
+
+    Stores \a t to address \a ptr, which may be misaligned.
+
+    Use of this function avoids the undefined behavior that the C++ standard
+    otherwise attributes to unaligned stores.
+*/
+
+
 /*!
     \fn T qFromBigEndian(const uchar *src)
     \since 4.3
-- 
cgit v1.2.3