memory_manip.hpp

#ifndef SIPLASPLAS_UTILITY_MEMORY_MANIP_HPP
#define SIPLASPLAS_UTILITY_MEMORY_MANIP_HPP

#include <memory>
#include <cstdint>
#include <climits>
#include <siplasplas/utility/export.hpp>

namespace cpp
{
    namespace detail
    {
        SIPLASPLAS_UTILITY_EXPORT char* aligned_ptr(char* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT void* aligned_ptr(void* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT const char* aligned_ptr(const char* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT const void* aligned_ptr(const void* pointer, std::size_t alignment);


        SIPLASPLAS_UTILITY_EXPORT bool is_aligned(char* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT bool is_aligned(void* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT bool is_aligned(const char* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT bool is_aligned(const void* pointer, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT std::uintptr_t missalignment(const char* address, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT std::uintptr_t missalignment(const void* address, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT std::uintptr_t missalignment(char* address, std::size_t alignment);

        SIPLASPLAS_UTILITY_EXPORT std::uintptr_t missalignment(void* address, std::size_t alignment);

        template<typename T, typename U>
        T* tagPointer(T* pointer, U data)
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<T*>(static_cast<std::uintptr_t>(data) << 48 | (reinterpret_cast<std::uintptr_t>(pointer) & 0x0000FFFFFFFFFFFF));
        }

        template<typename R, typename U, typename... Args>
        auto tagPointer(R(*pointer)(Args...), U data) -> decltype(pointer)
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<R(*)(Args...)>(data << 48 | (reinterpret_cast<std::uintptr_t>(pointer) & 0x0000FFFFFFFFFFFF));
        }

        template<typename T>
        T* untagPointer(T* pointer)
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<T*>(reinterpret_cast<std::uintptr_t>(pointer) & 0x0000FFFFFFFFFFFF);
        }

        template<typename R, typename... Args>
        auto untagPointer(R(*pointer)(Args...)) -> decltype(pointer)
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<R(*)(Args...)>(reinterpret_cast<std::uintptr_t>(pointer) & 0x0000FFFFFFFFFFFF);
        }

        template<typename T>
        std::uint16_t readTaggedPointer(T* pointer)
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<std::uintptr_t>(pointer) >> 48;
        }

        template<typename R, typename... Args>
        std::uint16_t readTaggedPointer(R(*pointer)(Args...))
        {
            static_assert(sizeof(nullptr) * CHAR_BIT == 64, "Tagging pointers is only supported in architectures with 64 bit virtual addresses");

            return reinterpret_cast<std::uintptr_t>(pointer) >> 48;
        }

#ifndef SIPLASPLAS_UTILITY_ALIGNEDMALLOC_ALIGNOFFSET_BITS

        using AlignedMallocAlingOffset = std::uint8_t;
#else
        using AlignedMallocAlingOffset = SIPLASPLAS_PP_CAT(
            SIPLASPLAS_PP_CAT(std::uint,SIPLASPLAS_UTILITY_ALIGNEDMALLOC_ALIGNOFFSET_BITS),
            _t
        );
#endif

        SIPLASPLAS_UTILITY_EXPORT void* aligned_malloc(std::size_t size, std::size_t alignment, std::size_t offset = 0);

        SIPLASPLAS_UTILITY_EXPORT void* aligned_malloc_block(void* pointer, std::size_t offset = 0);

        SIPLASPLAS_UTILITY_EXPORT void aligned_free(void* pointer, std::size_t offset = 0);

        template<typename T>
        void write_at(char* pointer, const T& value, std::intptr_t offset = 0)
        {
            *(reinterpret_cast<T*>(pointer) + offset) = value;
        }

        template<typename T>
        void write_at(void* pointer, const T& value, std::intptr_t offset = 0)
        {
            write_at(reinterpret_cast<char*>(pointer), value, offset);
        }

        template<typename T>
        T read_at(const char* pointer, std::intptr_t offset = 0)
        {
            return *(reinterpret_cast<const T*>(pointer + offset));
        }

        template<typename T>
        T read_at(const void* pointer, std::intptr_t offset = 0)
        {
            return read_at<T>(reinterpret_cast<const char*>(pointer), offset);
        }

        template<typename T>
        void write_before(char* pointer, const T& value)
        {
            write_at(pointer, value, -sizeof(T));
        }

        template<typename T>
        void write_before(void* pointer, const T& value)
        {
            write_before(reinterpret_cast<char*>(pointer), value);
        }

        template<typename T>
        T read_before(const char* pointer)
        {
            return read_at<T>(pointer, - sizeof(T));
        }

        template<typename T>
        T read_before(const void* pointer)
        {
            return read_before<T>(reinterpret_cast<const char*>(pointer));
        }

        template<typename T>
        class RawReaderWriter
        {
        public:
            RawReaderWriter(void* at) :
                _at{reinterpret_cast<char*>(at)}
            {}

            T get() const
            {
                return detail::read_at<T>(_at);
            }

            operator T() const
            {
                return get();
            }

            T operator=(T value)
            {
                detail::write_at(_at, value);
                return value;
            }
        private:
            char* _at;
        };
    }
}

#endif // SIPLASPLAS_UTILITY_MEMORY_MANIP_HPP