LLVM  10.0.0svn
Endian.h
Go to the documentation of this file.
1 //===- Endian.h - Utilities for IO with endian specific data ----*- 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 functions to read and write endian specific data.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_SUPPORT_ENDIAN_H
14 #define LLVM_SUPPORT_ENDIAN_H
15 
16 #include "llvm/Support/AlignOf.h"
17 #include "llvm/Support/Compiler.h"
18 #include "llvm/Support/Host.h"
20 #include <cassert>
21 #include <cstddef>
22 #include <cstdint>
23 #include <cstring>
24 #include <type_traits>
25 
26 namespace llvm {
27 namespace support {
28 
30 
31 // These are named values for common alignments.
32 enum {aligned = 0, unaligned = 1};
33 
34 namespace detail {
35 
36 /// ::value is either alignment, or alignof(T) if alignment is 0.
37 template<class T, int alignment>
38 struct PickAlignment {
39  enum { value = alignment == 0 ? alignof(T) : alignment };
40 };
41 
42 } // end namespace detail
43 
44 namespace endian {
45 
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()))
53  sys::swapByteOrder(value);
54  return value;
55 }
56 
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 
63 /// Read a value of a particular endianness from memory.
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,
71  sizeof(value_type));
72  return byte_swap<value_type>(ret, endian);
73 }
74 
75 template<typename value_type,
76  endianness endian,
77  std::size_t alignment>
78 inline value_type read(const void *memory) {
79  return read<value_type, alignment>(memory, endian);
80 }
81 
82 /// Read a value of a particular endianness from a buffer, and increment the
83 /// buffer past that value.
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);
87  memory += sizeof(value_type);
88  return ret;
89 }
90 
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 
97 /// Write a value to memory with a particular endianness.
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(
103  &value, sizeof(value_type));
104 }
105 
106 template<typename value_type,
107  endianness endian,
108  std::size_t alignment>
109 inline void write(void *memory, value_type value) {
110  write<value_type, alignment>(memory, value, endian);
111 }
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],
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],
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;
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(
198  &val[0], sizeof(value_type) * 2);
199  }
200 }
201 
202 } // end namespace endian
203 
204 namespace detail {
205 
206 template <typename ValueType, endianness Endian, std::size_t Alignment,
207  std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
210  static constexpr endianness endian = Endian;
211  static constexpr std::size_t alignment = Alignment;
212 
214 
215  explicit packed_endian_specific_integral(value_type val) { *this = val; }
216 
217  operator value_type() const {
218  return endian::read<value_type, endian, alignment>(
219  (const void*)Value.buffer);
220  }
221 
222  void operator=(value_type newValue) {
223  endian::write<value_type, endian, alignment>(
224  (void*)Value.buffer, newValue);
225  }
226 
228  *this = *this + newValue;
229  return *this;
230  }
231 
233  *this = *this - newValue;
234  return *this;
235  }
236 
238  *this = *this | newValue;
239  return *this;
240  }
241 
243  *this = *this & newValue;
244  return *this;
245  }
246 
247 private:
248  struct {
249  alignas(ALIGN) char buffer[sizeof(value_type)];
250  } Value;
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  };
267 };
268 
269 } // end namespace detail
270 
271 using ulittle16_t =
273 using ulittle32_t =
275 using ulittle64_t =
277 
278 using little16_t =
280 using little32_t =
282 using little64_t =
284 
285 using aligned_ulittle16_t =
287 using aligned_ulittle32_t =
289 using aligned_ulittle64_t =
291 
292 using aligned_little16_t =
294 using aligned_little32_t =
296 using aligned_little64_t =
298 
299 using ubig16_t =
301 using ubig32_t =
303 using ubig64_t =
305 
306 using big16_t =
308 using big32_t =
310 using big64_t =
312 
313 using aligned_ubig16_t =
315 using aligned_ubig32_t =
317 using aligned_ubig64_t =
319 
320 using aligned_big16_t =
322 using aligned_big32_t =
324 using aligned_big64_t =
326 
327 using unaligned_uint16_t =
329 using unaligned_uint32_t =
331 using unaligned_uint64_t =
333 
334 using unaligned_int16_t =
336 using unaligned_int32_t =
338 using unaligned_int64_t =
340 
341 template <typename T>
343 template <typename T>
345 
346 template <typename T>
347 using aligned_little_t =
349 template <typename T>
351 
352 namespace endian {
353 
354 template <typename T> inline T read(const void *P, endianness E) {
355  return read<T, unaligned>(P, E);
356 }
357 
358 template <typename T, endianness E> inline T read(const void *P) {
360 }
361 
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 
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); }
388 
389 template <typename T> inline void write(void *P, T V, endianness E) {
390  write<T, unaligned>(P, V, E);
391 }
392 
393 template <typename T, endianness E> inline void write(void *P, T V) {
395 }
396 
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 
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); }
423 
424 } // end namespace endian
425 
426 } // end namespace support
427 } // end namespace llvm
428 
429 #endif // LLVM_SUPPORT_ENDIAN_H
packed_endian_specific_integral & operator-=(value_type newValue)
Definition: Endian.h:232
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
void write32be(void *P, uint32_t V)
Definition: Endian.h:421
value_type readAtBitAlignment(const void *memory, uint64_t startBit)
Read a value of a particular endianness from memory, for a location that starts at the given bit offs...
Definition: Endian.h:119
#define LLVM_ASSUME_ALIGNED(p, a)
LLVM_ASSUME_ALIGNED Returns a pointer with an assumed alignment.
Definition: Compiler.h:357
void swapByteOrder(T &Value)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void write32le(void *P, uint32_t V)
Definition: Endian.h:418
uint16_t read16le(const void *P)
Definition: Endian.h:382
packed_endian_specific_integral & operator|=(value_type newValue)
Definition: Endian.h:237
uint64_t read64be(const void *P)
Definition: Endian.h:387
constexpr bool IsBigEndianHost
Definition: Host.h:46
uint32_t read32be(const void *P)
Definition: Endian.h:386
void write16le(void *P, uint16_t V)
Definition: Endian.h:417
uint64_t read64(const void *P)
Definition: Endian.h:378
void write32(void *P, uint32_t V)
Definition: Endian.h:410
T read(const void *P)
Definition: Endian.h:358
value_type byte_swap(value_type value)
Swap the bytes of value to match the given endianness.
Definition: Endian.h:59
#define P(N)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void write64(void *P, uint64_t V)
Definition: Endian.h:413
void writeAtBitAlignment(void *memory, value_type value, uint64_t startBit)
Write a value to memory with a particular endianness, for a location that starts at the given bit off...
Definition: Endian.h:153
void write16(void *P, uint16_t V)
Definition: Endian.h:407
static void write(bool isBE, void *P, T V)
value_type readNext(const CharT *&memory)
Definition: Endian.h:93
uint32_t read32(const void *P)
Definition: Endian.h:375
constexpr endianness system_endianness()
Definition: Endian.h:46
void write16be(void *P, uint16_t V)
Definition: Endian.h:420
uint64_t read64le(const void *P)
Definition: Endian.h:384
void write64le(void *P, uint64_t V)
Definition: Endian.h:419
uint32_t read32le(const void *P)
Definition: Endian.h:383
typename std::make_unsigned< value_type >::type make_unsigned_t
Definition: Endian.h:114
void write64be(void *P, uint64_t V)
Definition: Endian.h:422
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:74
packed_endian_specific_integral & operator &=(value_type newValue)
Definition: Endian.h:242
::value is either alignment, or alignof(T) if alignment is 0.
Definition: Endian.h:38
uint16_t read16be(const void *P)
Definition: Endian.h:385
uint16_t read16(const void *P)
Definition: Endian.h:372
packed_endian_specific_integral & operator+=(value_type newValue)
Definition: Endian.h:227
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:156