LLVM  14.0.0git
SwapByteOrder.h
Go to the documentation of this file.
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) {
160 }
161 
162 } // end namespace sys
163 } // end namespace llvm
164 
165 #endif
i
i
Definition: README.txt:29
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::sys::IsBigEndianHost
constexpr bool IsBigEndianHost
Definition: SwapByteOrder.h:98
llvm::sys::swapByteOrder
void swapByteOrder(T &Value)
Definition: SwapByteOrder.h:158
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::MipsISD::Hi
@ Hi
Definition: MipsISelLowering.h:75
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ByteSwap_64
uint64_t ByteSwap_64(uint64_t value)
This function returns a byte-swapped representation of the 64-bit argument.
Definition: SwapByteOrder.h:81
in
The object format emitted by the WebAssembly backed is documented in
Definition: README.txt:11
llvm::sys::getSwappedBytes
unsigned char getSwappedBytes(unsigned char C)
Definition: SwapByteOrder.h:103
llvm::ByteSwap_16
uint16_t ByteSwap_16(uint16_t value)
ByteSwap_16 - This function returns a byte-swapped representation of the 16-bit argument.
Definition: SwapByteOrder.h:53
uint64_t
uint32_t
uint16_t
llvm::sys::IsLittleEndianHost
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:101
llvm::ByteSwap_32
uint32_t ByteSwap_32(uint32_t value)
This function returns a byte-swapped representation of the 32-bit argument.
Definition: SwapByteOrder.h:66
d
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int int d
Definition: README.txt:418
llvm::Value
LLVM Value Representation.
Definition: Value.h:75