CompactPointerTuple.h [plain text]
#pragma once
#include <type_traits>
#include <wtf/StdLibExtras.h>
namespace WTF {
template<typename PointerType, typename Type>
class CompactPointerTuple {
public:
static_assert(sizeof(Type) == 1, "");
static_assert(std::is_pointer<PointerType>::value, "");
static_assert(alignof(typename std::remove_pointer<PointerType>::type) >= alignof(void*), "");
static_assert(std::is_integral<Type>::value || std::is_enum<Type>::value, "");
CompactPointerTuple() = default;
#if CPU(ADDRESS64)
public:
static constexpr uint64_t encodeType(uint8_t type)
{
return (static_cast<uint64_t>(type) << 59) | (static_cast<uint64_t>(type) >> 5);
}
static constexpr uint8_t decodeType(uint64_t value)
{
return static_cast<uint8_t>((value >> 59) | (value << 5));
}
static constexpr uint64_t typeMask = encodeType(UINT8_MAX);
static_assert(0xF800000000000007ULL == typeMask, "");
static constexpr uint64_t pointerMask = ~typeMask;
CompactPointerTuple(PointerType pointer, Type type)
: m_data(bitwise_cast<uint64_t>(pointer) | encodeType(static_cast<uint8_t>(type)))
{
ASSERT((bitwise_cast<uint64_t>(pointer) & 0b111) == 0x0);
}
PointerType pointer() const { return bitwise_cast<PointerType>(m_data & pointerMask); }
void setPointer(PointerType pointer)
{
ASSERT((bitwise_cast<uint64_t>(pointer) & 0b111) == 0x0);
m_data = CompactPointerTuple(pointer, type()).m_data;
}
Type type() const { return static_cast<Type>(decodeType(m_data)); }
void setType(Type type)
{
m_data = CompactPointerTuple(pointer(), type).m_data;
}
private:
uint64_t m_data { 0 };
#else
public:
CompactPointerTuple(PointerType pointer, Type type)
: m_pointer(pointer)
, m_type(type)
{
}
PointerType pointer() const { return m_pointer; }
void setPointer(PointerType pointer) { m_pointer = pointer; }
Type type() const { return m_type; }
void setType(Type type) { m_type = type; }
private:
PointerType m_pointer { nullptr };
Type m_type { 0 };
#endif
};
}
using WTF::CompactPointerTuple;