[Memory] Fix alignment to 16 bytes

Fix segmentation fault happening on linux when `src` or `dst` is not aligned to
16 bytes.
Assert against use of `src_ptr` and `dest_ptr` which are not unaligned by the
same amount of bits.
Grab all of words/dwords which are unaligned with 16 bytes.

Author: bwrsandman

src/xenia/base/memory.cc

@@ -27,14 +27,18 @@ void copy_128_aligned(void* dest, const void* src, size_t count) {
 void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
   assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x1);
+  assert_true((reinterpret_cast<uintptr_t>(src_ptr) & 0xF) ==
+              (reinterpret_cast<uintptr_t>(dest_ptr) & 0xF));
   auto dest = reinterpret_cast<uint16_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint16_t*>(src_ptr);
   __m128i shufmask =
       _mm_set_epi8(0x0E, 0x0F, 0x0C, 0x0D, 0x0A, 0x0B, 0x08, 0x09, 0x06, 0x07,
                    0x04, 0x05, 0x02, 0x03, 0x00, 0x01);
 
   size_t i = 0;
-  size_t unaligned_words = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 2;
+  size_t unaligned_words =
+      ((0x10 - (reinterpret_cast<uintptr_t>(src_ptr) & 0xF)) & 0xF) /
+      sizeof(uint16_t);
   for (; unaligned_words > 0 && i < count; unaligned_words--, i++) {
     // Copy up to 16 byte alignment.
     dest[i] = byte_swap(src[i]);
@@ -71,14 +75,18 @@ void copy_and_swap_16_unaligned(void* dest_ptr, const void* src_ptr,
 void copy_and_swap_32_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
   assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x3);
+  assert_true((reinterpret_cast<uintptr_t>(src_ptr) & 0xF) ==
+              (reinterpret_cast<uintptr_t>(dest_ptr) & 0xF));
   auto dest = reinterpret_cast<uint32_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint32_t*>(src_ptr);
   __m128i shufmask =
       _mm_set_epi8(0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B, 0x04, 0x05,
                    0x06, 0x07, 0x00, 0x01, 0x02, 0x03);
 
   size_t i = 0;
-  size_t unaligned_dwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 4;
+  size_t unaligned_dwords =
+      ((0x10 - (reinterpret_cast<uintptr_t>(src_ptr) & 0xF)) & 0xF) /
+      sizeof(uint32_t);
   for (; unaligned_dwords > 0 && i < count; unaligned_dwords--, i++) {
     // Copy up to 16 byte alignment.
     dest[i] = byte_swap(src[i]);
@@ -115,14 +123,17 @@ void copy_and_swap_32_unaligned(void* dest_ptr, const void* src_ptr,
 void copy_and_swap_64_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
   assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x7);
+  assert_true((reinterpret_cast<uintptr_t>(src_ptr) & 0xF) ==
+              (reinterpret_cast<uintptr_t>(dest_ptr) & 0xF));
   auto dest = reinterpret_cast<uint64_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint64_t*>(src_ptr);
   __m128i shufmask =
       _mm_set_epi8(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01,
                    0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
 
   size_t i = 0;
-  size_t unaligned_qwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 8;
+  size_t unaligned_qwords =
+      (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / sizeof(uint64_t);
   for (; unaligned_qwords > 0 && i < count; unaligned_qwords--, i++) {
     // Copy up to 16 byte alignment.
     dest[i] = byte_swap(src[i]);