⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 180679 in webkit


Ignore:
Timestamp:
Feb 26, 2015, 10:03:17 AM (12 years ago)
Author:
bshafiei@apple.com
Message:

Merge patch for r180247 and r180249. rdar://problem/19877186

Location:
branches/safari-600.5-branch/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • branches/safari-600.5-branch/Source/JavaScriptCore/ChangeLog

    r180463 r180679  
     12015-02-26  Babak Shafiei  <bshafiei@apple.com>
     2
     3        Merge patch for r180247 and r180249.
     4
     5    2015-02-20  Michael Saboff  <msaboff@apple.com>
     6
     7            CrashTracer: DFG_CRASH beneath JSC::FTL::LowerDFGToLLVM::compileNode
     8            https://bugs.webkit.org/show_bug.cgi?id=141730
     9
     10            Reviewed by Geoffrey Garen.
     11
     12            Added a new failure handler, loweringFailed(), to LowerDFGToLLVM that reports failures
     13            while processing DFG lowering.  For debug builds, the failures are logged identical
     14            to the way the DFG_CRASH() reports them.  For release builds, the failures are reported
     15            and that FTL compilation is terminated, but the process is allowed to continue.
     16            Wrapped calls to loweringFailed() in a macro LOWERING_FAILED so the function and
     17            line number are reported at the point of the inconsistancy.
     18
     19            Converted instances of DFG_CRASH to LOWERING_FAILED.
     20
     21            * dfg/DFGPlan.cpp:
     22            (JSC::DFG::Plan::compileInThreadImpl): Added lowerDFGToLLVM() failure check that
     23            will fail the FTL compile.
     24
     25            * ftl/FTLLowerDFGToLLVM.cpp:
     26            (JSC::FTL::LowerDFGToLLVM::LowerDFGToLLVM):
     27            Added new member variable, m_loweringSucceeded, to stop compilation on the first
     28            reported failure.
     29
     30            * ftl/FTLLowerDFGToLLVM.cpp:
     31            (JSC::FTL::LowerDFGToLLVM::lower):
     32            * ftl/FTLLowerDFGToLLVM.h:
     33            Added check for compilation failures and now report those failures via a boolean
     34            return value.
     35
     36            * ftl/FTLLowerDFGToLLVM.cpp:
     37            (JSC::FTL::LowerDFGToLLVM::createPhiVariables):
     38            (JSC::FTL::LowerDFGToLLVM::compileNode):
     39            (JSC::FTL::LowerDFGToLLVM::compileUpsilon):
     40            (JSC::FTL::LowerDFGToLLVM::compilePhi):
     41            (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
     42            (JSC::FTL::LowerDFGToLLVM::compileValueRep):
     43            (JSC::FTL::LowerDFGToLLVM::compileValueToInt32):
     44            (JSC::FTL::LowerDFGToLLVM::compilePutLocal):
     45            (JSC::FTL::LowerDFGToLLVM::compileArithAddOrSub):
     46            (JSC::FTL::LowerDFGToLLVM::compileArithMul):
     47            (JSC::FTL::LowerDFGToLLVM::compileArithDiv):
     48            (JSC::FTL::LowerDFGToLLVM::compileArithMod):
     49            (JSC::FTL::LowerDFGToLLVM::compileArithMinOrMax):
     50            (JSC::FTL::LowerDFGToLLVM::compileArithAbs):
     51            (JSC::FTL::LowerDFGToLLVM::compileArithNegate):
     52            (JSC::FTL::LowerDFGToLLVM::compileArrayifyToStructure):
     53            (JSC::FTL::LowerDFGToLLVM::compileGetById):
     54            (JSC::FTL::LowerDFGToLLVM::compileGetMyArgumentByVal):
     55            (JSC::FTL::LowerDFGToLLVM::compileGetArrayLength):
     56            (JSC::FTL::LowerDFGToLLVM::compileGetByVal):
     57            (JSC::FTL::LowerDFGToLLVM::compilePutByVal):
     58            (JSC::FTL::LowerDFGToLLVM::compileArrayPush):
     59            (JSC::FTL::LowerDFGToLLVM::compileArrayPop):
     60            (JSC::FTL::LowerDFGToLLVM::compileNewArray):
     61            (JSC::FTL::LowerDFGToLLVM::compileToString):
     62            (JSC::FTL::LowerDFGToLLVM::compileMakeRope):
     63            (JSC::FTL::LowerDFGToLLVM::compileCompareEq):
     64            (JSC::FTL::LowerDFGToLLVM::compileCompareStrictEq):
     65            (JSC::FTL::LowerDFGToLLVM::compileSwitch):
     66            (JSC::FTL::LowerDFGToLLVM::compare):
     67            (JSC::FTL::LowerDFGToLLVM::boolify):
     68            (JSC::FTL::LowerDFGToLLVM::opposite):
     69            (JSC::FTL::LowerDFGToLLVM::lowJSValue):
     70            (JSC::FTL::LowerDFGToLLVM::speculate):
     71            (JSC::FTL::LowerDFGToLLVM::isArrayType):
     72            (JSC::FTL::LowerDFGToLLVM::exitValueForAvailability):
     73            (JSC::FTL::LowerDFGToLLVM::exitValueForNode):
     74            (JSC::FTL::LowerDFGToLLVM::setInt52):
     75            Changed DFG_CRASH() to LOWERING_FAILED().  Updated related control flow as appropriate.
     76
     77            (JSC::FTL::LowerDFGToLLVM::loweringFailed): New error reporting member function.
     78
    1792015-02-20  Dana Burkart  <dburkart@apple.com>
    280

  • branches/safari-600.5-branch/Source/JavaScriptCore/dfg/DFGPlan.cpp

    r170876 r180679  
    349349           
    350350        FTL::State state(dfg);
    351         FTL::lowerDFGToLLVM(state);
     351        if (!FTL::lowerDFGToLLVM(state)) {
     352            FTL::fail(state);
     353            return FTLPath;
     354        }
    352355       
    353356        if (reportCompileTimes())

  • branches/safari-600.5-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp

    r171411 r180679  
    6969        : m_graph(state.graph)
    7070        , m_ftlState(state)
     71        , m_loweringSucceeded(true)
    7172        , m_heaps(state.context)
    7273        , m_out(state.context)
    … …  
    7778    {
    7879    }
    79    
    80     void lower()
     80
     81
     82#define LOWERING_FAILED(node, reason)                                  \
     83    loweringFailed((node), __FILE__, __LINE__, WTF_PRETTY_FUNCTION, (reason));
     84
     85    bool lower()
    8186    {
    8287        CString name;
    … …  
    158163        m_out.unreachable();
    159164       
     165        if (!m_loweringSucceeded)
     166            return m_loweringSucceeded;
     167
    160168        Vector<BasicBlock*> depthFirst;
    161169        m_graph.getBlocksInDepthFirstOrder(depthFirst);
    162         for (unsigned i = 0; i < depthFirst.size(); ++i)
     170        for (unsigned i = 0; i < depthFirst.size(); ++i) {
    163171            compileBlock(depthFirst[i]);
     172            if (!m_loweringSucceeded)
     173                return m_loweringSucceeded;
     174        }
    164175       
    165176        if (Options::dumpLLVMIR())
    … …  
    170181        if (validationEnabled())
    171182            verifyModule(m_ftlState.module);
     183
     184        return m_loweringSucceeded;
    172185    }
    173186
    … …  
    202215                    break;
    203216                default:
    204                     RELEASE_ASSERT_NOT_REACHED();
    205                     break;
     217                    LOWERING_FAILED(node, "Bad Phi node result type");
     218                    return;
    206219                }
    207220                m_phis.add(node, buildAlloca(m_out.m_builder, type));
    … …  
    632645            break;
    633646        default:
    634             dataLog("Unrecognized node in FTL backend:\n");
    635             m_graph.dump(WTF::dataFile(), "    ", m_node);
    636             dataLog("\n");
    637             dataLog("Full graph dump:\n");
    638             m_graph.dump();
    639             RELEASE_ASSERT_NOT_REACHED();
    640             break;
    641         }
    642        
     647            LOWERING_FAILED(m_node, "Unrecognized node in FTL backend");
     648            break;
     649        }
     650       
     651        if (!m_loweringSucceeded)
     652            return false;
     653
    643654        if (shouldExecuteEffects)
    644655            m_interpreter.executeEffects(nodeIndex);
    … …  
    671682            break;
    672683        default:
    673             RELEASE_ASSERT_NOT_REACHED();
     684            LOWERING_FAILED(m_node, "Bad use kind");
    674685            break;
    675686        }
    … …  
    697708            break;
    698709        default:
    699             RELEASE_ASSERT_NOT_REACHED();
     710            LOWERING_FAILED(m_node, "Bad use kind");
    700711            break;
    701712        }
    … …  
    740751           
    741752        default:
    742             RELEASE_ASSERT_NOT_REACHED();
     753            LOWERING_FAILED(m_node, "Bad use kind");
    743754        }
    744755    }
    … …  
    765776           
    766777        default:
    767             RELEASE_ASSERT_NOT_REACHED();
     778            LOWERING_FAILED(m_node, "Bad use kind");
    768779        }
    769780    }
    … …  
    789800           
    790801        default:
    791             RELEASE_ASSERT_NOT_REACHED();
     802            LOWERING_FAILED(m_node, "Bad use kind");
    792803        }
    793804    }
    … …  
    828839           
    829840        default:
    830             RELEASE_ASSERT_NOT_REACHED();
     841            LOWERING_FAILED(m_node, "Bad use kind");
    831842            break;
    832843        }
    … …  
    861872           
    862873        default:
    863             RELEASE_ASSERT_NOT_REACHED();
     874            LOWERING_FAILED(m_node, "Bad flush format");
    864875            return;
    865876        }
    … …  
    891902            break;
    892903        default:
    893             RELEASE_ASSERT_NOT_REACHED();
     904            LOWERING_FAILED(m_node, "Bad use kind");
    894905            break;
    895906        }
    … …  
    962973           
    963974        default:
    964             RELEASE_ASSERT_NOT_REACHED();
    965             break;
     975            LOWERING_FAILED(m_node, "Bad flush format for argument");
     976            return;
    966977        }
    967978       
    … …  
    11381149           
    11391150        default:
    1140             RELEASE_ASSERT_NOT_REACHED();
     1151            LOWERING_FAILED(m_node, "Bad use kind");
    11411152            break;
    11421153        }
    … …  
    12121223           
    12131224        default:
    1214             RELEASE_ASSERT_NOT_REACHED();
     1225            LOWERING_FAILED(m_node, "Bad use kind");
    12151226            break;
    12161227        }
    … …  
    13151326           
    13161327        default:
    1317             RELEASE_ASSERT_NOT_REACHED();
     1328            LOWERING_FAILED(m_node, "Bad use kind");
    13181329            break;
    13191330        }
    … …  
    14131424           
    14141425        default:
    1415             RELEASE_ASSERT_NOT_REACHED();
     1426            LOWERING_FAILED(m_node, "Bad use kind");
    14161427            break;
    14171428        }
    … …  
    14641475           
    14651476        default:
    1466             RELEASE_ASSERT_NOT_REACHED();
     1477            LOWERING_FAILED(m_node, "Bad use kind");
    14671478            break;
    14681479        }
    … …  
    14901501           
    14911502        default:
    1492             RELEASE_ASSERT_NOT_REACHED();
     1503            LOWERING_FAILED(m_node, "Bad use kind");
    14931504            break;
    14941505        }
    … …  
    15571568           
    15581569        default:
    1559             RELEASE_ASSERT_NOT_REACHED();
     1570            LOWERING_FAILED(m_node, "Bad use kind");
    15601571            break;
    15611572        }
    … …  
    17231734            break;
    17241735        default:
    1725             RELEASE_ASSERT_NOT_REACHED();
    1726             break;
     1736            LOWERING_FAILED(m_node, "Bad array type");
     1737            return;
    17271738        }
    17281739       
    … …  
    17971808           
    17981809        default:
    1799             RELEASE_ASSERT_NOT_REACHED();
     1810            LOWERING_FAILED(m_node, "Bad use kind");
    18001811            return;
    18011812        }
    … …  
    19491960            // https://bugs.webkit.org/show_bug.cgi?id=129576
    19501961           
    1951             RELEASE_ASSERT_NOT_REACHED();
     1962            LOWERING_FAILED(m_node, "Unimplemented");
     1963            return;
    19521964        }
    19531965       
    … …  
    19861998            }
    19871999           
    1988             RELEASE_ASSERT_NOT_REACHED();
     2000            LOWERING_FAILED(m_node, "Bad array type");
    19892001            return;
    19902002        }
    … …  
    21362148                        break;
    21372149                    default:
    2138                         RELEASE_ASSERT_NOT_REACHED();
     2150                        LOWERING_FAILED(m_node, "Bad element size");
     2151                        return;
    21392152                    }
    21402153                   
    … …  
    21802193                    break;
    21812194                default:
    2182                     RELEASE_ASSERT_NOT_REACHED();
     2195                    LOWERING_FAILED(m_node, "Bad typed array type");
     2196                    return;
    21832197                }
    21842198               
    … …  
    21872201            }
    21882202           
    2189             RELEASE_ASSERT_NOT_REACHED();
     2203            LOWERING_FAILED(m_node, "Bad array type");
    21902204            return;
    21912205        } }
    … …  
    22932307               
    22942308            default:
    2295                 RELEASE_ASSERT_NOT_REACHED();
     2309                LOWERING_FAILED(m_node, "Bad array type");
     2310                return;
    22962311            }
    22972312
    … …  
    23862401                       
    23872402                    default:
    2388                         RELEASE_ASSERT_NOT_REACHED();
     2403                        LOWERING_FAILED(m_node, "Bad use kind");
     2404                        return;
    23892405                    }
    23902406                   
    … …  
    24032419                        break;
    24042420                    default:
    2405                         RELEASE_ASSERT_NOT_REACHED();
     2421                        LOWERING_FAILED(m_node, "Bad element size");
     2422                        return;
    24062423                    }
    24072424                } else /* !isInt(type) */ {
    … …  
    24172434                        break;
    24182435                    default:
    2419                         RELEASE_ASSERT_NOT_REACHED();
     2436                        LOWERING_FAILED(m_node, "Bad typed array type");
     2437                        return;
    24202438                    }
    24212439                }
    … …  
    24412459            }
    24422460           
    2443             RELEASE_ASSERT_NOT_REACHED();
    2444             break;
     2461            LOWERING_FAILED(m_node, "Bad array type");
     2462            return;
    24452463        }
    24462464    }
    … …  
    25132531           
    25142532        default:
    2515             RELEASE_ASSERT_NOT_REACHED();
     2533            LOWERING_FAILED(m_node, "Bad array type");
    25162534            return;
    25172535        }
    … …  
    25712589
    25722590        default:
    2573             RELEASE_ASSERT_NOT_REACHED();
     2591            LOWERING_FAILED(m_node, "Bad array type");
    25742592            return;
    25752593        }
    … …  
    29302948           
    29312949        default:
    2932             RELEASE_ASSERT_NOT_REACHED();
    2933             break;
     2950            LOWERING_FAILED(m_node, "Bad use kind");
     2951            return;
    29342952        }
    29352953    }
    … …  
    30223040            break;
    30233041        default:
    3024             RELEASE_ASSERT_NOT_REACHED();
     3042            LOWERING_FAILED(m_node, "Bad number of children");
     3043            return;
    30253044            break;
    30263045        }
    … …  
    34273446            return;
    34283447        }
    3429        
    3430         RELEASE_ASSERT_NOT_REACHED();
     3448
     3449        LOWERING_FAILED(m_node, "Bad use kinds");
    34313450    }
    34323451   
    … …  
    35213540        }
    35223541       
    3523         RELEASE_ASSERT_NOT_REACHED();
     3542        LOWERING_FAILED(m_node, "Bad use kinds");
    35243543    }
    35253544   
    … …  
    36573676               
    36583677            default:
    3659                 RELEASE_ASSERT_NOT_REACHED();
    3660                 break;
     3678                LOWERING_FAILED(m_node, "Bad use kind");
     3679                return;
    36613680            }
    36623681           
    … …  
    37033722               
    37043723            default:
    3705                 RELEASE_ASSERT_NOT_REACHED();
    3706                 break;
     3724                LOWERING_FAILED(m_node, "Bad use kind");
     3725                return;
    37073726            }
    37083727           
    … …  
    37563775       
    37573776        case SwitchString:
    3758             RELEASE_ASSERT_NOT_REACHED();
    3759             break;
    3760         }
    3761        
    3762         RELEASE_ASSERT_NOT_REACHED();
     3777            LOWERING_FAILED(m_node, "Unimplemented");
     3778            break;
     3779        }
     3780       
     3781        LOWERING_FAILED(m_node, "Bad switch kind");
    37633782    }
    37643783   
    … …  
    42174236        }
    42184237       
    4219         RELEASE_ASSERT_NOT_REACHED();
     4238        LOWERING_FAILED(m_node, "Bad use kinds");
    42204239    }
    42214240   
    … …  
    44964515        }
    44974516        default:
    4498             RELEASE_ASSERT_NOT_REACHED();
     4517            LOWERING_FAILED(m_node, "Bad use kind");
    44994518            return 0;
    45004519        }
    … …  
    48694888            return Int52;
    48704889        }
    4871         RELEASE_ASSERT_NOT_REACHED();
     4890        LOWERING_FAILED(m_node, "Bad use kind");
    48724891        return Int52;
    48734892    }
    … …  
    50145033        }
    50155034       
    5016         RELEASE_ASSERT_NOT_REACHED();
     5035        LOWERING_FAILED(m_node, "Corrupt array class");
    50175036        return 0;
    50185037    }
    … …  
    53265345            break;
    53275346        default:
    5328             dataLog("Unsupported speculation use kind: ", edge.useKind(), "\n");
    5329             RELEASE_ASSERT_NOT_REACHED();
     5347            LOWERING_FAILED(m_node, "Unsupported speculation use kind");
     5348            return;
    53305349        }
    53315350    }
    … …  
    53885407            switch (arrayMode.arrayClass()) {
    53895408            case Array::OriginalArray:
    5390                 RELEASE_ASSERT_NOT_REACHED();
     5409                LOWERING_FAILED(m_node, "Unexpected original array");
    53915410                return 0;
    53925411               
    … …  
    54085427            }
    54095428           
    5410             RELEASE_ASSERT_NOT_REACHED();
     5429            LOWERING_FAILED(m_node, "Corrupt array class");
     5430            return 0;
    54115431        }
    54125432           
    … …  
    60446064        }
    60456065       
    6046         RELEASE_ASSERT_NOT_REACHED();
     6066        LOWERING_FAILED(m_node, "Corrupt int52 kind");
    60476067    }
    60486068    void setJSValue(Node* node, LValue value)
    … …  
    61716191    }
    61726192   
     6193    NO_RETURN_DUE_TO_ASSERT void loweringFailed(Node* node, const char* file, int line, const char* function, const char* assertion)
     6194    {
     6195        if (!ASSERT_DISABLED) {
     6196            dataLog("FTL ASSERTION FAILED: ", assertion, "\n");
     6197            dataLog(file, "(", line, ") : ", function, "\n");
     6198            dataLog("While handling node ", node, "\n");
     6199            RELEASE_ASSERT_NOT_REACHED();
     6200        }
     6201
     6202        m_loweringSucceeded = false;
     6203    }
     6204
    61736205    VM& vm() { return m_graph.m_vm; }
    61746206    CodeBlock* codeBlock() { return m_graph.m_codeBlock; }
    … …  
    61766208    Graph& m_graph;
    61776209    State& m_ftlState;
     6210    bool m_loweringSucceeded;
    61786211    AbstractHeapRepository m_heaps;
    61796212    Output m_out;
    … …  
    62166249};
    62176250
    6218 void lowerDFGToLLVM(State& state)
     6251bool lowerDFGToLLVM(State& state)
    62196252{
    62206253    LowerDFGToLLVM lowering(state);
    6221     lowering.lower();
     6254    return lowering.lower();
    62226255}
    62236256

  • branches/safari-600.5-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.h

    r164424 r180679  
    3434namespace JSC { namespace FTL {
    3535
    36 void lowerDFGToLLVM(State&);
     36bool lowerDFGToLLVM(State&);
    3737
    3838} } // namespace JSC::FTL
Note: See TracChangeset for help on using the changeset viewer.