Fix strict aliasing violation in swap function

There might be platform where addressing the user provided array of unknown
alignment as `uint32_t` would be incorrect. Generally the previous code violates
strict aliasing and thus invokes UB. By using the "magic" properties of `memcpy`
we can sidestep the issue by letting it do the load and store for us. In
practice this means on platforms where addressing the memory as 4 byte regions
is safe and efficient to do - which is most widely used platforms - the compiler
can insert the appropriate `mov` instructions inline and if a platform does not
support this operation it will likely insert a call to the `memcpy` function.

Author: Voultapher

libc/src/stdlib/qsort_data.h

@@ -11,8 +11,6 @@
 
 #include "src/__support/CPP/cstddef.h"
 #include "src/__support/macros/config.h"
-#include "src/string/memory_utils/inline_memcpy.h"
-#include "src/string/memory_utils/inline_memmove.h"
 
 #include <stdint.h>
 
@@ -48,26 +46,23 @@ class ArrayGenericSize {
     using block_t = uint32_t;
     constexpr size_t BLOCK_SIZE = sizeof(block_t);
 
+    alignas(block_t) cpp::byte tmp_block[BLOCK_SIZE];
+
     cpp::byte *elem_i = get_internal(i);
     cpp::byte *elem_j = get_internal(j);
 
     const size_t elem_size_rem = elem_size % BLOCK_SIZE;
-    const block_t *elem_i_block_end =
-        reinterpret_cast<block_t *>(elem_i + (elem_size - elem_size_rem));
-
-    block_t *elem_i_block = reinterpret_cast<block_t *>(elem_i);
-    block_t *elem_j_block = reinterpret_cast<block_t *>(elem_j);
-
-    while (elem_i_block != elem_i_block_end) {
-      block_t tmp = *elem_i_block;
-      *elem_i_block = *elem_j_block;
-      *elem_j_block = tmp;
-      elem_i_block += 1;
-      elem_j_block += 1;
+    const cpp::byte *elem_i_block_end = elem_i + (elem_size - elem_size_rem);
+
+    while (elem_i != elem_i_block_end) {
+      __builtin_memcpy(tmp_block, elem_i, BLOCK_SIZE);
+      __builtin_memcpy(elem_i, elem_j, BLOCK_SIZE);
+      __builtin_memcpy(elem_j, tmp_block, BLOCK_SIZE);
+
+      elem_i += BLOCK_SIZE;
+      elem_j += BLOCK_SIZE;
     }
 
-    elem_i = reinterpret_cast<cpp::byte *>(elem_i_block);
-    elem_j = reinterpret_cast<cpp::byte *>(elem_j_block);
     for (size_t n = 0; n < elem_size_rem; ++n) {
       cpp::byte tmp = elem_i[n];
       elem_i[n] = elem_j[n];
@@ -118,9 +113,9 @@ template <size_t ELEM_SIZE> class ArrayFixedSize {
     cpp::byte *elem_i = get_internal(i);
     cpp::byte *elem_j = get_internal(j);
 
-    inline_memcpy(tmp, elem_i, ELEM_SIZE);
-    inline_memmove(elem_i, elem_j, ELEM_SIZE);
-    inline_memcpy(elem_j, tmp, ELEM_SIZE);
+    __builtin_memcpy(tmp, elem_i, ELEM_SIZE);
+    __builtin_memmove(elem_i, elem_j, ELEM_SIZE);
+    __builtin_memcpy(elem_j, tmp, ELEM_SIZE);
   }
 
   LIBC_INLINE size_t len() const { return array_len; }