#pragma once
#if ENABLE(JIT)
#include "GPRInfo.h"
#include "MacroAssembler.h"
#include "Reg.h"
#include "TempRegisterSet.h"
#include <wtf/Bitmap.h>
namespace JSC {
typedef Bitmap<MacroAssembler::numGPRs + MacroAssembler::numFPRs + 1> RegisterBitmap;
class RegisterAtOffsetList;
class RegisterSet {
public:
RegisterSet() { }
template<typename... Regs>
explicit RegisterSet(Regs... regs)
{
setMany(regs...);
}
JS_EXPORT_PRIVATE static RegisterSet stackRegisters();
JS_EXPORT_PRIVATE static RegisterSet reservedHardwareRegisters();
static RegisterSet runtimeRegisters();
static RegisterSet specialRegisters(); JS_EXPORT_PRIVATE static RegisterSet calleeSaveRegisters();
static RegisterSet vmCalleeSaveRegisters(); static RegisterAtOffsetList* vmCalleeSaveRegisterOffsets();
static RegisterSet llintBaselineCalleeSaveRegisters(); static RegisterSet dfgCalleeSaveRegisters(); static RegisterSet ftlCalleeSaveRegisters(); #if ENABLE(WEBASSEMBLY)
static RegisterSet webAssemblyCalleeSaveRegisters(); #endif
static RegisterSet volatileRegistersForJSCall();
static RegisterSet stubUnavailableRegisters(); JS_EXPORT_PRIVATE static RegisterSet macroScratchRegisters();
JS_EXPORT_PRIVATE static RegisterSet allGPRs();
JS_EXPORT_PRIVATE static RegisterSet allFPRs();
static RegisterSet allRegisters();
JS_EXPORT_PRIVATE static RegisterSet argumentGPRS();
static RegisterSet registersToNotSaveForJSCall();
static RegisterSet registersToNotSaveForCCall();
void set(Reg reg, bool value = true)
{
ASSERT(!!reg);
m_bits.set(reg.index(), value);
}
void set(JSValueRegs regs, bool value = true)
{
if (regs.tagGPR() != InvalidGPRReg)
set(regs.tagGPR(), value);
set(regs.payloadGPR(), value);
}
void clear(Reg reg)
{
ASSERT(!!reg);
set(reg, false);
}
bool get(Reg reg) const
{
ASSERT(!!reg);
return m_bits.get(reg.index());
}
template<typename Iterable>
void setAll(const Iterable& iterable)
{
for (Reg reg : iterable)
set(reg);
}
bool add(Reg reg)
{
ASSERT(!!reg);
return !m_bits.testAndSet(reg.index());
}
bool remove(Reg reg)
{
ASSERT(!!reg);
return m_bits.testAndClear(reg.index());
}
bool contains(Reg reg) const { return get(reg); }
void merge(const RegisterSet& other) { m_bits.merge(other.m_bits); }
void filter(const RegisterSet& other) { m_bits.filter(other.m_bits); }
void exclude(const RegisterSet& other) { m_bits.exclude(other.m_bits); }
bool subsumes(const RegisterSet& other) const { return m_bits.subsumes(other.m_bits); }
size_t numberOfSetGPRs() const;
size_t numberOfSetFPRs() const;
size_t numberOfSetRegisters() const { return m_bits.count(); }
bool isEmpty() const { return m_bits.isEmpty(); }
JS_EXPORT_PRIVATE void dump(PrintStream&) const;
enum EmptyValueTag { EmptyValue };
enum DeletedValueTag { DeletedValue };
RegisterSet(EmptyValueTag)
{
m_bits.set(hashSpecialBitIndex);
}
RegisterSet(DeletedValueTag)
{
m_bits.set(hashSpecialBitIndex);
m_bits.set(deletedBitIndex);
}
bool isEmptyValue() const
{
return m_bits.get(hashSpecialBitIndex) && !m_bits.get(deletedBitIndex);
}
bool isDeletedValue() const
{
return m_bits.get(hashSpecialBitIndex) && m_bits.get(deletedBitIndex);
}
bool operator==(const RegisterSet& other) const { return m_bits == other.m_bits; }
bool operator!=(const RegisterSet& other) const { return m_bits != other.m_bits; }
unsigned hash() const { return m_bits.hash(); }
template<typename Func>
void forEach(const Func& func) const
{
m_bits.forEachSetBit(
[&] (size_t index) {
func(Reg::fromIndex(index));
});
}
class iterator {
public:
iterator()
{
}
iterator(const RegisterBitmap::iterator& iter)
: m_iter(iter)
{
}
Reg operator*() const { return Reg::fromIndex(*m_iter); }
iterator& operator++()
{
++m_iter;
return *this;
}
bool operator==(const iterator& other)
{
return m_iter == other.m_iter;
}
bool operator!=(const iterator& other)
{
return !(*this == other);
}
private:
RegisterBitmap::iterator m_iter;
};
iterator begin() const { return iterator(m_bits.begin()); }
iterator end() const { return iterator(m_bits.end()); }
private:
void setAny(Reg reg) { set(reg); }
void setAny(const RegisterSet& set) { merge(set); }
void setMany() { }
template<typename RegType, typename... Regs>
void setMany(RegType reg, Regs... regs)
{
setAny(reg);
setMany(regs...);
}
static const unsigned gprOffset = 0;
static const unsigned fprOffset = gprOffset + MacroAssembler::numGPRs;
static const unsigned hashSpecialBitIndex = fprOffset + MacroAssembler::numFPRs;
static const unsigned deletedBitIndex = 0;
RegisterBitmap m_bits;
};
struct RegisterSetHash {
static unsigned hash(const RegisterSet& set) { return set.hash(); }
static bool equal(const RegisterSet& a, const RegisterSet& b) { return a == b; }
static const bool safeToCompareToEmptyOrDeleted = false;
};
}
namespace WTF {
template<typename T> struct DefaultHash;
template<> struct DefaultHash<JSC::RegisterSet> {
typedef JSC::RegisterSetHash Hash;
};
template<typename T> struct HashTraits;
template<> struct HashTraits<JSC::RegisterSet> : public CustomHashTraits<JSC::RegisterSet> { };
}
#endif // ENABLE(JIT)