Changeset 36514 in webkit for trunk/JavaScriptCore/VM/CTI.cpp

Timestamp:

Sep 16, 2008, 10:40:01 AM (17 years ago)

Author:

[email protected]

Message:

2008-09-16 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

CTI code generation for op_ret. The majority of the work
(updating variables on the stack & on exec) can be performed
directly in generated code.

We still need to check, & to call out to C-code to handle
activation records, profiling, and full scope chains.

+1.5% Sunspider, +5/6% v8 tests.

• VM/CTI.cpp: (JSC::CTI::emitPutCTIParam): (JSC::CTI::compileOpCall): (JSC::CTI::privateCompileMainPass):
• VM/CTI.h:
• VM/Machine.cpp: (JSC::Machine::cti_op_ret_activation): (JSC::Machine::cti_op_ret_profiler): (JSC::Machine::cti_op_ret_scopeChain):
• VM/Machine.h:

File:

• trunk/JavaScriptCore/VM/CTI.cpp (modified) (3 diffs)

trunk/JavaScriptCore/VM/CTI.cpp

@@ -148 +148 @@
     }
     return 0;
+}
+
+ALWAYS_INLINE void CTI::emitPutCTIParam(void* value, unsigned name)
+{
+    m_jit.movl_i32m(reinterpret_cast<intptr_t>(value), name * sizeof(void*), X86::esp);
 }
 
@@ -465 +470 @@
     emitCall(i, ((type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction));
     m_jit.call_r(X86::eax);
-    emitGetCTIParam(CTI_ARGS_r, X86::edi); // edi := r
+    
+    // In the interpreter the following actions are performed by op_ret:
+    
+    // Store the scope chain - returned by op_ret in %edx (see below) - to ExecState::m_scopeChain and CTI_ARGS_scopeChain on the stack.
+    emitGetCTIParam(CTI_ARGS_exec, X86::ecx);
+    emitPutCTIParam(X86::edx, CTI_ARGS_scopeChain);
+    m_jit.movl_rm(X86::edx, OBJECT_OFFSET(ExecState, m_scopeChain), X86::ecx);
+    // Restore ExecState::m_callFrame.
+    m_jit.leal_mr(-(m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) * sizeof(Register), X86::edi, X86::edx);
+    m_jit.movl_rm(X86::edx, OBJECT_OFFSET(ExecState, m_callFrame), X86::ecx);
+    // Restore CTI_ARGS_codeBlock.
+    emitPutCTIParam(m_codeBlock, CTI_ARGS_codeBlock);
 
     X86Assembler::JmpDst end = m_jit.label();
@@ -799 +815 @@
         }
         case op_ret: {
-            emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCall(i, Machine::cti_op_ret);
-
-            m_jit.pushl_m(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize) - RegisterFile::CTIReturnEIP) * sizeof(Register), X86::edi);
+            // Check for an activation - if there is one, jump to the hook below.
+            m_jit.cmpl_i32m(0, -((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize - RegisterFile::OptionalCalleeActivation) * sizeof(Register)), X86::edi);
+            X86Assembler::JmpSrc activation = m_jit.emitUnlinkedJne();
+            X86Assembler::JmpDst activated = m_jit.label();
+
+            // Check for a profiler - if there is one, jump to the hook below.
+            emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
+            m_jit.cmpl_i32m(0, X86::eax);
+            X86Assembler::JmpSrc profile = m_jit.emitUnlinkedJne();
+            X86Assembler::JmpDst profiled = m_jit.label();
+
+            // We could JIT generate the deref, only calling out to C when the refcount hits zero.
+            if (m_codeBlock->needsFullScopeChain)
+                emitCall(i, Machine::cti_op_ret_scopeChain);
+
+            // Return the result in %eax, and the caller scope chain in %edx (this is read from the callee call frame,
+            // but is only assigned to ExecState::m_scopeChain if returning to a JSFunction).
+            emitGetArg(instruction[i + 1].u.operand, X86::eax);
+            m_jit.movl_mr(-((m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize - RegisterFile::CallerScopeChain) * sizeof(Register)), X86::edi, X86::edx);
+            // Restore the machine return addess from the callframe, roll the callframe back to the caller callframe,
+            // and preserve a copy of r on the stack at CTI_ARGS_r. 
+            m_jit.movl_mr(-(m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize - RegisterFile::CTIReturnEIP) * sizeof(Register), X86::edi, X86::ecx);
+            m_jit.movl_mr(-(m_codeBlock->numLocals + RegisterFile::CallFrameHeaderSize - RegisterFile::CallerRegisters) * sizeof(Register), X86::edi, X86::edi);
+            emitPutCTIParam(X86::edi, CTI_ARGS_r);
+
+            m_jit.pushl_r(X86::ecx);
             m_jit.ret();
+
+            // Activation hook
+            m_jit.link(activation, m_jit.label());
+            emitCall(i, Machine::cti_op_ret_activation);
+            m_jit.link(m_jit.emitUnlinkedJmp(), activated);
+
+            // Profiling hook
+            m_jit.link(profile, m_jit.label());
+            emitCall(i, Machine::cti_op_ret_profiler);
+            m_jit.link(m_jit.emitUnlinkedJmp(), profiled);
+
             i += 2;
             break;