mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 514110 - nanojit: avoid getresv() because it has a redundant test. r=gal.

This commit is contained in:
Nicholas Nethercote 2009-09-03 09:36:51 +10:00
Родитель 08626ce345
Коммит e760d49457
3 изменённых файлов: 60 добавлений и 58 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

42
js/src/nanojit/Assembler.cpp
Просмотреть файл

@ -158,8 +158,7 @@ namespace nanojit
LIns* vic = findVictim(regs, allow);
NanoAssert(vic);
Reservation* resv = getresv(vic);
NanoAssert(resv);
Reservation* resv = vic->resvUsed();
// restore vic
Register r = resv->reg;
@ -238,8 +237,7 @@ namespace nanojit
ins = ar.entry[i];
if ( !ins )
continue;
Reservation *r = getresv(ins);
NanoAssert(r != 0);
Reservation *r = ins->resvUsed();
if (r->arIndex) {
if (ins->isop(LIR_alloc)) {
int j=i+1;
@ -281,8 +279,7 @@ namespace nanojit
{
LIns* ins = regs->getActive(r);
// @todo we should be able to check across RegAlloc's somehow (to include savedGP...)
Reservation *v = getresv(ins);
NanoAssert(v != 0);
Reservation *v = ins->resvUsed();
NanoAssertMsg( regs->getActive(v->reg)==ins, "Register record mismatch");
}
}
@ -299,23 +296,23 @@ namespace nanojit
if (ia == ib)
{
findRegFor(ia, allow);
resva = resvb = getresv(ia);
resva = resvb = ia->resvUsed();
}
else
{
resvb = getresv(ib);
bool rbDone = (resvb && resvb->reg != UnknownReg && (allow & rmask(resvb->reg)));
resvb = ib->resv();
bool rbDone = (resvb->used && resvb->reg != UnknownReg && (allow & rmask(resvb->reg)));
if (rbDone) {
// ib already assigned to an allowable reg, keep that one
allow &= ~rmask(resvb->reg);
}
Register ra = findRegFor(ia, allow);
resva = getresv(ia);
NanoAssert(error() || (resva != 0 && ra != UnknownReg));
resva = ia->resv();
NanoAssert(error() || (resva->used && ra != UnknownReg));
if (!rbDone) {
allow &= ~rmask(ra);
findRegFor(ib, allow);
resvb = getresv(ib);
resvb = ib->resvUsed();
}
}
}
@ -402,9 +399,9 @@ namespace nanojit
int Assembler::findMemFor(LIns *i)
{
Reservation* resv = getresv(i);
if (!resv)
(resv = i->resv())->init();
Reservation* resv = i->resv();
if (!resv->used)
resv->init();
if (!resv->arIndex) {
resv->arIndex = arReserve(i);
NanoAssert(resv->arIndex <= _activation.highwatermark);
@ -414,8 +411,8 @@ namespace nanojit
Register Assembler::prepResultReg(LIns *i, RegisterMask allow)
{
Reservation* resv = getresv(i);
const bool pop = !resv || resv->reg == UnknownReg;
Reservation* resv = i->resv();
const bool pop = !resv->used || resv->reg == UnknownReg;
Register rr = findRegFor(i, allow);
freeRsrcOf(i, pop);
return rr;
@ -438,7 +435,7 @@ namespace nanojit
// detailed description.
void Assembler::freeRsrcOf(LIns *i, bool pop)
{
Reservation* resv = getresv(i);
Reservation* resv = i->resvUsed();
int index = resv->arIndex;
Register rr = resv->reg;
@ -469,8 +466,8 @@ namespace nanojit
// Get vic's resv, check r matches.
NanoAssert(!_allocator.isFree(r));
NanoAssert(vic == _allocator.getActive(r));
Reservation* resv = getresv(vic);
NanoAssert(resv && r == resv->reg);
Reservation* resv = vic->resvUsed();
NanoAssert(r == resv->reg);
// Free r.
_allocator.retire(r);
@ -758,8 +755,7 @@ namespace nanojit
if (i)
{
// clear reg allocation, preserve stack allocation.
Reservation* resv = getresv(i);
NanoAssert(resv != 0);
Reservation* resv = i->resvUsed();
_allocator.retire(r);
if (r == resv->reg)
resv->reg = UnknownReg;
@ -917,7 +913,7 @@ namespace nanojit
// is the address of the stack space.
case LIR_alloc: {
countlir_alloc();
Reservation *resv = getresv(ins);
Reservation *resv = ins->resvUsed();
NanoAssert(resv->arIndex != 0);
Register r = resv->reg;
if (r != UnknownReg) {

6
js/src/nanojit/LIR.h
Просмотреть файл

@ -677,6 +677,12 @@ namespace nanojit
uint64_t imm64() const;
double imm64f() const;
Reservation* resv() { return &lastWord; }
// Like resv(), but asserts that the Reservation is used.
Reservation* resvUsed() {
Reservation* r = resv();
NanoAssert(r->used);
return r;
}
void* payload() const;
inline int32_t size() const {
NanoAssert(isop(LIR_alloc));

70
js/src/nanojit/Nativei386.cpp
Просмотреть файл

@ -330,7 +330,7 @@ namespace nanojit
LIns* lo = ins->oprnd1();
LIns* hi = ins->oprnd2();
Reservation *resv = getresv(ins);
Reservation *resv = ins->resvUsed();
Register rr = resv->reg;
if (rr != UnknownReg && (rmask(rr) & FpRegs))
@ -460,7 +460,7 @@ namespace nanojit
{
LIns* base = ins->oprnd1();
int db = ins->disp();
Reservation *resv = getresv(ins);
Reservation *resv = ins->resvUsed();
Register rr = resv->reg;
if (rr != UnknownReg && rmask(rr) & XmmRegs)
@ -560,9 +560,9 @@ namespace nanojit
// if value already in a reg, use that, otherwise
// try to get it into XMM regs before FPU regs.
Reservation* rA = getresv(value);
Reservation* rA = value->resv();
Register rv;
int pop = !rA || rA->reg==UnknownReg;
int pop = !rA->used || rA->reg==UnknownReg;
if (pop) {
rv = findRegFor(value, config.sse2 ? XmmRegs : FpRegs);
} else {
@ -813,10 +813,10 @@ namespace nanojit
}
Register rr = prepResultReg(ins, allow);
Reservation* rA = getresv(lhs);
Reservation* rA = lhs->resv();
Register ra;
// if this is last use of lhs in reg, we can re-use result reg
if (rA == 0 || (ra = rA->reg) == UnknownReg)
if (!rA->used || (ra = rA->reg) == UnknownReg)
ra = findSpecificRegFor(lhs, rr);
// else, rA already has a register assigned.
@ -912,10 +912,10 @@ namespace nanojit
Register rr = prepResultReg(ins, GpRegs);
LIns* lhs = ins->oprnd1();
Reservation *rA = getresv(lhs);
Reservation *rA = lhs->resv();
// if this is last use of lhs in reg, we can re-use result reg
Register ra;
if (rA == 0 || (ra=rA->reg) == UnknownReg)
if (!rA->used || (ra=rA->reg) == UnknownReg)
ra = findSpecificRegFor(lhs, rr);
// else, rA already has a register assigned.
@ -965,21 +965,21 @@ namespace nanojit
}
Register rleft;
Reservation *rL = getresv(lhs);
Reservation *rL = lhs->resv();
/* Does LHS have a register yet? If not, re-use the result reg.
* @todo -- If LHS is const, we could eliminate a register use.
*/
if (rL == NULL || rL->reg == UnknownReg)
if (!rL->used || rL->reg == UnknownReg)
rleft = findSpecificRegFor(lhs, rr);
else
rleft = rL->reg;
Register rright = UnknownReg;
Reservation *rR = getresv(rhs);
Reservation *rR = rhs->resv();
/* Does RHS have a register yet? If not, try to re-use the result reg. */
if (rr != rleft && (rR == NULL || rR->reg == UnknownReg))
if (rr != rleft && (!rR->used || rR->reg == UnknownReg))
rright = findSpecificRegFor(rhs, rr);
if (rright == UnknownReg)
rright = findRegFor(rhs, GpRegs & ~(rmask(rleft)));
@ -1085,7 +1085,7 @@ namespace nanojit
void Assembler::asm_quad(LInsp ins)
{
Reservation *rR = getresv(ins);
Reservation *rR = ins->resvUsed();
Register rr = rR->reg;
if (rr != UnknownReg)
{
@ -1145,7 +1145,7 @@ namespace nanojit
}
else
{
Reservation *resv = getresv(ins);
Reservation *resv = ins->resvUsed();
Register rr = resv->reg;
if (rr == UnknownReg) {
// store quad in spill loc
@ -1168,11 +1168,11 @@ namespace nanojit
LIns *lhs = ins->oprnd1();
Register rr = prepResultReg(ins, XmmRegs);
Reservation *rA = getresv(lhs);
Reservation *rA = lhs->resv();
Register ra;
// if this is last use of lhs in reg, we can re-use result reg
if (rA == 0 || (ra = rA->reg) == UnknownReg) {
if (!rA->used || (ra = rA->reg) == UnknownReg) {
ra = findSpecificRegFor(lhs, rr);
} else if ((rmask(ra) & XmmRegs) == 0) {
/* We need this case on AMD64, because it's possible that
@ -1203,13 +1203,13 @@ namespace nanojit
LIns* lhs = ins->oprnd1();
// lhs into reg, prefer same reg as result
Reservation* rA = getresv(lhs);
Reservation* rA = lhs->resv();
// if this is last use of lhs in reg, we can re-use result reg
if (rA == 0 || rA->reg == UnknownReg)
if (!rA->used || rA->reg == UnknownReg)
findSpecificRegFor(lhs, rr);
// else, rA already has a different reg assigned
NanoAssert(getresv(lhs)!=0 && getresv(lhs)->reg==FST0);
NanoAssert(rA->used && rA->reg==FST0);
// assume that the lhs is in ST(0) and rhs is on stack
FCHS();
@ -1241,8 +1241,8 @@ namespace nanojit
if (p->isconst()) {
LDi(r, p->imm32());
} else {
Reservation* rA = getresv(p);
if (rA) {
Reservation* rA = p->resv();
if (rA->used) {
if (rA->reg == UnknownReg) {
// load it into the arg reg
int d = findMemFor(p);
@ -1277,13 +1277,13 @@ namespace nanojit
void Assembler::asm_pusharg(LInsp p)
{
// arg goes on stack
Reservation* rA = getresv(p);
if (rA == 0 && p->isconst())
Reservation* rA = p->resv();
if (!rA->used && p->isconst())
{
// small const we push directly
PUSHi(p->imm32());
}
else if (rA == 0 || p->isop(LIR_alloc))
else if (!rA->used || p->isop(LIR_alloc))
{
Register ra = findRegFor(p, GpRegs);
PUSHr(ra);
@ -1331,11 +1331,11 @@ namespace nanojit
}
Register rr = prepResultReg(ins, allow);
Reservation *rA = getresv(lhs);
Reservation *rA = lhs->resv();
Register ra;
// if this is last use of lhs in reg, we can re-use result reg
if (rA == 0 || (ra = rA->reg) == UnknownReg) {
if (!rA->used || (ra = rA->reg) == UnknownReg) {
ra = findSpecificRegFor(lhs, rr);
} else if ((rmask(ra) & XmmRegs) == 0) {
/* We need this case on AMD64, because it's possible that
@ -1376,13 +1376,13 @@ namespace nanojit
int db = findMemFor(rhs);
// lhs into reg, prefer same reg as result
Reservation* rA = getresv(lhs);
Reservation* rA = lhs->resv();
// last use of lhs in reg, can reuse rr
if (rA == 0 || rA->reg == UnknownReg)
if (!rA->used || rA->reg == UnknownReg)
findSpecificRegFor(lhs, rr);
// else, rA already has a different reg assigned
NanoAssert(getresv(lhs)!=0 && getresv(lhs)->reg==FST0);
NanoAssert(rA->used && rA->reg==FST0);
// assume that the lhs is in ST(0) and rhs is on stack
if (op == LIR_fadd)
{ FADD(db, FP); }
@ -1455,9 +1455,9 @@ namespace nanojit
SSE_CVTSI2SD(rr, gr);
Reservation* resv = getresv(ins->oprnd1());
Reservation* resv = ins->oprnd1()->resv();
Register xr;
if (resv && (xr = resv->reg) != UnknownReg && (rmask(xr) & GpRegs))
if (resv->used && (xr = resv->reg) != UnknownReg && (rmask(xr) & GpRegs))
{
LEA(gr, 0x80000000, xr);
}
@ -1627,8 +1627,8 @@ namespace nanojit
{
// compare two different numbers
int d = findMemFor(rhs);
rA = getresv(lhs);
int pop = !rA || rA->reg == UnknownReg;
rA = lhs->resv();
int pop = !rA->used || rA->reg == UnknownReg;
findSpecificRegFor(lhs, FST0);
// lhs is in ST(0) and rhs is on stack
FCOM(pop, d, FP);
@ -1636,8 +1636,8 @@ namespace nanojit
else
{
// compare n to itself, this is a NaN test.
rA = getresv(lhs);
int pop = !rA || rA->reg == UnknownReg;
rA = lhs->resv();
int pop = !rA->used || rA->reg == UnknownReg;
findSpecificRegFor(lhs, FST0);
// value in ST(0)
if (pop)