LLVM 18.0.0git
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
18#include <cassert>
19#include <cstddef>
20#include <cstdint>
21#include <cstring>
22#include <type_traits>
23
24namespace llvm {
25namespace support {
26
28
29// These are named values for common alignments.
30enum {aligned = 0, unaligned = 1};
31
32namespace detail {
33
34/// ::value is either alignment, or alignof(T) if alignment is 0.
35template<class T, int alignment>
37 enum { value = alignment == 0 ? alignof(T) : alignment };
38};
39
40} // end namespace detail
41
42namespace endian {
43
46}
47
48template <typename value_type>
49[[nodiscard]] inline value_type byte_swap(value_type value, endianness endian) {
50 if ((endian != native) && (endian != system_endianness()))
52 return value;
53}
54
55/// Swap the bytes of value to match the given endianness.
56template <typename value_type, endianness endian>
57[[nodiscard]] inline value_type byte_swap(value_type value) {
58 return byte_swap(value, endian);
59}
60
61/// Read a value of a particular endianness from memory.
62template <typename value_type, std::size_t alignment = unaligned>
63[[nodiscard]] inline value_type read(const void *memory, endianness endian) {
64 value_type ret;
65
66 memcpy(&ret,
69 sizeof(value_type));
70 return byte_swap<value_type>(ret, endian);
71}
72
73template <typename value_type, endianness endian, std::size_t alignment>
74[[nodiscard]] inline value_type read(const void *memory) {
75 return read<value_type, alignment>(memory, endian);
76}
77
78/// Read a value of a particular endianness from a buffer, and increment the
79/// buffer past that value.
80template <typename value_type, std::size_t alignment, typename CharT>
81[[nodiscard]] inline value_type readNext(const CharT *&memory,
83 value_type ret = read<value_type, alignment>(memory, endian);
84 memory += sizeof(value_type);
85 return ret;
86}
87
88template <typename value_type, endianness endian, std::size_t alignment,
89 typename CharT>
90[[nodiscard]] inline value_type readNext(const CharT *&memory) {
91 return readNext<value_type, alignment, CharT>(memory, endian);
92}
93
94/// Write a value to memory with a particular endianness.
95template <typename value_type, std::size_t alignment = unaligned>
96inline void write(void *memory, value_type value, endianness endian) {
97 value = byte_swap<value_type>(value, endian);
100 &value, sizeof(value_type));
101}
102
103template<typename value_type,
105 std::size_t alignment>
106inline void write(void *memory, value_type value) {
107 write<value_type, alignment>(memory, value, endian);
108}
109
110template <typename value_type>
111using make_unsigned_t = std::make_unsigned_t<value_type>;
112
113/// Read a value of a particular endianness from memory, for a location
114/// that starts at the given bit offset within the first byte.
115template <typename value_type, endianness endian, std::size_t alignment>
116[[nodiscard]] inline value_type readAtBitAlignment(const void *memory,
117 uint64_t startBit) {
118 assert(startBit < 8);
119 if (startBit == 0)
120 return read<value_type, endian, alignment>(memory);
121 else {
122 // Read two values and compose the result from them.
123 value_type val[2];
124 memcpy(&val[0],
127 sizeof(value_type) * 2);
128 val[0] = byte_swap<value_type, endian>(val[0]);
129 val[1] = byte_swap<value_type, endian>(val[1]);
130
131 // Shift bits from the lower value into place.
132 make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
133 // Mask off upper bits after right shift in case of signed type.
134 make_unsigned_t<value_type> numBitsFirstVal =
135 (sizeof(value_type) * 8) - startBit;
136 lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
137
138 // Get the bits from the upper value.
140 val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
141 // Shift them in to place.
142 upperVal <<= numBitsFirstVal;
143
144 return lowerVal | upperVal;
145 }
146}
147
148/// Write a value to memory with a particular endianness, for a location
149/// that starts at the given bit offset within the first byte.
150template <typename value_type, endianness endian, std::size_t alignment>
151inline void writeAtBitAlignment(void *memory, value_type value,
152 uint64_t startBit) {
153 assert(startBit < 8);
154 if (startBit == 0)
155 write<value_type, endian, alignment>(memory, value);
156 else {
157 // Read two values and shift the result into them.
158 value_type val[2];
159 memcpy(&val[0],
162 sizeof(value_type) * 2);
163 val[0] = byte_swap<value_type, endian>(val[0]);
164 val[1] = byte_swap<value_type, endian>(val[1]);
165
166 // Mask off any existing bits in the upper part of the lower value that
167 // we want to replace.
168 val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
169 make_unsigned_t<value_type> numBitsFirstVal =
170 (sizeof(value_type) * 8) - startBit;
172 if (startBit > 0) {
173 // Mask off the upper bits in the new value that are not going to go into
174 // the lower value. This avoids a left shift of a negative value, which
175 // is undefined behavior.
176 lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
177 // Now shift the new bits into place
178 lowerVal <<= startBit;
179 }
180 val[0] |= lowerVal;
181
182 // Mask off any existing bits in the lower part of the upper value that
183 // we want to replace.
184 val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
185 // Next shift the bits that go into the upper value into position.
186 make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
187 // Mask off upper bits after right shift in case of signed type.
188 upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
189 val[1] |= upperVal;
190
191 // Finally, rewrite values.
192 val[0] = byte_swap<value_type, endian>(val[0]);
193 val[1] = byte_swap<value_type, endian>(val[1]);
194 memcpy(LLVM_ASSUME_ALIGNED(
196 &val[0], sizeof(value_type) * 2);
197 }
198}
199
200} // end namespace endian
201
202namespace detail {
203
204template <typename ValueType, endianness Endian, std::size_t Alignment,
208 static constexpr endianness endian = Endian;
209 static constexpr std::size_t alignment = Alignment;
210
212
213 explicit packed_endian_specific_integral(value_type val) { *this = val; }
214
215 operator value_type() const {
216 return endian::read<value_type, endian, alignment>(
217 (const void*)Value.buffer);
218 }
219
220 void operator=(value_type newValue) {
221 endian::write<value_type, endian, alignment>(
222 (void*)Value.buffer, newValue);
223 }
224
226 *this = *this + newValue;
227 return *this;
228 }
229
231 *this = *this - newValue;
232 return *this;
233 }
234
236 *this = *this | newValue;
237 return *this;
238 }
239
241 *this = *this & newValue;
242 return *this;
243 }
244
245private:
246 struct {
247 alignas(ALIGN) char buffer[sizeof(value_type)];
248 } Value;
249
250public:
251 struct ref {
252 explicit ref(void *Ptr) : Ptr(Ptr) {}
253
254 operator value_type() const {
255 return endian::read<value_type, endian, alignment>(Ptr);
256 }
257
258 void operator=(value_type NewValue) {
259 endian::write<value_type, endian, alignment>(Ptr, NewValue);
260 }
261
262 private:
263 void *Ptr;
264 };
265};
266
267} // end namespace detail
268
275
282
289
296
297using ubig16_t =
299using ubig32_t =
301using ubig64_t =
303
304using big16_t =
306using big32_t =
308using big64_t =
310
317
324
331
338
339template <typename T>
341template <typename T>
343
344template <typename T>
347template <typename T>
349
350namespace endian {
351
352template <typename T, endianness E> [[nodiscard]] inline T read(const void *P) {
354}
355
356[[nodiscard]] inline uint16_t read16(const void *P, endianness E) {
357 return read<uint16_t>(P, E);
358}
359[[nodiscard]] inline uint32_t read32(const void *P, endianness E) {
360 return read<uint32_t>(P, E);
361}
362[[nodiscard]] inline uint64_t read64(const void *P, endianness E) {
363 return read<uint64_t>(P, E);
364}
365
366template <endianness E> [[nodiscard]] inline uint16_t read16(const void *P) {
367 return read<uint16_t, E>(P);
368}
369template <endianness E> [[nodiscard]] inline uint32_t read32(const void *P) {
370 return read<uint32_t, E>(P);
371}
372template <endianness E> [[nodiscard]] inline uint64_t read64(const void *P) {
373 return read<uint64_t, E>(P);
374}
375
376[[nodiscard]] inline uint16_t read16le(const void *P) {
377 return read16<little>(P);
378}
379[[nodiscard]] inline uint32_t read32le(const void *P) {
380 return read32<little>(P);
381}
382[[nodiscard]] inline uint64_t read64le(const void *P) {
383 return read64<little>(P);
384}
385[[nodiscard]] inline uint16_t read16be(const void *P) { return read16<big>(P); }
386[[nodiscard]] inline uint32_t read32be(const void *P) { return read32<big>(P); }
387[[nodiscard]] inline uint64_t read64be(const void *P) { return read64<big>(P); }
388
389template <typename T, endianness E> inline void write(void *P, T V) {
391}
392
393inline void write16(void *P, uint16_t V, endianness E) {
394 write<uint16_t>(P, V, E);
395}
396inline void write32(void *P, uint32_t V, endianness E) {
397 write<uint32_t>(P, V, E);
398}
399inline void write64(void *P, uint64_t V, endianness E) {
400 write<uint64_t>(P, V, E);
401}
402
403template <endianness E> inline void write16(void *P, uint16_t V) {
404 write<uint16_t, E>(P, V);
405}
406template <endianness E> inline void write32(void *P, uint32_t V) {
407 write<uint32_t, E>(P, V);
408}
409template <endianness E> inline void write64(void *P, uint64_t V) {
410 write<uint64_t, E>(P, V);
411}
412
413inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
414inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
415inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
416inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
417inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
418inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
419
420} // end namespace endian
421
422} // end namespace support
423} // end namespace llvm
424
425#endif // LLVM_SUPPORT_ENDIAN_H
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_ASSUME_ALIGNED(p, a)
\macro LLVM_ASSUME_ALIGNED Returns a pointer with an assumed alignment.
Definition: Compiler.h:376
Given that RA is a live value
#define T
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
endianness Endian
LLVM Value Representation.
Definition: Value.h:74
uint64_t read64le(const void *P)
Definition: Endian.h:382
value_type byte_swap(value_type value, endianness endian)
Definition: Endian.h:49
uint16_t read16le(const void *P)
Definition: Endian.h:376
uint32_t read32(const void *P, endianness E)
Definition: Endian.h:359
void write16be(void *P, uint16_t V)
Definition: Endian.h:416
void write64le(void *P, uint64_t V)
Definition: Endian.h:415
uint64_t read64be(const void *P)
Definition: Endian.h:387
void write32le(void *P, uint32_t V)
Definition: Endian.h:414
void write32(void *P, uint32_t V, endianness E)
Definition: Endian.h:396
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:151
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:116
void write32be(void *P, uint32_t V)
Definition: Endian.h:417
uint64_t read64(const void *P, endianness E)
Definition: Endian.h:362
uint32_t read32be(const void *P)
Definition: Endian.h:386
constexpr endianness system_endianness()
Definition: Endian.h:44
void write16(void *P, uint16_t V, endianness E)
Definition: Endian.h:393
void write16le(void *P, uint16_t V)
Definition: Endian.h:413
void write64be(void *P, uint64_t V)
Definition: Endian.h:418
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:63
void write64(void *P, uint64_t V, endianness E)
Definition: Endian.h:399
uint16_t read16be(const void *P)
Definition: Endian.h:385
void write(void *memory, value_type value, endianness endian)
Write a value to memory with a particular endianness.
Definition: Endian.h:96
value_type readNext(const CharT *&memory, endianness endian)
Read a value of a particular endianness from a buffer, and increment the buffer past that value.
Definition: Endian.h:81
uint32_t read32le(const void *P)
Definition: Endian.h:379
uint16_t read16(const void *P, endianness E)
Definition: Endian.h:356
std::make_unsigned_t< value_type > make_unsigned_t
Definition: Endian.h:111
constexpr bool IsBigEndianHost
Definition: SwapByteOrder.h:54
void swapByteOrder(T &Value)
Definition: SwapByteOrder.h:90
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
value is either alignment, or alignof(T) if alignment is 0.
Definition: Endian.h:36
packed_endian_specific_integral & operator+=(value_type newValue)
Definition: Endian.h:225
packed_endian_specific_integral & operator&=(value_type newValue)
Definition: Endian.h:240
packed_endian_specific_integral & operator|=(value_type newValue)
Definition: Endian.h:235
packed_endian_specific_integral & operator-=(value_type newValue)
Definition: Endian.h:230