#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