Changeset 208588 in webkit


Ignore:
Timestamp:
Nov 11, 2016 8:50:57 AM (7 years ago)
Author:
Chris Dumez
Message:

Unreviewed, rolling out r208117 and r208160.

Regressed Speedometer by >1.5%

Reverted changesets:

"We should have a way of profiling when a get_by_id is pure
and to emit a PureGetById in the DFG/FTL"
​https://bugs.webkit.org/show_bug.cgi?id=163305
​http://trac.webkit.org/changeset/208117

"Debug JSC test microbenchmarks/pure-get-by-id-cse-2.js timing
out"
​https://bugs.webkit.org/show_bug.cgi?id=164227
​http://trac.webkit.org/changeset/208160

Location:
trunk
Files:
4 deleted
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/JSTests/ChangeLog

    r208584 r208588  
     12016-11-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r208117 and r208160.
     4
     5        Regressed Speedometer by >1.5%
     6
     7        Reverted changesets:
     8
     9        "We should have a way of profiling when a get_by_id is pure
     10        and to emit a PureGetById in the DFG/FTL"
     11        https://bugs.webkit.org/show_bug.cgi?id=163305
     12        http://trac.webkit.org/changeset/208117
     13
     14        "Debug JSC test microbenchmarks/pure-get-by-id-cse-2.js timing
     15        out"
     16        https://bugs.webkit.org/show_bug.cgi?id=164227
     17        http://trac.webkit.org/changeset/208160
     18
    1192016-11-11  Saam Barati  <sbarati@apple.com>
    220

  • trunk/Source/JavaScriptCore/ChangeLog

    r208584 r208588  
     12016-11-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r208117 and r208160.
     4
     5        Regressed Speedometer by >1.5%
     6
     7        Reverted changesets:
     8
     9        "We should have a way of profiling when a get_by_id is pure
     10        and to emit a PureGetById in the DFG/FTL"
     11        https://bugs.webkit.org/show_bug.cgi?id=163305
     12        http://trac.webkit.org/changeset/208117
     13
     14        "Debug JSC test microbenchmarks/pure-get-by-id-cse-2.js timing
     15        out"
     16        https://bugs.webkit.org/show_bug.cgi?id=164227
     17        http://trac.webkit.org/changeset/208160
     18
    1192016-11-11  Saam Barati  <sbarati@apple.com>
    220

  • trunk/Source/JavaScriptCore/bytecode/StructureStubInfo.cpp

    r208117 r208588  
    4949    , tookSlowPath(false)
    5050    , everConsidered(false)
    51     , didSideEffects(false)
    5251{
    5352}
    … …  
    218217
    219218    switch (accessType) {
    220     case AccessType::TryGet:
    221         resetGetByID(codeBlock, *this, GetByIDKind::Try);
    222         break;
    223     case AccessType::PureGet:
     219    case AccessType::GetPure:
    224220        resetGetByID(codeBlock, *this, GetByIDKind::Pure);
    225221        break;

  • trunk/Source/JavaScriptCore/bytecode/StructureStubInfo.h

    r208117 r208588  
    4747enum class AccessType : int8_t {
    4848    Get,
    49     TryGet,
    50     PureGet,
     49    GetPure,
    5150    Put,
    5251    In
    … …  
    207206    bool tookSlowPath : 1;
    208207    bool everConsidered : 1;
    209     bool didSideEffects : 1;
    210208};
    211209

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

    r208584 r208588  
    21522152        break;
    21532153
    2154     case PureGetById:
    21552154    case GetById:
    21562155    case GetByIdFlush: {
    … …  
    21842183        }
    21852184
    2186         if (node->op() == PureGetById)
    2187             clobberStructures(clobberLimit);
    2188         else
    2189             clobberWorld(node->origin.semantic, clobberLimit);
     2185        clobberWorld(node->origin.semantic, clobberLimit);
    21902186        forNode(node).makeHeapTop();
    21912187        break;

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

    r208377 r208588  
    153153static bool canBecomeGetArrayLength(Graph& graph, Node* node)
    154154{
    155     if (node->op() == GetById || node->op() == PureGetById) {
    156         auto uid = graph.identifiers()[node->identifierNumber()];
    157         return uid == graph.m_vm.propertyNames->length.impl();
    158     }
    159     return false;
     155    if (node->op() != GetById)
     156        return false;
     157    auto uid = graph.identifiers()[node->identifierNumber()];
     158    return uid == graph.m_vm.propertyNames->length.impl();
    160159}
    161160

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

    r208584 r208588  
    33463346   
    33473347    NodeType getById;
    3348     switch (type) {
    3349     case AccessType::Get:
     3348    if (type == AccessType::Get)
    33503349        getById = getByIdStatus.makesCalls() ? GetByIdFlush : GetById;
    3351         break;
    3352     case AccessType::TryGet:
     3350    else
    33533351        getById = TryGetById;
    3354         break;
    3355     case AccessType::PureGet:
    3356         getById = PureGetById;
    3357         break;
    3358     default:
    3359         RELEASE_ASSERT_NOT_REACHED();
    3360     }
    33613352
    33623353    // Special path for custom accessors since custom's offset does not have any meanings.
    … …  
    42674258            Node* base = get(VirtualRegister(currentInstruction[2].u.operand));
    42684259            Node* property = get(VirtualRegister(currentInstruction[3].u.operand));
    4269             bool compileAsGetById = false;
    4270             bool compileAsPureGetById = false;
     4260            bool compiledAsGetById = false;
    42714261            GetByIdStatus getByIdStatus;
    42724262            unsigned identifierNumber = 0;
    … …  
    42774267                // At that time, there is no information.
    42784268                if (byValInfo && byValInfo->stubInfo && !byValInfo->tookSlowPath && !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, BadIdent) && !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, BadCell)) {
    4279                     compileAsGetById = true;
    4280                     compileAsPureGetById = !byValInfo->stubInfo->didSideEffects;
     4269                    compiledAsGetById = true;
    42814270                    identifierNumber = m_graph.identifiers().ensure(byValInfo->cachedId.impl());
    42824271                    UniquedStringImpl* uid = m_graph.identifiers()[identifierNumber];
    … …  
    42964285            }
    42974286
    4298             if (compileAsGetById) {
    4299                 AccessType type = compileAsPureGetById ? AccessType::PureGet : AccessType::Get;
    4300                 handleGetById(currentInstruction[1].u.operand, prediction, base, identifierNumber, getByIdStatus, type, OPCODE_LENGTH(op_get_by_val));
    4301             } else {
     4287            if (compiledAsGetById)
     4288                handleGetById(currentInstruction[1].u.operand, prediction, base, identifierNumber, getByIdStatus, AccessType::Get, OPCODE_LENGTH(op_get_by_val));
     4289            else {
    43024290                ArrayMode arrayMode = getArrayMode(currentInstruction[4].u.arrayProfile, Array::Read);
    43034291                Node* getByVal = addToGraph(GetByVal, OpInfo(arrayMode.asWord()), OpInfo(prediction), base, property);
    … …  
    44354423                m_inlineStackTop->m_stubInfos, m_dfgStubInfos,
    44364424                currentCodeOrigin(), uid);
    4437             AccessType type;
    4438             if (opcodeID == op_try_get_by_id)
    4439                 type = AccessType::TryGet;
    4440             else {
    4441                 ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
    4442                 unsigned bytecodeIndex = currentCodeOrigin().bytecodeIndex;
    4443                 StructureStubInfo* info = m_inlineStackTop->m_stubInfos.get(CodeOrigin(bytecodeIndex));
    4444                 if (info && info->everConsidered && !info->didSideEffects)
    4445                     type = AccessType::PureGet;
    4446                 else
    4447                     type = AccessType::Get;
    4448             }
     4425            AccessType type = op_try_get_by_id == opcodeID ? AccessType::GetPure : AccessType::Get;
    44494426
    44504427            unsigned opcodeLength = opcodeID == op_try_get_by_id ? OPCODE_LENGTH(op_try_get_by_id) : OPCODE_LENGTH(op_get_by_id);

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

    r208584 r208588  
    503503        return;
    504504       
    505     case PureGetById: {
    506         // We model what is allowed inside a getOwnPropertySlot(VMInquiry) here.
    507         // Some getOwnPropertySlot implementations will lazily inject properties, which
    508         // may change the object's structure.
    509 
    510         read(JSCell_structureID);
    511         read(JSCell_typeInfoFlags);
    512         read(JSCell_typeInfoType);
    513         read(JSCell_indexingType);
    514         read(JSObject_butterfly);
    515         read(MiscFields);
    516 
    517         AbstractHeap propertyNameHeap(NamedProperties, node->identifierNumber());
    518         read(propertyNameHeap);
    519 
    520         write(JSCell_structureID);
    521         write(JSCell_typeInfoFlags);
    522 
    523         write(Watchpoint_fire);
    524         write(MiscFields);
    525 
    526         // This can happen if lazily adding fields to an object happens in getOwnPropertySlot
    527         // and we need to allocate out of line storage.
    528         write(JSObject_butterfly);
    529 
    530         def(HeapLocation(NamedPropertyLoc, propertyNameHeap, node->child1()), LazyNode(node));
    531         return;
    532     }
    533 
    534505    case GetById:
    535506    case GetByIdFlush:

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

    r208235 r208588  
    450450            }
    451451       
    452             case PureGetById:
    453452            case GetById:
    454453            case GetByIdFlush: {
    … …  
    461460                m_interpreter.execute(indexInBlock); // Push CFA over this node after we get the state before.
    462461                alreadyHandled = true; // Don't allow the default constant folder to do things to this.
    463 
    464                 if (!Options::useAccessInlining())
    465                     break;
    466462
    467463                if (baseValue.m_structure.isTop() || baseValue.m_structure.isClobbered()
    … …  
    519515                m_interpreter.execute(indexInBlock); // Push CFA over this node after we get the state before.
    520516                alreadyHandled = true; // Don't allow the default constant folder to do things to this.
    521 
    522                 if (!Options::useAccessInlining())
    523                     break;
    524517
    525518                if (baseValue.m_structure.isTop() || baseValue.m_structure.isClobbered())

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

    r208584 r208588  
    267267        return false;
    268268
    269     case PureGetById: // We are modeling getOwnPropertySlot here, which may GC because it is allowed to allocate things.
    270269    case CreateActivation:
    271270    case CreateDirectArguments:

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

    r208584 r208588  
    12071207        }
    12081208
    1209         case PureGetById:
    12101209        case GetById:
    12111210        case GetByIdFlush: {

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

    r208584 r208588  
    535535    void convertToGetByOffset(StorageAccessData& data, Edge storage, Edge base)
    536536    {
    537         ASSERT(m_op == GetById || m_op == GetByIdFlush || m_op == PureGetById || m_op == MultiGetByOffset);
     537        ASSERT(m_op == GetById || m_op == GetByIdFlush || m_op == MultiGetByOffset);
    538538        m_opInfo = &data;
    539539        children.setChild1(storage);
    … …  
    545545    void convertToMultiGetByOffset(MultiGetByOffsetData* data)
    546546    {
    547         ASSERT(m_op == GetById || m_op == GetByIdFlush || m_op == PureGetById);
     547        ASSERT(m_op == GetById || m_op == GetByIdFlush);
    548548        m_opInfo = data;
    549549        child1().setUseKind(CellUse);
    … …  
    923923        case TryGetById:
    924924        case GetById:
    925         case PureGetById:
    926925        case GetByIdFlush:
    927926        case GetByIdWithThis:
    … …  
    14401439        case ArithTrunc:
    14411440        case GetDirectPname:
    1442         case PureGetById:
    14431441        case GetById:
    14441442        case GetByIdFlush:

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

    r208584 r208588  
    186186    macro(PutByValAlias, NodeMustGenerate | NodeHasVarArgs) \
    187187    macro(TryGetById, NodeResultJS) \
    188     macro(PureGetById, NodeResultJS | NodeMustGenerate) \
    189188    macro(GetById, NodeResultJS | NodeMustGenerate) \
    190189    macro(GetByIdFlush, NodeResultJS | NodeMustGenerate) \

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

    r208584 r208588  
    683683        case StringReplace:
    684684        case StringReplaceRegExp:
    685         case PureGetById:
    686685        case GetById:
    687686        case GetByIdFlush:

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

    r208584 r208588  
    200200    case DeleteById:
    201201    case DeleteByVal:
    202     case PureGetById:
    203202    case GetById:
    204203    case GetByIdWithThis:

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

    r208584 r208588  
    10011001        base.use();
    10021002
    1003         cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), JITCompiler::Jump(), NeedToSpill, AccessType::TryGet);
     1003        cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), JITCompiler::Jump(), NeedToSpill, AccessType::GetPure);
    10041004
    10051005        jsValueResult(resultRegs, node, DataFormatJS, UseChildrenCalledExplicitly);
    … …  
    10181018        JITCompiler::Jump notCell = m_jit.branchIfNotCell(baseRegs);
    10191019
    1020         cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), notCell, NeedToSpill, AccessType::TryGet);
     1020        cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), notCell, NeedToSpill, AccessType::GetPure);
    10211021
    10221022        jsValueResult(resultRegs, node, DataFormatJS, UseChildrenCalledExplicitly);
    … …  
    10281028        break;
    10291029    }
    1030 }
    1031 
    1032 void SpeculativeJIT::compilePureGetById(Node* node)
    1033 {
    1034     ASSERT(node->op() == PureGetById);
    1035 
    1036     switch (node->child1().useKind()) {
    1037     case CellUse: {
    1038         SpeculateCellOperand base(this, node->child1());
    1039         JSValueRegsTemporary result(this, Reuse, base);
    1040 
    1041         JSValueRegs baseRegs = JSValueRegs::payloadOnly(base.gpr());
    1042         JSValueRegs resultRegs = result.regs();
    1043 
    1044         cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), JITCompiler::Jump(), NeedToSpill, AccessType::PureGet);
    1045 
    1046         jsValueResult(resultRegs, node);
    1047         break;
    1048     }
    1049     case UntypedUse: {
    1050         JSValueOperand base(this, node->child1());
    1051         JSValueRegsTemporary result(this, Reuse, base);
    1052 
    1053         JSValueRegs baseRegs = base.jsValueRegs();
    1054         JSValueRegs resultRegs = result.regs();
    1055    
    1056         JITCompiler::Jump notCell = m_jit.branchIfNotCell(baseRegs);
    1057    
    1058         cachedGetById(node->origin.semantic, baseRegs, resultRegs, node->identifierNumber(), notCell, NeedToSpill, AccessType::PureGet);
    1059    
    1060         jsValueResult(resultRegs, node);
    1061         break;
    1062     }
    1063     default:
    1064         RELEASE_ASSERT_NOT_REACHED();
    1065     }
    10661030}
    10671031

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

    r208584 r208588  
    722722    void compileDeleteByVal(Node*);
    723723    void compileTryGetById(Node*);
    724     void compilePureGetById(Node*);
    725724    void compileIn(Node*);
    726725   

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

    r208584 r208588  
    211211    if (type == AccessType::Get)
    212212        getByIdFunction = operationGetByIdOptimize;
    213     else if (type == AccessType::PureGet)
    214         getByIdFunction = operationPureGetByIdOptimize;
    215213    else
    216214        getByIdFunction = operationTryGetByIdOptimize;
    … …  
    42824280    }
    42834281
    4284     case PureGetById: {
    4285         compilePureGetById(node);
    4286         break;
    4287     }
    4288 
    42894282    case GetByIdWithThis: {
    42904283        JSValueOperand base(this, node->child1());

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

    r208584 r208588  
    180180    slowCases.append(gen.slowPathJump());
    181181   
    182     auto slowPathFunction = type == AccessType::Get ? operationGetByIdOptimize :
    183         type == AccessType::PureGet ? operationPureGetByIdOptimize : operationTryGetByIdOptimize;
    184 
    185182    auto slowPath = slowPathCall(
    186         slowCases, this, slowPathFunction,
     183        slowCases, this, type == AccessType::Get ? operationGetByIdOptimize : operationTryGetByIdOptimize,
    187184        spillMode, ExceptionCheckRequirement::CheckNeeded,
    188185        resultGPR, gen.stubInfo(), baseGPR, identifierUID(identifierNumber));
    … …  
    42494246    }
    42504247
    4251     case PureGetById: {
    4252         compilePureGetById(node);
    4253         break;
    4254     }
    4255 
    42564248    case GetByIdFlush: {
    42574249        if (!node->prediction()) {

  • trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp

    r208584 r208588  
    180180    case TryGetById:
    181181    case GetById:
    182     case PureGetById:
    183182    case GetByIdFlush:
    184183    case GetByIdWithThis:

  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r208584 r208588  
    624624            break;
    625625        case TryGetById:
    626             compileGetById(AccessType::TryGet);
    627             break;
    628         case PureGetById:
    629             compileGetById(AccessType::PureGet);
     626            compileGetById(AccessType::GetPure);
    630627            break;
    631628        case GetById:
    … …  
    28052802    void compileGetById(AccessType type)
    28062803    {
    2807         ASSERT(type == AccessType::Get || type == AccessType::TryGet || type == AccessType::PureGet);
     2804        ASSERT(type == AccessType::Get || type == AccessType::GetPure);
    28082805        switch (m_node->child1().useKind()) {
    28092806        case CellUse: {
    … …  
    28322829            if (type == AccessType::Get)
    28332830                getByIdFunction = operationGetByIdGeneric;
    2834             else if (type == AccessType::PureGet)
    2835                 getByIdFunction = operationPureGetByIdGeneric;
    28362831            else
    28372832                getByIdFunction = operationTryGetByIdGeneric;
    … …  
    90959090                        if (type == AccessType::Get)
    90969091                            optimizationFunction = operationGetByIdOptimize;
    9097                         else if (type == AccessType::PureGet)
    9098                             optimizationFunction = operationPureGetByIdOptimize;
    90999092                        else
    91009093                            optimizationFunction = operationTryGetByIdOptimize;

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

    r208309 r208588  
    7676namespace JSC {
    7777
    78 ALWAYS_INLINE static EncodedJSValue pureGetByIdCommon(VM& vm, ExecState* exec, EncodedJSValue base, UniquedStringImpl* uid, const std::function<void (const PropertySlot&, const Identifier&)>& function = [] (const PropertySlot&, const Identifier&) { })
    79 {
    80     Identifier ident = Identifier::fromUid(&vm, uid);
    81     JSValue baseValue = JSValue::decode(base);
    82 
    83     ASSERT(JITCode::isOptimizingJIT(exec->codeBlock()->jitType()));
    84 
    85     PropertySlot slot(baseValue, PropertySlot::InternalMethodType::VMInquiry);
    86     return JSValue::encode(baseValue.getPropertySlot(exec, ident, slot, [&] (bool, PropertySlot&) -> JSValue {
    87         bool willDoSideEffects = !(slot.isValue() || slot.isUnset()) || slot.isTaintedByOpaqueObject();
    88         if (UNLIKELY(willDoSideEffects)) {
    89             {
    90                 CodeOrigin codeOrigin = exec->codeOrigin();
    91                 CodeBlock* currentBaseline = baselineCodeBlockForOriginAndBaselineCodeBlock(codeOrigin, exec->codeBlock()->alternative());
    92                 CodeOrigin originBytecodeIndex = CodeOrigin(codeOrigin.bytecodeIndex); // Since we're searching in the baseline, we just care about bytecode index.
    93                 ConcurrentJITLocker locker(currentBaseline->m_lock);
    94                 if (StructureStubInfo* stub = currentBaseline->findStubInfo(originBytecodeIndex))
    95                     stub->didSideEffects = true;
    96             }
    97 
    98             exec->codeBlock()->jettison(Profiler::JettisonDueToPureGetByIdEffects);
    99             return baseValue.get(exec, uid);
    100         }
    101 
    102         function(slot, ident);
    103         return slot.isValue() ? slot.getValue(exec, ident) : jsUndefined();
    104     }));
    105 }
    106 
    10778extern "C" {
    10879
    … …  
    200171}
    201172
    202 EncodedJSValue JIT_OPERATION operationPureGetByIdGeneric(ExecState* exec, EncodedJSValue base, UniquedStringImpl* uid)
    203 {
    204     VM* vm = &exec->vm();
    205     NativeCallFrameTracer tracer(vm, exec);
    206 
    207     return pureGetByIdCommon(*vm, exec, base, uid);
    208 }
    209 
    210 EncodedJSValue JIT_OPERATION operationPureGetById(ExecState* exec, StructureStubInfo* stubInfo, EncodedJSValue base, UniquedStringImpl* uid)
    211 {
    212     VM* vm = &exec->vm();
    213     NativeCallFrameTracer tracer(vm, exec);
    214 
    215     stubInfo->tookSlowPath = true;
    216 
    217     return pureGetByIdCommon(*vm, exec, base, uid);
    218 }
    219 
    220 EncodedJSValue JIT_OPERATION operationPureGetByIdOptimize(ExecState* exec, StructureStubInfo* stubInfo, EncodedJSValue base, UniquedStringImpl* uid)
    221 {
    222     VM* vm = &exec->vm();
    223     NativeCallFrameTracer tracer(vm, exec);
    224 
    225     return pureGetByIdCommon(*vm, exec, base, uid,
    226         [&] (const PropertySlot& slot, const Identifier& ident) {
    227             ASSERT((slot.isValue() || slot.isUnset()) && !slot.isTaintedByOpaqueObject());
    228             JSValue baseValue = JSValue::decode(base);
    229             if (stubInfo->considerCaching(baseValue.structureOrNull()))
    230                 repatchGetByID(exec, baseValue, ident, slot, *stubInfo, GetByIDKind::Pure);
    231         });
    232 }
    233 
    234173EncodedJSValue JIT_OPERATION operationTryGetById(ExecState* exec, StructureStubInfo* stubInfo, EncodedJSValue base, UniquedStringImpl* uid)
    235174{
    … …  
    246185}
    247186
     187
    248188EncodedJSValue JIT_OPERATION operationTryGetByIdGeneric(ExecState* exec, EncodedJSValue base, UniquedStringImpl* uid)
    249189{
    … …  
    273213
    274214    if (stubInfo->considerCaching(baseValue.structureOrNull()) && !slot.isTaintedByOpaqueObject() && (slot.isCacheableValue() || slot.isCacheableGetter() || slot.isUnset()))
    275         repatchGetByID(exec, baseValue, ident, slot, *stubInfo, GetByIDKind::Try);
     215        repatchGetByID(exec, baseValue, ident, slot, *stubInfo, GetByIDKind::Pure);
    276216
    277217    return JSValue::encode(slot.getPureResult());
    … …  
    292232   
    293233    LOG_IC((ICEvent::OperationGetById, baseValue.classInfoOrNull(), ident));
    294     JSValue result = baseValue.get(exec, ident, slot);
    295     bool willDoSideEffects = !(slot.isValue() || slot.isUnset()) || slot.isTaintedByOpaqueObject();
    296     stubInfo->didSideEffects |= willDoSideEffects;
    297     return JSValue::encode(result);
     234    return JSValue::encode(baseValue.get(exec, ident, slot));
    298235}
    299236
    … …  
    324261
    325262    return JSValue::encode(baseValue.getPropertySlot(exec, ident, [&] (bool found, PropertySlot& slot) -> JSValue {
    326         bool willDoSideEffects = !(slot.isValue() || slot.isUnset()) || slot.isTaintedByOpaqueObject();
    327         stubInfo->didSideEffects |= willDoSideEffects;
    328 
    329263        if (stubInfo->considerCaching(baseValue.structureOrNull()))
    330264            repatchGetByID(exec, baseValue, ident, slot, *stubInfo, GetByIDKind::Normal);

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

    r208584 r208588  
    333333EncodedJSValue JIT_OPERATION operationTryGetByIdGeneric(ExecState*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    334334EncodedJSValue JIT_OPERATION operationTryGetByIdOptimize(ExecState*, StructureStubInfo*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    335 EncodedJSValue JIT_OPERATION operationPureGetById(ExecState*, StructureStubInfo*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    336 EncodedJSValue JIT_OPERATION operationPureGetByIdGeneric(ExecState*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    337 EncodedJSValue JIT_OPERATION operationPureGetByIdOptimize(ExecState*, StructureStubInfo*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    338335EncodedJSValue JIT_OPERATION operationGetById(ExecState*, StructureStubInfo*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;
    339336EncodedJSValue JIT_OPERATION operationGetByIdGeneric(ExecState*, EncodedJSValue, UniquedStringImpl*) WTF_INTERNAL;

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

    r208117 r208588  
    580580    JITGetByIdGenerator gen(
    581581        m_codeBlock, CodeOrigin(m_bytecodeOffset), CallSiteIndex(m_bytecodeOffset), RegisterSet::stubUnavailableRegisters(),
    582         ident->impl(), JSValueRegs(regT0), JSValueRegs(regT0), AccessType::TryGet);
     582        ident->impl(), JSValueRegs(regT0), JSValueRegs(regT0), AccessType::GetPure);
    583583    gen.generateFastPath(*this);
    584584    addSlowCase(gen.slowPathJump());

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

    r208117 r208588  
    595595    JITGetByIdGenerator gen(
    596596        m_codeBlock, CodeOrigin(m_bytecodeOffset), CallSiteIndex(currentInstruction), RegisterSet::stubUnavailableRegisters(),
    597         ident->impl(), JSValueRegs::payloadOnly(regT0), JSValueRegs(regT1, regT0), AccessType::TryGet);
     597        ident->impl(), JSValueRegs::payloadOnly(regT0), JSValueRegs(regT1, regT0), AccessType::GetPure);
    598598    gen.generateFastPath(*this);
    599599    addSlowCase(gen.slowPathJump());

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

    r208309 r208588  
    137137inline J_JITOperation_ESsiJI appropriateOptimizingGetByIdFunction(GetByIDKind kind)
    138138{
    139     switch (kind) {
    140     case GetByIDKind::Normal:
     139    if (kind == GetByIDKind::Normal)
    141140        return operationGetByIdOptimize;
    142     case GetByIDKind::Try:
    143         return operationTryGetByIdOptimize;
    144     case GetByIDKind::Pure:
    145         return operationPureGetByIdOptimize;
    146     default:
    147         break;
    148     }
    149     ASSERT_NOT_REACHED();
    150     return operationGetByIdOptimize;
     141    return operationTryGetByIdOptimize;
    151142}
    152143
    153144inline J_JITOperation_ESsiJI appropriateGenericGetByIdFunction(GetByIDKind kind)
    154145{
    155     switch (kind) {
    156     case GetByIDKind::Normal:
     146    if (kind == GetByIDKind::Normal)
    157147        return operationGetById;
    158     case GetByIDKind::Try:
    159         return operationTryGetById;
    160     case GetByIDKind::Pure:
    161         return operationPureGetById;
    162     default:
    163         break;
    164     }
    165     ASSERT_NOT_REACHED();
    166     return operationGetById;
     148    return operationTryGetById;
    167149}
    168150
    … …  
    287269
    288270        if (kind == GetByIDKind::Pure) {
    289             AccessCase::AccessType type;
    290             if (slot.isCacheableValue())
    291                 type = AccessCase::Load;
    292             else if (slot.isUnset())
    293                 type = AccessCase::Miss;
    294             else
    295                 RELEASE_ASSERT_NOT_REACHED();
    296 
    297             newCase = AccessCase::tryGet(vm, codeBlock, type, offset, structure, conditionSet, loadTargetFromProxy, slot.watchpointSet());
    298         } else if (kind == GetByIDKind::Try) {
    299271            AccessCase::AccessType type;
    300272            if (slot.isCacheableValue())

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

    r208117 r208588  
    3737enum class GetByIDKind {
    3838    Normal,
    39     Try,
    4039    Pure
    4140};

  • trunk/Source/JavaScriptCore/profiler/ProfilerJettisonReason.cpp

    r208117 r208588  
    5757        out.print("OSRExit");
    5858        return;
    59     case JettisonDueToPureGetByIdEffects:
    60         out.print("PureGetByIdEffects");
    61         return;
    6259    case JettisonDueToProfiledWatchpoint:
    6360        out.print("ProfiledWatchpoint");

  • trunk/Source/JavaScriptCore/profiler/ProfilerJettisonReason.h

    r208117 r208588  
    3636    JettisonDueToBaselineLoopReoptimizationTriggerOnOSREntryFail,
    3737    JettisonDueToOSRExit,
    38     JettisonDueToPureGetByIdEffects,
    3938    JettisonDueToProfiledWatchpoint,
    4039    JettisonDueToUnprofiledWatchpoint,
Note: See TracChangeset for help on using the changeset viewer.