[JAEGER] Added JSOP_DEFLOCALFUN.

js/src/methodjit/Compiler.cpp

@@ -307,8 +307,10 @@ mjit::Compiler::generateMethod()
             /* Safe point! */
             FrameEntry *fe = frame.peek(-1);
             frame.storeTo(fe, Address(Assembler::FpReg, offsetof(JSStackFrame, rval)), true);
-            emitReturn();
             frame.pop();
+            /* :TODO: We only have to forget things that are closed over... */
+            frame.forgetEverything();
+            emitReturn();
           }
           END_CASE(JSOP_RETURN)
 
@@ -730,6 +732,20 @@ mjit::Compiler::generateMethod()
           }
           END_CASE(JSOP_CALLDSLOT)
 
+          BEGIN_CASE(JSOP_DEFLOCALFUN)
+          {
+            uint32 slot = GET_SLOTNO(PC);
+            JSFunction *fun = script->getFunction(fullAtomIndex(&PC[SLOTNO_LEN]));
+            prepareStubCall();
+            masm.move(ImmPtr(fun), Registers::ArgReg1);
+            stubCall(stubs::DefLocalFun, Uses(0), Defs(0));
+            frame.takeReg(Registers::ReturnReg);
+            frame.pushTypedPayload(JSVAL_MASK32_FUNOBJ, Registers::ReturnReg);
+            frame.storeLocal(slot);
+            frame.pop();
+          }
+          END_CASE(JSOP_DEFLOCALFUN)
+
           BEGIN_CASE(JSOP_GETUPVAR)
           BEGIN_CASE(JSOP_CALLUPVAR)
           {

js/src/methodjit/Compiler.h

@@ -155,6 +155,7 @@ class Compiler
     STUB_CALL_TYPE(VoidPtrStub);
     STUB_CALL_TYPE(BoolStub);
     STUB_CALL_TYPE(JSObjStubUInt32);
+    STUB_CALL_TYPE(JSObjStubFun);
 
 #undef STUB_CALL_TYPE
     void prepareStubCall();

js/src/methodjit/MethodJIT.h

@@ -189,6 +189,7 @@ typedef void * (JS_FASTCALL *VoidPtrStubPC)(VMFrame &, jsbytecode *);
 typedef void * (JS_FASTCALL *VoidPtrStubUInt32)(VMFrame &, uint32);
 typedef JSObject * (JS_FASTCALL *JSObjStub)(VMFrame &);
 typedef JSObject * (JS_FASTCALL *JSObjStubUInt32)(VMFrame &, uint32);
+typedef JSObject * (JS_FASTCALL *JSObjStubFun)(VMFrame &, JSFunction *);
 
 #define JS_UNJITTABLE_METHOD (reinterpret_cast<void*>(-1))
 

js/src/methodjit/StubCalls.cpp

@@ -1801,3 +1801,36 @@ stubs::GetUpvar(VMFrame &f, uint32 cookie)
     f.regs.sp[0] = js_GetUpvar(f.cx, staticLevel, cookie);
 }
 
+JSObject * JS_FASTCALL
+stubs::DefLocalFun(VMFrame &f, JSFunction *fun)
+{
+    /*
+     * Define a local function (i.e., one nested at the top level of another
+     * function), parented by the current scope chain, stored in a local
+     * variable slot that the compiler allocated.  This is an optimization over
+     * JSOP_DEFFUN that avoids requiring a call object for the outer function's
+     * activation.
+     */
+    JS_ASSERT(fun->isInterpreted());
+    JS_ASSERT(!FUN_FLAT_CLOSURE(fun));
+    JSObject *obj = FUN_OBJECT(fun);
+
+    if (FUN_NULL_CLOSURE(fun)) {
+        obj = CloneFunctionObject(f.cx, fun, f.fp->scopeChain);
+        if (!obj)
+            THROWV(NULL);
+    } else {
+        JSObject *parent = js_GetScopeChain(f.cx, f.fp);
+        if (!parent)
+            THROWV(NULL);
+
+        if (obj->getParent() != parent) {
+            obj = CloneFunctionObject(f.cx, fun, parent);
+            if (!obj)
+                THROWV(NULL);
+        }
+    }
+
+    return obj;
+}
+

js/src/methodjit/StubCalls.h

@@ -66,6 +66,7 @@ void JS_FASTCALL SetElem(VMFrame &f);
 void JS_FASTCALL CallName(VMFrame &f, uint32 index);
 void JS_FASTCALL GetUpvar(VMFrame &f, uint32 index);
 void JS_FASTCALL DefFun(VMFrame &f, uint32 index);
+JSObject * JS_FASTCALL DefLocalFun(VMFrame &f, JSFunction *fun);
 
 void JS_FASTCALL VpInc(VMFrame &f, Value *vp);
 void JS_FASTCALL VpDec(VMFrame &f, Value *vp);