X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fsim%2Fbyteswap.hh;h=3a0f7ce8ae440c00b55c4691fc3d6f945431e8b2;hb=0ed3c84c7b05d7d3c9d5f0e3f1c05c20afef93b9;hp=7b1ae701e3933115cde88995d2344bb5bcce5f44;hpb=21cf4a46b9e9ce52266aac873aa107cad82cc847;p=gem5.git diff --git a/src/sim/byteswap.hh b/src/sim/byteswap.hh index 7b1ae701e..3a0f7ce8a 100644 --- a/src/sim/byteswap.hh +++ b/src/sim/byteswap.hh @@ -37,8 +37,9 @@ #ifndef __SIM_BYTE_SWAP_HH__ #define __SIM_BYTE_SWAP_HH__ +#include "base/bigint.hh" #include "base/misc.hh" -#include "sim/host.hh" +#include "base/types.hh" // This lets us figure out what the byte order of the host system is #if defined(linux) @@ -47,7 +48,7 @@ // If one doesn't exist, we pretty much get what is listed below, so it all // works out #include -#elif defined (__sun__) +#elif defined (__sun) #include #else #include @@ -57,9 +58,11 @@ #include #endif +enum ByteOrder {BigEndianByteOrder, LittleEndianByteOrder}; + //These functions actually perform the swapping for parameters //of various bit lengths -static inline uint64_t +inline uint64_t swap_byte64(uint64_t x) { #if defined(linux) @@ -78,7 +81,7 @@ swap_byte64(uint64_t x) #endif } -static inline uint32_t +inline uint32_t swap_byte32(uint32_t x) { #if defined(linux) @@ -92,7 +95,7 @@ swap_byte32(uint32_t x) #endif } -static inline uint16_t +inline uint16_t swap_byte16(uint16_t x) { #if defined(linux) @@ -107,10 +110,10 @@ swap_byte16(uint16_t x) // This function lets the compiler figure out how to call the // swap_byte functions above for different data types. Since the -// sizeof() values are known at compiel time, it should inline to a +// sizeof() values are known at compile time, it should inline to a // direct call to the right swap_byteNN() function. template -static inline T swap_byte(T x) { +inline T swap_byte(T x) { if (sizeof(T) == 8) return swap_byte64((uint64_t)x); else if (sizeof(T) == 4) @@ -123,56 +126,76 @@ static inline T swap_byte(T x) { panic("Can't byte-swap values larger than 64 bits"); } +template<> +inline Twin64_t swap_byte(Twin64_t x) +{ + x.a = swap_byte(x.a); + x.b = swap_byte(x.b); + return x; +} + +template<> +inline Twin32_t swap_byte(Twin32_t x) +{ + x.a = swap_byte(x.a); + x.b = swap_byte(x.b); + return x; +} + //The conversion functions with fixed endianness on both ends don't need to //be in a namespace -template static inline T betole(T value) {return swap_byte(value);} -template static inline T letobe(T value) {return swap_byte(value);} +template inline T betole(T value) {return swap_byte(value);} +template 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 -template static inline T htole(T value) {return swap_byte(value);} -template static inline T letoh(T value) {return swap_byte(value);} -template static inline T htobe(T value) {return value;} -template static inline T betoh(T value) {return value;} +#if defined(_BIG_ENDIAN) || !defined(_LITTLE_ENDIAN) && BYTE_ORDER == BIG_ENDIAN +const ByteOrder HostByteOrder = BigEndianByteOrder; +template inline T htole(T value) {return swap_byte(value);} +template inline T letoh(T value) {return swap_byte(value);} +template inline T htobe(T value) {return value;} +template inline T betoh(T value) {return value;} #elif defined(_LITTLE_ENDIAN) || BYTE_ORDER == LITTLE_ENDIAN -template static inline T htole(T value) {return value;} -template static inline T letoh(T value) {return value;} -template static inline T htobe(T value) {return swap_byte(value);} -template static inline T betoh(T value) {return swap_byte(value);} +const ByteOrder HostByteOrder = LittleEndianByteOrder; +template inline T htole(T value) {return value;} +template inline T letoh(T value) {return value;} +template inline T htobe(T value) {return swap_byte(value);} +template inline T betoh(T value) {return swap_byte(value);} #else #error Invalid Endianess #endif namespace BigEndianGuest { - template - static inline T gtole(T value) {return betole(value);} - template - static inline T letog(T value) {return letobe(value);} - template - static inline T gtobe(T value) {return value;} - template - static inline T betog(T value) {return value;} - template - static inline T htog(T value) {return htobe(value);} - template - static inline T gtoh(T value) {return betoh(value);} + const ByteOrder GuestByteOrder = BigEndianByteOrder; + template + inline T gtole(T value) {return betole(value);} + template + inline T letog(T value) {return letobe(value);} + template + inline T gtobe(T value) {return value;} + template + inline T betog(T value) {return value;} + template + inline T htog(T value) {return htobe(value);} + template + inline T gtoh(T value) {return betoh(value);} } namespace LittleEndianGuest { - template - static inline T gtole(T value) {return value;} - template - static inline T letog(T value) {return value;} - template - static inline T gtobe(T value) {return letobe(value);} - template - static inline T betog(T value) {return betole(value);} - template - static inline T htog(T value) {return htole(value);} - template - static inline T gtoh(T value) {return letoh(value);} + const ByteOrder GuestByteOrder = LittleEndianByteOrder; + template + inline T gtole(T value) {return value;} + template + inline T letog(T value) {return value;} + template + inline T gtobe(T value) {return letobe(value);} + template + inline T betog(T value) {return betole(value);} + template + inline T htog(T value) {return htole(value);} + template + inline T gtoh(T value) {return letoh(value);} } #endif // __SIM_BYTE_SWAP_HH__