aligned.hh

Go to the documentation of this file.

#ifndef ALIGNED_HH
#define ALIGNED_HH
 
#include "inline.hh"
 
#include <cstdint>
#include <cstring>
 
// Only need to (more strictly) align when SSE is actually enabled.
#ifdef __SSE2__
inline constexpr size_t SSE_ALIGNMENT = 16;
#else
inline constexpr size_t SSE_ALIGNMENT = 0; // alignas(0) has no effect
#endif
 
// 'alignas(0)' has no effect according to the C++ standard, however gcc
// produces a warning for it. This for example triggers when using
//     alignas(SSE_ALIGNMENT)
// and the target has no SSE instructions (thus SSE_ALIGNMENT == 0).
// The following macro works around that.
#ifdef __SSE2__
#define ALIGNAS_SSE alignas(SSE_ALIGNMENT)
#else
#define ALIGNAS_SSE /*nothing*/
#endif
 
// Unaligned loads and stores.
template<typename T> [[nodiscard]] static ALWAYS_INLINE T unalignedLoad(const void* p)
{
        T t;
        memcpy(&t, p, sizeof(t));
        return t;
}
static ALWAYS_INLINE void unalignedStore(void* p, auto t)
{
        memcpy(p, &t, sizeof(t));
}
 
[[nodiscard]] ALWAYS_INLINE uint16_t unalignedLoad16(const void* p) {
        return unalignedLoad<uint16_t>(p);
}
[[nodiscard]] ALWAYS_INLINE uint32_t unalignedLoad32(const void* p) {
        return unalignedLoad<uint32_t>(p);
}
[[nodiscard]] ALWAYS_INLINE uint64_t unalignedLoad64(const void* p) {
        return unalignedLoad<uint64_t>(p);
}
ALWAYS_INLINE void unalignedStore16(void* p, uint16_t v) {
        unalignedStore(p, v);
}
ALWAYS_INLINE void unalignedStore32(void* p, uint32_t v) {
        unalignedStore(p, v);
}
ALWAYS_INLINE void unalignedStore64(void* p, uint64_t v) {
        unalignedStore(p, v);
}
 
#endif // ALIGNED_HH