#pragma once
#if ENABLE(B3_JIT)
#include "AirStackSlotKind.h"
#include "B3SparseCollection.h"
#include <limits.h>
#include <wtf/FastMalloc.h>
#include <wtf/Noncopyable.h>
#include <wtf/PrintStream.h>
namespace JSC { namespace B3 {
class StackSlot;
namespace Air {
class StackSlot {
WTF_MAKE_NONCOPYABLE(StackSlot);
WTF_MAKE_FAST_ALLOCATED;
public:
unsigned byteSize() const { return m_byteSize; }
StackSlotKind kind() const { return m_kind; }
bool isLocked() const { return m_kind == StackSlotKind::Locked; }
bool isSpill() const { return m_kind == StackSlotKind::Spill; }
unsigned index() const { return m_index; }
void ensureSize(unsigned requestedSize)
{
ASSERT(!m_offsetFromFP);
m_byteSize = std::max(m_byteSize, requestedSize);
}
unsigned alignment() const
{
if (byteSize() <= 1)
return 1;
if (byteSize() <= 2)
return 2;
if (byteSize() <= 4)
return 4;
return 8;
}
B3::StackSlot* b3Slot() const { return m_b3Slot; }
intptr_t offsetFromFP() const { return m_offsetFromFP; }
void setOffsetFromFP(intptr_t);
unsigned jsHash() const;
void dump(PrintStream&) const;
void deepDump(PrintStream&) const;
private:
friend class Code;
friend class SparseCollection<StackSlot>;
StackSlot(unsigned byteSize, StackSlotKind, B3::StackSlot*);
unsigned m_byteSize { 0 };
unsigned m_index { UINT_MAX };
intptr_t m_offsetFromFP { 0 };
StackSlotKind m_kind { StackSlotKind::Locked };
B3::StackSlot* m_b3Slot { nullptr };
};
class DeepStackSlotDump {
public:
DeepStackSlotDump(const StackSlot* slot)
: m_slot(slot)
{
}
void dump(PrintStream& out) const
{
if (m_slot)
m_slot->deepDump(out);
else
out.print("<null>");
}
private:
const StackSlot* m_slot;
};
inline DeepStackSlotDump deepDump(const StackSlot* slot)
{
return DeepStackSlotDump(slot);
}
} } }
namespace WTF {
inline void printInternal(PrintStream& out, JSC::B3::Air::StackSlot* stackSlot)
{
out.print(pointerDump(stackSlot));
}
}
#endif // ENABLE(B3_JIT)