Changeset 153177 in webkit for trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

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):

File:

• trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (24 diffs)

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -118 +118 @@
 void CodeBlock::dump(PrintStream& out) const
 {
-    dumpAssumingJITType(out, getJITType());
+    dumpAssumingJITType(out, jitType());
 }
 
@@ -2053 +2053 @@
 {
 #if ENABLE(PARALLEL_GC) && ENABLE(DFG_JIT)
-    if (JITCode::isOptimizingJIT(getJITType())) {
+    if (JITCode::isOptimizingJIT(jitType())) {
         DFG::CommonData* dfgCommon = m_jitCode->dfgCommon();
         
@@ -2302 +2302 @@
 #if ENABLE(JIT)
     // Handle inline caches.
-    if (!!getJITCode()) {
+    if (!!jitCode()) {
         RepatchBuffer repatchBuffer(this);
         for (unsigned i = 0; i < numberOfCallLinkInfos(); ++i) {
@@ -2362 +2362 @@
         dataLog("Clearing structure cache (kind ", static_cast<int>(stubInfo.accessType), ") in ", *this, ".\n");
 
-    switch (getJITType()) {
+    switch (jitType()) {
     case JITCode::BaselineJIT:
         if (isGetByIdAccess(accessType))
@@ -2413 +2413 @@
 
 #if ENABLE(DFG_JIT)
-    if (!JITCode::isOptimizingJIT(getJITType()))
+    if (!JITCode::isOptimizingJIT(jitType()))
         return;
     
@@ -2436 +2436 @@
     // to get its replacement. But we'll know that it's the original baseline code
     // block because it won't have JIT code yet and it won't have an alternative.
-    if (getJITType() == JITCode::None && !alternative())
+    if (jitType() == JITCode::None && !alternative())
         return this;
     
@@ -2444 +2444 @@
         result = result->alternative();
     ASSERT(result);
-    ASSERT(JITCode::isBaselineCode(result->getJITType()));
+    ASSERT(JITCode::isBaselineCode(result->jitType()));
     return result;
 #else
@@ -2454 +2454 @@
 bool CodeBlock::hasOptimizedReplacement()
 {
-    ASSERT(JITCode::isBaselineCode(getJITType()));
-    bool result = JITCode::isHigherTier(replacement()->getJITType(), getJITType());
+    ASSERT(JITCode::isBaselineCode(jitType()));
+    bool result = JITCode::isHigherTier(replacement()->jitType(), jitType());
     if (result)
-        ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
+        ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
     else {
-        ASSERT(JITCode::isBaselineCode(replacement()->getJITType()));
+        ASSERT(JITCode::isBaselineCode(replacement()->jitType()));
         ASSERT(replacement() == this);
     }
@@ -2709 +2709 @@
         RELEASE_ASSERT(exec->codeBlock());
         RELEASE_ASSERT(exec->codeBlock() == this);
-        RELEASE_ASSERT(JITCode::isBaselineCode(getJITType()));
+        RELEASE_ASSERT(JITCode::isBaselineCode(jitType()));
         Instruction* instruction = exec->currentVPC();
         RELEASE_ASSERT(instruction);
@@ -2725 +2725 @@
         return 1;
     
-    if (getJITCode()->contains(returnAddress.value())) {
-        unsigned callReturnOffset = getJITCode()->offsetOf(returnAddress.value());
+    if (jitCode()->contains(returnAddress.value())) {
+        unsigned callReturnOffset = jitCode()->offsetOf(returnAddress.value());
         CallReturnOffsetToBytecodeOffset* result =
             binarySearch<CallReturnOffsetToBytecodeOffset, unsigned>(
@@ -2759 +2759 @@
         return false;
 
-    if (!getJITCode()->contains(returnAddress.value())) {
+    if (!jitCode()->contains(returnAddress.value())) {
         ClosureCallStubRoutine* stub = findClosureCallForReturnPC(returnAddress);
         ASSERT(stub);
@@ -2768 +2768 @@
     }
     
-    unsigned offset = getJITCode()->offsetOf(returnAddress.value());
+    unsigned offset = jitCode()->offsetOf(returnAddress.value());
     CodeOriginAtCallReturnOffset* entry =
         tryBinarySearch<CodeOriginAtCallReturnOffset, unsigned>(
@@ -2842 +2842 @@
 JSObject* ProgramCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
 {
-    if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
+    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
         result = CompilationNotNeeded;
         return 0;
@@ -2857 +2857 @@
 JSObject* EvalCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
 {
-    if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
+    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
         result = CompilationNotNeeded;
         return 0;
@@ -2872 +2872 @@
 JSObject* FunctionCodeBlock::compileOptimized(ExecState* exec, JSScope* scope, CompilationResult& result, unsigned bytecodeIndex)
 {
-    if (JITCode::isHigherTier(replacement()->getJITType(), getJITType())) {
+    if (JITCode::isHigherTier(replacement()->jitType(), jitType())) {
         result = CompilationNotNeeded;
         return 0;
@@ -2904 +2904 @@
 void CodeBlock::jettison()
 {
-    ASSERT(JITCode::isOptimizingJIT(getJITType()));
+    ASSERT(JITCode::isOptimizingJIT(jitType()));
     ASSERT(this == replacement());
     alternative()->optimizeAfterWarmUp();
@@ -2920 +2920 @@
 void EvalCodeBlock::jettisonImpl()
 {
+    ASSERT(JITCode::isOptimizingJIT(jitType()));
+    ASSERT(this == replacement());
+    if (DFG::shouldShowDisassembly())
+        dataLog("Jettisoning ", *this, ".\n");
     static_cast<EvalExecutable*>(ownerExecutable())->jettisonOptimizedCode(*vm());
 }
@@ -2925 +2929 @@
 void FunctionCodeBlock::jettisonImpl()
 {
+    ASSERT(JITCode::isOptimizingJIT(jitType()));
+    ASSERT(this == replacement());
+    if (DFG::shouldShowDisassembly())
+        dataLog("Jettisoning ", *this, ".\n");
     static_cast<FunctionExecutable*>(ownerExecutable())->jettisonOptimizedCodeFor(*vm(), m_isConstructor ? CodeForConstruct : CodeForCall);
 }
@@ -2930 +2938 @@
 CompilationResult ProgramCodeBlock::jitCompileImpl(ExecState* exec)
 {
-    ASSERT(getJITType() == JITCode::InterpreterThunk);
+    ASSERT(jitType() == JITCode::InterpreterThunk);
     ASSERT(this == replacement());
     return static_cast<ProgramExecutable*>(ownerExecutable())->jitCompile(exec);
@@ -2937 +2945 @@
 CompilationResult EvalCodeBlock::jitCompileImpl(ExecState* exec)
 {
-    ASSERT(getJITType() == JITCode::InterpreterThunk);
+    ASSERT(jitType() == JITCode::InterpreterThunk);
     ASSERT(this == replacement());
     return static_cast<EvalExecutable*>(ownerExecutable())->jitCompile(exec);
@@ -2944 +2952 @@
 CompilationResult FunctionCodeBlock::jitCompileImpl(ExecState* exec)
 {
-    ASSERT(getJITType() == JITCode::InterpreterThunk);
+    ASSERT(jitType() == JITCode::InterpreterThunk);
     ASSERT(this == replacement());
     return static_cast<FunctionExecutable*>(ownerExecutable())->jitCompileFor(exec, m_isConstructor ? CodeForConstruct : CodeForCall);
@@ -3148 +3156 @@
 void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResult result)
 {
-    RELEASE_ASSERT(getJITType() == JITCode::BaselineJIT);
+    RELEASE_ASSERT(jitType() == JITCode::BaselineJIT);
     RELEASE_ASSERT((result == CompilationSuccessful) == (replacement() != this));
     switch (result) {
     case CompilationSuccessful:
-        RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->getJITType()));
+        RELEASE_ASSERT(JITCode::isOptimizingJIT(replacement()->jitType()));
         optimizeNextInvocation();
         break;
@@ -3180 +3188 @@
 uint32_t CodeBlock::adjustedExitCountThreshold(uint32_t desiredThreshold)
 {
-    ASSERT(JITCode::isOptimizingJIT(getJITType()));
+    ASSERT(JITCode::isOptimizingJIT(jitType()));
     // Compute this the lame way so we don't saturate. This is called infrequently
     // enough that this loop won't hurt us.
@@ -3325 +3333 @@
 void CodeBlock::tallyFrequentExitSites()
 {
-    ASSERT(JITCode::isOptimizingJIT(getJITType()));
-    ASSERT(alternative()->getJITType() == JITCode::BaselineJIT);
+    ASSERT(JITCode::isOptimizingJIT(jitType()));
+    ASSERT(alternative()->jitType() == JITCode::BaselineJIT);
     
     CodeBlock* profiledBlock = alternative();
     
-    switch (getJITType()) {
+    switch (jitType()) {
     case JITCode::DFGJIT: {
         DFG::JITCode* jitCode = m_jitCode->dfg();