Ignore:
Timestamp:
May 18, 2010, 10:10:11 PM (15 years ago)
Author:
[email protected]
Message:

JavaScriptCore: Simplified handling of 'arguments' -- 1.2% SunSpider speedup
​https://bugs.webkit.org/show_bug.cgi?id=39200

Reviewed by Darin Adler.

Removed the reserved OptionalCalleeArguments slot from the CallFrame.
Now, slots for 'arguments' are allocated and initialized only by
functions that might need them.

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dump): Updated for new bytecode operands.

(JSC::CodeBlock::CodeBlock):

  • bytecode/CodeBlock.h:

(JSC::unmodifiedArgumentsRegister): Added a helper function for mapping
from the arguments register to its unmodified counterpart.

(JSC::CodeBlock::setArgumentsRegister):
(JSC::CodeBlock::argumentsRegister):
(JSC::CodeBlock::usesArguments): Changed from a "usesArguments" bool to
an optional int index representing the arguments register.

  • bytecode/Opcode.h: Updated for new bytecode operands.
  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::addVar): Factored out a helper function for
allocating an anonymous var.

(JSC::BytecodeGenerator::BytecodeGenerator): Merged / simplified some
arguments vs activation logic, and added code to allocate the arguments
registers when needed.

(JSC::BytecodeGenerator::createArgumentsIfNecessary): Updated for new bytecode operands.

(JSC::BytecodeGenerator::emitCallEval): No need to create the arguments
object before calling eval; the activation object will lazily create the
arguments object if eval resolves it.

(JSC::BytecodeGenerator::emitReturn): Updated for new bytecode operands.

(JSC::BytecodeGenerator::emitPushScope):
(JSC::BytecodeGenerator::emitPushNewScope): Ditto emitCallEval.

  • bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::addVar): Factored out a helper function for
allocating an anonymous var.

(JSC::BytecodeGenerator::registerFor): No more need for special handling
of the arguments registers; they're allocated just like normal registers
now.

  • interpreter/CallFrame.h:

(JSC::ExecState::callerFrame):
(JSC::ExecState::init):

  • interpreter/CallFrameClosure.h:

(JSC::CallFrameClosure::resetCallFrame): Nixed optionalCalleeArguments.

  • interpreter/Interpreter.cpp:

(JSC::Interpreter::dumpRegisters):
(JSC::Interpreter::unwindCallFrame):
(JSC::Interpreter::privateExecute):
(JSC::Interpreter::retrieveArguments): Opcodes accessing 'arguments' now
take operands specifying registers, just like all other opcodes.
JSActivation::copyRegisters is no longer responsible for tearing off the
arguments object; instead, the VM is responsible for both.

Also, a behavior change: Each access to f.arguments creates a new object,
unless f itself uses 'arguments'. This matches Chrome, and is necessary
for the optimization. f.arguments is a nonstandard, deprecated feature,
so high fidelity to a given implementation is not necessarily a goal.
Also, as illustrated by the new test case, the identity of f.arguments
has been broken since 2008, except in the case where f itself accesses
f.arguments -- but nobody seemed to notice. So, hopefully this change won't
break the web.

  • interpreter/Register.h: Nixed the special arguments accessor. It's no

longer needed.

  • interpreter/RegisterFile.h:

(JSC::RegisterFile::):

  • jit/JITCall.cpp:

(JSC::JIT::compileOpCallInitializeCallFrame):
(JSC::JIT::compileOpCall):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_tear_off_activation):
(JSC::JIT::emit_op_tear_off_arguments):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emit_op_init_arguments):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_tear_off_activation):
(JSC::JIT::emit_op_tear_off_arguments):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emit_op_init_arguments): The actual optimization: Removed
OptionalCalleeArguments from the callframe slot. Now, it doesn't need
to be initialized for most calls.

  • jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

  • jit/JITStubs.h:

(JSC::): Updated stubs to support arbitrary 'arguments' registers,
instead of hard-coding something in the call frame.

  • runtime/Arguments.h:

(JSC::JSActivation::copyRegisters): Removed some obfuscatory abstraction.

  • runtime/Executable.h:

(JSC::FunctionExecutable::generatedByteCode): Added a helper for accessing
the 'arguments' register. In a future patch, that kind of data should
probably move out of CodeBlock and into Executable.

  • runtime/JSActivation.cpp:

(JSC::JSActivation::getOwnPropertySlot):
(JSC::JSActivation::argumentsGetter):

  • runtime/JSActivation.h: Simplified / fixed access to 'arguments' via

the activation object. It now implements the same behavior implemented
by optimized variable access in the VM. This simplifies some other
things, too -- like eval code generation.

LayoutTests: Simplified handling of 'arguments' -- 1.2% SunSpider speedup
​https://bugs.webkit.org/show_bug.cgi?id=39200

Reviewed by Darin Adler.

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

(argumentsIdentity): Updated to match new behavior.

  • fast/js/function-dot-arguments2-expected.txt:
  • fast/js/function-dot-arguments2.html: New tests for some things that

weren't covered before.

  • fast/js/global-recursion-on-full-stack.html: Rejiggered the stack

usage in this test. Since stack usage is more efficient now, you
need a slightly different usage pattern to hit the exact thing this
test wanted to test.

  • fast/js/kde/script-tests/function_arguments.js:

(f): Updated to more specifically test what this was trying to test,
to avoid just testing the identity of f.arguments.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/bytecode/CodeBlock.cpp

    r59339 r59742  
    491491        }
    492492        case op_create_arguments: {
    493             printf("[%4d] create_arguments\n", location);
     493            int r0 = (++it)->u.operand;
     494            printf("[%4d] create_arguments\t %s\n", location, registerName(exec, r0).data());
    494495            break;
    495496        }
    496497        case op_init_arguments: {
    497             printf("[%4d] init_arguments\n", location);
     498            int r0 = (++it)->u.operand;
     499            printf("[%4d] init_arguments\t %s\n", location, registerName(exec, r0).data());
    498500            break;
    499501        }
    … …  
    10561058        case op_tear_off_activation: {
    10571059            int r0 = (++it)->u.operand;
    1058             printf("[%4d] tear_off_activation\t %s\n", location, registerName(exec, r0).data());
     1060            int r1 = (++it)->u.operand;
     1061            printf("[%4d] tear_off_activation\t %s, %s\n", location, registerName(exec, r0).data(), registerName(exec, r1).data());
    10591062            break;
    10601063        }
    10611064        case op_tear_off_arguments: {
    1062             printf("[%4d] tear_off_arguments\n", location);
     1065            int r0 = (++it)->u.operand;
     1066            printf("[%4d] tear_off_arguments\t %s\n", location, registerName(exec, r0).data());
    10631067            break;
    10641068        }
    … …  
    13411345    , m_instructionCount(0)
    13421346#endif
     1347    , m_argumentsRegister(-1)
    13431348    , m_needsFullScopeChain(ownerExecutable->needsActivation())
    13441349    , m_usesEval(ownerExecutable->usesEval())
    1345     , m_usesArguments(false)
    13461350    , m_isNumericCompareFunction(false)
    13471351    , m_codeType(codeType)
Note: See TracChangeset for help on using the changeset viewer.