#include "config.h"
#include "FTLLocation.h"
#if ENABLE(FTL_JIT)
#include "FTLSaveRestore.h"
#include "RegisterSet.h"
#include <wtf/CommaPrinter.h>
#include <wtf/DataLog.h>
#include <wtf/ListDump.h>
namespace JSC { namespace FTL {
Location Location::forStackmaps(const StackMaps* stackmaps, const StackMaps::Location& location)
{
switch (location.kind) {
case StackMaps::Location::Unprocessed:
RELEASE_ASSERT_NOT_REACHED();
break;
case StackMaps::Location::Register:
case StackMaps::Location::Direct:
return forRegister(location.dwarfReg, location.offset);
case StackMaps::Location::Indirect:
return forIndirect(location.dwarfReg, location.offset);
case StackMaps::Location::Constant:
return forConstant(location.offset);
case StackMaps::Location::ConstantIndex:
ASSERT(stackmaps);
return forConstant(stackmaps->constants[location.offset].integer);
}
RELEASE_ASSERT_NOT_REACHED();
return Location();
}
void Location::dump(PrintStream& out) const
{
out.print("(", kind());
if (hasDwarfReg())
out.print(", ", dwarfReg());
if (hasOffset())
out.print(", ", offset());
if (hasAddend())
out.print(", ", addend());
if (hasConstant())
out.print(", ", constant());
out.print(")");
}
bool Location::involvesGPR() const
{
return isGPR() || kind() == Indirect;
}
bool Location::isGPR() const
{
return kind() == Register && dwarfReg().reg().isGPR();
}
GPRReg Location::gpr() const
{
return dwarfReg().reg().gpr();
}
bool Location::isFPR() const
{
return kind() == Register && dwarfReg().reg().isFPR();
}
FPRReg Location::fpr() const
{
return dwarfReg().reg().fpr();
}
void Location::restoreInto(MacroAssembler& jit, char* savedRegisters, GPRReg result, unsigned numFramesToPop) const
{
if (involvesGPR() && RegisterSet::stackRegisters().get(gpr())) {
if (numFramesToPop) {
jit.move(MacroAssembler::framePointerRegister, result);
for (unsigned i = numFramesToPop - 1; i--;)
jit.loadPtr(result, result);
if (gpr() == MacroAssembler::framePointerRegister)
jit.loadPtr(result, result);
else
jit.addPtr(MacroAssembler::TrustedImmPtr(sizeof(void*) * 2), result);
} else
jit.move(gpr(), result);
}
if (isGPR()) {
if (RegisterSet::stackRegisters().get(gpr())) {
} else
jit.load64(savedRegisters + offsetOfGPR(gpr()), result);
if (addend())
jit.add64(MacroAssembler::TrustedImm32(addend()), result);
return;
}
if (isFPR()) {
jit.load64(savedRegisters + offsetOfFPR(fpr()), result);
ASSERT(!addend());
return;
}
switch (kind()) {
case Register:
dataLog("Unrecognized location: ", *this, "\n");
RELEASE_ASSERT_NOT_REACHED();
return;
case Indirect:
if (RegisterSet::stackRegisters().get(gpr())) {
jit.load64(MacroAssembler::Address(result, offset()), result);
return;
}
jit.load64(savedRegisters + offsetOfGPR(gpr()), result);
jit.load64(MacroAssembler::Address(result, offset()), result);
return;
case Constant:
jit.move(MacroAssembler::TrustedImm64(constant()), result);
return;
case Unprocessed:
RELEASE_ASSERT_NOT_REACHED();
return;
}
RELEASE_ASSERT_NOT_REACHED();
}
GPRReg Location::directGPR() const
{
RELEASE_ASSERT(!addend());
return gpr();
}
} }
namespace WTF {
using namespace JSC::FTL;
void printInternal(PrintStream& out, JSC::FTL::Location::Kind kind)
{
switch (kind) {
case Location::Unprocessed:
out.print("Unprocessed");
return;
case Location::Register:
out.print("Register");
return;
case Location::Indirect:
out.print("Indirect");
return;
case Location::Constant:
out.print("Constant");
return;
}
RELEASE_ASSERT_NOT_REACHED();
}
}
#endif // ENABLE(FTL_JIT)