#ifndef RegisterSet_h
#define RegisterSet_h
#if ENABLE(JIT)
#include "FPRInfo.h"
#include "GPRInfo.h"
#include "MacroAssembler.h"
#include "Reg.h"
#include "TempRegisterSet.h"
#include <wtf/BitVector.h>
namespace JSC {
class RegisterSet {
public:
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(); static RegisterSet calleeSaveRegisters();
static RegisterSet vmCalleeSaveRegisters(); 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();
static RegisterSet argumentGPRS();
static RegisterSet registersToNotSaveForJSCall();
static RegisterSet registersToNotSaveForCCall();
void set(Reg reg, bool value = true)
{
ASSERT(!!reg);
m_vector.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_vector.get(reg.index());
}
template<typename Iterable>
void setAll(const Iterable& iterable)
{
for (Reg reg : iterable)
set(reg);
}
void merge(const RegisterSet& other) { m_vector.merge(other.m_vector); }
void filter(const RegisterSet& other) { m_vector.filter(other.m_vector); }
void exclude(const RegisterSet& other) { m_vector.exclude(other.m_vector); }
size_t numberOfSetGPRs() const;
size_t numberOfSetFPRs() const;
size_t numberOfSetRegisters() const { return m_vector.bitCount(); }
void dump(PrintStream&) const;
enum EmptyValueTag { EmptyValue };
enum DeletedValueTag { DeletedValue };
RegisterSet(EmptyValueTag)
: m_vector(BitVector::EmptyValue)
{
}
RegisterSet(DeletedValueTag)
: m_vector(BitVector::DeletedValue)
{
}
bool isEmptyValue() const { return m_vector.isEmptyValue(); }
bool isDeletedValue() const { return m_vector.isDeletedValue(); }
bool operator==(const RegisterSet& other) const { return m_vector == other.m_vector; }
unsigned hash() const { return m_vector.hash(); }
template<typename Functor>
void forEach(const Functor& functor) const
{
for (size_t index : m_vector)
functor(Reg::fromIndex(index));
}
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...);
}
BitVector m_vector;
};
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)
#endif // RegisterSet_h