Ignore:
Timestamp:
Oct 9, 2015, 4:10:16 PM (10 years ago)
Author:
[email protected]
Message:

2015-10-09 Geoffrey Garen <​[email protected]>

Unreviewed, rolling back in r190694
​https://bugs.webkit.org/show_bug.cgi?id=149727

This time for double sure?

The cause of the crash was an incorrect write barrier.

OSR exit was barriering the baseline codeblock for the top of the stack
twice, missing the baseline codeblock for the bottom of the stack.

Restored changesets:

"CodeBlock should be a GC object"
​https://bugs.webkit.org/show_bug.cgi?id=149727
​http://trac.webkit.org/changeset/r190694

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r190809 r190827  
    6161    m_numParametersForCall = NUM_PARAMETERS_NOT_COMPILED;
    6262    m_numParametersForConstruct = NUM_PARAMETERS_NOT_COMPILED;
     63
     64    if (classInfo() == FunctionExecutable::info()) {
     65        FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
     66        executable->m_codeBlockForCall.clear();
     67        executable->m_codeBlockForConstruct.clear();
     68        return;
     69    }
     70
     71    if (classInfo() == EvalExecutable::info()) {
     72        EvalExecutable* executable = jsCast<EvalExecutable*>(this);
     73        executable->m_evalCodeBlock.clear();
     74        executable->m_unlinkedEvalCodeBlock.clear();
     75        return;
     76    }
     77   
     78    if (classInfo() == ProgramExecutable::info()) {
     79        ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
     80        executable->m_programCodeBlock.clear();
     81        executable->m_unlinkedProgramCodeBlock.clear();
     82        return;
     83    }
     84
     85    if (classInfo() == ModuleProgramExecutable::info()) {
     86        ModuleProgramExecutable* executable = jsCast<ModuleProgramExecutable*>(this);
     87        executable->m_moduleProgramCodeBlock.clear();
     88        executable->m_unlinkedModuleProgramCodeBlock.clear();
     89        executable->m_moduleEnvironmentSymbolTable.clear();
     90        return;
     91    }
     92   
     93#if ENABLE(WEBASSEMBLY)
     94    if (classInfo() == WebAssemblyExecutable::info()) {
     95        WebAssemblyExecutable* executable = jsCast<WebAssemblyExecutable*>(this);
     96        executable->m_codeBlockForCall.clear();
     97        return;
     98    }
     99#endif
     100
     101    ASSERT(classInfo() == NativeExecutable::info());
    63102}
    64103
    … …  
    124163    ASSERT(vm.heap.isDeferred());
    125164   
    126     RefPtr<CodeBlock> oldCodeBlock;
     165    CodeBlock* oldCodeBlock = nullptr;
    127166   
    128167    switch (codeType) {
    … …  
    133172        ASSERT(kind == CodeForCall);
    134173       
    135         oldCodeBlock = executable->m_programCodeBlock;
    136         executable->m_programCodeBlock = codeBlock;
     174        oldCodeBlock = executable->m_programCodeBlock.get();
     175        executable->m_programCodeBlock.setMayBeNull(vm, this, codeBlock);
    137176        break;
    138177    }
    … …  
    144183        ASSERT(kind == CodeForCall);
    145184
    146         oldCodeBlock = executable->m_moduleProgramCodeBlock;
    147         executable->m_moduleProgramCodeBlock = codeBlock;
     185        oldCodeBlock = executable->m_moduleProgramCodeBlock.get();
     186        executable->m_moduleProgramCodeBlock.setMayBeNull(vm, this, codeBlock);
    148187        break;
    149188    }
    … …  
    155194        ASSERT(kind == CodeForCall);
    156195       
    157         oldCodeBlock = executable->m_evalCodeBlock;
    158         executable->m_evalCodeBlock = codeBlock;
     196        oldCodeBlock = executable->m_evalCodeBlock.get();
     197        executable->m_evalCodeBlock.setMayBeNull(vm, this, codeBlock);
    159198        break;
    160199    }
    … …  
    166205        switch (kind) {
    167206        case CodeForCall:
    168             oldCodeBlock = executable->m_codeBlockForCall;
    169             executable->m_codeBlockForCall = codeBlock;
     207            oldCodeBlock = executable->m_codeBlockForCall.get();
     208            executable->m_codeBlockForCall.setMayBeNull(vm, this, codeBlock);
    170209            break;
    171210        case CodeForConstruct:
    172             oldCodeBlock = executable->m_codeBlockForConstruct;
    173             executable->m_codeBlockForConstruct = codeBlock;
     211            oldCodeBlock = executable->m_codeBlockForConstruct.get();
     212            executable->m_codeBlockForConstruct.setMayBeNull(vm, this, codeBlock);
    174213            break;
    175214        }
    … …  
    211250}
    212251
    213 RefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(
     252CodeBlock* ScriptExecutable::newCodeBlockFor(
    214253    CodeSpecializationKind kind, JSFunction* function, JSScope* scope, JSObject*& exception)
    215254{
    … …  
    225264        RELEASE_ASSERT(!executable->m_evalCodeBlock);
    226265        RELEASE_ASSERT(!function);
    227         return adoptRef(new EvalCodeBlock(
     266        return EvalCodeBlock::create(vm,
    228267            executable, executable->m_unlinkedEvalCodeBlock.get(), scope,
    229             executable->source().provider()));
     268            executable->source().provider());
    230269    }
    231270   
    … …  
    235274        RELEASE_ASSERT(!executable->m_programCodeBlock);
    236275        RELEASE_ASSERT(!function);
    237         return adoptRef(new ProgramCodeBlock(
     276        return ProgramCodeBlock::create(vm,
    238277            executable, executable->m_unlinkedProgramCodeBlock.get(), scope,
    239             executable->source().provider(), executable->source().startColumn()));
     278            executable->source().provider(), executable->source().startColumn());
    240279    }
    241280
    … …  
    245284        RELEASE_ASSERT(!executable->m_moduleProgramCodeBlock);
    246285        RELEASE_ASSERT(!function);
    247         return adoptRef(new ModuleProgramCodeBlock(
     286        return ModuleProgramCodeBlock::create(vm,
    248287            executable, executable->m_unlinkedModuleProgramCodeBlock.get(), scope,
    249             executable->source().provider(), executable->source().startColumn()));
     288            executable->source().provider(), executable->source().startColumn());
    250289    }
    251290
    … …  
    277316    unsigned startColumn = executable->source().startColumn();
    278317
    279     return adoptRef(new FunctionCodeBlock(
    280         executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn));
    281 }
    282 
    283 PassRefPtr<CodeBlock> ScriptExecutable::newReplacementCodeBlockFor(
     318    return FunctionCodeBlock::create(vm,
     319        executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn);
     320}
     321
     322CodeBlock* ScriptExecutable::newReplacementCodeBlockFor(
    284323    CodeSpecializationKind kind)
    285324{
    … …  
    289328        EvalCodeBlock* baseline = static_cast<EvalCodeBlock*>(
    290329            executable->m_evalCodeBlock->baselineVersion());
    291         RefPtr<EvalCodeBlock> result = adoptRef(new EvalCodeBlock(
    292             CodeBlock::CopyParsedBlock, *baseline));
    293         result->setAlternative(baseline);
     330        EvalCodeBlock* result = EvalCodeBlock::create(vm(),
     331            CodeBlock::CopyParsedBlock, *baseline);
     332        result->setAlternative(*vm(), baseline);
    294333        return result;
    295334    }
    … …  
    300339        ProgramCodeBlock* baseline = static_cast<ProgramCodeBlock*>(
    301340            executable->m_programCodeBlock->baselineVersion());
    302         RefPtr<ProgramCodeBlock> result = adoptRef(new ProgramCodeBlock(
    303             CodeBlock::CopyParsedBlock, *baseline));
    304         result->setAlternative(baseline);
     341        ProgramCodeBlock* result = ProgramCodeBlock::create(vm(),
     342            CodeBlock::CopyParsedBlock, *baseline);
     343        result->setAlternative(*vm(), baseline);
    305344        return result;
    306345    }
    … …  
    311350        ModuleProgramCodeBlock* baseline = static_cast<ModuleProgramCodeBlock*>(
    312351            executable->m_moduleProgramCodeBlock->baselineVersion());
    313         RefPtr<ModuleProgramCodeBlock> result = adoptRef(new ModuleProgramCodeBlock(
    314             CodeBlock::CopyParsedBlock, *baseline));
    315         result->setAlternative(baseline);
     352        ModuleProgramCodeBlock* result = ModuleProgramCodeBlock::create(vm(),
     353            CodeBlock::CopyParsedBlock, *baseline);
     354        result->setAlternative(*vm(), baseline);
    316355        return result;
    317356    }
    … …  
    321360    FunctionCodeBlock* baseline = static_cast<FunctionCodeBlock*>(
    322361        executable->codeBlockFor(kind)->baselineVersion());
    323     RefPtr<FunctionCodeBlock> result = adoptRef(new FunctionCodeBlock(
    324         CodeBlock::CopyParsedBlock, *baseline));
    325     result->setAlternative(baseline);
     362    FunctionCodeBlock* result = FunctionCodeBlock::create(vm(),
     363        CodeBlock::CopyParsedBlock, *baseline);
     364    result->setAlternative(*vm(), baseline);
    326365    return result;
    327366}
    … …  
    351390   
    352391    JSObject* exception = 0;
    353     RefPtr<CodeBlock> codeBlock = newCodeBlockFor(kind, function, scope, exception);
     392    CodeBlock* codeBlock = newCodeBlockFor(kind, function, scope, exception);
    354393    if (!codeBlock) {
    355394        RELEASE_ASSERT(exception);
    … …  
    361400   
    362401    if (Options::useLLInt())
    363         setupLLInt(vm, codeBlock.get());
     402        setupLLInt(vm, codeBlock);
    364403    else
    365         setupJIT(vm, codeBlock.get());
    366    
    367     installCode(*codeBlock->vm(), codeBlock.get(), codeBlock->codeType(), codeBlock->specializationKind());
     404        setupJIT(vm, codeBlock);
     405   
     406    installCode(*codeBlock->vm(), codeBlock, codeBlock->codeType(), codeBlock->specializationKind());
    368407    return 0;
    369408}
    … …  
    503542    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    504543    ScriptExecutable::visitChildren(thisObject, visitor);
     544    visitor.append(&thisObject->m_unlinkedEvalCodeBlock);
    505545    if (thisObject->m_evalCodeBlock)
    506         thisObject->m_evalCodeBlock->visitAggregate(visitor);
    507     visitor.append(&thisObject->m_unlinkedEvalCodeBlock);
    508 }
    509 
    510 void EvalExecutable::clearCode()
    511 {
    512     m_evalCodeBlock = nullptr;
    513     m_unlinkedEvalCodeBlock.clear();
    514     Base::clearCode();
     546        thisObject->m_evalCodeBlock->visitWeakly(visitor);
    515547}
    516548
    … …  
    619651    visitor.append(&thisObject->m_unlinkedProgramCodeBlock);
    620652    if (thisObject->m_programCodeBlock)
    621         thisObject->m_programCodeBlock->visitAggregate(visitor);
    622 }
    623 
    624 void ProgramExecutable::clearCode()
    625 {
    626     m_programCodeBlock = nullptr;
    627     m_unlinkedProgramCodeBlock.clear();
    628     Base::clearCode();
     653        thisObject->m_programCodeBlock->visitWeakly(visitor);
    629654}
    630655
    … …  
    637662    visitor.append(&thisObject->m_moduleEnvironmentSymbolTable);
    638663    if (thisObject->m_moduleProgramCodeBlock)
    639         thisObject->m_moduleProgramCodeBlock->visitAggregate(visitor);
    640 }
    641 
    642 void ModuleProgramExecutable::clearCode()
    643 {
    644     m_moduleProgramCodeBlock = nullptr;
    645     m_unlinkedModuleProgramCodeBlock.clear();
    646     m_moduleEnvironmentSymbolTable.clear();
    647     Base::clearCode();
     664        thisObject->m_moduleProgramCodeBlock->visitWeakly(visitor);
    648665}
    649666
    … …  
    668685    ScriptExecutable::visitChildren(thisObject, visitor);
    669686    if (thisObject->m_codeBlockForCall)
    670         thisObject->m_codeBlockForCall->visitAggregate(visitor);
     687        thisObject->m_codeBlockForCall->visitWeakly(visitor);
    671688    if (thisObject->m_codeBlockForConstruct)
    672         thisObject->m_codeBlockForConstruct->visitAggregate(visitor);
     689        thisObject->m_codeBlockForConstruct->visitWeakly(visitor);
    673690    visitor.append(&thisObject->m_unlinkedExecutable);
    674691    visitor.append(&thisObject->m_singletonFunction);
    675 }
    676 
    677 void FunctionExecutable::clearCode()
    678 {
    679     m_codeBlockForCall = nullptr;
    680     m_codeBlockForConstruct = nullptr;
    681     Base::clearCode();
    682692}
    683693
    … …  
    717727    ExecutableBase::visitChildren(thisObject, visitor);
    718728    if (thisObject->m_codeBlockForCall)
    719         thisObject->m_codeBlockForCall->visitAggregate(visitor);
     729        thisObject->m_codeBlockForCall->visitWeakly(visitor);
    720730    visitor.append(&thisObject->m_module);
    721 }
    722 
    723 void WebAssemblyExecutable::clearCode()
    724 {
    725     m_codeBlockForCall = nullptr;
    726     Base::clearCode();
    727731}
    728732
    … …  
    735739    DeferGC deferGC(vm.heap);
    736740
    737     RefPtr<WebAssemblyCodeBlock> codeBlock = adoptRef(new WebAssemblyCodeBlock(
    738         this, vm, exec->lexicalGlobalObject()));
    739 
    740     WASMFunctionParser::compile(vm, codeBlock.get(), m_module.get(), m_source, m_functionIndex);
     741    WebAssemblyCodeBlock* codeBlock = WebAssemblyCodeBlock::create(vm,
     742        this, exec->lexicalGlobalObject()));
     743
     744    WASMFunctionParser::compile(vm, codeBlock, m_module.get(), m_source, m_functionIndex);
    741745
    742746    m_jitCodeForCall = codeBlock->jitCode();
    … …  
    744748    m_numParametersForCall = codeBlock->numParameters();
    745749
    746     m_codeBlockForCall = codeBlock;
     750    m_codeBlockForCall.set(vm, this, codeBlock);
    747751
    748752    Heap::heap(this)->writeBarrier(this);
Note: See TracChangeset for help on using the changeset viewer.