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 <cstddef> 18 #include <cstdint> 19 #include <type_traits> 20 #if defined(_MSC_VER) && !defined(_DEBUG) 21 #include <stdlib.h> 22 #endif 23 24 #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) || \ 25 defined(__Fuchsia__) || defined(__EMSCRIPTEN__) 26 #include <endian.h> 27 #elif defined(_AIX) 28 #include <sys/machine.h> 29 #elif defined(__sun) 30 /* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */ 31 #include <sys/types.h> 32 #define BIG_ENDIAN 4321 33 #define LITTLE_ENDIAN 1234 34 #if defined(_BIG_ENDIAN) 35 #define BYTE_ORDER BIG_ENDIAN 36 #else 37 #define BYTE_ORDER LITTLE_ENDIAN 38 #endif 39 #elif defined(__MVS__) 40 #define BIG_ENDIAN 4321 41 #define LITTLE_ENDIAN 1234 42 #define BYTE_ORDER BIG_ENDIAN 43 #else 44 #if !defined(BYTE_ORDER) && !defined(_WIN32) 45 #include <machine/endian.h> 46 #endif 47 #endif 48 49 namespace llvm { 50 51 /// ByteSwap_16 - This function returns a byte-swapped representation of 52 /// the 16-bit argument. 53 inline uint16_t ByteSwap_16(uint16_t value) { 54 #if defined(_MSC_VER) && !defined(_DEBUG) 55 // The DLL version of the runtime lacks these functions (bug!?), but in a 56 // release build they're replaced with BSWAP instructions anyway. 57 return _byteswap_ushort(value); 58 #else 59 uint16_t Hi = value << 8; 60 uint16_t Lo = value >> 8; 61 return Hi | Lo; 62 #endif 63 } 64 65 /// This function returns a byte-swapped representation of the 32-bit argument. 66 inline uint32_t ByteSwap_32(uint32_t value) { 67 #if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC)) 68 return __builtin_bswap32(value); 69 #elif defined(_MSC_VER) && !defined(_DEBUG) 70 return _byteswap_ulong(value); 71 #else 72 uint32_t Byte0 = value & 0x000000FF; 73 uint32_t Byte1 = value & 0x0000FF00; 74 uint32_t Byte2 = value & 0x00FF0000; 75 uint32_t Byte3 = value & 0xFF000000; 76 return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24); 77 #endif 78 } 79 80 /// This function returns a byte-swapped representation of the 64-bit argument. 81 inline uint64_t ByteSwap_64(uint64_t value) { 82 #if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC)) 83 return __builtin_bswap64(value); 84 #elif defined(_MSC_VER) && !defined(_DEBUG) 85 return _byteswap_uint64(value); 86 #else 87 uint64_t Hi = ByteSwap_32(uint32_t(value)); 88 uint32_t Lo = ByteSwap_32(uint32_t(value >> 32)); 89 return (Hi << 32) | Lo; 90 #endif 91 } 92 93 namespace sys { 94 95 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN 96 constexpr bool IsBigEndianHost = true; 97 #else 98 constexpr bool IsBigEndianHost = false; 99 #endif 100 101 static const bool IsLittleEndianHost = !IsBigEndianHost; 102 103 inline unsigned char getSwappedBytes(unsigned char C) { return C; } 104 inline signed char getSwappedBytes(signed char C) { return C; } 105 inline char getSwappedBytes(char C) { return C; } 106 107 inline unsigned short getSwappedBytes(unsigned short C) { return ByteSwap_16(C); } 108 inline signed short getSwappedBytes( signed short C) { return ByteSwap_16(C); } 109 110 inline unsigned int getSwappedBytes(unsigned int C) { return ByteSwap_32(C); } 111 inline signed int getSwappedBytes( signed int C) { return ByteSwap_32(C); } 112 113 inline unsigned long getSwappedBytes(unsigned long C) { 114 // Handle LLP64 and LP64 platforms. 115 return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C) 116 : ByteSwap_64((uint64_t)C); 117 } 118 inline signed long getSwappedBytes(signed long C) { 119 // Handle LLP64 and LP64 platforms. 120 return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C) 121 : ByteSwap_64((uint64_t)C); 122 } 123 124 inline unsigned long long getSwappedBytes(unsigned long long C) { 125 return ByteSwap_64(C); 126 } 127 inline signed long long getSwappedBytes(signed long long C) { 128 return ByteSwap_64(C); 129 } 130 131 inline float getSwappedBytes(float C) { 132 union { 133 uint32_t i; 134 float f; 135 } in, out; 136 in.f = C; 137 out.i = ByteSwap_32(in.i); 138 return out.f; 139 } 140 141 inline double getSwappedBytes(double C) { 142 union { 143 uint64_t i; 144 double d; 145 } in, out; 146 in.d = C; 147 out.i = ByteSwap_64(in.i); 148 return out.d; 149 } 150 151 template <typename T> 152 inline std::enable_if_t<std::is_enum<T>::value, T> getSwappedBytes(T C) { 153 return static_cast<T>( 154 getSwappedBytes(static_cast<std::underlying_type_t<T>>(C))); 155 } 156 157 template<typename T> 158 inline void swapByteOrder(T &Value) { 159 Value = getSwappedBytes(Value); 160 } 161 162 } // end namespace sys 163 } // end namespace llvm 164 165 #endif 166
Indexes created Sat Jun 06 00:24:59 UTC 2026