2010-10-21 20:28:21 +00:00
|
|
|
//===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file declares generic functions to read and write endian specific data.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_SUPPORT_ENDIAN_H
|
|
|
|
#define LLVM_SUPPORT_ENDIAN_H
|
|
|
|
|
2013-01-02 20:14:11 +00:00
|
|
|
#include "llvm/Support/AlignOf.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Host.h"
|
|
|
|
#include "llvm/Support/SwapByteOrder.h"
|
2010-10-21 20:28:21 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
namespace support {
|
2013-01-02 20:14:11 +00:00
|
|
|
enum endianness {big, little, native};
|
2010-10-21 20:28:21 +00:00
|
|
|
|
2013-01-02 20:14:11 +00:00
|
|
|
// These are named values for common alignments.
|
|
|
|
enum {aligned = 0, unaligned = 1};
|
2010-10-21 20:28:21 +00:00
|
|
|
|
|
|
|
namespace detail {
|
2013-01-02 20:14:11 +00:00
|
|
|
/// \brief ::value is either alignment, or alignof(T) if alignment is 0.
|
|
|
|
template<class T, int alignment>
|
|
|
|
struct PickAlignment {
|
|
|
|
enum {value = alignment == 0 ? AlignOf<T>::Alignment : alignment};
|
|
|
|
};
|
2010-10-21 20:28:21 +00:00
|
|
|
} // end namespace detail
|
|
|
|
|
2010-10-22 19:14:39 +00:00
|
|
|
namespace endian {
|
2014-03-24 21:30:55 +00:00
|
|
|
/// Swap the bytes of value to match the given endianness.
|
2013-01-02 20:14:11 +00:00
|
|
|
template<typename value_type, endianness endian>
|
|
|
|
inline value_type byte_swap(value_type value) {
|
2013-04-15 14:44:24 +00:00
|
|
|
if (endian != native && sys::IsBigEndianHost != (endian == big))
|
2014-06-14 13:18:07 +00:00
|
|
|
sys::swapByteOrder(value);
|
2013-01-02 20:14:11 +00:00
|
|
|
return value;
|
|
|
|
}
|
2010-10-22 19:14:39 +00:00
|
|
|
|
2014-03-24 21:30:55 +00:00
|
|
|
/// Read a value of a particular endianness from memory.
|
2013-01-02 20:14:11 +00:00
|
|
|
template<typename value_type,
|
|
|
|
endianness endian,
|
|
|
|
std::size_t alignment>
|
|
|
|
inline value_type read(const void *memory) {
|
|
|
|
value_type ret;
|
|
|
|
|
|
|
|
memcpy(&ret,
|
|
|
|
LLVM_ASSUME_ALIGNED(memory,
|
|
|
|
(detail::PickAlignment<value_type, alignment>::value)),
|
|
|
|
sizeof(value_type));
|
|
|
|
return byte_swap<value_type, endian>(ret);
|
|
|
|
}
|
2010-10-22 19:14:39 +00:00
|
|
|
|
2014-03-25 01:04:44 +00:00
|
|
|
/// Read a value of a particular endianness from a buffer, and increment the
|
|
|
|
/// buffer past that value.
|
2015-03-16 06:55:45 +00:00
|
|
|
template<typename value_type, endianness endian, std::size_t alignment,
|
|
|
|
typename CharT>
|
|
|
|
inline value_type readNext(const CharT *&memory) {
|
2014-03-25 01:04:44 +00:00
|
|
|
value_type ret = read<value_type, endian, alignment>(memory);
|
|
|
|
memory += sizeof(value_type);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-24 21:30:55 +00:00
|
|
|
/// Write a value to memory with a particular endianness.
|
2013-01-02 20:14:11 +00:00
|
|
|
template<typename value_type,
|
|
|
|
endianness endian,
|
|
|
|
std::size_t alignment>
|
|
|
|
inline void write(void *memory, value_type value) {
|
|
|
|
value = byte_swap<value_type, endian>(value);
|
|
|
|
memcpy(LLVM_ASSUME_ALIGNED(memory,
|
|
|
|
(detail::PickAlignment<value_type, alignment>::value)),
|
|
|
|
&value,
|
|
|
|
sizeof(value_type));
|
2010-10-22 19:14:39 +00:00
|
|
|
}
|
2013-01-02 20:14:11 +00:00
|
|
|
} // end namespace endian
|
2010-10-21 20:28:21 +00:00
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
template<typename value_type,
|
2010-10-22 18:45:12 +00:00
|
|
|
endianness endian,
|
2013-01-02 20:14:11 +00:00
|
|
|
std::size_t alignment>
|
|
|
|
struct packed_endian_specific_integral {
|
2010-10-21 20:28:21 +00:00
|
|
|
operator value_type() const {
|
2013-01-02 20:14:11 +00:00
|
|
|
return endian::read<value_type, endian, alignment>(
|
|
|
|
(const void*)Value.buffer);
|
2010-10-21 20:28:21 +00:00
|
|
|
}
|
|
|
|
|
2012-01-22 09:01:03 +00:00
|
|
|
void operator=(value_type newValue) {
|
2013-01-02 20:14:11 +00:00
|
|
|
endian::write<value_type, endian, alignment>(
|
|
|
|
(void*)Value.buffer, newValue);
|
2012-01-22 09:01:03 +00:00
|
|
|
}
|
2010-10-21 20:28:21 +00:00
|
|
|
|
2014-09-11 22:55:25 +00:00
|
|
|
packed_endian_specific_integral &operator+=(value_type newValue) {
|
|
|
|
*this = *this + newValue;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
packed_endian_specific_integral &operator-=(value_type newValue) {
|
|
|
|
*this = *this - newValue;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2010-10-21 20:28:21 +00:00
|
|
|
private:
|
2013-01-02 20:14:11 +00:00
|
|
|
AlignedCharArray<PickAlignment<value_type, alignment>::value,
|
|
|
|
sizeof(value_type)> Value;
|
2014-08-27 23:06:08 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
struct ref {
|
|
|
|
explicit ref(void *Ptr) : Ptr(Ptr) {}
|
|
|
|
|
|
|
|
operator value_type() const {
|
|
|
|
return endian::read<value_type, endian, alignment>(Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void operator=(value_type NewValue) {
|
|
|
|
endian::write<value_type, endian, alignment>(Ptr, NewValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void *Ptr;
|
|
|
|
};
|
2010-10-21 20:28:21 +00:00
|
|
|
};
|
2014-08-27 23:06:08 +00:00
|
|
|
|
2010-10-21 20:28:21 +00:00
|
|
|
} // end namespace detail
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint16_t, little, unaligned> ulittle16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint32_t, little, unaligned> ulittle32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint64_t, little, unaligned> ulittle64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int16_t, little, unaligned> little16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int32_t, little, unaligned> little32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int64_t, little, unaligned> little64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint16_t, little, aligned> aligned_ulittle16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint32_t, little, aligned> aligned_ulittle32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint64_t, little, aligned> aligned_ulittle64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int16_t, little, aligned> aligned_little16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int32_t, little, aligned> aligned_little32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int64_t, little, aligned> aligned_little64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint16_t, big, unaligned> ubig16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint32_t, big, unaligned> ubig32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint64_t, big, unaligned> ubig64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int16_t, big, unaligned> big16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int32_t, big, unaligned> big32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int64_t, big, unaligned> big64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint16_t, big, aligned> aligned_ubig16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint32_t, big, aligned> aligned_ubig32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint64_t, big, aligned> aligned_ubig64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int16_t, big, aligned> aligned_big16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int32_t, big, aligned> aligned_big32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int64_t, big, aligned> aligned_big64_t;
|
|
|
|
|
2013-01-02 20:14:11 +00:00
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint16_t, native, unaligned> unaligned_uint16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint32_t, native, unaligned> unaligned_uint32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<uint64_t, native, unaligned> unaligned_uint64_t;
|
|
|
|
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int16_t, native, unaligned> unaligned_int16_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int32_t, native, unaligned> unaligned_int32_t;
|
|
|
|
typedef detail::packed_endian_specific_integral
|
|
|
|
<int64_t, native, unaligned> unaligned_int64_t;
|
2015-03-02 20:00:15 +00:00
|
|
|
|
|
|
|
namespace endian {
|
2015-03-02 21:50:28 +00:00
|
|
|
inline uint16_t read16le(const void *p) { return *(const ulittle16_t *)p; }
|
|
|
|
inline uint32_t read32le(const void *p) { return *(const ulittle32_t *)p; }
|
|
|
|
inline uint64_t read64le(const void *p) { return *(const ulittle64_t *)p; }
|
|
|
|
inline uint16_t read16be(const void *p) { return *(const ubig16_t *)p; }
|
|
|
|
inline uint32_t read32be(const void *p) { return *(const ubig32_t *)p; }
|
|
|
|
inline uint64_t read64be(const void *p) { return *(const ubig64_t *)p; }
|
2015-03-02 20:00:15 +00:00
|
|
|
|
|
|
|
inline void write16le(void *p, uint16_t v) { *(ulittle16_t *)p = v; }
|
|
|
|
inline void write32le(void *p, uint32_t v) { *(ulittle32_t *)p = v; }
|
|
|
|
inline void write64le(void *p, uint64_t v) { *(ulittle64_t *)p = v; }
|
|
|
|
inline void write16be(void *p, uint16_t v) { *(ubig16_t *)p = v; }
|
|
|
|
inline void write32be(void *p, uint32_t v) { *(ubig32_t *)p = v; }
|
|
|
|
inline void write64be(void *p, uint64_t v) { *(ubig64_t *)p = v; }
|
|
|
|
} // end namespace endian
|
2010-10-21 20:28:21 +00:00
|
|
|
} // end namespace support
|
2015-03-02 20:00:15 +00:00
|
|
|
} // end namespace llvm
|
2010-10-21 20:28:21 +00:00
|
|
|
|
|
|
|
#endif
|