Changeset 31783

Timestamp:

04/10/08 13:27:40 (2 years ago)

Author:

ggaren@apple.com

Message:

2008-04-10 Geoffrey Garen < ggaren@apple.com>

Reviewed by Oliver Hunt and Sam Weinig.

Re-entrant execution of function code (global code -> built-in function
-> JS function):

Miraculously, sunspider --squirrelfish does not seem to complain.

A re-entrant function call is the same as a normal function call with
one exception: the re-entrant call leaves everything except for
CallerCodeBlock in the call frame header uninitialized, since the call
doesn't need to return to JS code. (It sets CallerCodeBlock to 0, to
indicate that the call shouldn't return to JS code.)

Also fixed a few issues along the way:

• Fixed two bugs in the read-write List implementation that caused m_size and m_buffer to go stale.

• Changed native call code to update "r" *before* setting the return value, since the call may in turn call JS code, which changes the value of "r".

• Migrated initialization of "r" outside of Machine::privateExecute, because global code and function code initialize "r" differently.

• Migrated a codegen warning from Machine::privateExecute to the wiki.

• Removed unnecessary "r" parameter from slideRegisterWindowForCall

• VM/Machine.cpp: (KJS::slideRegisterWindowForCall): (KJS::scopeChainForCall): (KJS::Machine::execute): (KJS::Machine::privateExecute):
• VM/Machine.h:
• kjs/function.cpp: (KJS::FunctionImp::callAsFunction):
• kjs/list.cpp: (KJS::List::getSlice):
• kjs/list.h: (KJS::List::clear):

Location:

branches/squirrelfish/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• VM/CodeBlock.h (modified) (1 diff)
• VM/Machine.cpp (modified) (8 diffs)
• VM/Machine.h (modified) (2 diffs)
• kjs/function.cpp (modified) (3 diffs)
• kjs/list.cpp (modified) (1 diff)
• kjs/list.h (modified) (1 diff)

branches/squirrelfish/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-04-10  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt and Sam Weinig.
+        
+        Re-entrant execution of function code (global code -> built-in function
+        -> JS function):
+        
+        Miraculously, sunspider --squirrelfish does not seem to complain.
+
+        A re-entrant function call is the same as a normal function call with
+        one exception: the re-entrant call leaves everything except for
+        CallerCodeBlock in the call frame header uninitialized, since the call
+        doesn't need to return to JS code. (It sets CallerCodeBlock to 0, to
+        indicate that the call shouldn't return to JS code.)
+        
+        Also fixed a few issues along the way:
+        
+        - Fixed two bugs in the read-write List implementation that caused
+        m_size and m_buffer to go stale.
+        
+        - Changed native call code to update "r" *before* setting the return
+        value, since the call may in turn call JS code, which changes the value
+        of "r".
+        
+        - Migrated initialization of "r" outside of Machine::privateExecute,
+        because global code and function code initialize "r" differently.
+        
+        - Migrated a codegen warning from Machine::privateExecute to the wiki.
+        
+        - Removed unnecessary "r" parameter from slideRegisterWindowForCall
+
+        * VM/Machine.cpp:
+        (KJS::slideRegisterWindowForCall):
+        (KJS::scopeChainForCall):
+        (KJS::Machine::execute):
+        (KJS::Machine::privateExecute):
+        * VM/Machine.h:
+        * kjs/function.cpp:
+        (KJS::FunctionImp::callAsFunction):
+        * kjs/list.cpp:
+        (KJS::List::getSlice):
+        * kjs/list.h:
+        (KJS::List::clear):
+
 2008-04-10  Maciej Stachowiak  <mjs@apple.com>
 

branches/squirrelfish/JavaScriptCore/VM/CodeBlock.h

@@ -31 +31 @@
 #define CodeBlock_h
 
+#include "Instruction.h"
+#include "nodes.h"
+#include "ustring.h"
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
-#include "nodes.h"
-#include "Instruction.h"
-#include "UString.h"
 
 namespace KJS {

branches/squirrelfish/JavaScriptCore/VM/Machine.cpp

@@ -296 +296 @@
 }
 
-ALWAYS_INLINE Register* slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, Register** registerBase, int registerOffset, int argv, int argc, Register* r)
-{
+ALWAYS_INLINE Register* slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, Register** registerBase, int registerOffset, int argv, int argc)
+{
+    Register* r;
     registerOffset += argv + argc + newCodeBlock->numVars;
+
     if (argc == newCodeBlock->numParameters) { // correct number of arguments
         size_t size = registerOffset + newCodeBlock->numTemporaries;
@@ -327 +329 @@
 }
 
-    ALWAYS_INLINE ScopeChain* scopeChainForCall(CodeBlock* newCodeBlock, ScopeChain* callDataScopeChain, FunctionBodyNode* functionBody, Register* callFrame, Register** registerBase, Register* r)
+ALWAYS_INLINE ScopeChain* scopeChainForCall(CodeBlock* newCodeBlock, ScopeChain* callDataScopeChain, FunctionBodyNode* functionBody, Register* callFrame, Register** registerBase, Register* r)
 {
     ScopeChain* scopeChain;
@@ -413 +415 @@
     registerFile->addGlobalSlots(codeBlock->numVars);
     registerFile->grow(codeBlock->numTemporaries);
-
-    JSValue* result = privateExecute(Normal, exec, registerFile, scopeChain, codeBlock, exception);
+    Register* r = (*registerFile->basePointer());
+
+    JSValue* result = privateExecute(Normal, exec, registerFile, r, scopeChain, codeBlock, exception);
 
     registerFileStack->popRegisterFile();
@@ -420 +423 @@
 }
 
-JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, ExecState* exec, RegisterFileStack* registerFileStack, ScopeChain* scopeChain, JSValue** exception)
+JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, const List& args, JSObject* thisObj, ExecState* exec, RegisterFileStack* registerFileStack, ScopeChain* scopeChain, JSValue** exception)
 {
     RegisterFile* registerFile = registerFileStack->current();
-    CodeBlock* codeBlock = &functionBodyNode->code(*scopeChain);
-    registerFile->grow(registerFile->size() + CallFrameHeaderSize + codeBlock->numParameters + codeBlock->numVars + codeBlock->numTemporaries);
-    // put return info in place
-    // use 0 codeBlock to indicate termination
-    // put args in place
-
-    return privateExecute(Normal, exec, registerFile, scopeChain, codeBlock, exception);
-}
-
-JSValue* Machine::privateExecute(ExecutionFlag flag, ExecState* exec, RegisterFile* registerFile, ScopeChain* scopeChain, CodeBlock* codeBlock, JSValue** exception)
+
+    int argv = CallFrameHeaderSize;
+    int argc = args.size() + 1; // implicit "this" parameter
+    
+    size_t oldSize = registerFile->size();
+    registerFile->grow(oldSize + CallFrameHeaderSize + argc);
+    
+    Register** registerBase = registerFile->basePointer();
+    int registerOffset = oldSize;
+    Register* callFrame = (*registerBase) + registerOffset;
+    
+    // put return info in place, using 0 codeBlock to indicate built-in caller
+    callFrame[CallerCodeBlock].u.codeBlock = 0;
+
+    // put args in place, including "this"
+    Register* dst = callFrame + CallFrameHeaderSize;
+    (*dst).u.jsValue = thisObj;
+    
+    List::const_iterator end = args.end();
+    for (List::const_iterator it = args.begin(); it != end; ++it)
+        (*++dst).u.jsValue = *it;
+
+    CodeBlock* newCodeBlock = &functionBodyNode->code(*scopeChain);
+    Register* r = slideRegisterWindowForCall(newCodeBlock, registerFile, registerBase, registerOffset, argv, argc);
+    scopeChain = scopeChainForCall(newCodeBlock, scopeChain, functionBodyNode, callFrame, registerBase, r);            
+    return privateExecute(Normal, exec, registerFile, r, scopeChain, newCodeBlock, exception);
+}
+
+JSValue* Machine::privateExecute(ExecutionFlag flag, ExecState* exec, RegisterFile* registerFile, Register* r, ScopeChain* scopeChain, CodeBlock* codeBlock, JSValue** exception)
 {
     // One-time initialization of our address tables. We have to put this code
@@ -454 +476 @@
     
     Register** registerBase = registerFile->basePointer();
-    Register* r = (*registerBase);
     Instruction* vPC = codeBlock->instructions.begin();
     Instruction* exceptionTarget = 0;
@@ -950 +971 @@
 
             initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, registerOffset, r0, argv, 0);
-
-            // WARNING: If code generation wants to optimize resolves to parent scopes,
-            // it needs to be aware that, for functions that require activations,
-            // the scope chain is off by one, since the activation hasn't been pushed yet.
             CodeBlock* newCodeBlock = &callData.js.functionBody->code(*scopeChain);
 
-            r = slideRegisterWindowForCall(newCodeBlock, registerFile, registerBase, registerOffset, argv, argc, r);
+            r = slideRegisterWindowForCall(newCodeBlock, registerFile, registerBase, registerOffset, argv, argc);
             scopeChain = scopeChainForCall(newCodeBlock, callData.js.scopeChain, callData.js.functionBody, callFrame, registerBase, r);            
             k = newCodeBlock->jsValues.data();
@@ -976 +993 @@
             List args(&r[argv + 1].u.jsValue, argc - 1);
 
-            r[r0].u.jsValue = static_cast<JSObject*>(v)->callAsFunction(exec, thisObj, args);
+            JSValue* returnValue = static_cast<JSObject*>(v)->callAsFunction(exec, thisObj, args);
 
             r = (*registerBase) + registerOffset;
-
+            r[r0].u.jsValue = returnValue;
+            
             ++vPC;
             NEXT_OPCODE;
@@ -1054 +1072 @@
 
             initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, registerOffset, r0, argv, 1);
-
-            // WARNING: If code generation wants to optimize resolves to parent scopes,
-            // it needs to be aware that, for functions that require activations,
-            // the scope chain is off by one, since the activation hasn't been pushed yet.
             CodeBlock* newCodeBlock = &callData.js.functionBody->code(*scopeChain);
 
-            r = slideRegisterWindowForCall(newCodeBlock, registerFile, registerBase, registerOffset, argv, argc, r);
+            r = slideRegisterWindowForCall(newCodeBlock, registerFile, registerBase, registerOffset, argv, argc);
             scopeChain = scopeChainForCall(newCodeBlock, callData.js.scopeChain, callData.js.functionBody, callFrame, registerBase, r);            
             k = newCodeBlock->jsValues.data();

branches/squirrelfish/JavaScriptCore/VM/Machine.h

@@ -76 +76 @@
         
         JSValue* execute(ProgramNode*, ExecState*, RegisterFileStack*, ScopeChain*, JSValue** exception);
-        JSValue* execute(FunctionBodyNode*, ExecState*, RegisterFileStack*, ScopeChain*, JSValue** exception);
+        JSValue* execute(FunctionBodyNode*, const List& args, JSObject* thisObj, ExecState*, RegisterFileStack*, ScopeChain*, JSValue** exception);
         
     private:
@@ -84 +84 @@
         NEVER_INLINE Instruction* throwException(CodeBlock*&, JSValue**&, ScopeChain*&, Register**, Register*&, const Instruction*);
 
-        JSValue* privateExecute(ExecutionFlag, ExecState* = 0, RegisterFile* = 0, ScopeChain* = 0, CodeBlock* = 0, JSValue** exception = 0);
+        JSValue* privateExecute(ExecutionFlag, ExecState* = 0, RegisterFile* = 0, Register* = 0, ScopeChain* = 0, CodeBlock* = 0, JSValue** exception = 0);
 
         void dumpCallFrame(const CodeBlock*, const ScopeChain*, RegisterFile*, const Register*);

branches/squirrelfish/JavaScriptCore/kjs/function.cpp

@@ -29 +29 @@
 #include "Activation.h"
 #include "ExecState.h"
+#include "ExecStateInlines.h"
 #include "JSGlobalObject.h"
+#include "Machine.h"
 #include "Parser.h"
 #include "PropertyNameArray.h"
@@ -40 +42 @@
 #include "operations.h"
 #include "scope_chain_mark.h"
-#include "ExecStateInlines.h"
 #include <errno.h>
 #include <stdio.h>
@@ -73 +74 @@
 }
 
-JSValue* FunctionImp::callAsFunction(ExecState*, JSObject*, const List&)
-{
-    ASSERT_NOT_REACHED();
-    return 0;
+JSValue* FunctionImp::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
+{
+    JSValue* exception;
+    JSValue* result = machine().execute(body.get(), args, thisObj, exec, &exec->dynamicGlobalObject()->registerFileStack(), &_scope, &exception);
+    if (!result)
+        exec->setException(exception);
+    return result;
 }
 

branches/squirrelfish/JavaScriptCore/kjs/list.cpp

@@ -28 +28 @@
 void List::getSlice(int startIndex, List& result) const
 {
+    ASSERT(!result.m_isReadOnly);
+
     const_iterator start = min(begin() + startIndex, end());
     result.m_vector.appendRange(start, end());
+    result.m_size = result.m_vector.size();
 }
 

branches/squirrelfish/JavaScriptCore/kjs/list.h

@@ -86 +86 @@
         {
             m_vector.clear();
-            m_buffer = 0;
             m_size = 0;
         }