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

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

Unreviewed, rolling out r190694
​https://bugs.webkit.org/show_bug.cgi?id=148560

Crashes seen on PLT bots and facebook.com.

Reverted changesets:

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r190694 r190809  
    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());
    10263}
    10364
    … …  
    163124    ASSERT(vm.heap.isDeferred());
    164125   
    165     CodeBlock* oldCodeBlock = nullptr;
     126    RefPtr<CodeBlock> oldCodeBlock;
    166127   
    167128    switch (codeType) {
    … …  
    172133        ASSERT(kind == CodeForCall);
    173134       
    174         oldCodeBlock = executable->m_programCodeBlock.get();
    175         executable->m_programCodeBlock.setMayBeNull(vm, this, codeBlock);
     135        oldCodeBlock = executable->m_programCodeBlock;
     136        executable->m_programCodeBlock = codeBlock;
    176137        break;
    177138    }
    … …  
    183144        ASSERT(kind == CodeForCall);
    184145
    185         oldCodeBlock = executable->m_moduleProgramCodeBlock.get();
    186         executable->m_moduleProgramCodeBlock.setMayBeNull(vm, this, codeBlock);
     146        oldCodeBlock = executable->m_moduleProgramCodeBlock;
     147        executable->m_moduleProgramCodeBlock = codeBlock;
    187148        break;
    188149    }
    … …  
    194155        ASSERT(kind == CodeForCall);
    195156       
    196         oldCodeBlock = executable->m_evalCodeBlock.get();
    197         executable->m_evalCodeBlock.setMayBeNull(vm, this, codeBlock);
     157        oldCodeBlock = executable->m_evalCodeBlock;
     158        executable->m_evalCodeBlock = codeBlock;
    198159        break;
    199160    }
    … …  
    205166        switch (kind) {
    206167        case CodeForCall:
    207             oldCodeBlock = executable->m_codeBlockForCall.get();
    208             executable->m_codeBlockForCall.setMayBeNull(vm, this, codeBlock);
     168            oldCodeBlock = executable->m_codeBlockForCall;
     169            executable->m_codeBlockForCall = codeBlock;
    209170            break;
    210171        case CodeForConstruct:
    211             oldCodeBlock = executable->m_codeBlockForConstruct.get();
    212             executable->m_codeBlockForConstruct.setMayBeNull(vm, this, codeBlock);
     172            oldCodeBlock = executable->m_codeBlockForConstruct;
     173            executable->m_codeBlockForConstruct = codeBlock;
    213174            break;
    214175        }
    … …  
    250211}
    251212
    252 CodeBlock* ScriptExecutable::newCodeBlockFor(
     213RefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(
    253214    CodeSpecializationKind kind, JSFunction* function, JSScope* scope, JSObject*& exception)
    254215{
    … …  
    264225        RELEASE_ASSERT(!executable->m_evalCodeBlock);
    265226        RELEASE_ASSERT(!function);
    266         return EvalCodeBlock::create(vm,
     227        return adoptRef(new EvalCodeBlock(
    267228            executable, executable->m_unlinkedEvalCodeBlock.get(), scope,
    268             executable->source().provider());
     229            executable->source().provider()));
    269230    }
    270231   
    … …  
    274235        RELEASE_ASSERT(!executable->m_programCodeBlock);
    275236        RELEASE_ASSERT(!function);
    276         return ProgramCodeBlock::create(vm,
     237        return adoptRef(new ProgramCodeBlock(
    277238            executable, executable->m_unlinkedProgramCodeBlock.get(), scope,
    278             executable->source().provider(), executable->source().startColumn());
     239            executable->source().provider(), executable->source().startColumn()));
    279240    }
    280241
    … …  
    284245        RELEASE_ASSERT(!executable->m_moduleProgramCodeBlock);
    285246        RELEASE_ASSERT(!function);
    286         return ModuleProgramCodeBlock::create(vm,
     247        return adoptRef(new ModuleProgramCodeBlock(
    287248            executable, executable->m_unlinkedModuleProgramCodeBlock.get(), scope,
    288             executable->source().provider(), executable->source().startColumn());
     249            executable->source().provider(), executable->source().startColumn()));
    289250    }
    290251
    … …  
    316277    unsigned startColumn = executable->source().startColumn();
    317278
    318     return FunctionCodeBlock::create(vm,
    319         executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn);
    320 }
    321 
    322 CodeBlock* ScriptExecutable::newReplacementCodeBlockFor(
     279    return adoptRef(new FunctionCodeBlock(
     280        executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn));
     281}
     282
     283PassRefPtr<CodeBlock> ScriptExecutable::newReplacementCodeBlockFor(
    323284    CodeSpecializationKind kind)
    324285{
    … …  
    328289        EvalCodeBlock* baseline = static_cast<EvalCodeBlock*>(
    329290            executable->m_evalCodeBlock->baselineVersion());
    330         EvalCodeBlock* result = EvalCodeBlock::create(vm(),
    331             CodeBlock::CopyParsedBlock, *baseline);
    332         result->setAlternative(*vm(), baseline);
     291        RefPtr<EvalCodeBlock> result = adoptRef(new EvalCodeBlock(
     292            CodeBlock::CopyParsedBlock, *baseline));
     293        result->setAlternative(baseline);
    333294        return result;
    334295    }
    … …  
    339300        ProgramCodeBlock* baseline = static_cast<ProgramCodeBlock*>(
    340301            executable->m_programCodeBlock->baselineVersion());
    341         ProgramCodeBlock* result = ProgramCodeBlock::create(vm(),
    342             CodeBlock::CopyParsedBlock, *baseline);
    343         result->setAlternative(*vm(), baseline);
     302        RefPtr<ProgramCodeBlock> result = adoptRef(new ProgramCodeBlock(
     303            CodeBlock::CopyParsedBlock, *baseline));
     304        result->setAlternative(baseline);
    344305        return result;
    345306    }
    … …  
    350311        ModuleProgramCodeBlock* baseline = static_cast<ModuleProgramCodeBlock*>(
    351312            executable->m_moduleProgramCodeBlock->baselineVersion());
    352         ModuleProgramCodeBlock* result = ModuleProgramCodeBlock::create(vm(),
    353             CodeBlock::CopyParsedBlock, *baseline);
    354         result->setAlternative(*vm(), baseline);
     313        RefPtr<ModuleProgramCodeBlock> result = adoptRef(new ModuleProgramCodeBlock(
     314            CodeBlock::CopyParsedBlock, *baseline));
     315        result->setAlternative(baseline);
    355316        return result;
    356317    }
    … …  
    360321    FunctionCodeBlock* baseline = static_cast<FunctionCodeBlock*>(
    361322        executable->codeBlockFor(kind)->baselineVersion());
    362     FunctionCodeBlock* result = FunctionCodeBlock::create(vm(),
    363         CodeBlock::CopyParsedBlock, *baseline);
    364     result->setAlternative(*vm(), baseline);
     323    RefPtr<FunctionCodeBlock> result = adoptRef(new FunctionCodeBlock(
     324        CodeBlock::CopyParsedBlock, *baseline));
     325    result->setAlternative(baseline);
    365326    return result;
    366327}
    … …  
    390351   
    391352    JSObject* exception = 0;
    392     CodeBlock* codeBlock = newCodeBlockFor(kind, function, scope, exception);
     353    RefPtr<CodeBlock> codeBlock = newCodeBlockFor(kind, function, scope, exception);
    393354    if (!codeBlock) {
    394355        RELEASE_ASSERT(exception);
    … …  
    400361   
    401362    if (Options::useLLInt())
    402         setupLLInt(vm, codeBlock);
     363        setupLLInt(vm, codeBlock.get());
    403364    else
    404         setupJIT(vm, codeBlock);
    405    
    406     installCode(*codeBlock->vm(), codeBlock, codeBlock->codeType(), codeBlock->specializationKind());
     365        setupJIT(vm, codeBlock.get());
     366   
     367    installCode(*codeBlock->vm(), codeBlock.get(), codeBlock->codeType(), codeBlock->specializationKind());
    407368    return 0;
    408369}
    … …  
    542503    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    543504    ScriptExecutable::visitChildren(thisObject, visitor);
     505    if (thisObject->m_evalCodeBlock)
     506        thisObject->m_evalCodeBlock->visitAggregate(visitor);
    544507    visitor.append(&thisObject->m_unlinkedEvalCodeBlock);
    545     if (thisObject->m_evalCodeBlock)
    546         thisObject->m_evalCodeBlock->visitWeakly(visitor);
     508}
     509
     510void EvalExecutable::clearCode()
     511{
     512    m_evalCodeBlock = nullptr;
     513    m_unlinkedEvalCodeBlock.clear();
     514    Base::clearCode();
    547515}
    548516
    … …  
    651619    visitor.append(&thisObject->m_unlinkedProgramCodeBlock);
    652620    if (thisObject->m_programCodeBlock)
    653         thisObject->m_programCodeBlock->visitWeakly(visitor);
     621        thisObject->m_programCodeBlock->visitAggregate(visitor);
     622}
     623
     624void ProgramExecutable::clearCode()
     625{
     626    m_programCodeBlock = nullptr;
     627    m_unlinkedProgramCodeBlock.clear();
     628    Base::clearCode();
    654629}
    655630
    … …  
    662637    visitor.append(&thisObject->m_moduleEnvironmentSymbolTable);
    663638    if (thisObject->m_moduleProgramCodeBlock)
    664         thisObject->m_moduleProgramCodeBlock->visitWeakly(visitor);
     639        thisObject->m_moduleProgramCodeBlock->visitAggregate(visitor);
     640}
     641
     642void ModuleProgramExecutable::clearCode()
     643{
     644    m_moduleProgramCodeBlock = nullptr;
     645    m_unlinkedModuleProgramCodeBlock.clear();
     646    m_moduleEnvironmentSymbolTable.clear();
     647    Base::clearCode();
    665648}
    666649
    … …  
    685668    ScriptExecutable::visitChildren(thisObject, visitor);
    686669    if (thisObject->m_codeBlockForCall)
    687         thisObject->m_codeBlockForCall->visitWeakly(visitor);
     670        thisObject->m_codeBlockForCall->visitAggregate(visitor);
    688671    if (thisObject->m_codeBlockForConstruct)
    689         thisObject->m_codeBlockForConstruct->visitWeakly(visitor);
     672        thisObject->m_codeBlockForConstruct->visitAggregate(visitor);
    690673    visitor.append(&thisObject->m_unlinkedExecutable);
    691674    visitor.append(&thisObject->m_singletonFunction);
     675}
     676
     677void FunctionExecutable::clearCode()
     678{
     679    m_codeBlockForCall = nullptr;
     680    m_codeBlockForConstruct = nullptr;
     681    Base::clearCode();
    692682}
    693683
    … …  
    727717    ExecutableBase::visitChildren(thisObject, visitor);
    728718    if (thisObject->m_codeBlockForCall)
    729         thisObject->m_codeBlockForCall->visitWeakly(visitor);
     719        thisObject->m_codeBlockForCall->visitAggregate(visitor);
    730720    visitor.append(&thisObject->m_module);
     721}
     722
     723void WebAssemblyExecutable::clearCode()
     724{
     725    m_codeBlockForCall = nullptr;
     726    Base::clearCode();
    731727}
    732728
    … …  
    739735    DeferGC deferGC(vm.heap);
    740736
    741     WebAssemblyCodeBlock* codeBlock = WebAssemblyCodeBlock::create(vm,
    742         this, exec->lexicalGlobalObject()));
    743 
    744     WASMFunctionParser::compile(vm, codeBlock, m_module.get(), m_source, m_functionIndex);
     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);
    745741
    746742    m_jitCodeForCall = codeBlock->jitCode();
    … …  
    748744    m_numParametersForCall = codeBlock->numParameters();
    749745
    750     m_codeBlockForCall.set(vm, this, codeBlock);
     746    m_codeBlockForCall = codeBlock;
    751747
    752748    Heap::heap(this)->writeBarrier(this);
Note: See TracChangeset for help on using the changeset viewer.