Changeset 37160 in webkit for trunk/JavaScriptCore/kjs/Arguments.h

Timestamp:

Oct 1, 2008, 3:18:50 PM (17 years ago)

Author:

[email protected]

Message:

2008-10-01 Cameron Zwarich <​[email protected]>

Reviewed by Darin Adler.

Bug 21123: using "arguments" in a function should not force creation of an activation object
<​https://bugs.webkit.org/show_bug.cgi?id=21123>

Make the 'arguments' object not require a JSActivation. We store the
'arguments' object in the OptionalCalleeArguments call frame slot. We
need to be able to get the original 'arguments' object to tear it off
when returning from a function, but 'arguments' may be assigned to in a
number of ways.

Therefore, we use the OptionalCalleeArguments slot when we want to get
the original activation or we know that 'arguments' was not assigned a
different value. When 'arguments' may have been assigned a new value,
we use a new local variable that is initialized with 'arguments'. Since
a function parameter named 'arguments' may overwrite the value of
'arguments', we also need to be careful to look up 'arguments' in the
symbol table, so we get the parameter named 'arguments' instead of the
local variable that we have added for holding the 'arguments' object.

This is a 19.1% win on the V8 Raytrace benchmark using the SunSpider
harness, and a 20.7% win using the V8 harness. This amounts to a 6.5%
total speedup on the V8 benchmark suite using the V8 harness.

JavaScriptCore:

• VM/CTI.cpp: (JSC::CTI::privateCompileMainPass):
• VM/CodeBlock.h:
• VM/CodeGenerator.cpp: (JSC::CodeGenerator::CodeGenerator):
• VM/Machine.cpp: (JSC::Machine::unwindCallFrame): (JSC::Machine::privateExecute): (JSC::Machine::retrieveArguments): (JSC::Machine::cti_op_init_arguments): (JSC::Machine::cti_op_ret_activation_arguments):
• VM/Machine.h:
• VM/RegisterFile.h: (JSC::RegisterFile::):
• kjs/Arguments.cpp: (JSC::Arguments::mark): (JSC::Arguments::fillArgList): (JSC::Arguments::getOwnPropertySlot): (JSC::Arguments::put):
• kjs/Arguments.h: (JSC::Arguments::setRegisters): (JSC::Arguments::init): (JSC::Arguments::Arguments): (JSC::Arguments::copyRegisters): (JSC::JSActivation::copyRegisters):
• kjs/JSActivation.cpp: (JSC::JSActivation::argumentsGetter):
• kjs/JSActivation.h: (JSC::JSActivation::JSActivationData::JSActivationData):
• kjs/grammar.y:
• kjs/nodes.h: (JSC::ScopeNode::setUsesArguments):
• masm/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::orl_mr):

LayoutTests:

• fast/js/arguments-expected.txt:
• fast/js/function-dot-arguments-expected.txt:
• fast/js/resources/arguments.js:
• fast/js/resources/function-dot-arguments.js:

File:

• trunk/JavaScriptCore/kjs/Arguments.h (modified) (3 diffs)

trunk/JavaScriptCore/kjs/Arguments.h

@@ -25 +25 @@
 #define Arguments_h
 
-#include "JSObject.h"
+#include "JSActivation.h"
+#include "JSFunction.h"
+#include "JSGlobalObject.h"
+#include "Machine.h"
 
 namespace JSC {
 
-    class JSActivation;
-    class JSFunction;
-    class Register;
+    struct ArgumentsData : Noncopyable {
+        JSActivation* activation;
 
-    struct ArgumentsData;
+        unsigned numParameters;
+        int firstParameterIndex;
+        unsigned numArguments;
+
+        Register* registers;
+        OwnArrayPtr<Register> registerArray;
+
+        Register* extraArguments;
+        OwnArrayPtr<bool> deletedArguments;
+        Register extraArgumentsFixedBuffer[4];
+
+        JSFunction* callee;
+        bool overrodeLength : 1;
+        bool overrodeCallee : 1;
+    };
+
 
     class Arguments : public JSObject {
     public:
-        Arguments(ExecState*, JSFunction*, JSActivation*, int firstArgumentIndex, Register* argv, int argc);
+        Arguments(ExecState*, Register* callFrame);
+        Arguments(ExecState*, JSActivation*);
         virtual ~Arguments();
 
@@ -45 +63 @@
 
         void fillArgList(ExecState*, ArgList&);
+
+        void copyRegisters();
+        void setRegisters(Register* registers) { d->registers = registers; }
 
     private:
@@ -56 +77 @@
         virtual const ClassInfo* classInfo() const { return &info; }
 
+        void init(ExecState*, Register* callFrame);
+
         OwnPtr<ArgumentsData> d;
     };
+
+    inline void Arguments::init(ExecState* exec, Register* callFrame)
+    {
+        JSFunction* callee;
+        int firstParameterIndex;
+        Register* argv;
+        int numArguments;
+        exec->machine()->getArgumentsData(callFrame, callee, firstParameterIndex, argv, numArguments);
+
+        d->numParameters = callee->numParameters();
+        d->firstParameterIndex = firstParameterIndex;
+        d->numArguments = numArguments;
+
+        d->registers = callFrame;
+
+        Register* extraArguments;
+        if (d->numArguments <= d->numParameters)
+            extraArguments = 0;
+        else {
+            unsigned numExtraArguments = d->numArguments - d->numParameters;
+            if (numExtraArguments > sizeof(d->extraArgumentsFixedBuffer) / sizeof(Register))
+                extraArguments = new Register[numExtraArguments];
+            else
+                extraArguments = d->extraArgumentsFixedBuffer;
+            for (unsigned i = 0; i < numExtraArguments; ++i)
+                extraArguments[i] = argv[d->numParameters + i];
+        }
+
+        d->extraArguments = extraArguments;
+
+        d->callee = callee;
+        d->overrodeLength = false;
+        d->overrodeCallee = false;
+    }
+
+    inline Arguments::Arguments(ExecState* exec, Register* callFrame)
+        : JSObject(exec->lexicalGlobalObject()->argumentsStructure())
+        , d(new ArgumentsData)
+    {
+        d->activation = 0;
+        init(exec, callFrame);
+    }
+
+    inline Arguments::Arguments(ExecState* exec, JSActivation* activation)
+        : JSObject(exec->lexicalGlobalObject()->argumentsStructure())
+        , d(new ArgumentsData)
+    {
+        ASSERT(activation);
+        d->activation = activation;
+        init(exec, &activation->registerAt(0));
+    }
+
+    inline void Arguments::copyRegisters()
+    {
+        ASSERT(!d->activation);
+        ASSERT(!d->registerArray);
+
+        size_t numParametersMinusThis = d->callee->m_body->generatedByteCode().numParameters - 1;
+
+        if (!numParametersMinusThis)
+            return;
+
+        int registerOffset = numParametersMinusThis + RegisterFile::CallFrameHeaderSize;
+        size_t registerArraySize = numParametersMinusThis;
+
+        Register* registerArray = new Register[registerArraySize];
+        memcpy(registerArray, d->registers - registerOffset, registerArraySize * sizeof(Register));
+        d->registerArray.set(registerArray);
+        d->registers = registerArray + registerOffset;
+    }
+
+    // This JSActivation function is defined here so it can get at Arguments::setRegisters.
+    inline void JSActivation::copyRegisters(JSValue* arguments)
+    {
+        ASSERT(!d()->registerArray);
+
+        size_t numParametersMinusThis = d()->functionBody->generatedByteCode().numParameters - 1;
+        size_t numVars = d()->functionBody->generatedByteCode().numVars;
+        size_t numLocals = numVars + numParametersMinusThis;
+
+        if (!numLocals)
+            return;
+
+        int registerOffset = numParametersMinusThis + RegisterFile::CallFrameHeaderSize;
+        size_t registerArraySize = numLocals + RegisterFile::CallFrameHeaderSize;
+
+        Register* registerArray = copyRegisterArray(d()->registers - registerOffset, registerArraySize);
+        setRegisters(registerArray + registerOffset, registerArray);
+        if (arguments) {
+            ASSERT(arguments->isObject(&Arguments::info));
+            static_cast<Arguments*>(arguments)->setRegisters(registerArray + registerOffset);
+        }
+    }
 
 } // namespace JSC