Changeset 160186 in webkit for trunk/Source/JavaScriptCore/interpreter/CallFrameClosure.h

Timestamp:

Dec 5, 2013, 12:33:35 PM (11 years ago)

Author:

[email protected]

Message:

Make the C Loop LLINT work with callToJavaScript.
​https://bugs.webkit.org/show_bug.cgi?id=125294.

Reviewed by Michael Saboff.

1. Changed the C Loop LLINT to dispatch to an Executable via its JITCode instance which is consistent with how the ASM LLINT works.
2. Changed CLoop::execute() to take an Opcode instead of an OpcodeID. This makes it play nice with the use of JITCode for dispatching.
3. Introduce a callToJavaScript and callToNativeFunction for the C Loop LLINT. These will call JSStack::pushFrame() and popFrame() to setup and teardown the CallFrame.
4. Also introduced a C Loop returnFromJavaScript which is just a replacement for ctiOpThrowNotCaught which had the same function.
5. Remove a lot of #if ENABLE(LLINT_C_LOOP) code now that the dispatch mechanism is consistent.

This patch has been tested with both configurations of COMPUTED_GOTOs
on and off.

• interpreter/CachedCall.h:

(JSC::CachedCall::CachedCall):
(JSC::CachedCall::call):
(JSC::CachedCall::setArgument):

• interpreter/CallFrameClosure.h:

(JSC::CallFrameClosure::setThis):
(JSC::CallFrameClosure::setArgument):
(JSC::CallFrameClosure::resetCallFrame):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::prepareForRepeatCall):

• interpreter/Interpreter.h:
• interpreter/JSStack.h:
• interpreter/JSStackInlines.h:

(JSC::JSStack::pushFrame):

• interpreter/ProtoCallFrame.h:

(JSC::ProtoCallFrame::scope):
(JSC::ProtoCallFrame::callee):
(JSC::ProtoCallFrame::thisValue):
(JSC::ProtoCallFrame::argument):
(JSC::ProtoCallFrame::setArgument):

• jit/JITCode.cpp:

(JSC::JITCode::execute):

• jit/JITCode.h:
• jit/JITExceptions.cpp:

(JSC::genericUnwind):

• llint/LLIntCLoop.cpp:

(JSC::LLInt::CLoop::initialize):

• llint/LLIntCLoop.h:
• llint/LLIntEntrypoint.cpp:

(JSC::LLInt::setFunctionEntrypoint):
(JSC::LLInt::setEvalEntrypoint):
(JSC::LLInt::setProgramEntrypoint):

• Inverted the check for vm.canUseJIT(). This allows the JIT case to be #if'd out nicely when building the C Loop LLINT.
• llint/LLIntOpcode.h:
• llint/LLIntThunks.cpp:

(JSC::doCallToJavaScript):
(JSC::executeJS):
(JSC::callToJavaScript):
(JSC::executeNative):
(JSC::callToNativeFunction):

• llint/LLIntThunks.h:
• llint/LowLevelInterpreter.cpp:

(JSC::CLoop::execute):

• runtime/Executable.h:

(JSC::ExecutableBase::offsetOfNumParametersFor):
(JSC::ExecutableBase::hostCodeEntryFor):
(JSC::ExecutableBase::jsCodeEntryFor):
(JSC::ExecutableBase::jsCodeWithArityCheckEntryFor):
(JSC::NativeExecutable::create):
(JSC::NativeExecutable::finishCreation):
(JSC::ProgramExecutable::generatedJITCode):

• runtime/JSArray.cpp:

(JSC::AVLTreeAbstractorForArrayCompare::compare_key_key):

• runtime/StringPrototype.cpp:

(JSC::replaceUsingRegExpSearch):

• runtime/VM.cpp:

(JSC::VM::getHostFunction):

File:

• trunk/Source/JavaScriptCore/interpreter/CallFrameClosure.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/interpreter/CallFrameClosure.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2009, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33 +33 @@
 struct CallFrameClosure {
     CallFrame* oldCallFrame;
-#if ENABLE(LLINT_C_LOOP)
-    CallFrame* newCallFrame;
-#else
-    ProtoCallFrame* newCallFrame;
-#endif
+    ProtoCallFrame* protoCallFrame;
     JSFunction* function;
     FunctionExecutable* functionExecutable;
@@ -47 +43 @@
     void setThis(JSValue value)
     {
-        newCallFrame->setThisValue(value);
+        protoCallFrame->setThisValue(value);
     }
 
     void setArgument(int argument, JSValue value)
     {
-        newCallFrame->setArgument(argument, value);
+        protoCallFrame->setArgument(argument, value);
     }
 
     void resetCallFrame()
     {
-        newCallFrame->setScope(scope);
-#if ENABLE(LLINT_C_LOOP)
-        // setArgument() takes an arg index that starts from 0 for the first
-        // argument after the 'this' value. Since both argumentCountIncludingThis
-        // and parameterCountIncludingThis includes the 'this' value, we need to
-        // subtract 1 from them to make it a valid argument index for setArgument().
-        for (int i = argumentCountIncludingThis-1; i < parameterCountIncludingThis-1; ++i)
-            newCallFrame->setArgument(i, jsUndefined());
-#endif
+        protoCallFrame->setScope(scope);
     }
 };