Moving byte order/memory access to poly.

src/poly/byte_order.h

@@ -0,0 +1,61 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef POLY_BYTE_ORDER_H_
+#define POLY_BYTE_ORDER_H_
+
+#include <cstdint>
+
+#include <poly/config.h>
+#include <poly/platform.h>
+
+#if XE_LIKE_OSX
+#include <libkern/OSByteOrder.h>
+#endif  // XE_LIKE_OSX
+
+namespace poly {
+
+#if XE_COMPILER_MSVC
+#define POLY_BYTE_SWAP_16 _byteswap_ushort
+#define POLY_BYTE_SWAP_32 _byteswap_ulong
+#define POLY_BYTE_SWAP_64 _byteswap_uint64
+#elif XE_LIKE_OSX
+#define POLY_BYTE_SWAP_16 OSSwapInt16
+#define POLY_BYTE_SWAP_32 OSSwapInt32
+#define POLY_BYTE_SWAP_64 OSSwapInt64
+#else
+#define POLY_BYTE_SWAP_16 __bswap_16
+#define POLY_BYTE_SWAP_32 __bswap_32
+#define POLY_BYTE_SWAP_64 __bswap_64
+#endif  // XE_COMPILER_MSVC
+
+inline int16_t byte_swap(int16_t value) {
+  return static_cast<int16_t>(POLY_BYTE_SWAP_16(static_cast<int16_t>(value)));
+}
+inline uint16_t byte_swap(uint16_t value) { return POLY_BYTE_SWAP_16(value); }
+inline int32_t byte_swap(int32_t value) {
+  return static_cast<int32_t>(POLY_BYTE_SWAP_32(static_cast<int32_t>(value)));
+}
+inline uint32_t byte_swap(uint32_t value) { return POLY_BYTE_SWAP_32(value); }
+inline int64_t byte_swap(int64_t value) {
+  return static_cast<int64_t>(POLY_BYTE_SWAP_64(static_cast<int64_t>(value)));
+}
+inline uint64_t byte_swap(uint64_t value) { return POLY_BYTE_SWAP_64(value); }
+inline float byte_swap(float value) {
+  uint32_t temp = byte_swap(*reinterpret_cast<uint32_t *>(&value));
+  return *reinterpret_cast<float *>(&temp);
+}
+inline double byte_swap(double value) {
+  uint64_t temp = byte_swap(*reinterpret_cast<uint64_t *>(&value));
+  return *reinterpret_cast<double *>(&temp);
+}
+
+}  // namespace poly
+
+#endif  // POLY_BYTE_ORDER_H_

src/poly/memory.h

@@ -10,13 +10,184 @@
 #ifndef POLY_MEMORY_H_
 #define POLY_MEMORY_H_
 
-#include <poly/config.h>
-#include <poly/platform.h>
+#include <poly/byte_order.h>
 
 namespace poly {
 
 size_t page_size();
 
+template <typename T>
+T load(const void* mem);
+template <>
+inline int8_t load<int8_t>(const void* mem) {
+  return *reinterpret_cast<const int8_t*>(mem);
+}
+template <>
+inline uint8_t load<uint8_t>(const void* mem) {
+  return *reinterpret_cast<const uint8_t*>(mem);
+}
+template <>
+inline int16_t load<int16_t>(const void* mem) {
+  return *reinterpret_cast<const int16_t*>(mem);
+}
+template <>
+inline uint16_t load<uint16_t>(const void* mem) {
+  return *reinterpret_cast<const uint16_t*>(mem);
+}
+template <>
+inline int32_t load<int32_t>(const void* mem) {
+  return *reinterpret_cast<const int32_t*>(mem);
+}
+template <>
+inline uint32_t load<uint32_t>(const void* mem) {
+  return *reinterpret_cast<const uint32_t*>(mem);
+}
+template <>
+inline int64_t load<int64_t>(const void* mem) {
+  return *reinterpret_cast<const int64_t*>(mem);
+}
+template <>
+inline uint64_t load<uint64_t>(const void* mem) {
+  return *reinterpret_cast<const uint64_t*>(mem);
+}
+template <>
+inline float load<float>(const void* mem) {
+  return *reinterpret_cast<const float*>(mem);
+}
+template <>
+inline double load<double>(const void* mem) {
+  return *reinterpret_cast<const double*>(mem);
+}
+
+template <typename T>
+T load_and_swap(const void* mem);
+template <>
+inline int8_t load_and_swap<int8_t>(const void* mem) {
+  return *reinterpret_cast<const int8_t*>(mem);
+}
+template <>
+inline uint8_t load_and_swap<uint8_t>(const void* mem) {
+  return *reinterpret_cast<const uint8_t*>(mem);
+}
+template <>
+inline int16_t load_and_swap<int16_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const int16_t*>(mem));
+}
+template <>
+inline uint16_t load_and_swap<uint16_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const uint16_t*>(mem));
+}
+template <>
+inline int32_t load_and_swap<int32_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const int32_t*>(mem));
+}
+template <>
+inline uint32_t load_and_swap<uint32_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const uint32_t*>(mem));
+}
+template <>
+inline int64_t load_and_swap<int64_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const int64_t*>(mem));
+}
+template <>
+inline uint64_t load_and_swap<uint64_t>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const uint64_t*>(mem));
+}
+template <>
+inline float load_and_swap<float>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const float*>(mem));
+}
+template <>
+inline double load_and_swap<double>(const void* mem) {
+  return byte_swap(*reinterpret_cast<const double*>(mem));
+}
+
+template <typename T>
+void store(void* mem, T value);
+template <>
+inline void store<int8_t>(void* mem, int8_t value) {
+  *reinterpret_cast<int8_t*>(mem) = value;
+}
+template <>
+inline void store<uint8_t>(void* mem, uint8_t value) {
+  *reinterpret_cast<uint8_t*>(mem) = value;
+}
+template <>
+inline void store<int16_t>(void* mem, int16_t value) {
+  *reinterpret_cast<int16_t*>(mem) = value;
+}
+template <>
+inline void store<uint16_t>(void* mem, uint16_t value) {
+  *reinterpret_cast<uint16_t*>(mem) = value;
+}
+template <>
+inline void store<int32_t>(void* mem, int32_t value) {
+  *reinterpret_cast<int32_t*>(mem) = value;
+}
+template <>
+inline void store<uint32_t>(void* mem, uint32_t value) {
+  *reinterpret_cast<uint32_t*>(mem) = value;
+}
+template <>
+inline void store<int64_t>(void* mem, int64_t value) {
+  *reinterpret_cast<int64_t*>(mem) = value;
+}
+template <>
+inline void store<uint64_t>(void* mem, uint64_t value) {
+  *reinterpret_cast<uint64_t*>(mem) = value;
+}
+template <>
+inline void store<float>(void* mem, float value) {
+  *reinterpret_cast<float*>(mem) = value;
+}
+template <>
+inline void store<double>(void* mem, double value) {
+  *reinterpret_cast<double*>(mem) = value;
+}
+
+template <typename T>
+void store_and_swap(void* mem, T value);
+template <>
+inline void store_and_swap<int8_t>(void* mem, int8_t value) {
+  *reinterpret_cast<int8_t*>(mem) = value;
+}
+template <>
+inline void store_and_swap<uint8_t>(void* mem, uint8_t value) {
+  *reinterpret_cast<uint8_t*>(mem) = value;
+}
+template <>
+inline void store_and_swap<int16_t>(void* mem, int16_t value) {
+  *reinterpret_cast<int16_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<uint16_t>(void* mem, uint16_t value) {
+  *reinterpret_cast<uint16_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<int32_t>(void* mem, int32_t value) {
+  *reinterpret_cast<int32_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<uint32_t>(void* mem, uint32_t value) {
+  *reinterpret_cast<uint32_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<int64_t>(void* mem, int64_t value) {
+  *reinterpret_cast<int64_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<uint64_t>(void* mem, uint64_t value) {
+  *reinterpret_cast<uint64_t*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<float>(void* mem, float value) {
+  *reinterpret_cast<float*>(mem) = byte_swap(value);
+}
+template <>
+inline void store_and_swap<double>(void* mem, double value) {
+  *reinterpret_cast<double*>(mem) = byte_swap(value);
+}
+
 }  // namespace poly
 
 #endif  // POLY_MEMORY_H_

src/poly/poly.h

@@ -12,6 +12,7 @@
 
 #include <poly/assert.h>
 #include <poly/atomic.h>
+#include <poly/byte_order.h>
 #include <poly/config.h>
 #include <poly/cxx_compat.h>
 #include <poly/math.h>

src/poly/sources.gypi

@@ -3,6 +3,7 @@
   'sources': [
     'assert.h',
     'atomic.h',
+    'byte_order.h',
     'config.h',
     'cxx_compat.h',
     'math.cc',