Cleanup byte swapping utilities to generate optimal code on the platforms we care about. (pytorch#11394)

Summary:
While the use of memcpy as part of the byte swapping sequence looks funky, all major
compilers recognize and optimize this pattern reliably, resulting in essentially
optimal code generation.

For example, decodeUInt32LE goes from this on iOS arm64:
>         ldrb    w8, [x0, #3]
>         ldrb    w9, [x0, #2]
>         bfi     w8, w9, #8, #8
>         ldrb    w9, [x0, #1]
>         bfi     w8, w9, #16, #8
>         ldrb            w9, [x0]
>         bfi     w8, w9, #24, #8
>         mov      x0, x8
>         ret

To this:
>         ldr             w8, [x0]
>         rev     w0, w8
>         ret
Pull Request resolved: pytorch#11394

Reviewed By: SsnL

Differential Revision: D9728659

Pulled By: resistor

fbshipit-source-id: 9afbd4adfad1d1fb7b01f1179e6707ee21fa726f

Author: Owen Anderson

torch/csrc/byte_order.cpp

@@ -2,34 +2,94 @@
 
 #include <string.h>
 
+#if defined(_MSC_VER)
+#include <stdlib.h>
+#endif
+
+static inline void swapBytes16(void *ptr)
+{
+  uint16_t output;
+  memcpy(&output, ptr, sizeof(uint16_t));
+#if defined(_MSC_VER) && !defined(_DEBUG)
+  output = _byteswap_ushort(output);
+#elif defined(__llvm__) || defined(__GNUC__) && !defined(__ICC)
+  output = __builtin_bswap16(output);
+#else
+  uint16_t Hi = output >> 8;
+  uint16_t Lo = output << 8;
+  output = Hi | Lo;
+#endif
+  memcpy(ptr, &output, sizeof(uint16_t));
+}
+
+static inline void swapBytes32(void *ptr)
+{
+  uint32_t output;
+  memcpy(&output, ptr, sizeof(uint32_t));
+#if defined(_MSC_VER) && !defined(_DEBUG)
+  output = _byteswap_ulong(output);
+#elif defined(__llvm__) || defined(__GNUC__) && !defined(__ICC)
+  output = __builtin_bswap32(output);
+#else
+   uint32_t Byte0 = output & 0x000000FF;
+   uint32_t Byte1 = output & 0x0000FF00;
+   uint32_t Byte2 = output & 0x00FF0000;
+   uint32_t Byte3 = output & 0xFF000000;
+   output = (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
+#endif
+  memcpy(ptr, &output, sizeof(uint32_t));
+}
+
+static inline void swapBytes64(void *ptr)
+{
+  uint64_t output;
+  memcpy(&output, ptr, sizeof(uint64_t));
+#if defined(_MSC_VER) && !defined(_DEBUG)
+  output = _byteswap_uint64(output);
+#elif defined(__llvm__) || defined(__GNUC__) && !defined(__ICC)
+  output = __builtin_bswap64(output);
+#else
+   uint64_t Hi = SwapByteOrder_32(uint32_t(value));
+   uint32_t Lo = SwapByteOrder_32(uint32_t(value >> 32));
+   return (Hi << 32) | Lo;
+#endif
+  memcpy(ptr, &output, sizeof(uint64_t));
+}
+
 static inline uint16_t decodeUInt16LE(const uint8_t *data) {
-  return (data[0]<<0) | (data[1]<<8);
+  uint16_t output;
+  memcpy(&output, data, sizeof(uint16_t));
+  return output;
 }
 
 static inline uint16_t decodeUInt16BE(const uint8_t *data) {
-  return (data[1]<<0) | (data[0]<<8);
+  uint16_t output = decodeUInt16LE(data);
+  swapBytes16(&output);
+  return output;
 }
 
 static inline uint32_t decodeUInt32LE(const uint8_t *data) {
-  return (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
+  uint32_t output;
+  memcpy(&output, data, sizeof(uint32_t));
+  return output;
 }
 
 static inline uint32_t decodeUInt32BE(const uint8_t *data) {
-  return (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24);
+  uint32_t output = decodeUInt32LE(data);
+  swapBytes32(&output);
+  return output;
 }
 
 static inline uint64_t decodeUInt64LE(const uint8_t *data) {
-  return (((uint64_t)data[0])<< 0) | (((uint64_t)data[1])<< 8) |
-         (((uint64_t)data[2])<<16) | (((uint64_t)data[3])<<24) |
-         (((uint64_t)data[4])<<32) | (((uint64_t)data[5])<<40) |
-         (((uint64_t)data[6])<<48) | (((uint64_t)data[7])<<56);
+  uint64_t output;
+  memcpy(&output, data, sizeof(uint64_t));
+  return output;
 }
 
 static inline uint64_t decodeUInt64BE(const uint8_t *data) {
-  return (((uint64_t)data[7])<< 0) | (((uint64_t)data[6])<< 8) |
-         (((uint64_t)data[5])<<16) | (((uint64_t)data[4])<<24) |
-         (((uint64_t)data[3])<<32) | (((uint64_t)data[2])<<40) |
-         (((uint64_t)data[1])<<48) | (((uint64_t)data[0])<<56);
+  uint64_t output = decodeUInt64LE(data);
+  swapBytes64(&output);
+  return output;
 }
 
 THPByteOrder THP_nativeByteOrder()
@@ -92,24 +152,12 @@ void THP_decodeDoubleBuffer(double* dst, const uint8_t* src, THPByteOrder order,
   }
 }
 
-template<size_t size>
-static void swapBytes(uint8_t *ptr)
-{
-  uint8_t tmp;
-  for (size_t i = 0; i < size / 2; i++) {
-    tmp = ptr[i];
-    ptr[i] = ptr[size-i];
-    ptr[size-i] = tmp;
-  }
-}
-
-
 void THP_encodeInt16Buffer(uint8_t* dst, const int16_t* src, THPByteOrder order, size_t len)
 {
   memcpy(dst, src, sizeof(int16_t) * len);
   if (order != THP_nativeByteOrder()) {
     for (size_t i = 0; i < len; i++) {
-      swapBytes<sizeof(int16_t)>(dst);
+      swapBytes16(dst);
       dst += sizeof(int16_t);
     }
   }
@@ -120,7 +168,7 @@ void THP_encodeInt32Buffer(uint8_t* dst, const int32_t* src, THPByteOrder order,
   memcpy(dst, src, sizeof(int32_t) * len);
   if (order != THP_nativeByteOrder()) {
     for (size_t i = 0; i < len; i++) {
-      swapBytes<sizeof(int32_t)>(dst);
+      swapBytes32(dst);
       dst += sizeof(int32_t);
     }
   }
@@ -131,7 +179,7 @@ void THP_encodeInt64Buffer(uint8_t* dst, const int64_t* src, THPByteOrder order,
   memcpy(dst, src, sizeof(int64_t) * len);
   if (order != THP_nativeByteOrder()) {
     for (size_t i = 0; i < len; i++) {
-      swapBytes<sizeof(int64_t)>(dst);
+      swapBytes64(dst);
       dst += sizeof(int64_t);
     }
   }
@@ -142,7 +190,7 @@ void THP_encodeFloatBuffer(uint8_t* dst, const float* src, THPByteOrder order, s
   memcpy(dst, src, sizeof(float) * len);
   if (order != THP_nativeByteOrder()) {
     for (size_t i = 0; i < len; i++) {
-      swapBytes<sizeof(float)>(dst);
+      swapBytes32(dst);
       dst += sizeof(float);
     }
   }
@@ -153,7 +201,7 @@ void THP_encodeDoubleBuffer(uint8_t* dst, const double* src, THPByteOrder order,
   memcpy(dst, src, sizeof(double) * len);
   if (order != THP_nativeByteOrder()) {
     for (size_t i = 0; i < len; i++) {
-      swapBytes<sizeof(double)>(dst);
+      swapBytes64(dst);
       dst += sizeof(double);
     }
   }