1 //===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file declares generic and optimized functions to swap the byte order of 10 // an integral type. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_SUPPORT_SWAPBYTEORDER_H 15 #define LLVM_SUPPORT_SWAPBYTEORDER_H 16 17 #include "llvm/ADT/bit.h" 18 #include <cstddef> 19 #include <cstdint> 20 #include <type_traits> 21 22 #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) || \ 23 defined(__Fuchsia__) || defined(__EMSCRIPTEN__) 24 #include <endian.h> 25 #elif defined(_AIX) 26 #include <sys/machine.h> 27 #elif defined(__sun) 28 /* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */ 29 #include <sys/types.h> 30 #define BIG_ENDIAN 4321 31 #define LITTLE_ENDIAN 1234 32 #if defined(_BIG_ENDIAN) 33 #define BYTE_ORDER BIG_ENDIAN 34 #else 35 #define BYTE_ORDER LITTLE_ENDIAN 36 #endif 37 #elif defined(__MVS__) 38 #define BIG_ENDIAN 4321 39 #define LITTLE_ENDIAN 1234 40 #define BYTE_ORDER BIG_ENDIAN 41 #else 42 #if !defined(BYTE_ORDER) && !defined(_WIN32) 43 #include <machine/endian.h> 44 #endif 45 #endif 46 47 namespace llvm { 48 49 /// ByteSwap_16 - This function returns a byte-swapped representation of 50 /// the 16-bit argument. 51 inline uint16_t ByteSwap_16(uint16_t value) { return llvm::byteswap(value); } 52 53 /// This function returns a byte-swapped representation of the 32-bit argument. 54 inline uint32_t ByteSwap_32(uint32_t value) { return llvm::byteswap(value); } 55 56 /// This function returns a byte-swapped representation of the 64-bit argument. 57 inline uint64_t ByteSwap_64(uint64_t value) { return llvm::byteswap(value); } 58 59 namespace sys { 60 61 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN 62 constexpr bool IsBigEndianHost = true; 63 #else 64 constexpr bool IsBigEndianHost = false; 65 #endif 66 67 static const bool IsLittleEndianHost = !IsBigEndianHost; 68 69 inline unsigned char getSwappedBytes(unsigned char C) { return llvm::byteswap(C); } 70 inline signed char getSwappedBytes( signed char C) { return llvm::byteswap(C); } 71 inline char getSwappedBytes( char C) { return llvm::byteswap(C); } 72 73 inline unsigned short getSwappedBytes(unsigned short C) { return llvm::byteswap(C); } 74 inline signed short getSwappedBytes( signed short C) { return llvm::byteswap(C); } 75 76 inline unsigned int getSwappedBytes(unsigned int C) { return llvm::byteswap(C); } 77 inline signed int getSwappedBytes( signed int C) { return llvm::byteswap(C); } 78 79 inline unsigned long getSwappedBytes(unsigned long C) { return llvm::byteswap(C); } 80 inline signed long getSwappedBytes( signed long C) { return llvm::byteswap(C); } 81 82 inline unsigned long long getSwappedBytes(unsigned long long C) { return llvm::byteswap(C); } 83 inline signed long long getSwappedBytes( signed long long C) { return llvm::byteswap(C); } 84 85 inline float getSwappedBytes(float C) { 86 union { 87 uint32_t i; 88 float f; 89 } in, out; 90 in.f = C; 91 out.i = llvm::byteswap(in.i); 92 return out.f; 93 } 94 95 inline double getSwappedBytes(double C) { 96 union { 97 uint64_t i; 98 double d; 99 } in, out; 100 in.d = C; 101 out.i = llvm::byteswap(in.i); 102 return out.d; 103 } 104 105 template <typename T> 106 inline std::enable_if_t<std::is_enum<T>::value, T> getSwappedBytes(T C) { 107 return static_cast<T>( 108 llvm::byteswap(static_cast<std::underlying_type_t<T>>(C))); 109 } 110 111 template<typename T> 112 inline void swapByteOrder(T &Value) { 113 Value = getSwappedBytes(Value); 114 } 115 116 } // end namespace sys 117 } // end namespace llvm 118 119 #endif 120