Changeset 37670 in webkit for trunk/JavaScriptCore/VM/Machine.cpp

Timestamp:

Oct 17, 2008, 7:51:52 PM (17 years ago)

Author:

[email protected]

Message:

2008-10-17 Gavin Barraclough <​[email protected]>

Optimize op_call by allowing call sites to be directly linked to callees.

For the hot path of op_call, CTI now generates a check (initially for an impossible
value), and the first time the call is executed we attempt to link the call directly
to the callee. WWe can currently only do so if the arity of the caller and callee
match. The (optimized) setup for the call on the hot path is linked directly to
the ctiCode for the callee, without indirection.

Two forms of the slow case of the call are generated, the first will be executed the
first time the call is reached. As well as this path attempting to link the call to
a callee, it also relinks the slow case to a second slow case, which will not continue
to attempt relinking the call. (This policy could be changed in future, but for not
this is intended to prevent thrashing).

If a callee that the caller has been linked to is garbage collected, then the link
in the caller's JIt code will be reset back to a value that cannot match - to prevent
any false positive matches.

~20% progression on deltablue & richards, >12% overall reduction in v8-tests
runtime, one or two percent progression on sunspider.

Reviewed by Oliver Hunt.

• VM/CTI.cpp: (JSC::): (JSC::CTI::emitNakedCall): (JSC::unreachable): (JSC::CTI::compileOpCallInitializeCallFrame): (JSC::CTI::compileOpCallSetupArgs): (JSC::CTI::compileOpCall): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompileSlowCases): (JSC::CTI::privateCompile): (JSC::CTI::unlinkCall): (JSC::CTI::linkCall):
• VM/CTI.h:
• VM/CodeBlock.cpp: (JSC::CodeBlock::~CodeBlock): (JSC::CodeBlock::unlinkCallers): (JSC::CodeBlock::derefStructureIDs):
• VM/CodeBlock.h: (JSC::StructureStubInfo::StructureStubInfo): (JSC::CallLinkInfo::CallLinkInfo): (JSC::CodeBlock::addCaller): (JSC::CodeBlock::removeCaller): (JSC::CodeBlock::getStubInfo):
• VM/CodeGenerator.cpp: (JSC::CodeGenerator::emitCall): (JSC::CodeGenerator::emitConstruct):
• VM/Machine.cpp: (JSC::Machine::cti_op_call_profiler): (JSC::Machine::cti_op_call_JSFunction): (JSC::Machine::cti_vm_lazyLinkCall): (JSC::Machine::cti_op_construct_JSConstructFast): (JSC::Machine::cti_op_construct_JSConstruct): (JSC::Machine::cti_op_construct_NotJSConstruct):
• VM/Machine.h:
• kjs/JSFunction.cpp: (JSC::JSFunction::~JSFunction):
• kjs/JSFunction.h:
• kjs/nodes.h: (JSC::FunctionBodyNode::):
• masm/X86Assembler.h: (JSC::X86Assembler::getDifferenceBetweenLabels):

File:

• trunk/JavaScriptCore/VM/Machine.cpp (modified) (6 diffs)

trunk/JavaScriptCore/VM/Machine.cpp

@@ -4545 +4545 @@
 }
 
+void Machine::cti_op_call_profiler(CTI_ARGS)
+{
+    ASSERT(*ARG_profilerReference);
+    (*ARG_profilerReference)->willExecute(ARG_callFrame, static_cast<JSFunction*>(ARG_src1));
+}
+
 VoidPtrPair Machine::cti_op_call_JSFunction(CTI_ARGS)
 {
@@ -4551 +4557 @@
     ASSERT(ARG_src1->getCallData(callData) == CallTypeJS);
 #endif
-
-    if (UNLIKELY(*ARG_profilerReference != 0))
-        (*ARG_profilerReference)->willExecute(ARG_callFrame, static_cast<JSFunction*>(ARG_src1));
 
     ScopeChainNode* callDataScopeChain = static_cast<JSFunction*>(ARG_src1)->m_scopeChain.node();
@@ -4592 +4595 @@
     VoidPtrPair pair = { newCodeBlock, CallFrame::create(r) };
     return pair;
+}
+
+void* Machine::cti_vm_lazyLinkCall(CTI_ARGS)
+{
+    Machine* machine = ARG_globalData->machine;
+    CallFrame* callFrame = CallFrame::create(ARG_callFrame);
+    CallFrame* callerCallFrame = callFrame->callerFrame();
+    CodeBlock* callerCodeBlock = callerCallFrame->codeBlock();
+
+    JSFunction* callee = static_cast<JSFunction*>(ARG_src1);
+    CodeBlock* codeBlock = &callee->m_body->byteCode(callee->m_scopeChain.node());
+    if (!codeBlock->ctiCode)
+        CTI::compile(machine, callFrame, codeBlock);
+
+    int argCount = ARG_int3;
+    CTI::linkCall(callerCodeBlock, callee, codeBlock, codeBlock->ctiCode, CTI_RETURN_ADDRESS, argCount);
+
+    return codeBlock->ctiCode;
 }
 
@@ -4716 +4737 @@
 }
 
-VoidPtrPair Machine::cti_op_construct_JSConstruct(CTI_ARGS)
-{
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSFunction* constructor = static_cast<JSFunction*>(ARG_src1);
-    JSValue* constrProtoVal = ARG_src2;
-    int firstArg = ARG_int3;
-    int registerOffset = ARG_int4;
-    int argCount = ARG_int5;
-
+JSValue* Machine::cti_op_construct_JSConstructFast(CTI_ARGS)
+{
 #ifndef NDEBUG
     ConstructData constructData;
-    ASSERT(ARG_src1->getConstructData(constructData) == ConstructTypeJS);
+    ASSERT(static_cast<JSFunction*>(ARG_src1)->getConstructData(constructData) == ConstructTypeJS);
 #endif
 
-    if (*ARG_profilerReference)
-        (*ARG_profilerReference)->willExecute(callFrame, constructor);
+    StructureID* structure;
+    if (ARG_src2->isObject())
+        structure = static_cast<JSObject*>(ARG_src2)->inheritorID();
+    else
+        structure = static_cast<JSFunction*>(ARG_src1)->m_scopeChain.node()->globalObject()->emptyObjectStructure();
+    return new (ARG_globalData) JSObject(structure);
+}
+
+VoidPtrPair Machine::cti_op_construct_JSConstruct(CTI_ARGS)
+{
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSFunction* constructor = static_cast<JSFunction*>(ARG_src1);
+    int registerOffset = ARG_int2;
+    int argCount = ARG_int3;
+    JSValue* constrProtoVal = ARG_src5;
+    int firstArg = ARG_int6;
+
+#ifndef NDEBUG
+    ConstructData constructData;
+    ASSERT(constructor->getConstructData(constructData) == ConstructTypeJS);
+#endif
 
     ScopeChainNode* callDataScopeChain = constructor->m_scopeChain.node();
@@ -4784 +4817 @@
 
     JSValue* constrVal = ARG_src1;
-    int firstArg = ARG_int3;
-    int argCount = ARG_int5;
+    int argCount = ARG_int3;
+    int firstArg = ARG_int6;
 
     ConstructData constructData;
@@ -4811 +4844 @@
     ASSERT(constructType == ConstructTypeNone);
 
-    ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, ARG_instr6, callFrame->codeBlock());
+    ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, ARG_instr4, callFrame->codeBlock());
     VM_THROW_EXCEPTION();
 }