0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 //===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 //
|
|
147
|
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
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 // This file declares generic functions to read and write endian specific data.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13 #ifndef LLVM_SUPPORT_ENDIAN_H
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 #define LLVM_SUPPORT_ENDIAN_H
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15
|
|
121
|
16 #include "llvm/Support/AlignOf.h"
|
|
|
17 #include "llvm/Support/Compiler.h"
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18 #include "llvm/Support/Host.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
19 #include "llvm/Support/SwapByteOrder.h"
|
|
121
|
20 #include <cassert>
|
|
|
21 #include <cstddef>
|
|
|
22 #include <cstdint>
|
|
|
23 #include <cstring>
|
|
|
24 #include <type_traits>
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
25
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
26 namespace llvm {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
27 namespace support {
|
|
121
|
28
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
29 enum endianness {big, little, native};
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
30
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
31 // These are named values for common alignments.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
32 enum {aligned = 0, unaligned = 1};
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
33
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
34 namespace detail {
|
|
121
|
35
|
|
147
|
36 /// ::value is either alignment, or alignof(T) if alignment is 0.
|
|
121
|
37 template<class T, int alignment>
|
|
|
38 struct PickAlignment {
|
|
|
39 enum { value = alignment == 0 ? alignof(T) : alignment };
|
|
|
40 };
|
|
|
41
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
42 } // end namespace detail
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
43
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
44 namespace endian {
|
|
121
|
45
|
|
|
46 constexpr endianness system_endianness() {
|
|
|
47 return sys::IsBigEndianHost ? big : little;
|
|
|
48 }
|
|
|
49
|
|
|
50 template <typename value_type>
|
|
|
51 inline value_type byte_swap(value_type value, endianness endian) {
|
|
|
52 if ((endian != native) && (endian != system_endianness()))
|
|
77
|
53 sys::swapByteOrder(value);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
54 return value;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
55 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
56
|
|
121
|
57 /// Swap the bytes of value to match the given endianness.
|
|
|
58 template<typename value_type, endianness endian>
|
|
|
59 inline value_type byte_swap(value_type value) {
|
|
|
60 return byte_swap(value, endian);
|
|
|
61 }
|
|
|
62
|
|
77
|
63 /// Read a value of a particular endianness from memory.
|
|
121
|
64 template <typename value_type, std::size_t alignment>
|
|
|
65 inline value_type read(const void *memory, endianness endian) {
|
|
|
66 value_type ret;
|
|
|
67
|
|
|
68 memcpy(&ret,
|
|
|
69 LLVM_ASSUME_ALIGNED(
|
|
|
70 memory, (detail::PickAlignment<value_type, alignment>::value)),
|
|
|
71 sizeof(value_type));
|
|
|
72 return byte_swap<value_type>(ret, endian);
|
|
|
73 }
|
|
|
74
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
75 template<typename value_type,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
76 endianness endian,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
77 std::size_t alignment>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
78 inline value_type read(const void *memory) {
|
|
121
|
79 return read<value_type, alignment>(memory, endian);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
80 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
81
|
|
77
|
82 /// Read a value of a particular endianness from a buffer, and increment the
|
|
|
83 /// buffer past that value.
|
|
121
|
84 template <typename value_type, std::size_t alignment, typename CharT>
|
|
|
85 inline value_type readNext(const CharT *&memory, endianness endian) {
|
|
|
86 value_type ret = read<value_type, alignment>(memory, endian);
|
|
77
|
87 memory += sizeof(value_type);
|
|
|
88 return ret;
|
|
|
89 }
|
|
|
90
|
|
121
|
91 template<typename value_type, endianness endian, std::size_t alignment,
|
|
|
92 typename CharT>
|
|
|
93 inline value_type readNext(const CharT *&memory) {
|
|
|
94 return readNext<value_type, alignment, CharT>(memory, endian);
|
|
|
95 }
|
|
|
96
|
|
77
|
97 /// Write a value to memory with a particular endianness.
|
|
121
|
98 template <typename value_type, std::size_t alignment>
|
|
|
99 inline void write(void *memory, value_type value, endianness endian) {
|
|
|
100 value = byte_swap<value_type>(value, endian);
|
|
|
101 memcpy(LLVM_ASSUME_ALIGNED(
|
|
|
102 memory, (detail::PickAlignment<value_type, alignment>::value)),
|
|
|
103 &value, sizeof(value_type));
|
|
|
104 }
|
|
|
105
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
106 template<typename value_type,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
107 endianness endian,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
108 std::size_t alignment>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
109 inline void write(void *memory, value_type value) {
|
|
121
|
110 write<value_type, alignment>(memory, value, endian);
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
111 }
|
|
95
|
112
|
|
|
113 template <typename value_type>
|
|
|
114 using make_unsigned_t = typename std::make_unsigned<value_type>::type;
|
|
|
115
|
|
|
116 /// Read a value of a particular endianness from memory, for a location
|
|
|
117 /// that starts at the given bit offset within the first byte.
|
|
|
118 template <typename value_type, endianness endian, std::size_t alignment>
|
|
|
119 inline value_type readAtBitAlignment(const void *memory, uint64_t startBit) {
|
|
|
120 assert(startBit < 8);
|
|
|
121 if (startBit == 0)
|
|
|
122 return read<value_type, endian, alignment>(memory);
|
|
|
123 else {
|
|
|
124 // Read two values and compose the result from them.
|
|
|
125 value_type val[2];
|
|
|
126 memcpy(&val[0],
|
|
|
127 LLVM_ASSUME_ALIGNED(
|
|
|
128 memory, (detail::PickAlignment<value_type, alignment>::value)),
|
|
|
129 sizeof(value_type) * 2);
|
|
|
130 val[0] = byte_swap<value_type, endian>(val[0]);
|
|
|
131 val[1] = byte_swap<value_type, endian>(val[1]);
|
|
|
132
|
|
|
133 // Shift bits from the lower value into place.
|
|
|
134 make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
|
|
|
135 // Mask off upper bits after right shift in case of signed type.
|
|
|
136 make_unsigned_t<value_type> numBitsFirstVal =
|
|
|
137 (sizeof(value_type) * 8) - startBit;
|
|
|
138 lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
|
|
|
139
|
|
|
140 // Get the bits from the upper value.
|
|
|
141 make_unsigned_t<value_type> upperVal =
|
|
|
142 val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
|
|
|
143 // Shift them in to place.
|
|
|
144 upperVal <<= numBitsFirstVal;
|
|
|
145
|
|
|
146 return lowerVal | upperVal;
|
|
|
147 }
|
|
|
148 }
|
|
|
149
|
|
|
150 /// Write a value to memory with a particular endianness, for a location
|
|
|
151 /// that starts at the given bit offset within the first byte.
|
|
|
152 template <typename value_type, endianness endian, std::size_t alignment>
|
|
|
153 inline void writeAtBitAlignment(void *memory, value_type value,
|
|
|
154 uint64_t startBit) {
|
|
|
155 assert(startBit < 8);
|
|
|
156 if (startBit == 0)
|
|
|
157 write<value_type, endian, alignment>(memory, value);
|
|
|
158 else {
|
|
|
159 // Read two values and shift the result into them.
|
|
|
160 value_type val[2];
|
|
|
161 memcpy(&val[0],
|
|
|
162 LLVM_ASSUME_ALIGNED(
|
|
|
163 memory, (detail::PickAlignment<value_type, alignment>::value)),
|
|
|
164 sizeof(value_type) * 2);
|
|
|
165 val[0] = byte_swap<value_type, endian>(val[0]);
|
|
|
166 val[1] = byte_swap<value_type, endian>(val[1]);
|
|
|
167
|
|
|
168 // Mask off any existing bits in the upper part of the lower value that
|
|
|
169 // we want to replace.
|
|
|
170 val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
|
|
|
171 make_unsigned_t<value_type> numBitsFirstVal =
|
|
|
172 (sizeof(value_type) * 8) - startBit;
|
|
|
173 make_unsigned_t<value_type> lowerVal = value;
|
|
|
174 if (startBit > 0) {
|
|
|
175 // Mask off the upper bits in the new value that are not going to go into
|
|
|
176 // the lower value. This avoids a left shift of a negative value, which
|
|
|
177 // is undefined behavior.
|
|
|
178 lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
|
|
|
179 // Now shift the new bits into place
|
|
|
180 lowerVal <<= startBit;
|
|
|
181 }
|
|
|
182 val[0] |= lowerVal;
|
|
|
183
|
|
|
184 // Mask off any existing bits in the lower part of the upper value that
|
|
|
185 // we want to replace.
|
|
|
186 val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
|
|
|
187 // Next shift the bits that go into the upper value into position.
|
|
|
188 make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
|
|
|
189 // Mask off upper bits after right shift in case of signed type.
|
|
|
190 upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
|
|
|
191 val[1] |= upperVal;
|
|
|
192
|
|
|
193 // Finally, rewrite values.
|
|
|
194 val[0] = byte_swap<value_type, endian>(val[0]);
|
|
|
195 val[1] = byte_swap<value_type, endian>(val[1]);
|
|
|
196 memcpy(LLVM_ASSUME_ALIGNED(
|
|
|
197 memory, (detail::PickAlignment<value_type, alignment>::value)),
|
|
|
198 &val[0], sizeof(value_type) * 2);
|
|
|
199 }
|
|
|
200 }
|
|
121
|
201
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
202 } // end namespace endian
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
203
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
204 namespace detail {
|
|
121
|
205
|
|
147
|
206 template <typename ValueType, endianness Endian, std::size_t Alignment,
|
|
|
207 std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
208 struct packed_endian_specific_integral {
|
|
147
|
209 using value_type = ValueType;
|
|
|
210 static constexpr endianness endian = Endian;
|
|
|
211 static constexpr std::size_t alignment = Alignment;
|
|
|
212
|
|
100
|
213 packed_endian_specific_integral() = default;
|
|
|
214
|
|
|
215 explicit packed_endian_specific_integral(value_type val) { *this = val; }
|
|
|
216
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
217 operator value_type() const {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
218 return endian::read<value_type, endian, alignment>(
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
219 (const void*)Value.buffer);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
222 void operator=(value_type newValue) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
223 endian::write<value_type, endian, alignment>(
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
224 (void*)Value.buffer, newValue);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
225 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
226
|
|
83
|
227 packed_endian_specific_integral &operator+=(value_type newValue) {
|
|
|
228 *this = *this + newValue;
|
|
|
229 return *this;
|
|
|
230 }
|
|
|
231
|
|
|
232 packed_endian_specific_integral &operator-=(value_type newValue) {
|
|
|
233 *this = *this - newValue;
|
|
|
234 return *this;
|
|
|
235 }
|
|
|
236
|
|
95
|
237 packed_endian_specific_integral &operator|=(value_type newValue) {
|
|
|
238 *this = *this | newValue;
|
|
|
239 return *this;
|
|
|
240 }
|
|
|
241
|
|
|
242 packed_endian_specific_integral &operator&=(value_type newValue) {
|
|
|
243 *this = *this & newValue;
|
|
|
244 return *this;
|
|
|
245 }
|
|
|
246
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247 private:
|
|
147
|
248 struct {
|
|
|
249 alignas(ALIGN) char buffer[sizeof(value_type)];
|
|
|
250 } Value;
|
|
77
|
251
|
|
|
252 public:
|
|
|
253 struct ref {
|
|
|
254 explicit ref(void *Ptr) : Ptr(Ptr) {}
|
|
|
255
|
|
|
256 operator value_type() const {
|
|
|
257 return endian::read<value_type, endian, alignment>(Ptr);
|
|
|
258 }
|
|
|
259
|
|
|
260 void operator=(value_type NewValue) {
|
|
|
261 endian::write<value_type, endian, alignment>(Ptr, NewValue);
|
|
|
262 }
|
|
|
263
|
|
|
264 private:
|
|
|
265 void *Ptr;
|
|
|
266 };
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
267 };
|
|
77
|
268
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
269 } // end namespace detail
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
270
|
|
121
|
271 using ulittle16_t =
|
|
|
272 detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
|
|
|
273 using ulittle32_t =
|
|
|
274 detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
|
|
|
275 using ulittle64_t =
|
|
|
276 detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
277
|
|
121
|
278 using little16_t =
|
|
|
279 detail::packed_endian_specific_integral<int16_t, little, unaligned>;
|
|
|
280 using little32_t =
|
|
|
281 detail::packed_endian_specific_integral<int32_t, little, unaligned>;
|
|
|
282 using little64_t =
|
|
|
283 detail::packed_endian_specific_integral<int64_t, little, unaligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
284
|
|
121
|
285 using aligned_ulittle16_t =
|
|
|
286 detail::packed_endian_specific_integral<uint16_t, little, aligned>;
|
|
|
287 using aligned_ulittle32_t =
|
|
|
288 detail::packed_endian_specific_integral<uint32_t, little, aligned>;
|
|
|
289 using aligned_ulittle64_t =
|
|
|
290 detail::packed_endian_specific_integral<uint64_t, little, aligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
291
|
|
121
|
292 using aligned_little16_t =
|
|
|
293 detail::packed_endian_specific_integral<int16_t, little, aligned>;
|
|
|
294 using aligned_little32_t =
|
|
|
295 detail::packed_endian_specific_integral<int32_t, little, aligned>;
|
|
|
296 using aligned_little64_t =
|
|
|
297 detail::packed_endian_specific_integral<int64_t, little, aligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
298
|
|
121
|
299 using ubig16_t =
|
|
|
300 detail::packed_endian_specific_integral<uint16_t, big, unaligned>;
|
|
|
301 using ubig32_t =
|
|
|
302 detail::packed_endian_specific_integral<uint32_t, big, unaligned>;
|
|
|
303 using ubig64_t =
|
|
|
304 detail::packed_endian_specific_integral<uint64_t, big, unaligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
305
|
|
121
|
306 using big16_t =
|
|
|
307 detail::packed_endian_specific_integral<int16_t, big, unaligned>;
|
|
|
308 using big32_t =
|
|
|
309 detail::packed_endian_specific_integral<int32_t, big, unaligned>;
|
|
|
310 using big64_t =
|
|
|
311 detail::packed_endian_specific_integral<int64_t, big, unaligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
312
|
|
121
|
313 using aligned_ubig16_t =
|
|
|
314 detail::packed_endian_specific_integral<uint16_t, big, aligned>;
|
|
|
315 using aligned_ubig32_t =
|
|
|
316 detail::packed_endian_specific_integral<uint32_t, big, aligned>;
|
|
|
317 using aligned_ubig64_t =
|
|
|
318 detail::packed_endian_specific_integral<uint64_t, big, aligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
319
|
|
121
|
320 using aligned_big16_t =
|
|
|
321 detail::packed_endian_specific_integral<int16_t, big, aligned>;
|
|
|
322 using aligned_big32_t =
|
|
|
323 detail::packed_endian_specific_integral<int32_t, big, aligned>;
|
|
|
324 using aligned_big64_t =
|
|
|
325 detail::packed_endian_specific_integral<int64_t, big, aligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
326
|
|
121
|
327 using unaligned_uint16_t =
|
|
|
328 detail::packed_endian_specific_integral<uint16_t, native, unaligned>;
|
|
|
329 using unaligned_uint32_t =
|
|
|
330 detail::packed_endian_specific_integral<uint32_t, native, unaligned>;
|
|
|
331 using unaligned_uint64_t =
|
|
|
332 detail::packed_endian_specific_integral<uint64_t, native, unaligned>;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
333
|
|
121
|
334 using unaligned_int16_t =
|
|
|
335 detail::packed_endian_specific_integral<int16_t, native, unaligned>;
|
|
|
336 using unaligned_int32_t =
|
|
|
337 detail::packed_endian_specific_integral<int32_t, native, unaligned>;
|
|
|
338 using unaligned_int64_t =
|
|
|
339 detail::packed_endian_specific_integral<int64_t, native, unaligned>;
|
|
95
|
340
|
|
147
|
341 template <typename T>
|
|
|
342 using little_t = detail::packed_endian_specific_integral<T, little, unaligned>;
|
|
|
343 template <typename T>
|
|
|
344 using big_t = detail::packed_endian_specific_integral<T, big, unaligned>;
|
|
|
345
|
|
|
346 template <typename T>
|
|
|
347 using aligned_little_t =
|
|
|
348 detail::packed_endian_specific_integral<T, little, aligned>;
|
|
|
349 template <typename T>
|
|
|
350 using aligned_big_t = detail::packed_endian_specific_integral<T, big, aligned>;
|
|
|
351
|
|
95
|
352 namespace endian {
|
|
121
|
353
|
|
|
354 template <typename T> inline T read(const void *P, endianness E) {
|
|
|
355 return read<T, unaligned>(P, E);
|
|
|
356 }
|
|
|
357
|
|
100
|
358 template <typename T, endianness E> inline T read(const void *P) {
|
|
|
359 return *(const detail::packed_endian_specific_integral<T, E, unaligned> *)P;
|
|
|
360 }
|
|
|
361
|
|
121
|
362 inline uint16_t read16(const void *P, endianness E) {
|
|
|
363 return read<uint16_t>(P, E);
|
|
|
364 }
|
|
|
365 inline uint32_t read32(const void *P, endianness E) {
|
|
|
366 return read<uint32_t>(P, E);
|
|
|
367 }
|
|
|
368 inline uint64_t read64(const void *P, endianness E) {
|
|
|
369 return read<uint64_t>(P, E);
|
|
|
370 }
|
|
|
371
|
|
100
|
372 template <endianness E> inline uint16_t read16(const void *P) {
|
|
|
373 return read<uint16_t, E>(P);
|
|
|
374 }
|
|
|
375 template <endianness E> inline uint32_t read32(const void *P) {
|
|
|
376 return read<uint32_t, E>(P);
|
|
|
377 }
|
|
|
378 template <endianness E> inline uint64_t read64(const void *P) {
|
|
|
379 return read<uint64_t, E>(P);
|
|
|
380 }
|
|
|
381
|
|
|
382 inline uint16_t read16le(const void *P) { return read16<little>(P); }
|
|
|
383 inline uint32_t read32le(const void *P) { return read32<little>(P); }
|
|
|
384 inline uint64_t read64le(const void *P) { return read64<little>(P); }
|
|
|
385 inline uint16_t read16be(const void *P) { return read16<big>(P); }
|
|
|
386 inline uint32_t read32be(const void *P) { return read32<big>(P); }
|
|
|
387 inline uint64_t read64be(const void *P) { return read64<big>(P); }
|
|
95
|
388
|
|
121
|
389 template <typename T> inline void write(void *P, T V, endianness E) {
|
|
|
390 write<T, unaligned>(P, V, E);
|
|
|
391 }
|
|
|
392
|
|
100
|
393 template <typename T, endianness E> inline void write(void *P, T V) {
|
|
|
394 *(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
|
|
|
395 }
|
|
|
396
|
|
121
|
397 inline void write16(void *P, uint16_t V, endianness E) {
|
|
|
398 write<uint16_t>(P, V, E);
|
|
|
399 }
|
|
|
400 inline void write32(void *P, uint32_t V, endianness E) {
|
|
|
401 write<uint32_t>(P, V, E);
|
|
|
402 }
|
|
|
403 inline void write64(void *P, uint64_t V, endianness E) {
|
|
|
404 write<uint64_t>(P, V, E);
|
|
|
405 }
|
|
|
406
|
|
100
|
407 template <endianness E> inline void write16(void *P, uint16_t V) {
|
|
|
408 write<uint16_t, E>(P, V);
|
|
|
409 }
|
|
|
410 template <endianness E> inline void write32(void *P, uint32_t V) {
|
|
|
411 write<uint32_t, E>(P, V);
|
|
|
412 }
|
|
|
413 template <endianness E> inline void write64(void *P, uint64_t V) {
|
|
|
414 write<uint64_t, E>(P, V);
|
|
|
415 }
|
|
|
416
|
|
|
417 inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
|
|
|
418 inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
|
|
|
419 inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
|
|
|
420 inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
|
|
|
421 inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
|
|
|
422 inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
|
|
121
|
423
|
|
95
|
424 } // end namespace endian
|
|
121
|
425
|
|
95
|
426 } // end namespace support
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
427 } // end namespace llvm
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
428
|
|
121
|
429 #endif // LLVM_SUPPORT_ENDIAN_H
|
