14 #ifndef LLVM_SUPPORT_ENDIAN_H
15 #define LLVM_SUPPORT_ENDIAN_H
29 template<
class T,
int alignment>
31 enum {
value = alignment == 0 ?
alignof(
T) : alignment };
37 template<
typename value_type, endianness endian>
45 template<
typename value_type,
47 std::size_t alignment>
48 inline value_type
read(
const void *memory) {
55 return byte_swap<value_type, endian>(ret);
60 template<
typename value_type,
endianness endian, std::size_t alignment,
62 inline value_type
readNext(
const CharT *&memory) {
63 value_type ret = read<value_type, endian, alignment>(memory);
64 memory +=
sizeof(value_type);
69 template<
typename value_type,
71 std::size_t alignment>
72 inline void write(
void *memory, value_type value) {
73 value = byte_swap<value_type, endian>(value);
80 template <
typename value_type>
85 template <
typename value_type, endianness endian, std::
size_t alignment>
89 return read<value_type, endian, alignment>(memory);
96 sizeof(value_type) * 2);
97 val[0] = byte_swap<value_type, endian>(val[0]);
98 val[1] = byte_swap<value_type, endian>(val[1]);
104 (
sizeof(value_type) * 8) - startBit;
111 upperVal <<= numBitsFirstVal;
113 return lowerVal | upperVal;
119 template <
typename value_type, endianness endian, std::
size_t alignment>
124 write<value_type, endian, alignment>(memory, value);
131 sizeof(value_type) * 2);
132 val[0] = byte_swap<value_type, endian>(val[0]);
133 val[1] = byte_swap<value_type, endian>(val[1]);
139 (
sizeof(value_type) * 8) - startBit;
147 lowerVal <<= startBit;
161 val[0] = byte_swap<value_type, endian>(val[0]);
162 val[1] = byte_swap<value_type, endian>(val[1]);
165 &val[0],
sizeof(value_type) * 2);
171 template<
typename value_type,
173 std::size_t alignment>
179 operator value_type()
const {
180 return endian::read<value_type, endian, alignment>(
181 (
const void*)
Value.buffer);
185 endian::write<value_type, endian, alignment>(
186 (
void*)
Value.buffer, newValue);
190 *
this = *
this + newValue;
195 *
this = *
this - newValue;
200 *
this = *
this | newValue;
205 *
this = *
this & newValue;
211 sizeof(value_type)>
Value;
217 operator value_type()
const {
218 return endian::read<value_type, endian, alignment>(
Ptr);
222 endian::write<value_type, endian, alignment>(
Ptr, NewValue);
232 typedef detail::packed_endian_specific_integral
303 template <
typename T, endianness E>
inline T read(
const void *
P) {
307 template <endianness E>
inline uint16_t
read16(
const void *
P) {
308 return read<uint16_t, E>(
P);
311 return read<uint32_t, E>(
P);
313 template <endianness E>
inline uint64_t
read64(
const void *
P) {
314 return read<uint64_t, E>(
P);
317 inline uint16_t
read16le(
const void *
P) {
return read16<little>(
P); }
319 inline uint64_t
read64le(
const void *
P) {
return read64<little>(
P); }
320 inline uint16_t
read16be(
const void *
P) {
return read16<big>(
P); }
322 inline uint64_t
read64be(
const void *
P) {
return read64<big>(
P); }
324 template <
typename T, endianness E>
inline void write(
void *
P,
T V) {
328 template <endianness E>
inline void write16(
void *
P, uint16_t V) {
329 write<uint16_t, E>(
P, V);
332 write<uint32_t, E>(
P, V);
334 template <endianness E>
inline void write64(
void *
P, uint64_t V) {
335 write<uint64_t, E>(
P, V);
338 inline void write16le(
void *
P, uint16_t V) { write16<little>(
P, V); }
340 inline void write64le(
void *
P, uint64_t V) { write64<little>(
P, V); }
341 inline void write16be(
void *
P, uint16_t V) { write16<big>(
P, V); }
343 inline void write64be(
void *
P, uint64_t V) { write64<big>(
P, V); }
detail::packed_endian_specific_integral< uint16_t, native, unaligned > unaligned_uint16_t
packed_endian_specific_integral & operator+=(value_type newValue)
void write32be(void *P, uint32_t V)
detail::packed_endian_specific_integral< int64_t, native, unaligned > unaligned_int64_t
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...
#define LLVM_ASSUME_ALIGNED(p, a)
LLVM_ASSUME_ALIGNED
void swapByteOrder(T &Value)
detail::packed_endian_specific_integral< uint64_t, big, aligned > aligned_ubig64_t
detail::packed_endian_specific_integral< int16_t, little, aligned > aligned_little16_t
void write32le(void *P, uint32_t V)
detail::packed_endian_specific_integral< uint64_t, big, unaligned > ubig64_t
uint16_t read16le(const void *P)
uint64_t read64be(const void *P)
uint32_t read32be(const void *P)
void write16le(void *P, uint16_t V)
detail::packed_endian_specific_integral< uint32_t, big, unaligned > ubig32_t
void operator=(value_type NewValue)
detail::packed_endian_specific_integral< uint16_t, big, aligned > aligned_ubig16_t
detail::packed_endian_specific_integral< int64_t, little, unaligned > little64_t
uint64_t read64(const void *P)
void write32(void *P, uint32_t V)
detail::packed_endian_specific_integral< int32_t, big, aligned > aligned_big32_t
value_type byte_swap(value_type value)
Swap the bytes of value to match the given endianness.
detail::packed_endian_specific_integral< int16_t, big, aligned > aligned_big16_t
detail::packed_endian_specific_integral< int64_t, little, aligned > aligned_little64_t
detail::packed_endian_specific_integral< int16_t, native, unaligned > unaligned_int16_t
void write64(void *P, uint64_t V)
detail::packed_endian_specific_integral< uint32_t, big, aligned > aligned_ubig32_t
detail::packed_endian_specific_integral< int32_t, little, aligned > aligned_little32_t
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...
void write16(void *P, uint16_t V)
static void write(bool isBE, void *P, T V)
packed_endian_specific_integral & operator|=(value_type newValue)
detail::packed_endian_specific_integral< uint32_t, little, aligned > aligned_ulittle32_t
detail::packed_endian_specific_integral< uint64_t, little, aligned > aligned_ulittle64_t
value_type readNext(const CharT *&memory)
Read a value of a particular endianness from a buffer, and increment the buffer past that value...
detail::packed_endian_specific_integral< int32_t, little, unaligned > little32_t
detail::packed_endian_specific_integral< int32_t, big, unaligned > big32_t
packed_endian_specific_integral & operator-=(value_type newValue)
detail::packed_endian_specific_integral< int16_t, little, unaligned > little16_t
uint32_t read32(const void *P)
packed_endian_specific_integral & operator&=(value_type newValue)
detail::packed_endian_specific_integral< uint64_t, native, unaligned > unaligned_uint64_t
detail::packed_endian_specific_integral< uint16_t, little, unaligned > ulittle16_t
void write16be(void *P, uint16_t V)
uint64_t read64le(const void *P)
void write64le(void *P, uint64_t V)
static const bool IsBigEndianHost
detail::packed_endian_specific_integral< uint64_t, little, unaligned > ulittle64_t
uint32_t read32le(const void *P)
void operator=(value_type newValue)
typename std::make_unsigned< value_type >::type make_unsigned_t
void write64be(void *P, uint64_t V)
detail::packed_endian_specific_integral< uint16_t, big, unaligned > ubig16_t
packed_endian_specific_integral(value_type val)
detail::packed_endian_specific_integral< int16_t, big, unaligned > big16_t
detail::packed_endian_specific_integral< int64_t, big, aligned > aligned_big64_t
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
detail::packed_endian_specific_integral< uint32_t, little, unaligned > ulittle32_t
LLVM Value Representation.
detail::packed_endian_specific_integral< int64_t, big, unaligned > big64_t
detail::packed_endian_specific_integral< int32_t, native, unaligned > unaligned_int32_t
detail::packed_endian_specific_integral< uint32_t, native, unaligned > unaligned_uint32_t
::value is either alignment, or alignof(T) if alignment is 0.
uint16_t read16be(const void *P)
Helper for building an aligned character array type.
uint16_t read16(const void *P)
detail::packed_endian_specific_integral< uint16_t, little, aligned > aligned_ulittle16_t