From 569e0e883bf1f2d068cc0591b59998d956a8669f Mon Sep 17 00:00:00 2001
From: Gabe Black <gblack@eecs.umich.edu>
Date: Sat, 16 Dec 2006 07:37:33 -0500
Subject: [PATCH] Add in constants which let you explicitly check if endian
 conversion would do anything. This was needed for a case where a piece of
 data was within a larger data type. When the larger data type was swapped,
 the location of the smaller data type would move.

--HG--
extra : convert_revision : 4c904c964678529c72b8f1044dfcb400604f6654
---
 src/sim/byteswap.hh | 54 +++++++++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 24 deletions(-)

diff --git a/src/sim/byteswap.hh b/src/sim/byteswap.hh
index 7b1ae701e..7b63cf6e0 100644
--- a/src/sim/byteswap.hh
+++ b/src/sim/byteswap.hh
@@ -57,6 +57,8 @@
 #include <libkern/OSByteOrder.h>
 #endif
 
+enum ByteOrder {BigEndianByteOrder, LittleEndianByteOrder};
+
 //These functions actually perform the swapping for parameters
 //of various bit lengths
 static inline uint64_t
@@ -131,11 +133,13 @@ template <typename T> static inline T letobe(T value) {return swap_byte(value);}
 //For conversions not involving the guest system, we can define the functions
 //conditionally based on the BYTE_ORDER macro and outside of the namespaces
 #if defined(_BIG_ENDIAN) || BYTE_ORDER == BIG_ENDIAN
+const ByteOrder HostByteOrder = BigEndianByteOrder;
 template <typename T> static inline T htole(T value) {return swap_byte(value);}
 template <typename T> static inline T letoh(T value) {return swap_byte(value);}
 template <typename T> static inline T htobe(T value) {return value;}
 template <typename T> static inline T betoh(T value) {return value;}
 #elif defined(_LITTLE_ENDIAN) || BYTE_ORDER == LITTLE_ENDIAN
+const ByteOrder HostByteOrder = LittleEndianByteOrder;
 template <typename T> static inline T htole(T value) {return value;}
 template <typename T> static inline T letoh(T value) {return value;}
 template <typename T> static inline T htobe(T value) {return swap_byte(value);}
@@ -146,33 +150,35 @@ template <typename T> static inline T betoh(T value) {return swap_byte(value);}
 
 namespace BigEndianGuest
 {
-        template <typename T>
-        static inline T gtole(T value) {return betole(value);}
-        template <typename T>
-        static inline T letog(T value) {return letobe(value);}
-        template <typename T>
-        static inline T gtobe(T value) {return value;}
-        template <typename T>
-        static inline T betog(T value) {return value;}
-        template <typename T>
-        static inline T htog(T value) {return htobe(value);}
-        template <typename T>
-        static inline T gtoh(T value) {return betoh(value);}
+    const bool ByteOrderDiffers = (HostByteOrder != BigEndianByteOrder);
+    template <typename T>
+    static inline T gtole(T value) {return betole(value);}
+    template <typename T>
+    static inline T letog(T value) {return letobe(value);}
+    template <typename T>
+    static inline T gtobe(T value) {return value;}
+    template <typename T>
+    static inline T betog(T value) {return value;}
+    template <typename T>
+    static inline T htog(T value) {return htobe(value);}
+    template <typename T>
+    static inline T gtoh(T value) {return betoh(value);}
 }
 
 namespace LittleEndianGuest
 {
-        template <typename T>
-        static inline T gtole(T value) {return value;}
-        template <typename T>
-        static inline T letog(T value) {return value;}
-        template <typename T>
-        static inline T gtobe(T value) {return letobe(value);}
-        template <typename T>
-        static inline T betog(T value) {return betole(value);}
-        template <typename T>
-        static inline T htog(T value) {return htole(value);}
-        template <typename T>
-        static inline T gtoh(T value) {return letoh(value);}
+    const bool ByteOrderDiffers = (HostByteOrder != LittleEndianByteOrder);
+    template <typename T>
+    static inline T gtole(T value) {return value;}
+    template <typename T>
+    static inline T letog(T value) {return value;}
+    template <typename T>
+    static inline T gtobe(T value) {return letobe(value);}
+    template <typename T>
+    static inline T betog(T value) {return betole(value);}
+    template <typename T>
+    static inline T htog(T value) {return htole(value);}
+    template <typename T>
+    static inline T gtoh(T value) {return letoh(value);}
 }
 #endif // __SIM_BYTE_SWAP_HH__
-- 
2.30.2