#ifndef DFGAbstractHeap_h
#define DFGAbstractHeap_h
#if ENABLE(DFG_JIT)
#include "VirtualRegister.h"
#include <wtf/HashMap.h>
#include <wtf/PrintStream.h>
namespace JSC { namespace DFG {
#define FOR_EACH_ABSTRACT_HEAP_KIND(macro) \
macro(InvalidAbstractHeap) \
macro(World) \
macro(Arguments_numArguments) \
macro(Arguments_overrideLength) \
macro(Arguments_registers) \
macro(Arguments_slowArguments) \
macro(ArrayBuffer_data) \
macro(Butterfly_arrayBuffer) \
macro(Butterfly_publicLength) \
macro(Butterfly_vectorLength) \
macro(JSArrayBufferView_length) \
macro(JSArrayBufferView_mode) \
macro(JSArrayBufferView_vector) \
macro(JSCell_structureID) \
macro(JSCell_indexingType) \
macro(JSCell_typeInfoFlags) \
macro(JSCell_typeInfoType) \
macro(JSFunction_executable) \
macro(JSFunction_scopeChain) \
macro(JSObject_butterfly) \
macro(JSVariableObject_registers) \
macro(NamedProperties) \
macro(IndexedInt32Properties) \
macro(IndexedDoubleProperties) \
macro(IndexedContiguousProperties) \
macro(ArrayStorageProperties) \
macro(Variables) \
macro(TypedArrayProperties) \
macro(GCState) \
macro(BarrierState) \
macro(RegExpState) \
macro(InternalState) \
macro(Absolute) \
\
macro(Watchpoint_fire) \
\
macro(MiscFields) \
\
macro(SideState)
enum AbstractHeapKind {
#define ABSTRACT_HEAP_DECLARATION(name) name,
FOR_EACH_ABSTRACT_HEAP_KIND(ABSTRACT_HEAP_DECLARATION)
#undef ABSTRACT_HEAP_DECLARATION
};
class AbstractHeap {
public:
class Payload {
public:
Payload()
: m_isTop(false)
, m_value(0)
{
}
Payload(bool isTop, int64_t value)
: m_isTop(isTop)
, m_value(value)
{
ASSERT(!(isTop && value));
}
Payload(int64_t value)
: m_isTop(false)
, m_value(value)
{
}
Payload(const void* pointer)
: m_isTop(false)
, m_value(bitwise_cast<intptr_t>(pointer))
{
}
Payload(VirtualRegister operand)
: m_isTop(false)
, m_value(operand.offset())
{
}
static Payload top() { return Payload(true, 0); }
bool isTop() const { return m_isTop; }
int64_t value() const
{
ASSERT(!isTop());
return valueImpl();
}
int64_t valueImpl() const
{
return m_value;
}
bool operator==(const Payload& other) const
{
return m_isTop == other.m_isTop
&& m_value == other.m_value;
}
bool operator!=(const Payload& other) const
{
return !(*this == other);
}
bool operator<(const Payload& other) const
{
if (isTop())
return !other.isTop();
if (other.isTop())
return false;
return value() < other.value();
}
bool isDisjoint(const Payload& other) const
{
if (isTop())
return false;
if (other.isTop())
return false;
return m_value != other.m_value;
}
bool overlaps(const Payload& other) const
{
return !isDisjoint(other);
}
void dump(PrintStream&) const;
private:
bool m_isTop;
int64_t m_value;
};
AbstractHeap()
{
m_value = encode(InvalidAbstractHeap, Payload());
}
AbstractHeap(AbstractHeapKind kind)
{
ASSERT(kind != InvalidAbstractHeap);
m_value = encode(kind, Payload::top());
}
AbstractHeap(AbstractHeapKind kind, Payload payload)
{
ASSERT(kind != InvalidAbstractHeap && kind != World);
m_value = encode(kind, payload);
}
AbstractHeap(WTF::HashTableDeletedValueType)
{
m_value = encode(InvalidAbstractHeap, Payload::top());
}
bool operator!() const { return kind() == InvalidAbstractHeap && !payloadImpl().isTop(); }
AbstractHeapKind kind() const { return static_cast<AbstractHeapKind>(m_value & ((1 << topShift) - 1)); }
Payload payload() const
{
ASSERT(kind() != World && kind() != InvalidAbstractHeap);
return payloadImpl();
}
bool isDisjoint(const AbstractHeap& other)
{
ASSERT(kind() != InvalidAbstractHeap);
ASSERT(other.kind() != InvalidAbstractHeap);
if (kind() == World)
return false;
if (other.kind() == World)
return false;
if (kind() != other.kind())
return true;
return payload().isDisjoint(other.payload());
}
bool overlaps(const AbstractHeap& other)
{
return !isDisjoint(other);
}
AbstractHeap supertype() const
{
ASSERT(kind() != InvalidAbstractHeap);
if (kind() == World)
return AbstractHeap();
if (payload().isTop())
return World;
return AbstractHeap(kind());
}
unsigned hash() const
{
return WTF::IntHash<int64_t>::hash(m_value);
}
bool operator==(const AbstractHeap& other) const
{
return m_value == other.m_value;
}
bool operator!=(const AbstractHeap& other) const
{
return !(*this == other);
}
bool operator<(const AbstractHeap& other) const
{
if (kind() != other.kind())
return kind() < other.kind();
return payload() < other.payload();
}
bool isHashTableDeletedValue() const
{
return kind() == InvalidAbstractHeap && payloadImpl().isTop();
}
void dump(PrintStream& out) const;
private:
static const unsigned valueShift = 15;
static const unsigned topShift = 14;
Payload payloadImpl() const
{
return Payload((m_value >> topShift) & 1, m_value >> valueShift);
}
static int64_t encode(AbstractHeapKind kind, Payload payload)
{
int64_t kindAsInt = static_cast<int64_t>(kind);
ASSERT(kindAsInt < (1 << topShift));
return kindAsInt | (payload.isTop() << topShift) | (payload.valueImpl() << valueShift);
}
int64_t m_value;
};
struct AbstractHeapHash {
static unsigned hash(const AbstractHeap& key) { return key.hash(); }
static bool equal(const AbstractHeap& a, const AbstractHeap& b) { return a == b; }
static const bool safeToCompareToEmptyOrDeleted = true;
};
} }
namespace WTF {
void printInternal(PrintStream&, JSC::DFG::AbstractHeapKind);
template<typename T> struct DefaultHash;
template<> struct DefaultHash<JSC::DFG::AbstractHeap> {
typedef JSC::DFG::AbstractHeapHash Hash;
};
template<typename T> struct HashTraits;
template<> struct HashTraits<JSC::DFG::AbstractHeap> : SimpleClassHashTraits<JSC::DFG::AbstractHeap> { };
}
#endif // ENABLE(DFG_JIT)
#endif // DFGAbstractHeap_h