Changeset 157559 in webkit


Ignore:
Timestamp:
Oct 17, 2013, 12:20:20 AM (11 years ago)
Author:
mark.lam@apple.com
Message:

Transition remaining op_get* JITStubs to JIT operations.
​https://bugs.webkit.org/show_bug.cgi?id=122925.

Reviewed by Geoffrey Garen.

Transitioning:

cti_op_get_by_id_generic
cti_op_get_by_val
cti_op_get_by_val_generic
cti_op_get_by_val_string

  • dfg/DFGOperations.cpp:
  • dfg/DFGOperations.h:
  • jit/JIT.h:
  • jit/JITInlines.h:

(JSC::JIT::callOperation):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emitSlow_op_get_arguments_length):
(JSC::JIT::emitSlow_op_get_argument_by_val):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emitSlow_op_get_arguments_length):
(JSC::JIT::emitSlow_op_get_argument_by_val):

  • jit/JITOperations.cpp:
  • jit/JITOperations.h:
  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emitSlow_op_get_by_pname):
(JSC::JIT::privateCompileGetByVal):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emitSlow_op_get_by_pname):

  • jit/JITStubs.cpp:
  • jit/JITStubs.h:
  • runtime/Executable.cpp:

(JSC::setupLLInt): Added some UNUSED_PARAMs to fix the no LLINT build.

  • runtime/Options.cpp:

(JSC::Options::initialize):

Location:
trunk/Source/JavaScriptCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r157558 r157559  
     12013-10-16  Mark Lam  <mark.lam@apple.com>
     2
     3        Transition remaining op_get* JITStubs to JIT operations.
     4        https://bugs.webkit.org/show_bug.cgi?id=122925.
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Transitioning:
     9            cti_op_get_by_id_generic
     10            cti_op_get_by_val
     11            cti_op_get_by_val_generic
     12            cti_op_get_by_val_string
     13
     14        * dfg/DFGOperations.cpp:
     15        * dfg/DFGOperations.h:
     16        * jit/JIT.h:
     17        * jit/JITInlines.h:
     18        (JSC::JIT::callOperation):
     19        * jit/JITOpcodes.cpp:
     20        (JSC::JIT::emitSlow_op_get_arguments_length):
     21        (JSC::JIT::emitSlow_op_get_argument_by_val):
     22        * jit/JITOpcodes32_64.cpp:
     23        (JSC::JIT::emitSlow_op_get_arguments_length):
     24        (JSC::JIT::emitSlow_op_get_argument_by_val):
     25        * jit/JITOperations.cpp:
     26        * jit/JITOperations.h:
     27        * jit/JITPropertyAccess.cpp:
     28        (JSC::JIT::emitSlow_op_get_by_val):
     29        (JSC::JIT::emitSlow_op_get_by_pname):
     30        (JSC::JIT::privateCompileGetByVal):
     31        * jit/JITPropertyAccess32_64.cpp:
     32        (JSC::JIT::emitSlow_op_get_by_val):
     33        (JSC::JIT::emitSlow_op_get_by_pname):
     34        * jit/JITStubs.cpp:
     35        * jit/JITStubs.h:
     36        * runtime/Executable.cpp:
     37        (JSC::setupLLInt): Added some UNUSED_PARAMs to fix the no LLINT build.
     38        * runtime/Options.cpp:
     39        (JSC::Options::initialize):
     40
    1412013-10-16  Filip Pizlo  <fpizlo@apple.com>
    242

  • trunk/Source/JavaScriptCore/dfg/DFGOperations.cpp

    r157457 r157559  
    700700}
    701701
    702 EncodedJSValue JIT_OPERATION operationGetArgumentsLength(ExecState* exec, int32_t argumentsRegister)
    703 {
    704     VM& vm = exec->vm();
    705     NativeCallFrameTracer tracer(&vm, exec);
    706     // Here we can assume that the argumernts were created. Because otherwise the JIT code would
    707     // have not made this call.
    708     Identifier ident(&vm, "length");
    709     JSValue baseValue = exec->uncheckedR(argumentsRegister).jsValue();
    710     PropertySlot slot(baseValue);
    711     return JSValue::encode(baseValue.get(exec, ident, slot));
    712 }
    713 
    714702EncodedJSValue JIT_OPERATION operationGetArgumentByVal(ExecState* exec, int32_t argumentsRegister, int32_t index)
    715703{

  • trunk/Source/JavaScriptCore/dfg/DFGOperations.h

    r157457 r157559  
    9393JSCell* JIT_OPERATION operationCreateInlinedArguments(ExecState*, InlineCallFrame*) WTF_INTERNAL;
    9494void JIT_OPERATION operationTearOffInlinedArguments(ExecState*, JSCell*, JSCell*, InlineCallFrame*) WTF_INTERNAL;
    95 EncodedJSValue JIT_OPERATION operationGetArgumentsLength(ExecState*, int32_t) WTF_INTERNAL;
    9695EncodedJSValue JIT_OPERATION operationGetInlinedArgumentByVal(ExecState*, int32_t, InlineCallFrame*, int32_t) WTF_INTERNAL;
    9796EncodedJSValue JIT_OPERATION operationGetArgumentByVal(ExecState*, int32_t, int32_t) WTF_INTERNAL;

  • trunk/Source/JavaScriptCore/jit/JIT.h

    r157554 r157559  
    788788        MacroAssembler::Call callOperation(J_JITOperation_EJIdc, int, GPRReg, const Identifier*);
    789789        MacroAssembler::Call callOperation(J_JITOperation_EJJ, int, GPRReg, GPRReg);
     790#if USE(JSVALUE64)
     791        MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EJJ, int, GPRReg, GPRReg);
     792#else
     793        MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EJJ, int, GPRReg, GPRReg, GPRReg, GPRReg);
     794#endif
    790795        MacroAssembler::Call callOperation(J_JITOperation_EP, int, void*);
    791796        MacroAssembler::Call callOperation(WithProfileTag, J_JITOperation_EPc, int, Instruction*);

  • trunk/Source/JavaScriptCore/jit/JITInlines.h

    r157546 r157559  
    218218    return appendCallWithExceptionCheckSetJSValueResultWithProfile(operation, dst);
    219219}
     220
     221ALWAYS_INLINE MacroAssembler::Call JIT::callOperation(JIT::WithProfileTag, J_JITOperation_EJJ operation, int dst, GPRReg arg1, GPRReg arg2)
     222{
     223    setupArgumentsWithExecState(arg1, arg2);
     224    return appendCallWithExceptionCheckSetJSValueResultWithProfile(operation, dst);
     225}
    220226#endif
    221227
    … …  
    458464    setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, SH4_32BIT_DUMMY_ARG arg2Payload, arg2Tag);
    459465    return appendCallWithExceptionCheckSetJSValueResult(operation, dst);
     466}
     467
     468ALWAYS_INLINE MacroAssembler::Call JIT::callOperation(JIT::WithProfileTag, J_JITOperation_EJJ operation, int dst, GPRReg arg1Tag, GPRReg arg1Payload, GPRReg arg2Tag, GPRReg arg2Payload)
     469{
     470    setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, SH4_32BIT_DUMMY_ARG arg2Payload, arg2Tag);
     471    return appendCallWithExceptionCheckSetJSValueResultWithProfile(operation, dst);
    460472}
    461473

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r157457 r157559  
    11/*
    2  * Copyright (C) 2009, 2012 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009, 2012, 2013 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
    44 *
    … …  
    10701070    int dst = currentInstruction[1].u.operand;
    10711071    int base = currentInstruction[2].u.operand;
    1072     const Identifier* ident = &(m_codeBlock->identifier(currentInstruction[3].u.operand));
    1073    
    1074     emitGetVirtualRegister(base, regT0);
    1075     JITStubCall stubCall(this, cti_op_get_by_id_generic);
    1076     stubCall.addArgument(regT0);
    1077     stubCall.addArgument(TrustedImmPtr(ident));
    1078     stubCall.call(dst);
     1072    callOperation(operationGetArgumentsLength, dst, base);
    10791073}
    10801074
    … …  
    11141108   
    11151109    skipArgumentsCreation.link(this);
    1116     JITStubCall stubCall(this, cti_op_get_by_val_generic);
    1117     stubCall.addArgument(arguments, regT2);
    1118     stubCall.addArgument(property, regT2);
    1119     stubCall.callWithValueProfiling(dst);
     1110    emitGetVirtualRegister(arguments, regT0);
     1111    emitGetVirtualRegister(property, regT1);
     1112    callOperation(WithProfile, operationGetByValGeneric, dst, regT0, regT1);
    11201113}
    11211114

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r157521 r157559  
    11/*
    2  * Copyright (C) 2009, 2012 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009, 2012, 2013 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
    44 *
    … …  
    11931193    int dst = currentInstruction[1].u.operand;
    11941194    int base = currentInstruction[2].u.operand;
    1195     int ident = currentInstruction[3].u.operand;
    1196    
    1197     JITStubCall stubCall(this, cti_op_get_by_id_generic);
    1198     stubCall.addArgument(base);
    1199     stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
    1200     stubCall.call(dst);
     1195    callOperation(operationGetArgumentsLength, dst, base);
    12011196}
    12021197
    … …  
    12371232   
    12381233    skipArgumentsCreation.link(this);
    1239     JITStubCall stubCall(this, cti_op_get_by_val_generic);
    1240     stubCall.addArgument(arguments);
    1241     stubCall.addArgument(property);
    1242     stubCall.callWithValueProfiling(dst);
     1234    emitLoad(arguments, regT1, regT0);
     1235    emitLoad(property, regT3, regT2);
     1236    callOperation(WithProfile, operationGetByValGeneric, dst, regT1, regT0, regT3, regT2);
    12431237}
    12441238

  • trunk/Source/JavaScriptCore/jit/JITOperations.cpp

    r157546 r157559  
    12961296}
    12971297
     1298EncodedJSValue JIT_OPERATION operationGetArgumentsLength(ExecState* exec, int32_t argumentsRegister)
     1299{
     1300    VM& vm = exec->vm();
     1301    NativeCallFrameTracer tracer(&vm, exec);
     1302    // Here we can assume that the argumernts were created. Because otherwise the JIT code would
     1303    // have not made this call.
     1304    Identifier ident(&vm, "length");
     1305    JSValue baseValue = exec->uncheckedR(argumentsRegister).jsValue();
     1306    PropertySlot slot(baseValue);
     1307    return JSValue::encode(baseValue.get(exec, ident, slot));
     1308}
     1309
     1310static JSValue getByVal(ExecState* exec, JSValue baseValue, JSValue subscript, ReturnAddressPtr returnAddress)
     1311{
     1312    if (LIKELY(baseValue.isCell() && subscript.isString())) {
     1313        if (JSValue result = baseValue.asCell()->fastGetOwnProperty(exec, asString(subscript)->value(exec)))
     1314            return result;
     1315    }
     1316
     1317    if (subscript.isUInt32()) {
     1318        uint32_t i = subscript.asUInt32();
     1319        if (isJSString(baseValue) && asString(baseValue)->canGetIndex(i)) {
     1320            ctiPatchCallByReturnAddress(exec->codeBlock(), returnAddress, FunctionPtr(operationGetByValString));
     1321            return asString(baseValue)->getIndex(exec, i);
     1322        }
     1323        return baseValue.get(exec, i);
     1324    }
     1325
     1326    if (isName(subscript))
     1327        return baseValue.get(exec, jsCast<NameInstance*>(subscript.asCell())->privateName());
     1328
     1329    Identifier property(exec, subscript.toString(exec)->value(exec));
     1330    return baseValue.get(exec, property);
     1331}
     1332
     1333EncodedJSValue JIT_OPERATION operationGetByValGeneric(ExecState* exec, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript)
     1334{
     1335    VM& vm = exec->vm();
     1336    NativeCallFrameTracer tracer(&vm, exec);
     1337    JSValue baseValue = JSValue::decode(encodedBase);
     1338    JSValue subscript = JSValue::decode(encodedSubscript);
     1339
     1340    JSValue result = getByVal(exec, baseValue, subscript, ReturnAddressPtr(OUR_RETURN_ADDRESS));
     1341    return JSValue::encode(result);
     1342}
     1343
     1344EncodedJSValue JIT_OPERATION operationGetByValDefault(ExecState* exec, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript)
     1345{
     1346    VM& vm = exec->vm();
     1347    NativeCallFrameTracer tracer(&vm, exec);
     1348    JSValue baseValue = JSValue::decode(encodedBase);
     1349    JSValue subscript = JSValue::decode(encodedSubscript);
     1350   
     1351    if (baseValue.isObject() && subscript.isInt32()) {
     1352        // See if it's worth optimizing this at all.
     1353        JSObject* object = asObject(baseValue);
     1354        bool didOptimize = false;
     1355
     1356        unsigned bytecodeOffset = exec->locationAsBytecodeOffset();
     1357        ASSERT(bytecodeOffset);
     1358        ByValInfo& byValInfo = exec->codeBlock()->getByValInfo(bytecodeOffset - 1);
     1359        ASSERT(!byValInfo.stubRoutine);
     1360       
     1361        if (hasOptimizableIndexing(object->structure())) {
     1362            // Attempt to optimize.
     1363            JITArrayMode arrayMode = jitArrayModeForStructure(object->structure());
     1364            if (arrayMode != byValInfo.arrayMode) {
     1365                JIT::compileGetByVal(&vm, exec->codeBlock(), &byValInfo, ReturnAddressPtr(OUR_RETURN_ADDRESS), arrayMode);
     1366                didOptimize = true;
     1367            }
     1368        }
     1369       
     1370        if (!didOptimize) {
     1371            // If we take slow path more than 10 times without patching then make sure we
     1372            // never make that mistake again. Or, if we failed to patch and we have some object
     1373            // that intercepts indexed get, then don't even wait until 10 times. For cases
     1374            // where we see non-index-intercepting objects, this gives 10 iterations worth of
     1375            // opportunity for us to observe that the get_by_val may be polymorphic.
     1376            if (++byValInfo.slowPathCount >= 10
     1377                || object->structure()->typeInfo().interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero()) {
     1378                // Don't ever try to optimize.
     1379                RepatchBuffer repatchBuffer(exec->codeBlock());
     1380                repatchBuffer.relinkCallerToFunction(ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationGetByValGeneric));
     1381            }
     1382        }
     1383    }
     1384   
     1385    JSValue result = getByVal(exec, baseValue, subscript, ReturnAddressPtr(OUR_RETURN_ADDRESS));
     1386    return JSValue::encode(result);
     1387}
     1388   
     1389EncodedJSValue JIT_OPERATION operationGetByValString(ExecState* exec, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript)
     1390{
     1391    VM& vm = exec->vm();
     1392    NativeCallFrameTracer tracer(&vm, exec);
     1393    JSValue baseValue = JSValue::decode(encodedBase);
     1394    JSValue subscript = JSValue::decode(encodedSubscript);
     1395   
     1396    JSValue result;
     1397    if (LIKELY(subscript.isUInt32())) {
     1398        uint32_t i = subscript.asUInt32();
     1399        if (isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
     1400            result = asString(baseValue)->getIndex(exec, i);
     1401        else {
     1402            result = baseValue.get(exec, i);
     1403            if (!isJSString(baseValue))
     1404                ctiPatchCallByReturnAddress(exec->codeBlock(), ReturnAddressPtr(OUR_RETURN_ADDRESS), FunctionPtr(operationGetByValDefault));
     1405        }
     1406    } else if (isName(subscript))
     1407        result = baseValue.get(exec, jsCast<NameInstance*>(subscript.asCell())->privateName());
     1408    else {
     1409        Identifier property(exec, subscript.toString(exec)->value(exec));
     1410        result = baseValue.get(exec, property);
     1411    }
     1412
     1413    return JSValue::encode(result);
     1414}
     1415   
    12981416void JIT_OPERATION operationTearOffActivation(ExecState* exec, JSCell* activationCell)
    12991417{

  • trunk/Source/JavaScriptCore/jit/JITOperations.h

    r157546 r157559  
    279279JSCell* JIT_OPERATION operationCreateActivation(ExecState*, int32_t offset) WTF_INTERNAL;
    280280JSCell* JIT_OPERATION operationCreateArguments(ExecState*) WTF_INTERNAL;
     281EncodedJSValue JIT_OPERATION operationGetArgumentsLength(ExecState*, int32_t) WTF_INTERNAL;
     282EncodedJSValue JIT_OPERATION operationGetByValDefault(ExecState*, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript) WTF_INTERNAL;
     283EncodedJSValue JIT_OPERATION operationGetByValGeneric(ExecState*, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript) WTF_INTERNAL;
     284EncodedJSValue JIT_OPERATION operationGetByValString(ExecState*, EncodedJSValue encodedBase, EncodedJSValue encodedSubscript) WTF_INTERNAL;
    281285void JIT_OPERATION operationTearOffActivation(ExecState*, JSCell*) WTF_INTERNAL;
    282286void JIT_OPERATION operationTearOffArguments(ExecState*, JSCell*, JSCell*) WTF_INTERNAL;

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r157546 r157559  
    231231    Label slowPath = label();
    232232   
    233     JITStubCall stubCall(this, cti_op_get_by_val);
    234     stubCall.addArgument(base, regT2);
    235     stubCall.addArgument(property, regT2);
    236     Call call = stubCall.call(dst);
     233    emitGetVirtualRegister(base, regT0);
     234    emitGetVirtualRegister(property, regT1);
     235    Call call = callOperation(operationGetByValDefault, dst, regT0, regT1);
    237236
    238237    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    … …  
    308307    linkSlowCase(iter);
    309308
    310     JITStubCall stubCall(this, cti_op_get_by_val_generic);
    311     stubCall.addArgument(base, regT2);
    312     stubCall.addArgument(property, regT2);
    313     stubCall.call(dst);
     309    emitGetVirtualRegister(base, regT0);
     310    emitGetVirtualRegister(property, regT1);
     311    callOperation(operationGetByValGeneric, dst, regT0, regT1);
    314312}
    315313
    … …  
    993991    RepatchBuffer repatchBuffer(m_codeBlock);
    994992    repatchBuffer.relink(byValInfo->badTypeJump, CodeLocationLabel(byValInfo->stubRoutine->code().code()));
    995     repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_val_generic));
     993    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(operationGetByValGeneric));
    996994}
    997995

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp

    r157546 r157559  
    263263    Label slowPath = label();
    264264   
    265     JITStubCall stubCall(this, cti_op_get_by_val);
    266     stubCall.addArgument(base);
    267     stubCall.addArgument(property);
    268     Call call = stubCall.call(dst);
     265    emitLoad(base, regT1, regT0);
     266    emitLoad(property, regT3, regT2);
     267    Call call = callOperation(operationGetByValDefault, dst, regT1, regT0, regT3, regT2);
    269268
    270269    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    … …  
    703702    linkSlowCase(iter);
    704703   
    705     JITStubCall stubCall(this, cti_op_get_by_val_generic);
    706     stubCall.addArgument(base);
    707     stubCall.addArgument(property);
    708     stubCall.call(dst);
     704    emitLoad(base, regT1, regT0);
     705    emitLoad(property, regT3, regT2);
     706    callOperation(operationGetByValGeneric, dst, regT1, regT0, regT3, regT2);
    709707}
    710708

  • trunk/Source/JavaScriptCore/jit/JITStubs.cpp

    r157546 r157559  
    273273#endif
    274274
    275 // FIXME: This is still used by get_arguments_length, but other than that it's dead.
    276 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_generic)
    277 {
    278     STUB_INIT_STACK_FRAME(stackFrame);
    279 
    280     CallFrame* callFrame = stackFrame.callFrame;
    281     Identifier& ident = stackFrame.args[1].identifier();
    282 
    283     JSValue baseValue = stackFrame.args[0].jsValue();
    284     PropertySlot slot(baseValue);
    285     JSValue result = baseValue.get(callFrame, ident, slot);
    286 
    287     CHECK_FOR_EXCEPTION_AT_END();
    288     return JSValue::encode(result);
    289 }
    290 
    291 static JSValue getByVal(
    292     CallFrame* callFrame, JSValue baseValue, JSValue subscript, ReturnAddressPtr returnAddress)
    293 {
    294     if (LIKELY(baseValue.isCell() && subscript.isString())) {
    295         if (JSValue result = baseValue.asCell()->fastGetOwnProperty(callFrame, asString(subscript)->value(callFrame)))
    296             return result;
    297     }
    298 
    299     if (subscript.isUInt32()) {
    300         uint32_t i = subscript.asUInt32();
    301         if (isJSString(baseValue) && asString(baseValue)->canGetIndex(i)) {
    302             ctiPatchCallByReturnAddress(callFrame->codeBlock(), returnAddress, FunctionPtr(cti_op_get_by_val_string));
    303             return asString(baseValue)->getIndex(callFrame, i);
    304         }
    305         return baseValue.get(callFrame, i);
    306     }
    307 
    308     if (isName(subscript))
    309         return baseValue.get(callFrame, jsCast<NameInstance*>(subscript.asCell())->privateName());
    310 
    311     Identifier property(callFrame, subscript.toString(callFrame)->value(callFrame));
    312     return baseValue.get(callFrame, property);
    313 }
    314 
    315 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val)
    316 {
    317     STUB_INIT_STACK_FRAME(stackFrame);
    318 
    319     CallFrame* callFrame = stackFrame.callFrame;
    320 
    321     JSValue baseValue = stackFrame.args[0].jsValue();
    322     JSValue subscript = stackFrame.args[1].jsValue();
    323    
    324     if (baseValue.isObject() && subscript.isInt32()) {
    325         // See if it's worth optimizing this at all.
    326         JSObject* object = asObject(baseValue);
    327         bool didOptimize = false;
    328 
    329         unsigned bytecodeOffset = callFrame->locationAsBytecodeOffset();
    330         ASSERT(bytecodeOffset);
    331         ByValInfo& byValInfo = callFrame->codeBlock()->getByValInfo(bytecodeOffset - 1);
    332         ASSERT(!byValInfo.stubRoutine);
    333        
    334         if (hasOptimizableIndexing(object->structure())) {
    335             // Attempt to optimize.
    336             JITArrayMode arrayMode = jitArrayModeForStructure(object->structure());
    337             if (arrayMode != byValInfo.arrayMode) {
    338                 JIT::compileGetByVal(&callFrame->vm(), callFrame->codeBlock(), &byValInfo, STUB_RETURN_ADDRESS, arrayMode);
    339                 didOptimize = true;
    340             }
    341         }
    342        
    343         if (!didOptimize) {
    344             // If we take slow path more than 10 times without patching then make sure we
    345             // never make that mistake again. Or, if we failed to patch and we have some object
    346             // that intercepts indexed get, then don't even wait until 10 times. For cases
    347             // where we see non-index-intercepting objects, this gives 10 iterations worth of
    348             // opportunity for us to observe that the get_by_val may be polymorphic.
    349             if (++byValInfo.slowPathCount >= 10
    350                 || object->structure()->typeInfo().interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero()) {
    351                 // Don't ever try to optimize.
    352                 RepatchBuffer repatchBuffer(callFrame->codeBlock());
    353                 repatchBuffer.relinkCallerToFunction(STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val_generic));
    354             }
    355         }
    356     }
    357    
    358     JSValue result = getByVal(callFrame, baseValue, subscript, STUB_RETURN_ADDRESS);
    359     CHECK_FOR_EXCEPTION();
    360     return JSValue::encode(result);
    361 }
    362    
    363 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_generic)
    364 {
    365     STUB_INIT_STACK_FRAME(stackFrame);
    366 
    367     CallFrame* callFrame = stackFrame.callFrame;
    368 
    369     JSValue baseValue = stackFrame.args[0].jsValue();
    370     JSValue subscript = stackFrame.args[1].jsValue();
    371    
    372     JSValue result = getByVal(callFrame, baseValue, subscript, STUB_RETURN_ADDRESS);
    373     CHECK_FOR_EXCEPTION();
    374     return JSValue::encode(result);
    375 }
    376    
    377 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_string)
    378 {
    379     STUB_INIT_STACK_FRAME(stackFrame);
    380    
    381     CallFrame* callFrame = stackFrame.callFrame;
    382    
    383     JSValue baseValue = stackFrame.args[0].jsValue();
    384     JSValue subscript = stackFrame.args[1].jsValue();
    385    
    386     JSValue result;
    387    
    388     if (LIKELY(subscript.isUInt32())) {
    389         uint32_t i = subscript.asUInt32();
    390         if (isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
    391             result = asString(baseValue)->getIndex(callFrame, i);
    392         else {
    393             result = baseValue.get(callFrame, i);
    394             if (!isJSString(baseValue))
    395                 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val));
    396         }
    397     } else if (isName(subscript))
    398         result = baseValue.get(callFrame, jsCast<NameInstance*>(subscript.asCell())->privateName());
    399     else {
    400         Identifier property(callFrame, subscript.toString(callFrame)->value(callFrame));
    401         result = baseValue.get(callFrame, property);
    402     }
    403    
    404     CHECK_FOR_EXCEPTION_AT_END();
    405     return JSValue::encode(result);
    406 }
    407 
    408275DEFINE_STUB_FUNCTION(void*, op_throw)
    409276{

  • trunk/Source/JavaScriptCore/jit/JITStubs.h

    r157546 r157559  
    356356
    357357extern "C" {
    358 EncodedJSValue JIT_STUB cti_op_get_by_id_generic(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    359 EncodedJSValue JIT_STUB cti_op_get_by_val(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    360 EncodedJSValue JIT_STUB cti_op_get_by_val_generic(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    361 EncodedJSValue JIT_STUB cti_op_get_by_val_string(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    362358void JIT_STUB cti_op_throw_static_error(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    363359void* JIT_STUB cti_op_throw(STUB_ARGS_DECLARATION) WTF_INTERNAL;

  • trunk/Source/JavaScriptCore/runtime/Executable.cpp

    r157543 r157559  
    266266    LLInt::setEntrypoint(vm, codeBlock);
    267267#else
     268    UNUSED_PARAM(vm);
     269    UNUSED_PARAM(codeBlock);
    268270    UNREACHABLE_FOR_PLATFORM();
    269271#endif
Note: See TracChangeset for help on using the changeset viewer.