|
|
@@ -1444,15 +1444,16 @@ TranslatorX64::lookupTranslation(SrcKey sk) const { |
|
|
|
|
|
TCA
|
|
|
TranslatorX64::translate(SrcKey sk, bool align, bool allowIR) {
|
|
|
bool useHHIR = allowIR && RuntimeOption::EvalJitUseIR;
|
|
|
bool useHHIR = allowIR;
|
|
|
INC_TPC(translate);
|
|
|
assert(((uintptr_t)vmsp() & (sizeof(Cell) - 1)) == 0);
|
|
|
assert(((uintptr_t)vmfp() & (sizeof(Cell) - 1)) == 0);
|
|
|
|
|
|
if (useHHIR) {
|
|
|
if (m_numHHIRTrans == RuntimeOption::EvalMaxHHIRTrans) {
|
|
|
if (m_numHHIRTrans == RuntimeOption::EvalMaxTrans) {
|
|
|
useHHIR = m_useHHIR = false;
|
|
|
RuntimeOption::EvalJitUseIR = false;
|
|
|
RuntimeOption::EvalJit = false;
|
|
|
ThreadInfo::s_threadInfo->m_reqInjectionData.updateJit();
|
|
|
} else {
|
|
|
m_useHHIR = true;
|
|
|
}
|
|
|
@@ -1468,7 +1469,7 @@ TranslatorX64::translate(SrcKey sk, bool align, bool allowIR) { |
|
|
|
|
|
TCA start = a.code.frontier;
|
|
|
m_lastHHIRPunt.clear();
|
|
|
translateTracelet(sk, m_useHHIR || RuntimeOption::EvalHHIRDisableTx64);
|
|
|
translateTracelet(sk, true);
|
|
|
|
|
|
SKTRACE(1, sk, "translate moved head from %p to %p\n",
|
|
|
getTopTranslation(sk), start);
|
|
|
@@ -10878,10 +10879,6 @@ TranslatorX64::emitPredictionGuards(const NormalizedInstruction& i) { |
|
|
Stats::emitInc(a, Stats::TC_TypePredHit);
|
|
|
}
|
|
|
|
|
|
static void failedTypePred() {
|
|
|
raise_error("A type prediction was incorrect");
|
|
|
}
|
|
|
|
|
|
void
|
|
|
TranslatorX64::translateInstrWork(const Tracelet& t,
|
|
|
const NormalizedInstruction& i) {
|
|
|
@@ -10904,146 +10901,7 @@ TranslatorX64::translateInstrWork(const Tracelet& t, |
|
|
void
|
|
|
TranslatorX64::translateInstr(const Tracelet& t,
|
|
|
const NormalizedInstruction& i) {
|
|
|
/**
|
|
|
* translateInstr() translates an individual instruction in a tracelet,
|
|
|
* either by directly emitting machine code for that instruction or by
|
|
|
* emitting a call to the interpreter.
|
|
|
*
|
|
|
* If the instruction ends the current tracelet, we must emit machine code
|
|
|
* to transfer control to some target that will continue to make forward
|
|
|
* progress. This target may be the beginning of another tracelet, or it may
|
|
|
* be a translator service request. Before transferring control, a tracelet
|
|
|
* must ensure the following invariants hold:
|
|
|
* 1) The machine registers rVmFp and rVmSp are in sync with vmfp()
|
|
|
* and vmsp().
|
|
|
* 2) All "dirty" values are synced in memory. This includes the
|
|
|
* evaluation stack, locals, globals, statics, and any other program
|
|
|
* accessible locations. This also means that all refcounts must be
|
|
|
* up to date.
|
|
|
*/
|
|
|
assert(!m_useHHIR);
|
|
|
assert(!(RuntimeOption::EvalJitUseIR && RuntimeOption::EvalHHIRDisableTx64));
|
|
|
assert(!i.outStack || i.outStack->isStack());
|
|
|
assert(!i.outLocal || i.outLocal->isLocal());
|
|
|
const char *opNames[] = {
|
|
|
#define O(name, imm, push, pop, flags) \
|
|
|
#name,
|
|
|
OPCODES
|
|
|
#undef O
|
|
|
};
|
|
|
SpaceRecorder sr(opNames[i.op()], a);
|
|
|
SKTRACE(1, i.source, "translate %#lx\n", long(a.code.frontier));
|
|
|
const Opcode op = i.op();
|
|
|
|
|
|
TCA start = a.code.frontier;
|
|
|
TCA astart = astubs.code.frontier;
|
|
|
|
|
|
m_regMap.bumpEpoch();
|
|
|
// Allocate the input regs upfront unless instructed otherwise
|
|
|
// or the instruction is interpreted
|
|
|
if (!i.manuallyAllocInputs && i.m_txFlags) {
|
|
|
m_regMap.allocInputRegs(i);
|
|
|
}
|
|
|
|
|
|
if (debug) {
|
|
|
for (unsigned j = 0; j < i.inputs.size(); j++) {
|
|
|
if (i.inputWasInferred(j)) {
|
|
|
DynLocation* dl = i.inputs[j];
|
|
|
assert(dl->rtt.isValue() &&
|
|
|
!dl->rtt.isVagueValue() &&
|
|
|
dl->outerType() != KindOfInvalid);
|
|
|
PhysReg base;
|
|
|
int disp;
|
|
|
locToRegDisp(dl->location, &base, &disp);
|
|
|
DataType type = dl->rtt.typeCheckValue();
|
|
|
emitTypeCheck(a, type, base, disp);
|
|
|
ConditionCode cc = IS_STRING_TYPE(type) ? CC_Z : CC_NZ;
|
|
|
{
|
|
|
UnlikelyIfBlock typePredFailed(cc, a, astubs);
|
|
|
EMIT_CALL(astubs, failedTypePred);
|
|
|
recordReentrantStubCall(i);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!i.grouped) {
|
|
|
emitVariantGuards(t, i);
|
|
|
const NormalizedInstruction* n = &i;
|
|
|
while (n->next && n->next->grouped) {
|
|
|
n = n->next;
|
|
|
emitVariantGuards(t, *n);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Allocate the input regs upfront unless instructed otherwise
|
|
|
// or the instruction is interpreted
|
|
|
if (!i.manuallyAllocInputs && i.m_txFlags) {
|
|
|
m_regMap.allocInputRegs(i);
|
|
|
}
|
|
|
|
|
|
if (i.m_txFlags == Interp || RuntimeOption::EvalThreadingJit) {
|
|
|
// If the problem is local to this instruction, just call out to
|
|
|
// the interpreter. emitInterpOne will perform end-of-tracelet duties
|
|
|
// if this instruction ends the tracelet.
|
|
|
SKTRACE(1, i.source, "Interp\n");
|
|
|
emitInterpOne(t, i);
|
|
|
} else {
|
|
|
// Actually translate the instruction's body.
|
|
|
Stats::emitIncTranslOp(a, op, RuntimeOption::EnableInstructionCounts);
|
|
|
translateInstrWork(t, i);
|
|
|
}
|
|
|
|
|
|
// Invalidate locations that are no longer live
|
|
|
for (unsigned k = 0; k < i.deadLocs.size(); ++k) {
|
|
|
const Location& l = i.deadLocs[k];
|
|
|
m_regMap.invalidate(l);
|
|
|
}
|
|
|
|
|
|
// Kill any live regs that won't be of further use in this trace.
|
|
|
RegSet live = m_regMap.getRegsLike(RegInfo::DIRTY) |
|
|
|
m_regMap.getRegsLike(RegInfo::CLEAN);
|
|
|
PhysReg pr;
|
|
|
while (live.findFirst(pr)) {
|
|
|
live.remove(pr);
|
|
|
const RegInfo* ri = m_regMap.getInfo(pr);
|
|
|
assert(ri->m_state == RegInfo::CLEAN || ri->m_state == RegInfo::DIRTY);
|
|
|
bool dirty = ri->m_state == RegInfo::DIRTY;
|
|
|
if (ri->m_cont.m_kind != RegContent::Loc) continue;
|
|
|
const Location loc = ri->m_cont.m_loc;
|
|
|
// These heuristics do poorly on stack slots, which are more like
|
|
|
// ephemeral temps.
|
|
|
if (loc.space != Location::Local) continue;
|
|
|
if (false && dirty && !t.isWrittenAfterInstr(loc, i)) {
|
|
|
// This seems plausible enough: the intuition is that carrying aroud
|
|
|
// a register we'll read, but not write, in a dirty state, has a cost
|
|
|
// because any control-flow diamonds will have to spill it and then
|
|
|
// refill it. It appears to hurt performance today, though.
|
|
|
m_regMap.cleanLoc(loc);
|
|
|
}
|
|
|
if (t.isLiveAfterInstr(loc, i)) continue;
|
|
|
SKTRACE(1, i.source, "killing %s reg %d for (%s, %d)\n",
|
|
|
dirty ? "dirty" : "clean", (int)pr, loc.spaceName(), loc.offset);
|
|
|
if (dirty) {
|
|
|
m_regMap.cleanLoc(loc);
|
|
|
}
|
|
|
assert(ri->m_state == RegInfo::CLEAN);
|
|
|
m_regMap.smashLoc(loc);
|
|
|
}
|
|
|
|
|
|
emitPredictionGuards(i);
|
|
|
recordBCInstr(op, a, start);
|
|
|
recordBCInstr(op + Op_count, astubs, astart);
|
|
|
|
|
|
if (i.breaksTracelet && !i.changesPC) {
|
|
|
// If this instruction's opcode always ends the tracelet then the
|
|
|
// instruction case is responsible for performing end-of-tracelet
|
|
|
// duties. Otherwise, we handle ending the tracelet here.
|
|
|
syncOutputs(t);
|
|
|
emitBindJmp(t.m_nextSk);
|
|
|
}
|
|
|
|
|
|
m_regMap.assertNoScratch();
|
|
|
not_reached();
|
|
|
}
|
|
|
|
|
|
bool
|
|
|
@@ -11218,9 +11076,7 @@ TranslatorX64::translateTracelet(SrcKey sk, bool considerHHIR/*=true*/, |
|
|
// with more aggressive assumptions, or fall back to the
|
|
|
// interpreter.
|
|
|
if (considerHHIR) {
|
|
|
if (RuntimeOption::EvalHHIRDisableTx64) {
|
|
|
punt();
|
|
|
}
|
|
|
punt();
|
|
|
// Recur. We need to re-analyze. Since m_useHHIR is clear, we
|
|
|
// won't go down this path again.
|
|
|
return translateTracelet(sk, false);
|
|
|
|
0 comments on commit
f323a90