Changeset 150565 in webkit


Ignore:
Timestamp:
May 22, 2013, 9:53:58 PM (12 years ago)
Author:
fpizlo@apple.com
Message:

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:
branches/dfgFourthTier/Source/JavaScriptCore
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog

    r150563 r150565  
     12013-05-22  Filip Pizlo  <fpizlo@apple.com>
     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  <fpizlo@apple.com>
    294

  • branches/dfgFourthTier/Source/JavaScriptCore/assembler/RepatchBuffer.h

    r148347 r150565  
    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();

  • branches/dfgFourthTier/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r150466 r150565  
    119119void CodeBlock::dump(PrintStream& out) const
    120120{
    121     dumpAssumingJITType(out, getJITType());
     121    dumpAssumingJITType(out, jitType());
    122122}
    123123
    … …  
    20482048{
    20492049#if ENABLE(PARALLEL_GC) && ENABLE(DFG_JIT)
    2050     if (JITCode::isOptimizingJIT(getJITType())) {
     2050    if (JITCode::isOptimizingJIT(jitType())) {
    20512051        DFG::CommonData* dfgCommon = m_jitCode->dfgCommon();
    20522052       
    … …  
    23012301#if ENABLE(JIT)
    23022302    // Handle inline caches.
    2303     if (!!getJITCode()) {
     2303    if (!!jitCode()) {
    23042304        RepatchBuffer repatchBuffer(this);
    23052305        for (unsigned i = 0; i < numberOfCallLinkInfos(); ++i) {
    … …  
    23612361        dataLog("Clearing structure cache (kind ", static_cast<int>(stubInfo.accessType), ") in ", *this, ".\n");
    23622362
    2363     switch (getJITType()) {
     2363    switch (jitType()) {
    23642364    case JITCode::BaselineJIT:
    23652365        if (isGetByIdAccess(accessType))
    … …  
    24062406
    24072407#if ENABLE(DFG_JIT)
    2408     if (!JITCode::isOptimizingJIT(getJITType()))
     2408    if (!JITCode::isOptimizingJIT(jitType()))
    24092409        return;
    24102410   
    … …  
    24292429    // to get its replacement. But we'll know that it's the original baseline code
    24302430    // block because it won't have JIT code yet and it won't have an alternative.
    2431     if (getJITType() == JITCode::None && !alternative())
     2431    if (jitType() == JITCode::None && !alternative())
    24322432        return this;
    24332433   
    … …  
    24372437        result = result->alternative();
    24382438    ASSERT(result);
    2439     ASSERT(JITCode::isBaselineCode(result->getJITType()));
     2439    ASSERT(JITCode::isBaselineCode(result->jitType()));
    24402440    return result;
    24412441#else
    … …  
    24472447bool CodeBlock::hasOptimizedReplacement()
    24482448{
    2449     ASSERT(JITCode::isBaselineCode(getJITType()));
    2450     bool result = JITCode::isHigherTier(replacement()->getJITType(), getJITType());
     2449    ASSERT(JITCode::isBaselineCode(jitType()));
     2450    bool result = JITCode::isHigherTier(replacement()->jitType(), jitType());
    24512451    if (result)
    2452         ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
     2452        ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
    24532453    else {
    2454         ASSERT(JITCode::isBaselineCode(replacement()->getJITType()));
     2454        ASSERT(JITCode::isBaselineCode(replacement()->jitType()));
    24552455        ASSERT(replacement() == this);
    24562456    }
    … …  
    26892689        RELEASE_ASSERT(exec->codeBlock());
    26902690        RELEASE_ASSERT(exec->codeBlock() == this);
    2691         RELEASE_ASSERT(JITCode::isBaselineCode(getJITType()));
     2691        RELEASE_ASSERT(JITCode::isBaselineCode(jitType()));
    26922692        Instruction* instruction = exec->currentVPC();
    26932693        RELEASE_ASSERT(instruction);
    … …  
    27052705        return 1;
    27062706   
    2707     if (getJITCode()->contains(returnAddress.value())) {
    2708         unsigned callReturnOffset = getJITCode()->offsetOf(returnAddress.value());
     2707    if (jitCode()->contains(returnAddress.value())) {
     2708        unsigned callReturnOffset = jitCode()->offsetOf(returnAddress.value());
    27092709        CallReturnOffsetToBytecodeOffset* result =
    27102710            binarySearch<CallReturnOffsetToBytecodeOffset, unsigned>(
    … …  
    27282728        return false;
    27292729
    2730     if (!getJITCode()->contains(returnAddress.value())) {
     2730    if (!jitCode()->contains(returnAddress.value())) {
    27312731        codeOrigin = findClosureCallForReturnPC(returnAddress)->codeOrigin();
    27322732        return true;
    27332733    }
    27342734   
    2735     unsigned offset = getJITCode()->offsetOf(returnAddress.value());
     2735    unsigned offset = jitCode()->offsetOf(returnAddress.value());
    27362736    CodeOriginAtCallReturnOffset* entry =
    27372737        tryBinarySearch<CodeOriginAtCallReturnOffset, unsigned>(
    … …  
    28092809JSObject* ProgramCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28102810{
    2811     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2811    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28122812        result = CompilationNotNeeded;
    28132813        return 0;
    … …  
    28242824JSObject* EvalCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28252825{
    2826     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2826    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28272827        result = CompilationNotNeeded;
    28282828        return 0;
    … …  
    28392839JSObject* FunctionCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
    28402840{
    2841     if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
     2841    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
    28422842        result = CompilationNotNeeded;
    28432843        return 0;
    … …  
    28712871void ProgramCodeBlock::jettison()
    28722872{
    2873     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     2873    ASSERT(JITCode::isOptimizingJIT(jitType()));
    28742874    ASSERT(this == replacement());
    28752875    if (DFG::shouldShowDisassembly())
    … …  
    28802880void EvalCodeBlock::jettison()
    28812881{
    2882     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     2882    ASSERT(JITCode::isOptimizingJIT(jitType()));
    28832883    ASSERT(this == replacement());
    28842884    if (DFG::shouldShowDisassembly())
    … …  
    28892889void FunctionCodeBlock::jettison()
    28902890{
    2891     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     2891    ASSERT(JITCode::isOptimizingJIT(jitType()));
    28922892    ASSERT(this == replacement());
    28932893    if (DFG::shouldShowDisassembly())
    … …  
    28982898CompilationResult ProgramCodeBlock::jitCompileImpl(ExecState* exec)
    28992899{
    2900     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2900    ASSERT(jitType() == JITCode::InterpreterThunk);
    29012901    ASSERT(this == replacement());
    29022902    return static_cast<ProgramExecutable*>(ownerExecutable())->jitCompile(exec);
    … …  
    29052905CompilationResult EvalCodeBlock::jitCompileImpl(ExecState* exec)
    29062906{
    2907     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2907    ASSERT(jitType() == JITCode::InterpreterThunk);
    29082908    ASSERT(this == replacement());
    29092909    return static_cast<EvalExecutable*>(ownerExecutable())->jitCompile(exec);
    … …  
    29122912CompilationResult FunctionCodeBlock::jitCompileImpl(ExecState* exec)
    29132913{
    2914     ASSERT(getJITType() == JITCode::InterpreterThunk);
     2914    ASSERT(jitType() == JITCode::InterpreterThunk);
    29152915    ASSERT(this == replacement());
    29162916    return static_cast<FunctionExecutable*>(ownerExecutable())->jitCompileFor(exec, m_isConstructor ? CodeForConstruct : CodeForCall);
    … …  
    31163116void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResult result)
    31173117{
    3118     RELEASE_ASSERT(getJITType() == JITCode::BaselineJIT);
     3118    RELEASE_ASSERT(jitType() == JITCode::BaselineJIT);
    31193119    RELEASE_ASSERT((result == CompilationSuccessful) == (replacement() != this));
    31203120    switch (result) {
    31213121    case CompilationSuccessful:
    3122         RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
     3122        RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
    31233123        optimizeNextInvocation();
    31243124        break;
    … …  
    31483148uint32_t CodeBlock::adjustedExitCountThreshold(uint32_t desiredThreshold)
    31493149{
    3150     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     3150    ASSERT(JITCode::isOptimizingJIT(jitType()));
    31513151    // Compute this the lame way so we don't saturate. This is called infrequently
    31523152    // enough that this loop won't hurt us.
    … …  
    32933293void CodeBlock::tallyFrequentExitSites()
    32943294{
    3295     ASSERT(JITCode::isOptimizingJIT(getJITType()));
    3296     ASSERT(alternative()->getJITType() == JITCode::BaselineJIT);
     3295    ASSERT(JITCode::isOptimizingJIT(jitType()));
     3296    ASSERT(alternative()->jitType() == JITCode::BaselineJIT);
    32973297   
    32983298    CodeBlock* profiledBlock = alternative();
    32993299   
    3300     switch (getJITType()) {
     3300    switch (jitType()) {
    33013301    case JITCode::DFGJIT: {
    33023302        DFG::JITCode* jitCode = m_jitCode->dfg();

  • branches/dfgFourthTier/Source/JavaScriptCore/bytecode/CodeBlock.h

    r150563 r150565  
    191191        CallLinkInfo& getCallLinkInfo(unsigned bytecodeIndex)
    192192        {
    193             ASSERT(JITCode::isBaselineCode(getJITType()));
     193            ASSERT(JITCode::isBaselineCode(jitType()));
    194194            return *(binarySearch<CallLinkInfo, unsigned>(m_callLinkInfos, m_callLinkInfos.size(), bytecodeIndex, getCallLinkInfoBytecodeIndex));
    195195        }
    … …  
    280280#endif
    281281        }
    282         PassRefPtr<JITCode> getJITCode() { return m_jitCode; }
    283         MacroAssemblerCodePtr getJITCodeWithArityCheck() { return m_jitCodeWithArityCheck; }
    284         JITCode::JITType getJITType() const
     282        PassRefPtr<JITCode> jitCode() { return m_jitCode; }
     283        MacroAssemblerCodePtr jitCodeWithArityCheck() { return m_jitCodeWithArityCheck; }
     284        JITCode::JITType jitType() const
    285285        {
    286286            JITCode* jitCode = m_jitCode.get();
    … …  
    292292        bool hasBaselineJITProfiling() const
    293293        {
    294             return getJITType() == JITCode::BaselineJIT;
     294            return jitType() == JITCode::BaselineJIT;
    295295        }
    296296        virtual JSObject* compileOptimized(ExecState*, JSScope*, CompilationResult&, unsigned bytecodeIndex) = 0;
    … …  
    299299        CompilationResult jitCompile(ExecState* exec)
    300300        {
    301             if (getJITType() != JITCode::InterpreterThunk) {
    302                 ASSERT(getJITType() == JITCode::BaselineJIT);
     301            if (jitType() != JITCode::InterpreterThunk) {
     302                ASSERT(jitType() == JITCode::BaselineJIT);
    303303                return CompilationNotNeeded;
    304304            }
    … …  
    318318        bool hasOptimizedReplacement();
    319319#else
    320         JITCode::JITType getJITType() const { return JITCode::BaselineJIT; }
     320        JITCode::JITType jitType() const { return JITCode::BaselineJIT; }
    321321#endif
    322322
    … …  
    622622        bool addFrequentExitSite(const DFG::FrequentExitSite& site)
    623623        {
    624             ASSERT(JITCode::isBaselineCode(getJITType()));
     624            ASSERT(JITCode::isBaselineCode(jitType()));
    625625            return m_exitProfile.add(site);
    626626        }
    … …  
    974974            // stale. So if a basline JIT CodeBlock gets scanned, we can assume that
    975975            // this means that it's live.
    976             if (!JITCode::isOptimizingJIT(getJITType()))
     976            if (!JITCode::isOptimizingJIT(jitType()))
    977977                return true;
    978978           
    … …  
    12441244    inline bool ExecState::isInlineCallFrame()
    12451245    {
    1246         if (LIKELY(!codeBlock() || !JITCode::isOptimizingJIT(codeBlock()->getJITType())))
     1246        if (LIKELY(!codeBlock() || !JITCode::isOptimizingJIT(codeBlock()->jitType())))
    12471247            return false;
    12481248        return isInlineCallFrameSlow();

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGAssemblyHelpers.cpp

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

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGAssemblyHelpers.h

    r148697 r150565  
    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    }

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGDriver.cpp

    r150465 r150565  
    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);

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGOSREntry.cpp

    r150465 r150565  
    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())

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGOSRExit.cpp

    r148347 r150565  
    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

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp

    r148697 r150565  
    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(

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp

    r148350 r150565  
    7878{
    7979#if USE(JSVALUE64)
    80     ASSERT(jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
     80    ASSERT(jit.baselineCodeBlock()->jitType() == JITCode::BaselineJIT);
    8181    jit.storePtr(AssemblyHelpers::TrustedImmPtr(jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    8282   
    … …  
    9292        ASSERT(mapping->m_bytecodeIndex == returnBytecodeIndex);
    9393       
    94         void* jumpTarget = baselineCodeBlockForCaller->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     94        void* jumpTarget = baselineCodeBlockForCaller->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    9595
    9696        GPRReg callerFrameGPR;
    … …  
    111111    }
    112112#else // USE(JSVALUE64) // so this is the 32-bit part
    113     ASSERT(jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
     113    ASSERT(jit.baselineCodeBlock()->jitType() == JITCode::BaselineJIT);
    114114    jit.storePtr(AssemblyHelpers::TrustedImmPtr(jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    115115   
    … …  
    125125        ASSERT(mapping->m_bytecodeIndex == returnBytecodeIndex);
    126126       
    127         void* jumpTarget = baselineCodeBlockForCaller->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     127        void* jumpTarget = baselineCodeBlockForCaller->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    128128
    129129        GPRReg callerFrameGPR;
    … …  
    162162    ASSERT(mapping->m_bytecodeIndex == exit.m_codeOrigin.bytecodeIndex);
    163163   
    164     void* jumpTarget = baselineCodeBlock->getJITCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
     164    void* jumpTarget = baselineCodeBlock->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
    165165   
    166166    jit.move(AssemblyHelpers::TrustedImmPtr(jumpTarget), GPRInfo::regT2);

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGOperations.cpp

    r150465 r150565  
    16901690        dataLog(*codeBlock, ": Entered reoptimize\n");
    16911691    // We must be called with the baseline code block.
    1692     ASSERT(JITCode::isBaselineCode(codeBlock->getJITType()));
     1692    ASSERT(JITCode::isBaselineCode(codeBlock->jitType()));
    16931693
    16941694    // If I am my own replacement, then reoptimization has already been triggered.
    … …  
    17001700    // to check our logic.
    17011701    ASSERT(codeBlock->hasOptimizedReplacement());
    1702     ASSERT(JITCode::isOptimizingJIT(codeBlock->replacement()->getJITType()));
     1702    ASSERT(JITCode::isOptimizingJIT(codeBlock->replacement()->jitType()));
    17031703
    17041704    codeBlock->reoptimize();

  • branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp

    r148347 r150565  
    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   

  • branches/dfgFourthTier/Source/JavaScriptCore/ftl/FTLOSRExit.cpp

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

  • branches/dfgFourthTier/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp

    r148697 r150565  
    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);

  • branches/dfgFourthTier/Source/JavaScriptCore/heap/DFGCodeBlocks.cpp

    r149860 r150565  
    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    }

  • branches/dfgFourthTier/Source/JavaScriptCore/interpreter/Interpreter.cpp

    r149636 r150565  
    581581#if ENABLE(JIT) || ENABLE(LLINT)
    582582#if ENABLE(DFG_JIT)
    583     if (JITCode::isOptimizingJIT(codeBlock->getJITType()))
     583    if (JITCode::isOptimizingJIT(codeBlock->jitType()))
    584584        return codeBlock->lineNumberForBytecodeOffset(codeBlock->codeOrigin(callFrame->codeOriginIndexForDFG()).bytecodeIndex);
    585585#endif
    … …  
    617617#if ENABLE(JIT) || ENABLE(LLINT)
    618618#if ENABLE(DFG_JIT)
    619         if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->getJITType())) {
     619        if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->jitType())) {
    620620            unsigned codeOriginIndex = callerFrame->codeOriginIndexForDFG();
    621621            bytecodeOffset = callerCodeBlock->codeOrigin(codeOriginIndex).bytecodeIndex;
    … …  
    637637                callerCodeBlock = newCodeBlock;
    638638            }
    639         } else if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->getJITType())) {
     639        } else if (callerCodeBlock && JITCode::isOptimizingJIT(callerCodeBlock->jitType())) {
    640640            CodeOrigin origin;
    641641            if (!callerCodeBlock->codeOriginForReturn(callFrame->returnPC(), origin))

  • branches/dfgFourthTier/Source/JavaScriptCore/jit/JITDriver.h

    r150323 r150565  
    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   

  • branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp

    r150466 r150565  
    10351035   
    10361036    CodeBlock* optimizedCodeBlock = codeBlock->replacement();
    1037     ASSERT(JITCode::isOptimizingJIT(optimizedCodeBlock->getJITType()));
    1038    
    1039     if (optimizedCodeBlock->getJITType() == JITCode::FTLJIT) {
     1037    ASSERT(JITCode::isOptimizingJIT(optimizedCodeBlock->jitType()));
     1038   
     1039    if (optimizedCodeBlock->jitType() == JITCode::FTLJIT) {
    10401040        // FTL JIT doesn't support OSR entry yet.
    10411041        // https://bugs.webkit.org/show_bug.cgi?id=113625

  • branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r150466 r150565  
    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   

  • branches/dfgFourthTier/Source/JavaScriptCore/runtime/Executable.cpp

    r150466 r150565  
    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();
    … …  
    161161    ASSERT(!!m_evalCodeBlock);
    162162    JSObject* error = 0;
    163     if (!JITCode::isOptimizingJIT(m_evalCodeBlock->getJITType()))
    164         error = compileInternal(exec, scope, JITCode::nextTierJIT(m_evalCodeBlock->getJITType()), &result, bytecodeIndex);
     163    if (!JITCode::isOptimizingJIT(m_evalCodeBlock->jitType()))
     164        error = compileInternal(exec, scope, JITCode::nextTierJIT(m_evalCodeBlock->jitType()), &result, bytecodeIndex);
    165165    else
    166166        result = CompilationNotNeeded;
    … …  
    247247{
    248248    jettisonCodeBlock(vm, m_evalCodeBlock);
    249     m_jitCodeForCall = m_evalCodeBlock->getJITCode();
     249    m_jitCodeForCall = m_evalCodeBlock->jitCode();
    250250    ASSERT(!m_jitCodeForCallWithArityCheck);
    251251}
    … …  
    298298    ASSERT(!!m_programCodeBlock);
    299299    JSObject* error = 0;
    300     if (!JITCode::isOptimizingJIT(m_programCodeBlock->getJITType()))
    301         error = compileInternal(exec, scope, JITCode::nextTierJIT(m_programCodeBlock->getJITType()), &result, bytecodeIndex);
     300    if (!JITCode::isOptimizingJIT(m_programCodeBlock->jitType()))
     301        error = compileInternal(exec, scope, JITCode::nextTierJIT(m_programCodeBlock->jitType()), &result, bytecodeIndex);
    302302    else
    303303        result = CompilationNotNeeded;
    … …  
    353353{
    354354    jettisonCodeBlock(vm, m_programCodeBlock);
    355     m_jitCodeForCall = m_programCodeBlock->getJITCode();
     355    m_jitCodeForCall = m_programCodeBlock->jitCode();
    356356    ASSERT(!m_jitCodeForCallWithArityCheck);
    357357}
    … …  
    463463        result = static_cast<FunctionCodeBlock*>(result->alternative());
    464464    RELEASE_ASSERT(result);
    465     ASSERT(JITCode::isBaselineCode(result->getJITType()));
     465    ASSERT(JITCode::isBaselineCode(result->jitType()));
    466466    return result;
    467467}
    … …  
    472472    ASSERT(!!m_codeBlockForCall);
    473473    JSObject* error = 0;
    474     if (!JITCode::isOptimizingJIT(m_codeBlockForCall->getJITType()))
    475         error = compileForCallInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForCall->getJITType()), &result, bytecodeIndex);
     474    if (!JITCode::isOptimizingJIT(m_codeBlockForCall->jitType()))
     475        error = compileForCallInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForCall->jitType()), &result, bytecodeIndex);
    476476    else
    477477        result = CompilationNotNeeded;
    … …  
    485485    ASSERT(!!m_codeBlockForConstruct);
    486486    JSObject* error = 0;
    487     if (!JITCode::isOptimizingJIT(m_codeBlockForConstruct->getJITType()))
    488         error = compileForConstructInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForConstruct->getJITType()), &result, bytecodeIndex);
     487    if (!JITCode::isOptimizingJIT(m_codeBlockForConstruct->jitType()))
     488        error = compileForConstructInternal(exec, scope, JITCode::nextTierJIT(m_codeBlockForConstruct->jitType()), &result, bytecodeIndex);
    489489    else
    490490        result = CompilationNotNeeded;
    … …  
    607607{
    608608    jettisonCodeBlock(vm, m_codeBlockForCall);
    609     m_jitCodeForCall = m_codeBlockForCall->getJITCode();
    610     m_jitCodeForCallWithArityCheck = m_codeBlockForCall->getJITCodeWithArityCheck();
     609    m_jitCodeForCall = m_codeBlockForCall->jitCode();
     610    m_jitCodeForCallWithArityCheck = m_codeBlockForCall->jitCodeWithArityCheck();
    611611}
    612612
    … …  
    614614{
    615615    jettisonCodeBlock(vm, m_codeBlockForConstruct);
    616     m_jitCodeForConstruct = m_codeBlockForConstruct->getJITCode();
    617     m_jitCodeForConstructWithArityCheck = m_codeBlockForConstruct->getJITCodeWithArityCheck();
     616    m_jitCodeForConstruct = m_codeBlockForConstruct->jitCode();
     617    m_jitCodeForConstructWithArityCheck = m_codeBlockForConstruct->jitCodeWithArityCheck();
    618618}
    619619#endif

  • branches/dfgFourthTier/Source/JavaScriptCore/tools/CodeProfile.cpp

    r140594 r150565  
    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.