diff --git a/js/src/nanojit/Assembler.cpp b/js/src/nanojit/Assembler.cpp
index ff16785d7962..ea3162fad9db 100644
--- a/js/src/nanojit/Assembler.cpp
+++ b/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) {
diff --git a/js/src/nanojit/LIR.h b/js/src/nanojit/LIR.h
index 004b6b4d921d..3d87157846bc 100644
--- a/js/src/nanojit/LIR.h
+++ b/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));
diff --git a/js/src/nanojit/Nativei386.cpp b/js/src/nanojit/Nativei386.cpp
index 73b3c83858bb..d5915019dc20 100644
--- a/js/src/nanojit/Nativei386.cpp
+++ b/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)