Changeset 153177 in webkit


Ignore:
Timestamp:
Jul 24, 2013, 9:00:54 PM (12 years ago)
Author:
[email protected]
Message:

fourthTier: Rename getJITCode and getJITType to jitCode and jitType.

Rubber stampted by Mark Hahnenberg.

  • assembler/RepatchBuffer.h:

(JSC::RepatchBuffer::RepatchBuffer):

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dump):
(JSC::CodeBlock::visitAggregate):
(JSC::CodeBlock::finalizeUnconditionally):
(JSC::CodeBlock::resetStubInternal):
(JSC::CodeBlock::stronglyVisitWeakReferences):
(JSC::CodeBlock::baselineVersion):
(JSC::CodeBlock::hasOptimizedReplacement):
(JSC::CodeBlock::bytecodeOffset):
(JSC::CodeBlock::codeOriginForReturn):
(JSC::ProgramCodeBlock::compileOptimized):
(JSC::EvalCodeBlock::compileOptimized):
(JSC::FunctionCodeBlock::compileOptimized):
(JSC::ProgramCodeBlock::jettison):
(JSC::EvalCodeBlock::jettison):
(JSC::FunctionCodeBlock::jettison):
(JSC::ProgramCodeBlock::jitCompileImpl):
(JSC::EvalCodeBlock::jitCompileImpl):
(JSC::FunctionCodeBlock::jitCompileImpl):
(JSC::CodeBlock::setOptimizationThresholdBasedOnCompilationResult):
(JSC::CodeBlock::adjustedExitCountThreshold):
(JSC::CodeBlock::tallyFrequentExitSites):

  • bytecode/CodeBlock.h:

(JSC::CodeBlock::getCallLinkInfo):
(JSC::CodeBlock::jitCode):
(JSC::CodeBlock::jitCodeWithArityCheck):
(JSC::CodeBlock::jitType):
(JSC::CodeBlock::hasBaselineJITProfiling):
(JSC::CodeBlock::jitCompile):
(JSC::CodeBlock::addFrequentExitSite):
(JSC::CodeBlock::shouldImmediatelyAssumeLivenessDuringScan):
(JSC::ExecState::isInlineCallFrame):

  • dfg/DFGAssemblyHelpers.cpp:

(JSC::DFG::AssemblyHelpers::decodedCodeMapFor):

  • dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::AssemblyHelpers):

  • dfg/DFGDriver.cpp:

(JSC::DFG::compile):

  • dfg/DFGOSREntry.cpp:

(JSC::DFG::prepareOSREntry):

  • dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::codeLocationForRepatch):

  • dfg/DFGOSRExitCompiler.cpp:
  • dfg/DFGOSRExitCompilerCommon.cpp:

(JSC::DFG::reifyInlinedCallFrames):
(JSC::DFG::adjustAndJumpToTarget):

  • dfg/DFGOperations.cpp:
  • dfg/DFGVariableEventStream.cpp:

(JSC::DFG::VariableEventStream::reconstruct):

  • ftl/FTLOSRExit.cpp:

(JSC::FTL::OSRExit::codeLocationForRepatch):

  • ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileFTLOSRExit):

  • heap/DFGCodeBlocks.cpp:

(JSC::DFGCodeBlocks::~DFGCodeBlocks):
(JSC::DFGCodeBlocks::jettison):
(JSC::DFGCodeBlocks::clearMarks):
(JSC::DFGCodeBlocks::deleteUnmarkedJettisonedCodeBlocks):
(JSC::DFGCodeBlocks::traceMarkedCodeBlocks):

  • interpreter/Interpreter.cpp:

(JSC::getLineNumberForCallFrame):
(JSC::getCallerInfo):

  • jit/JITDriver.h:

(JSC::jitCompileIfAppropriateImpl):
(JSC::jitCompileFunctionIfAppropriateImpl):

  • jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::entryOSR):
(JSC::LLInt::LLINT_SLOW_PATH_DECL):

  • runtime/Executable.cpp:

(JSC::jettisonCodeBlock):
(JSC::EvalExecutable::compileOptimized):
(JSC::EvalExecutable::jettisonOptimizedCode):
(JSC::ProgramExecutable::compileOptimized):
(JSC::ProgramExecutable::jettisonOptimizedCode):
(JSC::FunctionExecutable::baselineCodeBlockFor):
(JSC::FunctionExecutable::compileOptimizedForCall):
(JSC::FunctionExecutable::compileOptimizedForConstruct):
(JSC::FunctionExecutable::jettisonOptimizedCodeForCall):
(JSC::FunctionExecutable::jettisonOptimizedCodeForConstruct):

  • tools/CodeProfile.cpp:

(JSC::CodeProfile::sample):

Location:
trunk/Source/JavaScriptCore
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r153176 r153177  
     12013-05-22  Filip Pizlo  <[email protected]>
     2
     3        Rename getJITCode and getJITType to jitCode and jitType.
     4       
     5        Rubber stampted by Mark Hahnenberg.
     6
     7        * assembler/RepatchBuffer.h:
     8        (JSC::RepatchBuffer::RepatchBuffer):
     9        * bytecode/CodeBlock.cpp:
     10        (JSC::CodeBlock::dump):
     11        (JSC::CodeBlock::visitAggregate):
     12        (JSC::CodeBlock::finalizeUnconditionally):
     13        (JSC::CodeBlock::resetStubInternal):
     14        (JSC::CodeBlock::stronglyVisitWeakReferences):
     15        (JSC::CodeBlock::baselineVersion):
     16        (JSC::CodeBlock::hasOptimizedReplacement):
     17        (JSC::CodeBlock::bytecodeOffset):
     18        (JSC::CodeBlock::codeOriginForReturn):
     19        (JSC::ProgramCodeBlock::compileOptimized):
     20        (JSC::EvalCodeBlock::compileOptimized):
     21        (JSC::FunctionCodeBlock::compileOptimized):
     22        (JSC::ProgramCodeBlock::jettison):
     23        (JSC::EvalCodeBlock::jettison):
     24        (JSC::FunctionCodeBlock::jettison):
     25        (JSC::ProgramCodeBlock::jitCompileImpl):
     26        (JSC::EvalCodeBlock::jitCompileImpl):
     27        (JSC::FunctionCodeBlock::jitCompileImpl):
     28        (JSC::CodeBlock::setOptimizationThresholdBasedOnCompilationResult):
     29        (JSC::CodeBlock::adjustedExitCountThreshold):
     30        (JSC::CodeBlock::tallyFrequentExitSites):
     31        * bytecode/CodeBlock.h:
     32        (JSC::CodeBlock::getCallLinkInfo):
     33        (JSC::CodeBlock::jitCode):
     34        (JSC::CodeBlock::jitCodeWithArityCheck):
     35        (JSC::CodeBlock::jitType):
     36        (JSC::CodeBlock::hasBaselineJITProfiling):
     37        (JSC::CodeBlock::jitCompile):
     38        (JSC::CodeBlock::addFrequentExitSite):
     39        (JSC::CodeBlock::shouldImmediatelyAssumeLivenessDuringScan):
     40        (JSC::ExecState::isInlineCallFrame):
     41        * dfg/DFGAssemblyHelpers.cpp:
     42        (JSC::DFG::AssemblyHelpers::decodedCodeMapFor):
     43        * dfg/DFGAssemblyHelpers.h:
     44        (JSC::DFG::AssemblyHelpers::AssemblyHelpers):
     45        * dfg/DFGDriver.cpp:
     46        (JSC::DFG::compile):
     47        * dfg/DFGOSREntry.cpp:
     48        (JSC::DFG::prepareOSREntry):
     49        * dfg/DFGOSRExit.cpp:
     50        (JSC::DFG::OSRExit::codeLocationForRepatch):
     51        * dfg/DFGOSRExitCompiler.cpp:
     52        * dfg/DFGOSRExitCompilerCommon.cpp:
     53        (JSC::DFG::reifyInlinedCallFrames):
     54        (JSC::DFG::adjustAndJumpToTarget):
     55        * dfg/DFGOperations.cpp:
     56        * dfg/DFGVariableEventStream.cpp:
     57        (JSC::DFG::VariableEventStream::reconstruct):
     58        * ftl/FTLOSRExit.cpp:
     59        (JSC::FTL::OSRExit::codeLocationForRepatch):
     60        * ftl/FTLOSRExitCompiler.cpp:
     61        (JSC::FTL::compileFTLOSRExit):
     62        * heap/DFGCodeBlocks.cpp:
     63        (JSC::DFGCodeBlocks::~DFGCodeBlocks):
     64        (JSC::DFGCodeBlocks::jettison):
     65        (JSC::DFGCodeBlocks::clearMarks):
     66        (JSC::DFGCodeBlocks::deleteUnmarkedJettisonedCodeBlocks):
     67        (JSC::DFGCodeBlocks::traceMarkedCodeBlocks):
     68        * interpreter/Interpreter.cpp:
     69        (JSC::getLineNumberForCallFrame):
     70        (JSC::getCallerInfo):
     71        * jit/JITDriver.h:
     72        (JSC::jitCompileIfAppropriateImpl):
     73        (JSC::jitCompileFunctionIfAppropriateImpl):
     74        * jit/JITStubs.cpp:
     75        (JSC::DEFINE_STUB_FUNCTION):
     76        * llint/LLIntSlowPaths.cpp:
     77        (JSC::LLInt::entryOSR):
     78        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
     79        * runtime/Executable.cpp:
     80        (JSC::jettisonCodeBlock):
     81        (JSC::EvalExecutable::compileOptimized):
     82        (JSC::EvalExecutable::jettisonOptimizedCode):
     83        (JSC::ProgramExecutable::compileOptimized):
     84        (JSC::ProgramExecutable::jettisonOptimizedCode):
     85        (JSC::FunctionExecutable::baselineCodeBlockFor):
     86        (JSC::FunctionExecutable::compileOptimizedForCall):
     87        (JSC::FunctionExecutable::compileOptimizedForConstruct):
     88        (JSC::FunctionExecutable::jettisonOptimizedCodeForCall):
     89        (JSC::FunctionExecutable::jettisonOptimizedCodeForConstruct):
     90        * tools/CodeProfile.cpp:
     91        (JSC::CodeProfile::sample):
     92
    1932013-05-22  Filip Pizlo  <[email protected]>
    294

  • trunk/Source/JavaScriptCore/assembler/RepatchBuffer.h

    r153121 r153177  
    4848    {
    4949#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
    50         RefPtr<JITCode> code = codeBlock->getJITCode();
     50        RefPtr<JITCode> code = codeBlock->jitCode();
    5151        m_start = code->start();
    5252        m_size = code->size();

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

    r153170 r153177  
    118118void CodeBlock::dump(PrintStream& out) const
    119119{
    120     dumpAssumingJITType(out, getJITType());
     120    dumpAssumingJITType(out, jitType());
    121121}
    122122
    … …  
    20532053{
    20542054#if ENABLE(PARALLEL_GC) && ENABLE(DFG_JIT)
    2055     if (JITCode::isOptimizingJIT(getJITType())) {
     2055    if (JITCode::isOptimizingJIT(jitType())) {
    20562056        DFG::CommonData* dfgCommon = m_jitCode->dfgCommon();
    20572057       
    … …  
    23022302#if ENABLE(JIT)
    23032303    // Handle inline caches.
    2304     if (!!getJITCode()) {
     2304    if (!!jitCode()) {
    23052305        RepatchBuffer repatchBuffer(this);
    23062306        for (unsigned i = 0; i < numberOfCallLinkInfos(); ++i) {
    … …  
    23622362        dataLog("Clearing structure cache (kind ", static_cast<int>(stubInfo.accessType), ") in ", *this, ".\n");
    23632363
    2364     switch (getJITType()) {
     2364    switch (jitType()) {
    23652365    case JITCode::BaselineJIT:
    23662366        if (isGetByIdAccess(accessType))
    … …  
    24132413
    24142414#if ENABLE(DFG_JIT)
    2415     if (!JITCode::isOptimizingJIT(getJITType()))
     2415    if (!JITCode::isOptimizingJIT(jitType()))
    24162416        return;
    24172417   
    … …  
    24362436    // to get its replacement. But we'll know that it's the original baseline code
    24372437    // block because it won't have JIT code yet and it won't have an alternative.
    2438     if (getJITType() == JITCode::None && !alternative())
     2438    if (jitType() == JITCode::None && !alternative())
    24392439        return this;
    24402440   
    … …  
    24442444        result = result->alternative();
    24452445    ASSERT(result);
    2446     ASSERT(JITCode::isBaselineCode(result->getJITType()));
     2446    ASSERT(JITCode::isBaselineCode(result->jitType()));
    24472447    return result;
    24482448#else
    … …  
    24542454bool CodeBlock::hasOptimizedReplacement()
    24552455{
    2456     ASSERT(JITCode::isBaselineCode(getJITType()));
    2457     bool result = JITCode::isHigherTier(replacement()->getJITType(), getJITType());
     2456    ASSERT(JITCode::isBaselineCode(jitType()));
     2457    bool result = JITCode::isHigherTier(replacement()->jitType(), jitType());
    24582458    if (result)
    2459         ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
     2459        ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
    24602460    else {
    2461         ASSERT(JITCode::isBaselineCode(replacement()->getJITType()));
     2461        ASSERT(JITCode::isBaselineCode(replacement()->jitType()));
    24622462        ASSERT(replacement() == this);
    24632463    }
    … …  
    27092709        RELEASE_ASSERT(exec->codeBlock());
    27102710        RELEASE_ASSERT(exec->codeBlock() == this);
    2711         RELEASE_ASSERT(JITCode::isBaselineCode(getJITType()));
     2711        RELEASE_ASSERT(JITCode::isBaselineCode(jitType()));
    27122712        Instruction* instruction = exec->currentVPC();
    27132713        RELEASE_ASSERT(instruction);
    … …  
    27252725        return 1;
    27262726   
    2727     if (getJITCode()->contains(returnAddress.value())) {
    2728         unsigned callReturnOffset = getJITCode()->offsetOf(returnAddress.value());
     2727    if (jitCode()->contains(returnAddress.value())) {
     2728        unsigned callReturnOffset = jitCode()->offsetOf(returnAddress.value());
    27292729        CallReturnOffsetToBytecodeOffset* result =
    27302730            binarySearch<CallReturnOffsetToBytecodeOffset, unsigned>(
    … …  
    27592759        return false;
    27602760
    2761     if (!getJITCode()->contains(returnAddress.value())) {
     2761    if (!jitCode()->contains(returnAddress.value())) {
    27622762        ClosureCallStubRoutine* stub = findClosureCallForReturnPC(returnAddress);
    27632763        ASSERT(stub);
    … …  
    27682768    }
    27692769   
    2770     unsigned offset = getJITCode()->offsetOf(returnAddress.value());
     2770    unsigned offset = jitCode()->offsetOf(returnAddress.value());
    27712771    CodeOriginAtCallReturnOffset* entry =
    27722772        tryBinarySearch<CodeOriginAtCallReturnOffset, unsigned>(
    … …  
    28422842JSObject* ProgramCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28432843{
    2844     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2844    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28452845        result = CompilationNotNeeded;
    28462846        return 0;
    … …  
    28572857JSObject* EvalCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28582858{
    2859     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2859    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28602860        result = CompilationNotNeeded;
    28612861        return 0;
    … …  
    28722872JSObject* FunctionCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28732873{
    2874     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2874    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28752875        result = CompilationNotNeeded;
    28762876        return 0;
    … …  
    29042904void CodeBlock::jettison()
    29052905{
    2906     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     2906    ASSERT(JITCode::isOptimizingJIT(jitType()));
    29072907    ASSERT(this == replacement());
    29082908    alternative()->optimizeAfterWarmUp();
    … …  
    29202920void EvalCodeBlock::jettisonImpl()
    29212921{
     2922    ASSERT(JITCode::isOptimizingJIT(jitType()));
     2923    ASSERT(this == replacement());
     2924    if (DFG::shouldShowDisassembly())
     2925        dataLog("Jettisoning ", *this, ".\n");
    29222926    static_cast<EvalExecutable*>(ownerExecutable())->jettisonOptimizedCode(*vm());
    29232927}
    … …  
    29252929void FunctionCodeBlock::jettisonImpl()
    29262930{
     2931    ASSERT(JITCode::isOptimizingJIT(jitType()));
     2932    ASSERT(this == replacement());
     2933    if (DFG::shouldShowDisassembly())
     2934        dataLog("Jettisoning ", *this, ".\n");
    29272935    static_cast<FunctionExecutable*>(ownerExecutable())->jettisonOptimizedCodeFor(*vm(), m_isConstructor ? CodeForConstruct : CodeForCall);
    29282936}
    … …  
    29302938CompilationResult ProgramCodeBlock::jitCompileImpl(ExecState* exec)
    29312939{
    2932     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2940    ASSERT(jitType() == JITCode::InterpreterThunk);
    29332941    ASSERT(this == replacement());
    29342942    return static_cast<ProgramExecutable*>(ownerExecutable())->jitCompile(exec);
    … …  
    29372945CompilationResult EvalCodeBlock::jitCompileImpl(ExecState* exec)
    29382946{
    2939     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2947    ASSERT(jitType() == JITCode::InterpreterThunk);
    29402948    ASSERT(this == replacement());
    29412949    return static_cast<EvalExecutable*>(ownerExecutable())->jitCompile(exec);
    … …  
    29442952CompilationResult FunctionCodeBlock::jitCompileImpl(ExecState* exec)
    29452953{
    2946     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2954    ASSERT(jitType() == JITCode::InterpreterThunk);
    29472955    ASSERT(this == replacement());
    29482956    return static_cast<FunctionExecutable*>(ownerExecutable())->jitCompileFor(exec, m_isConstructor ? CodeForConstruct : CodeForCall);
    … …  
    31483156void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResult result)
    31493157{
    3150     RELEASE_ASSERT(getJITType() == JITCode::BaselineJIT);
     3158    RELEASE_ASSERT(jitType() == JITCode::BaselineJIT);
    31513159    RELEASE_ASSERT((result == CompilationSuccessful) == (replacement() != this));
    31523160    switch (result) {
    31533161    case CompilationSuccessful:
    3154         RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
     3162        RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
    31553163        optimizeNextInvocation();
    31563164        break;
    … …  
    31803188uint32_t CodeBlock::adjustedExitCountThreshold(uint32_t desiredThreshold)
    31813189{
    3182     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     3190    ASSERT(JITCode::isOptimizingJIT(jitType()));
    31833191    // Compute this the lame way so we don't saturate. This is called infrequently
    31843192    // enough that this loop won't hurt us.
    … …  
    33253333void CodeBlock::tallyFrequentExitSites()
    33263334{
    3327     ASSERT(JITCode::isOptimizingJIT(getJITType()));
    3328     ASSERT(alternative()->getJITType() == JITCode::BaselineJIT);
     3335    ASSERT(JITCode::isOptimizingJIT(jitType()));
     3336    ASSERT(alternative()->jitType() == JITCode::BaselineJIT);
    33293337   
    33303338    CodeBlock* profiledBlock = alternative();
    33313339   
    3332     switch (getJITType()) {
     3340    switch (jitType()) {
    33333341    case JITCode::DFGJIT: {
    33343342        DFG::JITCode* jitCode = m_jitCode->dfg();

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

    r153176 r153177  
    193193        CallLinkInfo& getCallLinkInfo(unsigned bytecodeIndex)
    194194        {
    195             ASSERT(JITCode::isBaselineCode(getJITType()));
     195            ASSERT(JITCode::isBaselineCode(jitType()));
    196196            return *(binarySearch<CallLinkInfo, unsigned>(m_callLinkInfos, m_callLinkInfos.size(), bytecodeIndex, getCallLinkInfoBytecodeIndex));
    197197        }
    … …  
    285285#endif
    286286        }
    287         PassRefPtr<JITCode> getJITCode() { return m_jitCode; }
    288         MacroAssemblerCodePtr getJITCodeWithArityCheck() { return m_jitCodeWithArityCheck; }
    289         JITCode::JITType getJITType() const
     287        PassRefPtr<JITCode> jitCode() { return m_jitCode; }
     288        MacroAssemblerCodePtr jitCodeWithArityCheck() { return m_jitCodeWithArityCheck; }
     289        JITCode::JITType jitType() const
    290290        {
    291291            JITCode* jitCode = m_jitCode.get();
    … …  
    297297        bool hasBaselineJITProfiling() const
    298298        {
    299             return getJITType() == JITCode::BaselineJIT;
     299            return jitType() == JITCode::BaselineJIT;
    300300        }
    301301        virtual JSObject* compileOptimized(ExecState*, JSScope*, CompilationResult&, unsigned bytecodeIndex) = 0;
    … …  
    304304        CompilationResult jitCompile(ExecState* exec)
    305305        {
    306             if (getJITType() != JITCode::InterpreterThunk) {
    307                 ASSERT(getJITType() == JITCode::BaselineJIT);
     306            if (jitType() != JITCode::InterpreterThunk) {
     307                ASSERT(jitType() == JITCode::BaselineJIT);
    308308                return CompilationNotNeeded;
    309309            }
    … …  
    323323        bool hasOptimizedReplacement();
    324324#else
    325         JITCode::JITType getJITType() const { return JITCode::BaselineJIT; }
     325        JITCode::JITType jitType() const { return JITCode::BaselineJIT; }
    326326#endif
    327327
    … …  
    635635        bool addFrequentExitSite(const DFG::FrequentExitSite& site)
    636636        {
    637             ASSERT(JITCode::isBaselineCode(getJITType()));
     637            ASSERT(JITCode::isBaselineCode(jitType()));
    638638            return m_exitProfile.add(site);
    639639        }
    … …  
    989989            // stale. So if a basline JIT CodeBlock gets scanned, we can assume that
    990990            // this means that it's live.
    991             if (!JITCode::isOptimizingJIT(getJITType()))
     991            if (!JITCode::isOptimizingJIT(jitType()))
    992992                return true;
    993993
    … …  
    12611261    inline bool ExecState::isInlineCallFrame()
    12621262    {
    1263         if (LIKELY(!codeBlock() || !JITCode::isOptimizingJIT(codeBlock()->getJITType())))
     1263        if (LIKELY(!codeBlock() || !JITCode::isOptimizingJIT(codeBlock()->jitType())))
    12641264            return false;
    12651265        return isInlineCallFrameSlow();

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

    r131858 r153177  
    4242{
    4343    ASSERT(codeBlock == codeBlock->baselineVersion());
    44     ASSERT(codeBlock->getJITType() == JITCode::BaselineJIT);
     44    ASSERT(codeBlock->jitType() == JITCode::BaselineJIT);
    4545    ASSERT(codeBlock->jitCodeMap());
    4646   

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

    r153116 r153177  
    5353            ASSERT(m_baselineCodeBlock);
    5454            ASSERT(!m_baselineCodeBlock->alternative());
    55             ASSERT(m_baselineCodeBlock->getJITType() == JITCode::BaselineJIT);
     55            ASSERT(m_baselineCodeBlock->jitType() == JITCode::BaselineJIT);
    5656        }
    5757    }

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

    r153169 r153177  
    6161    ASSERT(codeBlock);
    6262    ASSERT(codeBlock->alternative());
    63     ASSERT(codeBlock->alternative()->getJITType() == JITCode::BaselineJIT);
     63    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
    6464   
    6565    ASSERT(osrEntryBytecodeIndex != UINT_MAX);

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

    r153169 r153177  
    4141{
    4242#if DFG_ENABLE(OSR_ENTRY)
    43     ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
     43    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
    4444    ASSERT(codeBlock->alternative());
    45     ASSERT(codeBlock->alternative()->getJITType() == JITCode::BaselineJIT);
     45    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
    4646    ASSERT(!codeBlock->jitCodeMap());
    4747
    … …  
    5353   
    5454    VM* vm = &exec->vm();
    55     OSREntryData* entry = codeBlock->getJITCode()->dfg()->osrEntryDataForBytecodeIndex(bytecodeIndex);
     55    OSREntryData* entry = codeBlock->jitCode()->dfg()->osrEntryDataForBytecodeIndex(bytecodeIndex);
    5656   
    5757    if (!entry) {
    … …  
    164164    // 5) Find and return the destination machine code address.
    165165   
    166     void* result = codeBlock->getJITCode()->executableAddressAtOffset(entry->m_machineCodeOffset);
     166    void* result = codeBlock->jitCode()->executableAddressAtOffset(entry->m_machineCodeOffset);
    167167   
    168168    if (Options::verboseOSR())

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

    r153121 r153177  
    6161CodeLocationJump OSRExit::codeLocationForRepatch(CodeBlock* dfgCodeBlock) const
    6262{
    63     return CodeLocationJump(dfgCodeBlock->getJITCode()->dataAddressAtOffset(m_patchableCodeOffset));
     63    return CodeLocationJump(dfgCodeBlock->jitCode()->dataAddressAtOffset(m_patchableCodeOffset));
    6464}
    6565

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

    r153121 r153177  
    4949   
    5050    ASSERT(codeBlock);
    51     ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
     51    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
    5252   
    5353    VM* vm = &exec->vm();
    5454   
    5555    uint32_t exitIndex = vm->osrExitIndex;
    56     OSRExit& exit = codeBlock->getJITCode()->dfg()->osrExit[exitIndex];
     56    OSRExit& exit = codeBlock->jitCode()->dfg()->osrExit[exitIndex];
    5757   
    5858    prepareCodeOriginForOSRExit(exec, exit.m_codeOrigin);
    … …  
    6060    // Compute the value recoveries.
    6161    Operands<ValueRecovery> operands;
    62     codeBlock->getJITCode()->dfg()->variableEventStream.reconstruct(codeBlock, exit.m_codeOrigin, codeBlock->getJITCode()->dfg()->minifiedDFG, exit.m_streamIndex, operands);
     62    codeBlock->jitCode()->dfg()->variableEventStream.reconstruct(codeBlock, exit.m_codeOrigin, codeBlock->jitCode()->dfg()->minifiedDFG, exit.m_streamIndex, operands);
    6363   
    6464    // There may be an override, for forward speculations.
    … …  
    7070    SpeculationRecovery* recovery = 0;
    7171    if (exit.m_recoveryIndex != UINT_MAX)
    72         recovery = &codeBlock->getJITCode()->dfg()->speculationRecovery[exit.m_recoveryIndex];
     72        recovery = &codeBlock->jitCode()->dfg()->speculationRecovery[exit.m_recoveryIndex];
    7373
    7474#if DFG_ENABLE(DEBUG_VERBOSE)
    … …  
    8585        jit.jitAssertHasValidCallFrame();
    8686       
    87         if (vm->m_perBytecodeProfiler && codeBlock->getJITCode()->dfgCommon()->compilation) {
     87        if (vm->m_perBytecodeProfiler && codeBlock->jitCode()->dfgCommon()->compilation) {
    8888            Profiler::Database& database = *vm->m_perBytecodeProfiler;
    89             Profiler::Compilation* compilation = codeBlock->getJITCode()->dfgCommon()->compilation.get();
     89            Profiler::Compilation* compilation = codeBlock->jitCode()->dfgCommon()->compilation.get();
    9090           
    9191            Profiler::OSRExit* profilerExit = compilation->addOSRExit(

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

    r153121 r153177  
    7979{
    8080#if USE(JSVALUE64)
    81     ASSERT(jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
     81    ASSERT(jit.baselineCodeBlock()->jitType() == JITCode::BaselineJIT);
    8282    jit.storePtr(AssemblyHelpers::TrustedImmPtr(jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    8383   
    … …  
    9393        ASSERT(mapping->m_bytecodeIndex == returnBytecodeIndex);
    9494       
    95         void* jumpTarget = baselineCodeBlockForCaller->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     95        void* jumpTarget = baselineCodeBlockForCaller->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    9696
    9797        GPRReg callerFrameGPR;
    … …  
    112112    }
    113113#else // USE(JSVALUE64) // so this is the 32-bit part
    114     ASSERT(jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
     114    ASSERT(jit.baselineCodeBlock()->jitType() == JITCode::BaselineJIT);
    115115    jit.storePtr(AssemblyHelpers::TrustedImmPtr(jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    116116   
    … …  
    126126        ASSERT(mapping->m_bytecodeIndex == returnBytecodeIndex);
    127127       
    128         void* jumpTarget = baselineCodeBlockForCaller->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     128        void* jumpTarget = baselineCodeBlockForCaller->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    129129
    130130        GPRReg callerFrameGPR;
    … …  
    163163    ASSERT(mapping->m_bytecodeIndex == exit.m_codeOrigin.bytecodeIndex);
    164164   
    165     void* jumpTarget = baselineCodeBlock->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     165    void* jumpTarget = baselineCodeBlock->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    166166   
    167167    jit.move(AssemblyHelpers::TrustedImmPtr(jumpTarget), GPRInfo::regT2);

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

    r153169 r153177  
    17261726        dataLog(*codeBlock, ": Entered reoptimize\n");
    17271727    // We must be called with the baseline code block.
    1728     ASSERT(JITCode::isBaselineCode(codeBlock->getJITType()));
     1728    ASSERT(JITCode::isBaselineCode(codeBlock->jitType()));
    17291729
    17301730    // If I am my own replacement, then reoptimization has already been triggered.
    … …  
    17361736    // to check our logic.
    17371737    ASSERT(codeBlock->hasOptimizedReplacement());
    1738     ASSERT(JITCode::isOptimizingJIT(codeBlock->replacement()->getJITType()));
     1738    ASSERT(JITCode::isOptimizingJIT(codeBlock->replacement()->jitType()));
    17391739
    17401740    codeBlock->reoptimize();

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

    r153121 r153177  
    111111    unsigned index, Operands<ValueRecovery>& valueRecoveries) const
    112112{
    113     ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
     113    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
    114114    CodeBlock* baselineCodeBlock = codeBlock->baselineVersion();
    115115   

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

    r153121 r153177  
    5858    return CodeLocationJump(
    5959        reinterpret_cast<char*>(
    60             ftlCodeBlock->getJITCode()->ftl()->exitThunks().dataLocation()) +
     60            ftlCodeBlock->jitCode()->ftl()->exitThunks().dataLocation()) +
    6161        m_patchableCodeOffset);
    6262}

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

    r153121 r153177  
    173173   
    174174    ASSERT(codeBlock);
    175     ASSERT(codeBlock->getJITType() == JITCode::FTLJIT);
     175    ASSERT(codeBlock->jitType() == JITCode::FTLJIT);
    176176   
    177177    VM* vm = &exec->vm();
    178178   
    179     OSRExit& exit = codeBlock->getJITCode()->ftl()->osrExit[exitID];
     179    OSRExit& exit = codeBlock->jitCode()->ftl()->osrExit[exitID];
    180180   
    181181    prepareCodeOriginForOSRExit(exec, exit.m_codeOrigin);

  • trunk/Source/JavaScriptCore/heap/DFGCodeBlocks.cpp

    r153147 r153177  
    4242   
    4343    for (HashSet<CodeBlock*>::iterator iter = m_set.begin(); iter != m_set.end(); ++iter) {
    44         if ((*iter)->getJITCode()->dfgCommon()->isJettisoned)
     44        if ((*iter)->jitCode()->dfgCommon()->isJettisoned)
    4545            toRemove.append(adoptRef(*iter));
    4646    }
    … …  
    5353   
    5454    ASSERT(codeBlock);
    55     ASSERT(JITCode::isOptimizingJIT(codeBlock->getJITType()));
     55    ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));
    5656   
    5757    // It should not have already been jettisoned.
    58     ASSERT(!codeBlock->getJITCode()->dfgCommon()->isJettisoned);
     58    ASSERT(!codeBlock->jitCode()->dfgCommon()->isJettisoned);
    5959
    6060    // We should have this block already.
    6161    ASSERT(m_set.find(codeBlock) != m_set.end());
    6262   
    63     codeBlock->getJITCode()->dfgCommon()->isJettisoned = true;
     63    codeBlock->jitCode()->dfgCommon()->isJettisoned = true;
    6464}
    6565
    … …  
    6767{
    6868    for (HashSet<CodeBlock*>::iterator iter = m_set.begin(); iter != m_set.end(); ++iter) {
    69         (*iter)->getJITCode()->dfgCommon()->mayBeExecuting = false;
    70         (*iter)->getJITCode()->dfgCommon()->visitAggregateHasBeenCalled = false;
     69        (*iter)->jitCode()->dfgCommon()->mayBeExecuting = false;
     70        (*iter)->jitCode()->dfgCommon()->visitAggregateHasBeenCalled = false;
    7171    }
    7272}
    … …  
    7777   
    7878    for (HashSet<CodeBlock*>::iterator iter = m_set.begin(); iter != m_set.end(); ++iter) {
    79         if ((*iter)->getJITCode()->dfgCommon()->isJettisoned && !(*iter)->getJITCode()->dfgCommon()->mayBeExecuting)
     79        if ((*iter)->jitCode()->dfgCommon()->isJettisoned && !(*iter)->jitCode()->dfgCommon()->mayBeExecuting)
    8080            toRemove.append(adoptRef(*iter));
    8181    }
    … …  
    8585{
    8686    for (HashSet<CodeBlock*>::iterator iter = m_set.begin(); iter != m_set.end(); ++iter) {
    87         if ((*iter)->getJITCode()->dfgCommon()->mayBeExecuting)
     87        if ((*iter)->jitCode()->dfgCommon()->mayBeExecuting)
    8888            (*iter)->visitAggregate(visitor);
    8989    }

  • trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

    r153145 r153177  
    473473        return 0;
    474474#if ENABLE(DFG_JIT)
    475     if (JITCode::isOptimizingJIT(codeBlock->getJITType()))
     475    if (JITCode::isOptimizingJIT(codeBlock->jitType()))
    476476        return codeBlock->codeOrigin(callFrame->codeOriginIndexForDFG()).bytecodeIndex;
    477477#endif
    … …  
    500500    if (wasCalledByHost) {
    501501#if ENABLE(DFG_JIT)
    502         if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->getJITType())) {
     502        if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->jitType())) {
    503503            unsigned codeOriginIndex = callFrame->callerFrame()->removeHostCallFrameFlag()->codeOriginIndexForDFG();
    504504            CodeOrigin origin = callerCodeBlock->codeOrigin(codeOriginIndex);
    … …  
    521521                callerCodeBlock = newCodeBlock;
    522522            }
    523         } else if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->getJITType())) {
     523        } else if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->jitType())) {
    524524            CodeOrigin origin;
    525525            if (!callerCodeBlock->codeOriginForReturn(callFrame->returnPC(), origin)) {

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

    r153165 r153177  
    4646    VM& vm = exec->vm();
    4747   
    48     if (jitType == codeBlock->getJITType())
     48    if (jitType == codeBlock->jitType())
    4949        return CompilationNotNeeded;
    5050   
    … …  
    8383    VM& vm = exec->vm();
    8484   
    85     if (jitType == codeBlock->getJITType())
     85    if (jitType == codeBlock->jitType())
    8686        return CompilationNotNeeded;
    8787   

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

    r153170 r153177  
    10901090   
    10911091    CodeBlock* optimizedCodeBlock = codeBlock->replacement();
    1092     ASSERT(JITCode::isOptimizingJIT(optimizedCodeBlock->getJITType()));
    1093    
    1094     if (optimizedCodeBlock->getJITType() == JITCode::FTLJIT) {
     1092    ASSERT(JITCode::isOptimizingJIT(optimizedCodeBlock->jitType()));
     1093   
     1094    if (optimizedCodeBlock->jitType() == JITCode::FTLJIT) {
    10951095        // FTL JIT doesn't support OSR entry yet.
    10961096        // https://bugs.webkit.org/show_bug.cgi?id=113625

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r153170 r153177  
    328328   
    329329    if (kind == Prologue)
    330         LLINT_RETURN_TWO(codeBlock->getJITCode()->executableAddress(), exec);
     330        LLINT_RETURN_TWO(codeBlock->jitCode()->executableAddress(), exec);
    331331    ASSERT(kind == ArityCheck);
    332     LLINT_RETURN_TWO(codeBlock->getJITCodeWithArityCheck().executableAddress(), exec);
     332    LLINT_RETURN_TWO(codeBlock->jitCodeWithArityCheck().executableAddress(), exec);
    333333}
    334334
    … …  
    376376        LLINT_RETURN_TWO(0, exec);
    377377   
    378     ASSERT(codeBlock->getJITType() == JITCode::BaselineJIT);
     378    ASSERT(codeBlock->jitType() == JITCode::BaselineJIT);
    379379   
    380380    Vector<BytecodeAndMachineOffset> map;
    … …  
    384384    ASSERT(mapping->m_bytecodeIndex == static_cast<unsigned>(pc - codeBlock->instructions().begin()));
    385385   
    386     void* jumpTarget = codeBlock->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     386    void* jumpTarget = codeBlock->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    387387    ASSERT(jumpTarget);
    388388   

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

    r153170 r153177  
    9797static void jettisonCodeBlock(VM& vm, RefPtr<T>& codeBlock)
    9898{
    99     ASSERT(JITCode::isOptimizingJIT(codeBlock->getJITType()));
     99    ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));
    100100    ASSERT(codeBlock->alternative());
    101101    RefPtr<T> codeBlockToJettison = codeBlock.release();
    … …  
    163163    ASSERT(!!m_evalCodeBlock);
    164164    JSObject* error = 0;
    165     if (!JITCode::isOptimizingJIT(m_evalCodeBlock->getJITType()))
    166         error = compileInternal(exec, scope, JITCode::nextTierJIT(m_evalCodeBlock->getJITType()), &result, bytecodeIndex);
     165    if (!JITCode::isOptimizingJIT(m_evalCodeBlock->jitType()))
     166        error = compileInternal(exec, scope, JITCode::nextTierJIT(m_evalCodeBlock->jitType()), &result, bytecodeIndex);
    167167    else
    168168        result = CompilationNotNeeded;
    … …  
    249249{
    250250    jettisonCodeBlock(vm, m_evalCodeBlock);
    251     m_jitCodeForCall = m_evalCodeBlock->getJITCode();
     251    m_jitCodeForCall = m_evalCodeBlock->jitCode();
    252252    ASSERT(!m_jitCodeForCallWithArityCheck);
    253253}
    … …  
    300300    ASSERT(!!m_programCodeBlock);
    301301    JSObject* error = 0;
    302     if (!JITCode::isOptimizingJIT(m_programCodeBlock->getJITType()))
    303         error = compileInternal(exec, scope, JITCode::nextTierJIT(m_programCodeBlock->getJITType()), &result, bytecodeIndex);
     302    if (!JITCode::isOptimizingJIT(m_programCodeBlock->jitType()))
     303        error = compileInternal(exec, scope, JITCode::nextTierJIT(m_programCodeBlock->jitType()), &result, bytecodeIndex);
    304304    else
    305305        result = CompilationNotNeeded;
    … …  
    355355{
    356356    jettisonCodeBlock(vm, m_programCodeBlock);
    357     m_jitCodeForCall = m_programCodeBlock->getJITCode();
     357    m_jitCodeForCall = m_programCodeBlock->jitCode();
    358358    ASSERT(!m_jitCodeForCallWithArityCheck);
    359359}
    … …  
    465465        result = static_cast<FunctionCodeBlock*>(result->alternative());
    466466    RELEASE_ASSERT(result);
    467     ASSERT(JITCode::isBaselineCode(result->getJITType()));
     467    ASSERT(JITCode::isBaselineCode(result->jitType()));
    468468    return result;
    469469}
    … …  
    474474    ASSERT(!!m_codeBlockForCall);
    475475    JSObject* error = 0;
    476     if (!JITCode::isOptimizingJIT(m_codeBlockForCall->getJITType()))
    477         error = compileForCallInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForCall->getJITType()), &result, bytecodeIndex);
     476    if (!JITCode::isOptimizingJIT(m_codeBlockForCall->jitType()))
     477        error = compileForCallInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForCall->jitType()), &result, bytecodeIndex);
    478478    else
    479479        result = CompilationNotNeeded;
    … …  
    487487    ASSERT(!!m_codeBlockForConstruct);
    488488    JSObject* error = 0;
    489     if (!JITCode::isOptimizingJIT(m_codeBlockForConstruct->getJITType()))
    490         error = compileForConstructInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForConstruct->getJITType()), &result, bytecodeIndex);
     489    if (!JITCode::isOptimizingJIT(m_codeBlockForConstruct->jitType()))
     490        error = compileForConstructInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForConstruct->jitType()), &result, bytecodeIndex);
    491491    else
    492492        result = CompilationNotNeeded;
    … …  
    613613{
    614614    jettisonCodeBlock(vm, m_codeBlockForCall);
    615     m_jitCodeForCall = m_codeBlockForCall->getJITCode();
    616     m_jitCodeForCallWithArityCheck = m_codeBlockForCall->getJITCodeWithArityCheck();
     615    m_jitCodeForCall = m_codeBlockForCall->jitCode();
     616    m_jitCodeForCallWithArityCheck = m_codeBlockForCall->jitCodeWithArityCheck();
    617617}
    618618
    … …  
    620620{
    621621    jettisonCodeBlock(vm, m_codeBlockForConstruct);
    622     m_jitCodeForConstruct = m_codeBlockForConstruct->getJITCode();
    623     m_jitCodeForConstructWithArityCheck = m_codeBlockForConstruct->getJITCodeWithArityCheck();
     622    m_jitCodeForConstruct = m_codeBlockForConstruct->jitCode();
     623    m_jitCodeForConstructWithArityCheck = m_codeBlockForConstruct->jitCodeWithArityCheck();
    624624}
    625625#endif

  • trunk/Source/JavaScriptCore/tools/CodeProfile.cpp

    r140594 r153177  
    106106        else {
    107107            CodeBlock* codeBlock = static_cast<CodeBlock*>(ownerUID);
    108             if (codeBlock->getJITType() == JITCode::DFGJIT)
     108            if (codeBlock->jitType() == JITCode::DFGJIT)
    109109                type = DFGJIT;
    110110            else if (codeBlock->canCompileWithDFGState() != DFG::CanCompile)
Note: See TracChangeset for help on using the changeset viewer.