Changeset 59339 in webkit for trunk/JavaScriptCore/runtime


Ignore:
Timestamp:
May 12, 2010, 9:01:56 PM (15 years ago)
Author:
[email protected]
Message:

​https://bugs.webkit.org/show_bug.cgi?id=39039
Provide support for separate bytecode/JIT code translations for call/construct usage
This will allow us to produce code generated specifically for use as a constructor, not for general function use.

Reviewed by Oliver Hunt.

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):
(JSC::CodeBlock::unlinkCallers):

  • bytecode/CodeBlock.h:

(JSC::CodeBlock::getBytecodeIndex):
(JSC::CodeBlock::getJITCode):
(JSC::CodeBlock::executablePool):
(JSC::GlobalCodeBlock::GlobalCodeBlock):
(JSC::FunctionCodeBlock::FunctionCodeBlock):

  • interpreter/Interpreter.cpp:

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

  • interpreter/Interpreter.h:
  • jit/JIT.cpp:

(JSC::JIT::unlinkCallOrConstruct):
(JSC::JIT::linkConstruct):

  • jit/JIT.h:
  • jit/JITCall.cpp:

(JSC::JIT::compileOpCall):
(JSC::JIT::compileOpCallSlowCase):

  • jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emitSlow_op_get_by_val):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emitSlow_op_get_by_val):

  • jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

  • jit/JITStubs.h:

(JSC::JITThunks::ctiVirtualConstructLink):
(JSC::JITThunks::ctiVirtualConstruct):
(JSC::):

  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::finalize):

  • runtime/Arguments.h:

(JSC::JSActivation::copyRegisters):

  • runtime/ArrayPrototype.cpp:

(JSC::isNumericCompareFunction):

  • runtime/Executable.cpp:

(JSC::FunctionExecutable::~FunctionExecutable):
(JSC::FunctionExecutable::compileForCall):
(JSC::FunctionExecutable::compileForConstruct):
(JSC::EvalExecutable::generateJITCode):
(JSC::ProgramExecutable::generateJITCode):
(JSC::FunctionExecutable::generateJITCodeForCall):
(JSC::FunctionExecutable::generateJITCodeForConstruct):
(JSC::FunctionExecutable::markAggregate):
(JSC::FunctionExecutable::reparseExceptionInfo):
(JSC::EvalExecutable::reparseExceptionInfo):
(JSC::FunctionExecutable::recompile):

  • runtime/Executable.h:

(JSC::ExecutableBase::ExecutableBase):
(JSC::ExecutableBase::isHostFunction):
(JSC::ExecutableBase::generatedJITCodeForCall):
(JSC::ExecutableBase::generatedJITCodeForConstruct):
(JSC::NativeExecutable::NativeExecutable):
(JSC::EvalExecutable::jitCode):
(JSC::ProgramExecutable::jitCode):
(JSC::FunctionExecutable::bytecodeForCall):
(JSC::FunctionExecutable::isGeneratedForCall):
(JSC::FunctionExecutable::generatedBytecodeForCall):
(JSC::FunctionExecutable::bytecodeForConstruct):
(JSC::FunctionExecutable::isGeneratedForConstruct):
(JSC::FunctionExecutable::generatedBytecodeForConstruct):
(JSC::FunctionExecutable::symbolTable):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::FunctionExecutable::jitCodeForCall):
(JSC::FunctionExecutable::jitCodeForConstruct):

  • runtime/JSActivation.h:

(JSC::JSActivation::JSActivationData::JSActivationData):

  • runtime/JSFunction.cpp:

(JSC::JSFunction::~JSFunction):
(JSC::JSFunction::call):
(JSC::JSFunction::construct):

  • runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::numericCompareFunction):

Location:
trunk/JavaScriptCore/runtime
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/runtime/Arguments.h

    r54022 r59339  
    221221        ASSERT(!d()->registerArray);
    222222
    223         size_t numParametersMinusThis = d()->functionExecutable->generatedBytecode().m_numParameters - 1;
    224         size_t numVars = d()->functionExecutable->generatedBytecode().m_numVars;
     223        size_t numParametersMinusThis = d()->functionExecutable->parameterCount();
     224        size_t numVars = d()->functionExecutable->variableCount();
    225225        size_t numLocals = numVars + numParametersMinusThis;
    226226

  • trunk/JavaScriptCore/runtime/ArrayPrototype.cpp

    r58824 r59339  
    7777    // If the JIT is enabled then we need to preserve the invariant that every
    7878    // function with a CodeBlock also has JIT code.
    79     callData.js.functionExecutable->jitCode(exec, callData.js.scopeChain);
    80     CodeBlock& codeBlock = callData.js.functionExecutable->generatedBytecode();
     79    callData.js.functionExecutable->jitCodeForCall(exec, callData.js.scopeChain);
     80    CodeBlock& codeBlock = callData.js.functionExecutable->generatedBytecodeForCall();
    8181#else
    82     CodeBlock& codeBlock = callData.js.functionExecutable->bytecode(exec, callData.js.scopeChain);
     82    CodeBlock& codeBlock = callData.js.functionExecutable->bytecodeForCall(exec, callData.js.scopeChain);
    8383#endif
    8484

  • trunk/JavaScriptCore/runtime/Executable.cpp

    r54571 r59339  
    5858FunctionExecutable::~FunctionExecutable()
    5959{
    60     delete m_codeBlock;
     60    delete m_codeBlockForCall;
     61    delete m_codeBlockForConstruct;
    6162}
    6263
    … …  
    113114}
    114115
    115 void FunctionExecutable::compile(ExecState*, ScopeChainNode* scopeChainNode)
     116void FunctionExecutable::compileForCall(ExecState*, ScopeChainNode* scopeChainNode)
    116117{
    117118    JSGlobalData* globalData = scopeChainNode->globalData;
    … …  
    125126    JSGlobalObject* globalObject = scopeChain.globalObject();
    126127
    127     ASSERT(!m_codeBlock);
    128     m_codeBlock = new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset());
    129     OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body.get(), globalObject->debugger(), scopeChain, m_codeBlock->symbolTable(), m_codeBlock));
    130     generator->generate();
    131     m_numParameters = m_codeBlock->m_numParameters;
    132     ASSERT(m_numParameters);
    133     m_numVariables = m_codeBlock->m_numVars;
     128    ASSERT(!m_codeBlockForCall);
     129    m_codeBlockForCall = new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset(), false);
     130    OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body.get(), globalObject->debugger(), scopeChain, m_codeBlockForCall->symbolTable(), m_codeBlockForCall));
     131    generator->generate();
     132    m_numParametersForCall = m_codeBlockForCall->m_numParameters;
     133    ASSERT(m_numParametersForCall);
     134    m_numVariables = m_codeBlockForCall->m_numVars;
     135    m_symbolTable = m_codeBlockForCall->sharedSymbolTable();
    134136
    135137    body->destroyData();
    136138}
    137139
     140void FunctionExecutable::compileForConstruct(ExecState*, ScopeChainNode* scopeChainNode)
     141{
     142    JSGlobalData* globalData = scopeChainNode->globalData;
     143    RefPtr<FunctionBodyNode> body = globalData->parser->parse<FunctionBodyNode>(globalData, 0, 0, m_source);
     144    if (m_forceUsesArguments)
     145        body->setUsesArguments();
     146    body->finishParsing(m_parameters, m_name);
     147    recordParse(body->features(), body->lineNo(), body->lastLine());
     148
     149    ScopeChain scopeChain(scopeChainNode);
     150    JSGlobalObject* globalObject = scopeChain.globalObject();
     151
     152    ASSERT(!m_codeBlockForConstruct);
     153    m_codeBlockForConstruct = new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset(), true);
     154    OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body.get(), globalObject->debugger(), scopeChain, m_codeBlockForConstruct->symbolTable(), m_codeBlockForConstruct));
     155    generator->generate();
     156    m_numParametersForConstruct = m_codeBlockForConstruct->m_numParameters;
     157    ASSERT(m_numParametersForConstruct);
     158    m_numVariables = m_codeBlockForConstruct->m_numVars;
     159    m_symbolTable = m_codeBlockForConstruct->sharedSymbolTable();
     160
     161    body->destroyData();
     162}
     163
    138164#if ENABLE(JIT)
    139165
    … …  
    141167{
    142168    CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    143     m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
     169    m_jitCodeForCall = JIT::compile(scopeChainNode->globalData, codeBlock);
    144170
    145171#if !ENABLE(OPCODE_SAMPLING)
    … …  
    152178{
    153179    CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    154     m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
     180    m_jitCodeForCall = JIT::compile(scopeChainNode->globalData, codeBlock);
    155181
    156182#if !ENABLE(OPCODE_SAMPLING)
    … …  
    160186}
    161187
    162 void FunctionExecutable::generateJITCode(ExecState* exec, ScopeChainNode* scopeChainNode)
    163 {
    164     CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    165     m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
     188void FunctionExecutable::generateJITCodeForCall(ExecState* exec, ScopeChainNode* scopeChainNode)
     189{
     190    CodeBlock* codeBlock = &bytecodeForCall(exec, scopeChainNode);
     191    m_jitCodeForCall = JIT::compile(scopeChainNode->globalData, codeBlock);
    166192
    167193#if !ENABLE(OPCODE_SAMPLING)
    … …  
    171197}
    172198
     199void FunctionExecutable::generateJITCodeForConstruct(ExecState* exec, ScopeChainNode* scopeChainNode)
     200{
     201    CodeBlock* codeBlock = &bytecodeForConstruct(exec, scopeChainNode);
     202    m_jitCodeForConstruct = JIT::compile(scopeChainNode->globalData, codeBlock);
     203
     204#if !ENABLE(OPCODE_SAMPLING)
     205    if (!BytecodeGenerator::dumpsGeneratedCode())
     206        codeBlock->discardBytecode();
     207#endif
     208}
     209
    173210#endif
    174211
    175212void FunctionExecutable::markAggregate(MarkStack& markStack)
    176213{
    177     if (m_codeBlock)
    178         m_codeBlock->markAggregate(markStack);
     214    if (m_codeBlockForCall)
     215        m_codeBlockForCall->markAggregate(markStack);
     216    if (m_codeBlockForConstruct)
     217        m_codeBlockForConstruct->markAggregate(markStack);
    179218}
    180219
    … …  
    189228    JSGlobalObject* globalObject = scopeChain.globalObject();
    190229
    191     OwnPtr<CodeBlock> newCodeBlock(new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset()));
     230    OwnPtr<CodeBlock> newCodeBlock(new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset(), codeBlock->m_isConstructor));
    192231    globalData->functionCodeBlockBeingReparsed = newCodeBlock.get();
    193232
    … …  
    200239#if ENABLE(JIT)
    201240    JITCode newJITCode = JIT::compile(globalData, newCodeBlock.get());
    202     ASSERT(newJITCode.size() == generatedJITCode().size());
     241    ASSERT(codeBlock->m_isConstructor ? newJITCode.size() == generatedJITCodeForConstruct().size() : newJITCode.size() == generatedJITCodeForCall().size());
    203242#endif
    204243
    … …  
    225264#if ENABLE(JIT)
    226265    JITCode newJITCode = JIT::compile(globalData, newCodeBlock.get());
    227     ASSERT(newJITCode.size() == generatedJITCode().size());
     266    ASSERT(newJITCode.size() == generatedJITCodeForCall().size());
    228267#endif
    229268
    … …  
    233272void FunctionExecutable::recompile(ExecState*)
    234273{
    235     delete m_codeBlock;
    236     m_codeBlock = 0;
    237     m_numParameters = NUM_PARAMETERS_NOT_COMPILED;
    238 #if ENABLE(JIT)
    239     m_jitCode = JITCode();
     274    delete m_codeBlockForCall;
     275    m_codeBlockForCall = 0;
     276    delete m_codeBlockForConstruct;
     277    m_codeBlockForConstruct = 0;
     278    m_numParametersForCall = NUM_PARAMETERS_NOT_COMPILED;
     279    m_numParametersForConstruct = NUM_PARAMETERS_NOT_COMPILED;
     280#if ENABLE(JIT)
     281    m_jitCodeForCall = JITCode();
     282    m_jitCodeForConstruct = JITCode();
    240283#endif
    241284}

  • trunk/JavaScriptCore/runtime/Executable.h

    r58469 r59339  
    3737    class Debugger;
    3838    class EvalCodeBlock;
     39    class FunctionCodeBlock;
    3940    class ProgramCodeBlock;
    4041    class ScopeChainNode;
    … …  
    5152    public:
    5253        ExecutableBase(int numParameters)
    53             : m_numParameters(numParameters)
     54            : m_numParametersForCall(numParameters)
     55            , m_numParametersForConstruct(numParameters)
    5456        {
    5557        }
    … …  
    5759        virtual ~ExecutableBase() {}
    5860
    59         bool isHostFunction() const { return m_numParameters == NUM_PARAMETERS_IS_HOST; }
     61        bool isHostFunction() const
     62        {
     63            ASSERT((m_numParametersForCall == NUM_PARAMETERS_IS_HOST) == (m_numParametersForConstruct == NUM_PARAMETERS_IS_HOST));
     64            return m_numParametersForCall == NUM_PARAMETERS_IS_HOST;
     65        }
    6066
    6167    protected:
    62         int m_numParameters;
     68        int m_numParametersForCall;
     69        int m_numParametersForConstruct;
    6370
    6471#if ENABLE(JIT)
    6572    public:
    66         JITCode& generatedJITCode()
    67         {
    68             ASSERT(m_jitCode);
    69             return m_jitCode;
    70         }
    71 
    72         ExecutablePool* getExecutablePool()
    73         {
    74             return m_jitCode.getExecutablePool();
     73        JITCode& generatedJITCodeForCall()
     74        {
     75            ASSERT(m_jitCodeForCall);
     76            return m_jitCodeForCall;
     77        }
     78
     79        JITCode& generatedJITCodeForConstruct()
     80        {
     81            ASSERT(m_jitCodeForConstruct);
     82            return m_jitCodeForConstruct;
    7583        }
    7684
    7785    protected:
    78         JITCode m_jitCode;
     86        JITCode m_jitCodeForCall;
     87        JITCode m_jitCodeForConstruct;
    7988#endif
    8089    };
    … …  
    8695            : ExecutableBase(NUM_PARAMETERS_IS_HOST)
    8796        {
    88             m_jitCode = exec->globalData().jitStubs.ctiNativeCallThunk()->m_jitCode;
     97            m_jitCodeForCall = exec->globalData().jitStubs.ctiNativeCallThunk()->m_jitCodeForCall;
     98            m_jitCodeForConstruct = exec->globalData().jitStubs.ctiNativeCallThunk()->m_jitCodeForCall; // FIXME: this thunk should have a construct form
    8999        }
    90100        NativeExecutable(JITCode thunk)
    91101            : ExecutableBase(NUM_PARAMETERS_IS_HOST)
    92102        {
    93             m_jitCode = thunk;
     103            m_jitCodeForCall = thunk;
     104            m_jitCodeForConstruct = thunk;
    94105        }
    95106
    … …  
    193204        JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
    194205        {
    195             if (!m_jitCode)
     206            if (!m_jitCodeForCall)
    196207                generateJITCode(exec, scopeChainNode);
    197             return m_jitCode;
     208            return m_jitCodeForCall;
    198209        }
    199210
    … …  
    239250        JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
    240251        {
    241             if (!m_jitCode)
     252            if (!m_jitCodeForCall)
    242253                generateJITCode(exec, scopeChainNode);
    243             return m_jitCode;
     254            return m_jitCodeForCall;
    244255        }
    245256
    … …  
    269280        }
    270281
    271         CodeBlock& bytecode(ExecState* exec, ScopeChainNode* scopeChainNode)
     282        FunctionCodeBlock& bytecodeForCall(ExecState* exec, ScopeChainNode* scopeChainNode)
    272283        {
    273284            ASSERT(scopeChainNode);
    274             if (!m_codeBlock)
    275                 compile(exec, scopeChainNode);
    276             return *m_codeBlock;
    277         }
    278 
    279         bool isGenerated() const
    280         {
    281             return m_codeBlock;
    282         }
    283 
    284         CodeBlock& generatedBytecode()
    285         {
    286             ASSERT(m_codeBlock);
    287             return *m_codeBlock;
     285            if (!m_codeBlockForCall)
     286                compileForCall(exec, scopeChainNode);
     287            return *m_codeBlockForCall;
     288        }
     289
     290        bool isGeneratedForCall() const
     291        {
     292            return m_codeBlockForCall;
     293        }
     294
     295        FunctionCodeBlock& generatedBytecodeForCall()
     296        {
     297            ASSERT(m_codeBlockForCall);
     298            return *m_codeBlockForCall;
     299        }
     300
     301        FunctionCodeBlock& bytecodeForConstruct(ExecState* exec, ScopeChainNode* scopeChainNode)
     302        {
     303            ASSERT(scopeChainNode);
     304            if (!m_codeBlockForConstruct)
     305                compileForConstruct(exec, scopeChainNode);
     306            return *m_codeBlockForConstruct;
     307        }
     308
     309        bool isGeneratedForConstruct() const
     310        {
     311            return m_codeBlockForConstruct;
     312        }
     313
     314        FunctionCodeBlock& generatedBytecodeForConstruct()
     315        {
     316            ASSERT(m_codeBlockForConstruct);
     317            return *m_codeBlockForConstruct;
    288318        }
    289319
    … …  
    292322        size_t variableCount() const { return m_numVariables; }
    293323        UString paramString() const;
     324        SharedSymbolTable* symbolTable() const { return m_symbolTable; }
    294325
    295326        void recompile(ExecState*);
    … …  
    303334            , m_forceUsesArguments(forceUsesArguments)
    304335            , m_parameters(parameters)
    305             , m_codeBlock(0)
     336            , m_codeBlockForCall(0)
     337            , m_codeBlockForConstruct(0)
    306338            , m_name(name)
    307339            , m_numVariables(0)
     340            , m_symbolTable(0)
    308341        {
    309342            m_firstLine = firstLine;
    … …  
    315348            , m_forceUsesArguments(forceUsesArguments)
    316349            , m_parameters(parameters)
    317             , m_codeBlock(0)
     350            , m_codeBlockForCall(0)
     351            , m_codeBlockForConstruct(0)
    318352            , m_name(name)
    319353            , m_numVariables(0)
     354            , m_symbolTable(0)
    320355        {
    321356            m_firstLine = firstLine;
    … …  
    323358        }
    324359
    325         void compile(ExecState*, ScopeChainNode*);
     360        void compileForCall(ExecState*, ScopeChainNode*);
     361        void compileForConstruct(ExecState*, ScopeChainNode*);
    326362
    327363        bool m_forceUsesArguments;
    328364        RefPtr<FunctionParameters> m_parameters;
    329         CodeBlock* m_codeBlock;
     365        FunctionCodeBlock* m_codeBlockForCall;
     366        FunctionCodeBlock* m_codeBlockForConstruct;
    330367        Identifier m_name;
    331368        size_t m_numVariables;
     369        SharedSymbolTable* m_symbolTable;
    332370
    333371#if ENABLE(JIT)
    334372    public:
    335         JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
    336         {
    337             if (!m_jitCode)
    338                 generateJITCode(exec, scopeChainNode);
    339             return m_jitCode;
    340         }
    341 
    342     private:
    343         void generateJITCode(ExecState*, ScopeChainNode*);
     373        JITCode& jitCodeForCall(ExecState* exec, ScopeChainNode* scopeChainNode)
     374        {
     375            if (!m_jitCodeForCall)
     376                generateJITCodeForCall(exec, scopeChainNode);
     377            return m_jitCodeForCall;
     378        }
     379
     380        JITCode& jitCodeForConstruct(ExecState* exec, ScopeChainNode* scopeChainNode)
     381        {
     382            if (!m_jitCodeForConstruct)
     383                generateJITCodeForConstruct(exec, scopeChainNode);
     384            return m_jitCodeForConstruct;
     385        }
     386
     387    private:
     388        void generateJITCodeForCall(ExecState*, ScopeChainNode*);
     389        void generateJITCodeForConstruct(ExecState*, ScopeChainNode*);
    344390#endif
    345391    };

  • trunk/JavaScriptCore/runtime/JSActivation.h

    r58986 r59339  
    7474        struct JSActivationData : public JSVariableObjectData {
    7575            JSActivationData(NonNullPassRefPtr<FunctionExecutable> _functionExecutable, Register* registers)
    76                 : JSVariableObjectData(_functionExecutable->generatedBytecode().symbolTable(), registers)
     76                : JSVariableObjectData(_functionExecutable->symbolTable(), registers)
    7777                , functionExecutable(_functionExecutable)
    7878            {
    7979                // We have to manually ref and deref the symbol table as JSVariableObjectData
    8080                // doesn't know about SharedSymbolTable
    81                 functionExecutable->generatedBytecode().sharedSymbolTable()->ref();
     81                functionExecutable->symbolTable()->ref();
    8282            }
    8383            ~JSActivationData()

  • trunk/JavaScriptCore/runtime/JSFunction.cpp

    r58469 r59339  
    107107#if ENABLE(JIT_OPTIMIZE_CALL)
    108108        ASSERT(m_executable);
    109         if (jsExecutable()->isGenerated())
    110             jsExecutable()->generatedBytecode().unlinkCallers();
     109        if (jsExecutable()->isGeneratedForCall())
     110            jsExecutable()->generatedBytecodeForCall().unlinkCallers();
     111        if (jsExecutable()->isGeneratedForConstruct())
     112            jsExecutable()->generatedBytecodeForConstruct().unlinkCallers();
    111113#endif
    112114        scopeChain().~ScopeChain(); // FIXME: Don't we need to do this in the interpreter too?
    … …  
    137139{
    138140    ASSERT(!isHostFunction());
    139     return exec->interpreter()->execute(jsExecutable(), exec, this, thisValue.toThisObject(exec), args, scopeChain().node(), exec->exceptionSlot());
     141    return exec->interpreter()->executeCall(jsExecutable(), exec, this, thisValue.toThisObject(exec), args, scopeChain().node(), exec->exceptionSlot());
    140142}
    141143
    … …  
    278280    JSObject* thisObj = new (exec) JSObject(structure);
    279281
    280     JSValue result = exec->interpreter()->execute(jsExecutable(), exec, this, thisObj, args, scopeChain().node(), exec->exceptionSlot());
     282    JSValue result = exec->interpreter()->executeConstruct(jsExecutable(), exec, this, thisObj, args, scopeChain().node(), exec->exceptionSlot());
    281283    if (exec->hadException() || !result.isObject())
    282284        return thisObj;

  • trunk/JavaScriptCore/runtime/JSGlobalData.cpp

    r58712 r59339  
    247247        initializingLazyNumericCompareFunction = true;
    248248        RefPtr<FunctionExecutable> function = FunctionExecutable::fromGlobalCode(Identifier(exec, "numericCompare"), exec, 0, makeSource(UString("(function (v1, v2) { return v1 - v2; })")), 0, 0);
    249         lazyNumericCompareFunction = function->bytecode(exec, exec->scopeChain()).instructions();
     249        lazyNumericCompareFunction = function->bytecodeForCall(exec, exec->scopeChain()).instructions();
    250250        initializingLazyNumericCompareFunction = false;
    251251    }
Note: See TracChangeset for help on using the changeset viewer.