Changeset 244764 in webkit

Timestamp:

Apr 29, 2019, 8:27:39 PM (7 years ago)

Author:

sbarati@apple.com

Message:

Make JITType an enum class
​https://bugs.webkit.org/show_bug.cgi?id=197394

Reviewed by Yusuke Suzuki.

This makes the code more easily searchable.

• bytecode/CallLinkStatus.cpp:

(JSC::CallLinkStatus::computeFor):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dumpAssumingJITType const):
(JSC::CodeBlock::specialOSREntryBlockOrNull):
(JSC::timeToLive):
(JSC::CodeBlock::propagateTransitions):
(JSC::CodeBlock::baselineAlternative):
(JSC::CodeBlock::baselineVersion):
(JSC::CodeBlock::hasOptimizedReplacement):
(JSC::CodeBlock::noticeIncomingCall):
(JSC::CodeBlock::setOptimizationThresholdBasedOnCompilationResult):
(JSC::CodeBlock::tallyFrequentExitSites):
(JSC::CodeBlock::frameRegisterCount):
(JSC::CodeBlock::bytecodeOffsetFromCallSiteIndex):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::jitType const):
(JSC::CodeBlock::hasBaselineJITProfiling const):

• bytecode/CodeBlockWithJITType.h:

(JSC::CodeBlockWithJITType::CodeBlockWithJITType):

• bytecode/DeferredSourceDump.cpp:

(JSC::DeferredSourceDump::DeferredSourceDump):

• bytecode/DeferredSourceDump.h:
• bytecode/ExitingJITType.h:

(JSC::exitingJITTypeFor):

• bytecode/InlineCallFrame.h:

(JSC::baselineCodeBlockForOriginAndBaselineCodeBlock):

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::parseCodeBlock):

• dfg/DFGDisassembler.cpp:

(JSC::DFG::Disassembler::dumpHeader):

• dfg/DFGDriver.cpp:

(JSC::DFG::compileImpl):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::dump):

• dfg/DFGJITCode.cpp:

(JSC::DFG::JITCode::JITCode):
(JSC::DFG::JITCode::checkIfOptimizationThresholdReached):
(JSC::DFG::JITCode::optimizeNextInvocation):
(JSC::DFG::JITCode::dontOptimizeAnytimeSoon):
(JSC::DFG::JITCode::optimizeAfterWarmUp):
(JSC::DFG::JITCode::optimizeSoon):
(JSC::DFG::JITCode::forceOptimizationSlowPathConcurrently):
(JSC::DFG::JITCode::setOptimizationThresholdBasedOnCompilationResult):

• dfg/DFGJITFinalizer.cpp:

(JSC::DFG::JITFinalizer::finalize):
(JSC::DFG::JITFinalizer::finalizeFunction):

• dfg/DFGOSREntry.cpp:

(JSC::DFG::prepareOSREntry):
(JSC::DFG::prepareCatchOSREntry):

• dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::executeOSRExit):
(JSC::DFG::reifyInlinedCallFrames):
(JSC::DFG::OSRExit::compileOSRExit):

• dfg/DFGOSRExitCompilerCommon.cpp:

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

• dfg/DFGOSRExitCompilerCommon.h:

(JSC::DFG::adjustFrameAndStackInOSRExitCompilerThunk):

• dfg/DFGOperations.cpp:
• dfg/DFGThunks.cpp:

(JSC::DFG::osrExitGenerationThunkGenerator):

• dfg/DFGVariableEventStream.cpp:

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

• ftl/FTLCompile.cpp:

(JSC::FTL::compile):

• ftl/FTLJITCode.cpp:

(JSC::FTL::JITCode::JITCode):

• ftl/FTLJITFinalizer.cpp:

(JSC::FTL::JITFinalizer::finalizeCommon):

• ftl/FTLLink.cpp:

(JSC::FTL::link):

• ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileFTLOSRExit):

• ftl/FTLThunks.cpp:

(JSC::FTL::genericGenerationThunkGenerator):

• interpreter/CallFrame.cpp:

(JSC::CallFrame::callSiteBitsAreBytecodeOffset const):
(JSC::CallFrame::callSiteBitsAreCodeOriginIndex const):

• interpreter/StackVisitor.cpp:

(JSC::StackVisitor::Frame::dump const):

• jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::AssemblyHelpers):

• jit/JIT.cpp:

(JSC::JIT::link):

• jit/JITCode.cpp:

(JSC::JITCode::typeName):
(WTF::printInternal):

• jit/JITCode.h:

(JSC::JITCode::bottomTierJIT):
(JSC::JITCode::topTierJIT):
(JSC::JITCode::nextTierJIT):
(JSC::JITCode::isExecutableScript):
(JSC::JITCode::couldBeInterpreted):
(JSC::JITCode::isJIT):
(JSC::JITCode::isOptimizingJIT):
(JSC::JITCode::isBaselineCode):
(JSC::JITCode::jitTypeFor):

• jit/JITDisassembler.cpp:

(JSC::JITDisassembler::dumpHeader):

• jit/JITOperations.cpp:
• jit/JITThunks.cpp:

(JSC::JITThunks::hostFunctionStub):

• jit/JITToDFGDeferredCompilationCallback.cpp:

(JSC::JITToDFGDeferredCompilationCallback::compilationDidBecomeReadyAsynchronously):
(JSC::JITToDFGDeferredCompilationCallback::compilationDidComplete):

• jit/JITWorklist.cpp:

(JSC::JITWorklist::compileLater):
(JSC::JITWorklist::compileNow):

• jit/Repatch.cpp:

(JSC::readPutICCallTarget):
(JSC::ftlThunkAwareRepatchCall):

• llint/LLIntEntrypoint.cpp:

(JSC::LLInt::setFunctionEntrypoint):
(JSC::LLInt::setEvalEntrypoint):
(JSC::LLInt::setProgramEntrypoint):
(JSC::LLInt::setModuleProgramEntrypoint):

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::jitCompileAndSetHeuristics):
(JSC::LLInt::LLINT_SLOW_PATH_DECL):

• runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::processUnverifiedStackTraces):

• runtime/SamplingProfiler.h:
• runtime/VM.cpp:

(JSC::jitCodeForCallTrampoline):
(JSC::jitCodeForConstructTrampoline):

• tools/CodeProfile.cpp:

(JSC::CodeProfile::sample):

• tools/JSDollarVM.cpp:

(JSC::CallerFrameJITTypeFunctor::CallerFrameJITTypeFunctor):
(JSC::CallerFrameJITTypeFunctor::jitType):
(JSC::functionLLintTrue):
(JSC::functionJITTrue):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/CallLinkStatus.cpp (modified) (1 diff)
• bytecode/CodeBlock.cpp (modified) (18 diffs)
• bytecode/CodeBlock.h (modified) (4 diffs)
• bytecode/CodeBlockWithJITType.h (modified) (2 diffs)
• bytecode/DeferredSourceDump.cpp (modified) (1 diff)
• bytecode/DeferredSourceDump.h (modified) (2 diffs)
• bytecode/ExitingJITType.h (modified) (1 diff)
• bytecode/InlineCallFrame.h (modified) (1 diff)
• dfg/DFGByteCodeParser.cpp (modified) (2 diffs)
• dfg/DFGDisassembler.cpp (modified) (1 diff)
• dfg/DFGDriver.cpp (modified) (1 diff)
• dfg/DFGGraph.cpp (modified) (1 diff)
• dfg/DFGJITCode.cpp (modified) (8 diffs)
• dfg/DFGJITFinalizer.cpp (modified) (2 diffs)
• dfg/DFGOSREntry.cpp (modified) (3 diffs)
• dfg/DFGOSRExit.cpp (modified) (5 diffs)
• dfg/DFGOSRExitCompilerCommon.cpp (modified) (3 diffs)
• dfg/DFGOSRExitCompilerCommon.h (modified) (1 diff)
• dfg/DFGOperations.cpp (modified) (3 diffs)
• dfg/DFGThunks.cpp (modified) (1 diff)
• dfg/DFGVariableEventStream.cpp (modified) (1 diff)
• ftl/FTLCompile.cpp (modified) (2 diffs)
• ftl/FTLJITCode.cpp (modified) (1 diff)
• ftl/FTLJITFinalizer.cpp (modified) (1 diff)
• ftl/FTLLink.cpp (modified) (1 diff)
• ftl/FTLOSRExitCompiler.cpp (modified) (1 diff)
• ftl/FTLThunks.cpp (modified) (1 diff)
• interpreter/CallFrame.cpp (modified) (2 diffs)
• interpreter/StackVisitor.cpp (modified) (1 diff)
• jit/AssemblyHelpers.h (modified) (1 diff)
• jit/JIT.cpp (modified) (2 diffs)
• jit/JITCode.cpp (modified) (2 diffs)
• jit/JITCode.h (modified) (9 diffs)
• jit/JITDisassembler.cpp (modified) (1 diff)
• jit/JITOperations.cpp (modified) (3 diffs)
• jit/JITThunks.cpp (modified) (1 diff)
• jit/JITToDFGDeferredCompilationCallback.cpp (modified) (2 diffs)
• jit/JITWorklist.cpp (modified) (3 diffs)
• jit/Repatch.cpp (modified) (2 diffs)
• llint/LLIntEntrypoint.cpp (modified) (10 diffs)
• llint/LLIntSlowPaths.cpp (modified) (3 diffs)
• runtime/SamplingProfiler.cpp (modified) (1 diff)
• runtime/SamplingProfiler.h (modified) (1 diff)
• runtime/VM.cpp (modified) (2 diffs)
• tools/CodeProfile.cpp (modified) (1 diff)
• tools/JSDollarVM.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2019-04-29  Saam Barati  <sbarati@apple.com>
+
+        Make JITType an enum class
+        https://bugs.webkit.org/show_bug.cgi?id=197394
+
+        Reviewed by Yusuke Suzuki.
+
+        This makes the code more easily searchable.
+
+        * bytecode/CallLinkStatus.cpp:
+        (JSC::CallLinkStatus::computeFor):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::dumpAssumingJITType const):
+        (JSC::CodeBlock::specialOSREntryBlockOrNull):
+        (JSC::timeToLive):
+        (JSC::CodeBlock::propagateTransitions):
+        (JSC::CodeBlock::baselineAlternative):
+        (JSC::CodeBlock::baselineVersion):
+        (JSC::CodeBlock::hasOptimizedReplacement):
+        (JSC::CodeBlock::noticeIncomingCall):
+        (JSC::CodeBlock::setOptimizationThresholdBasedOnCompilationResult):
+        (JSC::CodeBlock::tallyFrequentExitSites):
+        (JSC::CodeBlock::frameRegisterCount):
+        (JSC::CodeBlock::bytecodeOffsetFromCallSiteIndex):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlock::jitType const):
+        (JSC::CodeBlock::hasBaselineJITProfiling const):
+        * bytecode/CodeBlockWithJITType.h:
+        (JSC::CodeBlockWithJITType::CodeBlockWithJITType):
+        * bytecode/DeferredSourceDump.cpp:
+        (JSC::DeferredSourceDump::DeferredSourceDump):
+        * bytecode/DeferredSourceDump.h:
+        * bytecode/ExitingJITType.h:
+        (JSC::exitingJITTypeFor):
+        * bytecode/InlineCallFrame.h:
+        (JSC::baselineCodeBlockForOriginAndBaselineCodeBlock):
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::parseCodeBlock):
+        * dfg/DFGDisassembler.cpp:
+        (JSC::DFG::Disassembler::dumpHeader):
+        * dfg/DFGDriver.cpp:
+        (JSC::DFG::compileImpl):
+        * dfg/DFGGraph.cpp:
+        (JSC::DFG::Graph::dump):
+        * dfg/DFGJITCode.cpp:
+        (JSC::DFG::JITCode::JITCode):
+        (JSC::DFG::JITCode::checkIfOptimizationThresholdReached):
+        (JSC::DFG::JITCode::optimizeNextInvocation):
+        (JSC::DFG::JITCode::dontOptimizeAnytimeSoon):
+        (JSC::DFG::JITCode::optimizeAfterWarmUp):
+        (JSC::DFG::JITCode::optimizeSoon):
+        (JSC::DFG::JITCode::forceOptimizationSlowPathConcurrently):
+        (JSC::DFG::JITCode::setOptimizationThresholdBasedOnCompilationResult):
+        * dfg/DFGJITFinalizer.cpp:
+        (JSC::DFG::JITFinalizer::finalize):
+        (JSC::DFG::JITFinalizer::finalizeFunction):
+        * dfg/DFGOSREntry.cpp:
+        (JSC::DFG::prepareOSREntry):
+        (JSC::DFG::prepareCatchOSREntry):
+        * dfg/DFGOSRExit.cpp:
+        (JSC::DFG::OSRExit::executeOSRExit):
+        (JSC::DFG::reifyInlinedCallFrames):
+        (JSC::DFG::OSRExit::compileOSRExit):
+        * dfg/DFGOSRExitCompilerCommon.cpp:
+        (JSC::DFG::handleExitCounts):
+        (JSC::DFG::reifyInlinedCallFrames):
+        (JSC::DFG::adjustAndJumpToTarget):
+        * dfg/DFGOSRExitCompilerCommon.h:
+        (JSC::DFG::adjustFrameAndStackInOSRExitCompilerThunk):
+        * dfg/DFGOperations.cpp:
+        * dfg/DFGThunks.cpp:
+        (JSC::DFG::osrExitGenerationThunkGenerator):
+        * dfg/DFGVariableEventStream.cpp:
+        (JSC::DFG::VariableEventStream::reconstruct const):
+        * ftl/FTLCompile.cpp:
+        (JSC::FTL::compile):
+        * ftl/FTLJITCode.cpp:
+        (JSC::FTL::JITCode::JITCode):
+        * ftl/FTLJITFinalizer.cpp:
+        (JSC::FTL::JITFinalizer::finalizeCommon):
+        * ftl/FTLLink.cpp:
+        (JSC::FTL::link):
+        * ftl/FTLOSRExitCompiler.cpp:
+        (JSC::FTL::compileFTLOSRExit):
+        * ftl/FTLThunks.cpp:
+        (JSC::FTL::genericGenerationThunkGenerator):
+        * interpreter/CallFrame.cpp:
+        (JSC::CallFrame::callSiteBitsAreBytecodeOffset const):
+        (JSC::CallFrame::callSiteBitsAreCodeOriginIndex const):
+        * interpreter/StackVisitor.cpp:
+        (JSC::StackVisitor::Frame::dump const):
+        * jit/AssemblyHelpers.h:
+        (JSC::AssemblyHelpers::AssemblyHelpers):
+        * jit/JIT.cpp:
+        (JSC::JIT::link):
+        * jit/JITCode.cpp:
+        (JSC::JITCode::typeName):
+        (WTF::printInternal):
+        * jit/JITCode.h:
+        (JSC::JITCode::bottomTierJIT):
+        (JSC::JITCode::topTierJIT):
+        (JSC::JITCode::nextTierJIT):
+        (JSC::JITCode::isExecutableScript):
+        (JSC::JITCode::couldBeInterpreted):
+        (JSC::JITCode::isJIT):
+        (JSC::JITCode::isOptimizingJIT):
+        (JSC::JITCode::isBaselineCode):
+        (JSC::JITCode::jitTypeFor):
+        * jit/JITDisassembler.cpp:
+        (JSC::JITDisassembler::dumpHeader):
+        * jit/JITOperations.cpp:
+        * jit/JITThunks.cpp:
+        (JSC::JITThunks::hostFunctionStub):
+        * jit/JITToDFGDeferredCompilationCallback.cpp:
+        (JSC::JITToDFGDeferredCompilationCallback::compilationDidBecomeReadyAsynchronously):
+        (JSC::JITToDFGDeferredCompilationCallback::compilationDidComplete):
+        * jit/JITWorklist.cpp:
+        (JSC::JITWorklist::compileLater):
+        (JSC::JITWorklist::compileNow):
+        * jit/Repatch.cpp:
+        (JSC::readPutICCallTarget):
+        (JSC::ftlThunkAwareRepatchCall):
+        * llint/LLIntEntrypoint.cpp:
+        (JSC::LLInt::setFunctionEntrypoint):
+        (JSC::LLInt::setEvalEntrypoint):
+        (JSC::LLInt::setProgramEntrypoint):
+        (JSC::LLInt::setModuleProgramEntrypoint):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::jitCompileAndSetHeuristics):
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::processUnverifiedStackTraces):
+        * runtime/SamplingProfiler.h:
+        * runtime/VM.cpp:
+        (JSC::jitCodeForCallTrampoline):
+        (JSC::jitCodeForConstructTrampoline):
+        * tools/CodeProfile.cpp:
+        (JSC::CodeProfile::sample):
+        * tools/JSDollarVM.cpp:
+        (JSC::CallerFrameJITTypeFunctor::CallerFrameJITTypeFunctor):
+        (JSC::CallerFrameJITTypeFunctor::jitType):
+        (JSC::functionLLintTrue):
+        (JSC::functionJITTrue):
+
 2019-04-29  Yusuke Suzuki  <ysuzuki@apple.com>
 

trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp

@@ -343 +343 @@
         // path or it's a full IC. So, for them, if there is an IC status then it means case (1).
         
-        bool checkStatusFirst = context->optimizedCodeBlock->jitType() == JITCode::FTLJIT;
+        bool checkStatusFirst = context->optimizedCodeBlock->jitType() == JITType::FTLJIT;
         
         auto bless = [&] (CallLinkStatus& result) {

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -181 +181 @@
 }
 
-void CodeBlock::dumpAssumingJITType(PrintStream& out, JITCode::JITType jitType) const
+void CodeBlock::dumpAssumingJITType(PrintStream& out, JITType jitType) const
 {
     out.print(inferredName(), "#", hashAsStringIfPossible());
@@ -192 +192 @@
         out.print(specializationKind());
     out.print(", ", instructionCount());
-    if (this->jitType() == JITCode::BaselineJIT && m_shouldAlwaysBeInlined)
+    if (this->jitType() == JITType::BaselineJIT && m_shouldAlwaysBeInlined)
         out.print(" (ShouldAlwaysBeInlined)");
     if (ownerExecutable()->neverInline())
@@ -206 +206 @@
     if (m_didFailJITCompilation)
         out.print(" (JITFail)");
-    if (this->jitType() == JITCode::BaselineJIT && m_didFailFTLCompilation)
+    if (this->jitType() == JITType::BaselineJIT && m_didFailFTLCompilation)
         out.print(" (FTLFail)");
-    if (this->jitType() == JITCode::BaselineJIT && m_hasBeenCompiledWithFTL)
+    if (this->jitType() == JITType::BaselineJIT && m_hasBeenCompiledWithFTL)
         out.print(" (HadFTLReplacement)");
     out.print("]");
@@ -930 +930 @@
 {
 #if ENABLE(FTL_JIT)
-    if (jitType() != JITCode::DFGJIT)
+    if (jitType() != JITType::DFGJIT)
         return 0;
     DFG::JITCode* jitCode = m_jitCode->dfg();
@@ -1003 +1003 @@
 }
 
-static Seconds timeToLive(JITCode::JITType jitType)
+static Seconds timeToLive(JITType jitType)
 {
     if (UNLIKELY(Options::useEagerCodeBlockJettisonTiming())) {
         switch (jitType) {
-        case JITCode::InterpreterThunk:
+        case JITType::InterpreterThunk:
             return 10_ms;
-        case JITCode::BaselineJIT:
+        case JITType::BaselineJIT:
             return 30_ms;
-        case JITCode::DFGJIT:
+        case JITType::DFGJIT:
             return 40_ms;
-        case JITCode::FTLJIT:
+        case JITType::FTLJIT:
             return 120_ms;
         default:
@@ -1021 +1021 @@
 
     switch (jitType) {
-    case JITCode::InterpreterThunk:
+    case JITType::InterpreterThunk:
         return 5_s;
-    case JITCode::BaselineJIT:
+    case JITType::BaselineJIT:
         // Effectively 10 additional seconds, since BaselineJIT and
         // InterpreterThunk share a CodeBlock.
         return 15_s;
-    case JITCode::DFGJIT:
+    case JITType::DFGJIT:
         return 20_s;
-    case JITCode::FTLJIT:
+    case JITType::FTLJIT:
         return 60_s;
     default:
@@ -1069 +1069 @@
     VM& vm = *m_vm;
 
-    if (jitType() == JITCode::InterpreterThunk) {
+    if (jitType() == JITType::InterpreterThunk) {
         const Vector<InstructionStream::Offset>& propertyAccessInstructions = m_unlinkedCode->propertyAccessInstructions();
         const InstructionStream& instructionStream = instructions();
@@ -1631 +1631 @@
         result = result->alternative();
     RELEASE_ASSERT(result);
-    RELEASE_ASSERT(JITCode::isBaselineCode(result->jitType()) || result->jitType() == JITCode::None);
+    RELEASE_ASSERT(JITCode::isBaselineCode(result->jitType()) || result->jitType() == JITType::None);
     return result;
 #else
@@ -1641 +1641 @@
 {
 #if ENABLE(JIT)
-    JITCode::JITType selfJITType = jitType();
+    JITType selfJITType = jitType();
     if (JITCode::isBaselineCode(selfJITType))
         return this;
@@ -1655 +1655 @@
             // This can happen if we're creating the original CodeBlock for an executable.
             // Assume that we're the baseline CodeBlock.
-            RELEASE_ASSERT(selfJITType == JITCode::None);
+            RELEASE_ASSERT(selfJITType == JITType::None);
             return this;
         }
@@ -1668 +1668 @@
 
 #if ENABLE(JIT)
-bool CodeBlock::hasOptimizedReplacement(JITCode::JITType typeToReplace)
+bool CodeBlock::hasOptimizedReplacement(JITType typeToReplace)
 {
     CodeBlock* replacement = this->replacement();
@@ -2148 +2148 @@
     }
 
-    if (callerCodeBlock->jitType() == JITCode::InterpreterThunk) {
+    if (callerCodeBlock->jitType() == JITType::InterpreterThunk) {
         // If the caller is still in the interpreter, then we can't expect inlining to
         // happen anytime soon. Assume it's profitable to optimize it separately. This
@@ -2490 +2490 @@
 void CodeBlock::setOptimizationThresholdBasedOnCompilationResult(CompilationResult result)
 {
-    JITCode::JITType type = jitType();
-    if (type != JITCode::BaselineJIT) {
+    JITType type = jitType();
+    if (type != JITType::BaselineJIT) {
         dataLog(*this, ": expected to have baseline code but have ", type, "\n");
-        CRASH_WITH_INFO(bitwise_cast<uintptr_t>(jitCode().get()), type);
+        CRASH_WITH_INFO(bitwise_cast<uintptr_t>(jitCode().get()), static_cast<uint8_t>(type));
     }
     
@@ -2724 +2724 @@
 {
     ASSERT(JITCode::isOptimizingJIT(jitType()));
-    ASSERT(alternative()->jitType() == JITCode::BaselineJIT);
+    ASSERT(alternative()->jitType() == JITType::BaselineJIT);
     
     CodeBlock* profiledBlock = alternative();
     
     switch (jitType()) {
-    case JITCode::DFGJIT: {
+    case JITType::DFGJIT: {
         DFG::JITCode* jitCode = m_jitCode->dfg();
         for (auto& exit : jitCode->osrExit)
@@ -2737 +2737 @@
 
 #if ENABLE(FTL_JIT)
-    case JITCode::FTLJIT: {
+    case JITType::FTLJIT: {
         // There is no easy way to avoid duplicating this code since the FTL::JITCode::osrExit
         // vector contains a totally different type, that just so happens to behave like
@@ -2825 +2825 @@
 {
     switch (jitType()) {
-    case JITCode::InterpreterThunk:
+    case JITType::InterpreterThunk:
         return LLInt::frameRegisterCountFor(this);
 
 #if ENABLE(JIT)
-    case JITCode::BaselineJIT:
+    case JITType::BaselineJIT:
         return JIT::frameRegisterCountFor(this);
 #endif // ENABLE(JIT)
 
 #if ENABLE(DFG_JIT)
-    case JITCode::DFGJIT:
-    case JITCode::FTLJIT:
+    case JITType::DFGJIT:
+    case JITType::FTLJIT:
         return jitCode()->dfgCommon()->frameRegisterCount;
 #endif // ENABLE(DFG_JIT)
@@ -3176 +3176 @@
 {
     Optional<unsigned> bytecodeOffset;
-    JITCode::JITType jitType = this->jitType();
-    if (jitType == JITCode::InterpreterThunk || jitType == JITCode::BaselineJIT) {
+    JITType jitType = this->jitType();
+    if (jitType == JITType::InterpreterThunk || jitType == JITType::BaselineJIT) {
 #if USE(JSVALUE64)
         bytecodeOffset = callSiteIndex.bits();
@@ -3184 +3184 @@
         bytecodeOffset = this->bytecodeOffset(instruction);
 #endif
-    } else if (jitType == JITCode::DFGJIT || jitType == JITCode::FTLJIT) {
+    } else if (jitType == JITType::DFGJIT || jitType == JITType::FTLJIT) {
 #if ENABLE(DFG_JIT)
         RELEASE_ASSERT(canGetCodeOrigin(callSiteIndex));

trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

@@ -143 +143 @@
     CString sourceCodeForTools() const; // Not quite the actual source we parsed; this will do things like prefix the source for a function with a reified signature.
     CString sourceCodeOnOneLine() const; // As sourceCodeForTools(), but replaces all whitespace runs with a single space.
-    void dumpAssumingJITType(PrintStream&, JITCode::JITType) const;
+    void dumpAssumingJITType(PrintStream&, JITType) const;
     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
 
@@ -403 +403 @@
     RefPtr<JITCode> jitCode() { return m_jitCode; }
     static ptrdiff_t jitCodeOffset() { return OBJECT_OFFSETOF(CodeBlock, m_jitCode); }
-    JITCode::JITType jitType() const
+    JITType jitType() const
     {
         JITCode* jitCode = m_jitCode.get();
         WTF::loadLoadFence();
-        JITCode::JITType result = JITCode::jitTypeFor(jitCode);
+        JITType result = JITCode::jitTypeFor(jitCode);
         WTF::loadLoadFence(); // This probably isn't needed. Oh well, paranoia is good.
         return result;
@@ -414 +414 @@
     bool hasBaselineJITProfiling() const
     {
-        return jitType() == JITCode::BaselineJIT;
+        return jitType() == JITType::BaselineJIT;
     }
     
@@ -424 +424 @@
     DFG::CapabilityLevel capabilityLevelState() { return static_cast<DFG::CapabilityLevel>(m_capabilityLevelState); }
 
-    bool hasOptimizedReplacement(JITCode::JITType typeToReplace);
+    bool hasOptimizedReplacement(JITType typeToReplace);
     bool hasOptimizedReplacement(); // the typeToReplace is my JITType
 #endif

trunk/Source/JavaScriptCore/bytecode/CodeBlockWithJITType.h

@@ -35 +35 @@
 class CodeBlockWithJITType {
 public:
-    CodeBlockWithJITType(CodeBlock* codeBlock, JITCode::JITType jitType)
+    CodeBlockWithJITType(CodeBlock* codeBlock, JITType jitType)
         : m_codeBlock(codeBlock)
         , m_jitType(jitType)
@@ -47 +47 @@
 private:
     CodeBlock* m_codeBlock;
-    JITCode::JITType m_jitType;
+    JITType m_jitType;
 };
 

trunk/Source/JavaScriptCore/bytecode/DeferredSourceDump.cpp

@@ -35 +35 @@
 DeferredSourceDump::DeferredSourceDump(CodeBlock* codeBlock)
     : m_codeBlock(*codeBlock->vm(), codeBlock)
-    , m_rootJITType(JITCode::None)
+    , m_rootJITType(JITType::None)
 {
 }
 
-DeferredSourceDump::DeferredSourceDump(CodeBlock* codeBlock, CodeBlock* rootCodeBlock, JITCode::JITType rootJITType, unsigned callerBytecodeIndex)
+DeferredSourceDump::DeferredSourceDump(CodeBlock* codeBlock, CodeBlock* rootCodeBlock, JITType rootJITType, unsigned callerBytecodeIndex)
     : m_codeBlock(*codeBlock->vm(), codeBlock)
     , m_rootCodeBlock(*codeBlock->vm(), rootCodeBlock)

trunk/Source/JavaScriptCore/bytecode/DeferredSourceDump.h

@@ -36 +36 @@
 public:
     DeferredSourceDump(CodeBlock*);
-    DeferredSourceDump(CodeBlock*, CodeBlock* rootCodeBlock, JITCode::JITType rootJITType, unsigned callerBytecodeIndex);
+    DeferredSourceDump(CodeBlock*, CodeBlock* rootCodeBlock, JITType rootJITType, unsigned callerBytecodeIndex);
 
     void dump();
@@ -43 +43 @@
     Strong<CodeBlock> m_codeBlock;
     Strong<CodeBlock> m_rootCodeBlock;
-    JITCode::JITType m_rootJITType;
+    JITType m_rootJITType;
     unsigned m_callerBytecodeIndex { UINT_MAX };
 };

trunk/Source/JavaScriptCore/bytecode/ExitingJITType.h

@@ -36 +36 @@
 };
 
-inline ExitingJITType exitingJITTypeFor(JITCode::JITType type)
+inline ExitingJITType exitingJITTypeFor(JITType type)
 {
     switch (type) {
-    case JITCode::DFGJIT:
+    case JITType::DFGJIT:
         return ExitFromDFG;
-    case JITCode::FTLJIT:
+    case JITType::FTLJIT:
         return ExitFromFTL;
     default:

trunk/Source/JavaScriptCore/bytecode/InlineCallFrame.h

@@ -241 +241 @@
 inline CodeBlock* baselineCodeBlockForOriginAndBaselineCodeBlock(const CodeOrigin& codeOrigin, CodeBlock* baselineCodeBlock)
 {
-    ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
+    ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
     auto* inlineCallFrame = codeOrigin.inlineCallFrame();
     if (inlineCallFrame)

trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

@@ -7095 +7095 @@
         Vector<DeferredSourceDump>& deferredSourceDump = m_graph.m_plan.callback()->ensureDeferredSourceDump();
         if (inlineCallFrame()) {
-            DeferredSourceDump dump(codeBlock->baselineVersion(), m_codeBlock, JITCode::DFGJIT, inlineCallFrame()->directCaller.bytecodeIndex());
+            DeferredSourceDump dump(codeBlock->baselineVersion(), m_codeBlock, JITType::DFGJIT, inlineCallFrame()->directCaller.bytecodeIndex());
             deferredSourceDump.append(dump);
         } else
@@ -7105 +7105 @@
         if (inlineCallFrame()) {
             dataLog(
-                " for inlining at ", CodeBlockWithJITType(m_codeBlock, JITCode::DFGJIT),
+                " for inlining at ", CodeBlockWithJITType(m_codeBlock, JITType::DFGJIT),
                 " ", inlineCallFrame()->directCaller);
         }

trunk/Source/JavaScriptCore/dfg/DFGDisassembler.cpp

@@ -75 +75 @@
 void Disassembler::dumpHeader(PrintStream& out, LinkBuffer& linkBuffer)
 {
-    out.print("Generated DFG JIT code for ", CodeBlockWithJITType(m_graph.m_codeBlock, JITCode::DFGJIT), ", instruction count = ", m_graph.m_codeBlock->instructionCount(), ":\n");
+    out.print("Generated DFG JIT code for ", CodeBlockWithJITType(m_graph.m_codeBlock, JITType::DFGJIT), ", instruction count = ", m_graph.m_codeBlock->instructionCount(), ":\n");
     out.print("    Optimized with execution counter = ", m_graph.m_profiledBlock->jitExecuteCounter(), "\n");
     out.print("    Code at [", RawPointer(linkBuffer.debugAddress()), ", ", RawPointer(static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.size()), "):\n");

trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

@@ -82 +82 @@
     ASSERT(codeBlock);
     ASSERT(codeBlock->alternative());
-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
-    ASSERT(!profiledDFGCodeBlock || profiledDFGCodeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
+    ASSERT(!profiledDFGCodeBlock || profiledDFGCodeBlock->jitType() == JITType::DFGJIT);
     
     if (logCompilationChanges(mode))

trunk/Source/JavaScriptCore/dfg/DFGGraph.cpp

@@ -526 +526 @@
     
     out.print("\n");
-    out.print("DFG for ", CodeBlockWithJITType(m_codeBlock, JITCode::DFGJIT), ":\n");
+    out.print("DFG for ", CodeBlockWithJITType(m_codeBlock, JITType::DFGJIT), ":\n");
     out.print("  Fixpoint state: ", m_fixpointState, "; Form: ", m_form, "; Unification state: ", m_unificationState, "; Ref count state: ", m_refCountState, "\n");
     if (m_form == SSA) {

trunk/Source/JavaScriptCore/dfg/DFGJITCode.cpp

@@ -37 +37 @@
 
 JITCode::JITCode()
-    : DirectJITCode(DFGJIT)
+    : DirectJITCode(JITType::DFGJIT)
 #if ENABLE(FTL_JIT)
     , osrEntryRetry(0)
@@ -124 +124 @@
 bool JITCode::checkIfOptimizationThresholdReached(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     return tierUpCounter.checkIfThresholdCrossedAndSet(codeBlock);
 }
@@ -130 +130 @@
 void JITCode::optimizeNextInvocation(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     if (Options::verboseOSR())
         dataLog(*codeBlock, ": FTL-optimizing next invocation.\n");
@@ -138 +138 @@
 void JITCode::dontOptimizeAnytimeSoon(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     if (Options::verboseOSR())
         dataLog(*codeBlock, ": Not FTL-optimizing anytime soon.\n");
@@ -146 +146 @@
 void JITCode::optimizeAfterWarmUp(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     if (Options::verboseOSR())
         dataLog(*codeBlock, ": FTL-optimizing after warm-up.\n");
@@ -157 +157 @@
 void JITCode::optimizeSoon(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     if (Options::verboseOSR())
         dataLog(*codeBlock, ": FTL-optimizing soon.\n");
@@ -168 +168 @@
 void JITCode::forceOptimizationSlowPathConcurrently(CodeBlock* codeBlock)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     if (Options::verboseOSR())
         dataLog(*codeBlock, ": Forcing slow path concurrently for FTL entry.\n");
@@ -177 +177 @@
     CodeBlock* codeBlock, CompilationResult result)
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     switch (result) {
     case CompilationSuccessful:

trunk/Source/JavaScriptCore/dfg/DFGJITFinalizer.cpp

@@ -57 +57 @@
 bool JITFinalizer::finalize()
 {
-    MacroAssemblerCodeRef<JSEntryPtrTag> codeRef = FINALIZE_DFG_CODE(*m_linkBuffer, JSEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITCode::DFGJIT)).data());
+    MacroAssemblerCodeRef<JSEntryPtrTag> codeRef = FINALIZE_DFG_CODE(*m_linkBuffer, JSEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITType::DFGJIT)).data());
     m_jitCode->initializeCodeRefForDFG(codeRef, codeRef.code());
 
@@ -71 +71 @@
     RELEASE_ASSERT(!m_withArityCheck.isEmptyValue());
     m_jitCode->initializeCodeRefForDFG(
-        FINALIZE_DFG_CODE(*m_linkBuffer, JSEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITCode::DFGJIT)).data()),
+        FINALIZE_DFG_CODE(*m_linkBuffer, JSEntryPtrTag, "DFG JIT code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITType::DFGJIT)).data()),
         m_withArityCheck);
     m_plan.codeBlock()->setJITCode(m_jitCode.copyRef());

trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp

@@ -97 +97 @@
     ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));
     ASSERT(codeBlock->alternative());
-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
     ASSERT(!codeBlock->jitCodeMap());
 
@@ -116 +116 @@
         codeBlock->ownerExecutable()->setDidTryToEnterInLoop(true);
     
-    if (codeBlock->jitType() != JITCode::DFGJIT) {
-        RELEASE_ASSERT(codeBlock->jitType() == JITCode::FTLJIT);
+    if (codeBlock->jitType() != JITType::DFGJIT) {
+        RELEASE_ASSERT(codeBlock->jitType() == JITType::FTLJIT);
         
         // When will this happen? We could have:
@@ -342 +342 @@
 MacroAssemblerCodePtr<ExceptionHandlerPtrTag> prepareCatchOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
 { 
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT || codeBlock->jitType() == JITCode::FTLJIT);
-
-    if (!Options::useOSREntryToDFG() && codeBlock->jitCode()->jitType() == JITCode::DFGJIT)
-        return nullptr;
-    if (!Options::useOSREntryToFTL() && codeBlock->jitCode()->jitType() == JITCode::FTLJIT)
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT || codeBlock->jitType() == JITType::FTLJIT);
+
+    if (!Options::useOSREntryToDFG() && codeBlock->jitCode()->jitType() == JITType::DFGJIT)
+        return nullptr;
+    if (!Options::useOSREntryToFTL() && codeBlock->jitCode()->jitType() == JITType::FTLJIT)
         return nullptr;
 

trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp

@@ -352 +352 @@
     CodeBlock* codeBlock = exec->codeBlock();
     ASSERT(codeBlock);
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
 
     // It's sort of preferable that we don't GC while in here. Anyways, doing so wouldn't
@@ -376 +376 @@
 
         CodeBlock* baselineCodeBlock = codeBlock->baselineAlternative();
-        ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
+        ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
 
         SpeculationRecovery* recovery = nullptr;
@@ -446 +446 @@
     OSRExitState& exitState = *exit.exitState.get();
     CodeBlock* baselineCodeBlock = exitState.baselineCodeBlock;
-    ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
+    ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
 
     Operands<ValueRecovery>& operands = exitState.operands;
@@ -753 +753 @@
     // in presence of inlined tail calls.
     // https://bugs.webkit.org/show_bug.cgi?id=147511
-    ASSERT(outermostBaselineCodeBlock->jitType() == JITCode::BaselineJIT);
+    ASSERT(outermostBaselineCodeBlock->jitType() == JITType::BaselineJIT);
     frame.setOperand<CodeBlock*>(CallFrameSlot::codeBlock, outermostBaselineCodeBlock);
 
@@ -1036 +1036 @@
     CodeBlock* codeBlock = exec->codeBlock();
     ASSERT(codeBlock);
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
 
     // It's sort of preferable that we don't GC while in here. Anyways, doing so wouldn't

trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp

@@ -117 +117 @@
     int32_t clippedValue;
     switch (jit.codeBlock()->jitType()) {
-    case JITCode::DFGJIT:
+    case JITType::DFGJIT:
         clippedValue = BaselineExecutionCounter::clippedThreshold(jit.codeBlock()->globalObject(), targetValue);
         break;
-    case JITCode::FTLJIT:
+    case JITType::FTLJIT:
         clippedValue = UpperTierExecutionCounter::clippedThreshold(jit.codeBlock()->globalObject(), targetValue);
         break;
@@ -142 +142 @@
     // in presence of inlined tail calls.
     // https://bugs.webkit.org/show_bug.cgi?id=147511
-    ASSERT(jit.baselineCodeBlock()->jitType() == JITCode::BaselineJIT);
+    ASSERT(jit.baselineCodeBlock()->jitType() == JITType::BaselineJIT);
     jit.storePtr(AssemblyHelpers::TrustedImmPtr(jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)CallFrameSlot::codeBlock));
 
@@ -311 +311 @@
     CodeBlock* codeBlockForExit = jit.baselineCodeBlockFor(exit.m_codeOrigin);
     ASSERT(codeBlockForExit == codeBlockForExit->baselineVersion());
-    ASSERT(codeBlockForExit->jitType() == JITCode::BaselineJIT);
+    ASSERT(codeBlockForExit->jitType() == JITType::BaselineJIT);
     CodeLocationLabel<JSEntryPtrTag> codeLocation = codeBlockForExit->jitCodeMap().find(exit.m_codeOrigin.bytecodeIndex());
     ASSERT(codeLocation);

trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h

@@ -42 +42 @@
 
 template <typename JITCodeType>
-void adjustFrameAndStackInOSRExitCompilerThunk(MacroAssembler& jit, VM* vm, JITCode::JITType jitType)
+void adjustFrameAndStackInOSRExitCompilerThunk(MacroAssembler& jit, VM* vm, JITType jitType)
 {
-    ASSERT(jitType == JITCode::DFGJIT || jitType == JITCode::FTLJIT);
+    ASSERT(jitType == JITType::DFGJIT || jitType == JITType::FTLJIT);
 
-    bool isFTLOSRExit = jitType == JITCode::FTLJIT;
+    bool isFTLOSRExit = jitType == JITType::FTLJIT;
     RegisterSet registersToPreserve;
     registersToPreserve.set(GPRInfo::regT0);

trunk/Source/JavaScriptCore/dfg/DFGOperations.cpp

@@ -3168 +3168 @@
     sanitizeStackForVM(vm);
 
-    if (codeBlock->jitType() != JITCode::DFGJIT) {
+    if (codeBlock->jitType() != JITType::DFGJIT) {
         dataLog("Unexpected code block in DFG->FTL tier-up: ", *codeBlock, "\n");
         RELEASE_ASSERT_NOT_REACHED();
@@ -3434 +3434 @@
     sanitizeStackForVM(vm);
 
-    if (codeBlock->jitType() != JITCode::DFGJIT) {
+    if (codeBlock->jitType() != JITType::DFGJIT) {
         dataLog("Unexpected code block in DFG->FTL trigger tier up now in loop: ", *codeBlock, "\n");
         RELEASE_ASSERT_NOT_REACHED();
@@ -3468 +3468 @@
     sanitizeStackForVM(vm);
 
-    if (codeBlock->jitType() != JITCode::DFGJIT) {
+    if (codeBlock->jitType() != JITType::DFGJIT) {
         dataLog("Unexpected code block in DFG->FTL tier-up: ", *codeBlock, "\n");
         RELEASE_ASSERT_NOT_REACHED();

trunk/Source/JavaScriptCore/dfg/DFGThunks.cpp

@@ -54 +54 @@
 
     // This needs to happen before we use the scratch buffer because this function also uses the scratch buffer.
-    adjustFrameAndStackInOSRExitCompilerThunk<DFG::JITCode>(jit, vm, JITCode::DFGJIT);
+    adjustFrameAndStackInOSRExitCompilerThunk<DFG::JITCode>(jit, vm, JITType::DFGJIT);
     
     size_t scratchSize = sizeof(EncodedJSValue) * (GPRInfo::numberOfRegisters + FPRInfo::numberOfRegisters);

trunk/Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp

@@ -120 +120 @@
     unsigned index, Operands<ValueRecovery>& valueRecoveries, Vector<UndefinedOperandSpan>* undefinedOperandSpans) const
 {
-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
     CodeBlock* baselineCodeBlock = codeBlock->baselineVersion();
 

trunk/Source/JavaScriptCore/ftl/FTLCompile.cpp

@@ -80 +80 @@
         std::make_unique<RegisterAtOffsetList>(state.proc->calleeSaveRegisterAtOffsetList());
     if (shouldDumpDisassembly())
-        dataLog("Unwind info for ", CodeBlockWithJITType(codeBlock, JITCode::FTLJIT), ": ", *registerOffsets, "\n");
+        dataLog("Unwind info for ", CodeBlockWithJITType(codeBlock, JITType::FTLJIT), ": ", *registerOffsets, "\n");
     codeBlock->setCalleeSaveRegisters(WTFMove(registerOffsets));
     ASSERT(!(state.proc->frameSize() % sizeof(EncodedJSValue)));
@@ -169 +169 @@
         PrintStream& out = WTF::dataFile();
 
-        out.print("Generated ", state.graph.m_plan.mode(), " code for ", CodeBlockWithJITType(state.graph.m_codeBlock, JITCode::FTLJIT), ", instruction count = ", state.graph.m_codeBlock->instructionCount(), ":\n");
+        out.print("Generated ", state.graph.m_plan.mode(), " code for ", CodeBlockWithJITType(state.graph.m_codeBlock, JITType::FTLJIT), ", instruction count = ", state.graph.m_codeBlock->instructionCount(), ":\n");
 
         LinkBuffer& linkBuffer = *state.finalizer->b3CodeLinkBuffer;

trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp

@@ -37 +37 @@
 
 JITCode::JITCode()
-    : JSC::JITCode(FTLJIT)
+    : JSC::JITCode(JITType::FTLJIT)
 {
 }

trunk/Source/JavaScriptCore/ftl/FTLJITFinalizer.cpp

@@ -76 +76 @@
     MacroAssemblerCodeRef<JSEntryPtrTag> b3CodeRef =
         FINALIZE_CODE_IF(dumpDisassembly, *b3CodeLinkBuffer, JSEntryPtrTag,
-            "FTL B3 code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITCode::FTLJIT)).data());
+            "FTL B3 code for %s", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITType::FTLJIT)).data());
 
     MacroAssemblerCodeRef<JSEntryPtrTag> arityCheckCodeRef = entrypointLinkBuffer
         ? FINALIZE_CODE_IF(dumpDisassembly, *entrypointLinkBuffer, JSEntryPtrTag,
-            "FTL entrypoint thunk for %s with B3 generated code at %p", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITCode::FTLJIT)).data(), function)
+            "FTL entrypoint thunk for %s with B3 generated code at %p", toCString(CodeBlockWithJITType(m_plan.codeBlock(), JITType::FTLJIT)).data(), function)
         : MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(b3CodeRef.code());
 

trunk/Source/JavaScriptCore/ftl/FTLLink.cpp

@@ -72 +72 @@
         compilation->addDescription(
             Profiler::OriginStack(),
-            toCString("Generated FTL JIT code for ", CodeBlockWithJITType(codeBlock, JITCode::FTLJIT), ", instruction count = ", graph.m_codeBlock->instructionCount(), ":\n"));
+            toCString("Generated FTL JIT code for ", CodeBlockWithJITType(codeBlock, JITType::FTLJIT), ", instruction count = ", graph.m_codeBlock->instructionCount(), ":\n"));
         
         graph.ensureSSADominators();

trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp

@@ -507 +507 @@
     
     ASSERT(codeBlock);
-    ASSERT(codeBlock->jitType() == JITCode::FTLJIT);
+    ASSERT(codeBlock->jitType() == JITType::FTLJIT);
     
     // It's sort of preferable that we don't GC while in here. Anyways, doing so wouldn't

trunk/Source/JavaScriptCore/ftl/FTLThunks.cpp

@@ -54 +54 @@
     if (frameAndStackAdjustmentRequirement == FrameAndStackAdjustmentRequirement::Needed) {
         // This needs to happen before we use the scratch buffer because this function also uses the scratch buffer.
-        adjustFrameAndStackInOSRExitCompilerThunk<FTL::JITCode>(jit, vm, JITCode::FTLJIT);
+        adjustFrameAndStackInOSRExitCompilerThunk<FTL::JITCode>(jit, vm, JITType::FTLJIT);
     }
     

trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp

@@ -53 +53 @@
     ASSERT(codeBlock());
     switch (codeBlock()->jitType()) {
-    case JITCode::InterpreterThunk:
-    case JITCode::BaselineJIT:
+    case JITType::InterpreterThunk:
+    case JITType::BaselineJIT:
         return true;
-    case JITCode::None:
-    case JITCode::HostCallThunk:
+    case JITType::None:
+    case JITType::HostCallThunk:
         RELEASE_ASSERT_NOT_REACHED();
         return false;
@@ -72 +72 @@
     ASSERT(codeBlock());
     switch (codeBlock()->jitType()) {
-    case JITCode::DFGJIT:
-    case JITCode::FTLJIT:
+    case JITType::DFGJIT:
+    case JITType::FTLJIT:
         return true;
-    case JITCode::None:
-    case JITCode::HostCallThunk:
+    case JITType::None:
+    case JITType::HostCallThunk:
         RELEASE_ASSERT_NOT_REACHED();
         return false;

trunk/Source/JavaScriptCore/interpreter/StackVisitor.cpp

@@ -493 +493 @@
                     out.print(indent, "callSiteIndex: ", callSiteIndex.bits(), " of ", codeBlock->codeOrigins().size(), "\n");
 
-                    JITCode::JITType jitType = codeBlock->jitType();
-                    if (jitType != JITCode::FTLJIT) {
+                    JITType jitType = codeBlock->jitType();
+                    if (jitType != JITType::FTLJIT) {
                         JITCode* jitCode = codeBlock->jitCode().get();
                         out.print(indent, "jitCode: ", RawPointer(jitCode),

trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

@@ -58 +58 @@
             ASSERT(m_baselineCodeBlock);
             ASSERT(!m_baselineCodeBlock->alternative());
-            ASSERT(m_baselineCodeBlock->jitType() == JITCode::None || JITCode::isBaselineCode(m_baselineCodeBlock->jitType()));
+            ASSERT(m_baselineCodeBlock->jitType() == JITType::None || JITCode::isBaselineCode(m_baselineCodeBlock->jitType()));
         }
     }

trunk/Source/JavaScriptCore/jit/JIT.cpp

@@ -904 +904 @@
     CodeRef<JSEntryPtrTag> result = FINALIZE_CODE(
         patchBuffer, JSEntryPtrTag,
-        "Baseline JIT code for %s", toCString(CodeBlockWithJITType(m_codeBlock, JITCode::BaselineJIT)).data());
+        "Baseline JIT code for %s", toCString(CodeBlockWithJITType(m_codeBlock, JITType::BaselineJIT)).data());
     
     m_vm->machineCodeBytesPerBytecodeWordForBaselineJIT->add(
@@ -912 +912 @@
     m_codeBlock->shrinkToFit(CodeBlock::LateShrink);
     m_codeBlock->setJITCode(
-        adoptRef(*new DirectJITCode(result, withArityCheck, JITCode::BaselineJIT)));
+        adoptRef(*new DirectJITCode(result, withArityCheck, JITType::BaselineJIT)));
 
     if (JITInternal::verbose)

trunk/Source/JavaScriptCore/jit/JITCode.cpp

@@ -46 +46 @@
 {
     switch (jitType) {
-    case None:
+    case JITType::None:
         return "None";
-    case HostCallThunk:
+    case JITType::HostCallThunk:
         return "Host";
-    case InterpreterThunk:
+    case JITType::InterpreterThunk:
         return "LLInt";
-    case BaselineJIT:
+    case JITType::BaselineJIT:
         return "Baseline";
-    case DFGJIT:
+    case JITType::DFGJIT:
         return "DFG";
-    case FTLJIT:
+    case JITType::FTLJIT:
         return "FTL";
     default:
@@ -242 +242 @@
 namespace WTF {
 
-void printInternal(PrintStream& out, JSC::JITCode::JITType type)
+void printInternal(PrintStream& out, JSC::JITType type)
 {
     out.print(JSC::JITCode::typeName(type));

trunk/Source/JavaScriptCore/jit/JITCode.h

@@ -52 +52 @@
 class VM;
 
+enum class JITType : uint8_t {
+    None,
+    HostCallThunk,
+    InterpreterThunk,
+    BaselineJIT,
+    DFGJIT,
+    FTLJIT
+};
+
 class JITCode : public ThreadSafeRefCounted<JITCode> {
 public:
@@ -57 +66 @@
     template<PtrTag tag> using CodeRef = MacroAssemblerCodeRef<tag>;
 
-    enum JITType : uint8_t {
-        None,
-        HostCallThunk,
-        InterpreterThunk,
-        BaselineJIT,
-        DFGJIT,
-        FTLJIT
-    };
-    
     static const char* typeName(JITType);
 
     static JITType bottomTierJIT()
     {
-        return BaselineJIT;
+        return JITType::BaselineJIT;
     }
     
     static JITType topTierJIT()
     {
-        return FTLJIT;
+        return JITType::FTLJIT;
     }
     
@@ -81 +81 @@
     {
         switch (jitType) {
-        case BaselineJIT:
-            return DFGJIT;
-        case DFGJIT:
-            return FTLJIT;
+        case JITType::BaselineJIT:
+            return JITType::DFGJIT;
+        case JITType::DFGJIT:
+            return JITType::FTLJIT;
         default:
             RELEASE_ASSERT_NOT_REACHED();
-            return None;
+            return JITType::None;
         }
     }
@@ -94 +94 @@
     {
         switch (jitType) {
-        case None:
-        case HostCallThunk:
+        case JITType::None:
+        case JITType::HostCallThunk:
             return false;
         default:
@@ -105 +105 @@
     {
         switch (jitType) {
-        case InterpreterThunk:
-        case BaselineJIT:
+        case JITType::InterpreterThunk:
+        case JITType::BaselineJIT:
             return true;
         default:
@@ -116 +116 @@
     {
         switch (jitType) {
-        case BaselineJIT:
-        case DFGJIT:
-        case FTLJIT:
+        case JITType::BaselineJIT:
+        case JITType::DFGJIT:
+        case JITType::FTLJIT:
             return true;
         default:
@@ -149 +149 @@
     static bool isOptimizingJIT(JITType jitType)
     {
-        return jitType == DFGJIT || jitType == FTLJIT;
+        return jitType == JITType::DFGJIT || jitType == JITType::FTLJIT;
     }
     
     static bool isBaselineCode(JITType jitType)
     {
-        return jitType == InterpreterThunk || jitType == BaselineJIT;
+        return jitType == JITType::InterpreterThunk || jitType == JITType::BaselineJIT;
     }
 
@@ -179 +179 @@
     {
         if (!jitCode)
-            return None;
+            return JITType::None;
         return jitCode->jitType();
     }
@@ -279 +279 @@
 
 class PrintStream;
-void printInternal(PrintStream&, JSC::JITCode::JITType);
+void printInternal(PrintStream&, JSC::JITType);
 
 } // namespace WTF

trunk/Source/JavaScriptCore/jit/JITDisassembler.cpp

@@ -90 +90 @@
 void JITDisassembler::dumpHeader(PrintStream& out, LinkBuffer& linkBuffer)
 {
-    out.print("Generated Baseline JIT code for ", CodeBlockWithJITType(m_codeBlock, JITCode::BaselineJIT), ", instruction count = ", m_codeBlock->instructionCount(), "\n");
+    out.print("Generated Baseline JIT code for ", CodeBlockWithJITType(m_codeBlock, JITType::BaselineJIT), ", instruction count = ", m_codeBlock->instructionCount(), "\n");
     out.print("   Source: ", m_codeBlock->sourceCodeOnOneLine(), "\n");
     out.print("   Code at [", RawPointer(linkBuffer.debugAddress()), ", ", RawPointer(static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.size()), "):\n");

trunk/Source/JavaScriptCore/jit/JITOperations.cpp

@@ -1428 +1428 @@
     
     CodeBlock* codeBlock = exec->codeBlock();
-    if (UNLIKELY(codeBlock->jitType() != JITCode::BaselineJIT)) {
+    if (UNLIKELY(codeBlock->jitType() != JITType::BaselineJIT)) {
         dataLog("Unexpected code block in Baseline->DFG tier-up: ", *codeBlock, "\n");
         RELEASE_ASSERT_NOT_REACHED();
@@ -1661 +1661 @@
 
     switch (optimizedReplacement->jitType()) {
-    case JITCode::DFGJIT:
-    case JITCode::FTLJIT: {
+    case JITType::DFGJIT:
+    case JITType::FTLJIT: {
         MacroAssemblerCodePtr<ExceptionHandlerPtrTag> entry = DFG::prepareCatchOSREntry(exec, optimizedReplacement, bytecodeIndex);
         return entry.executableAddress<char*>();
@@ -1683 +1683 @@
 
     switch (optimizedReplacement->jitType()) {
-    case JITCode::DFGJIT:
-    case JITCode::FTLJIT: {
+    case JITType::DFGJIT:
+    case JITType::FTLJIT: {
         MacroAssemblerCodePtr<ExceptionHandlerPtrTag> entry = DFG::prepareCatchOSREntry(exec, optimizedReplacement, bytecodeIndex);
         return entry.executableAddress<char*>();

trunk/Source/JavaScriptCore/jit/JITThunks.cpp

@@ -125 +125 @@
     if (generator) {
         MacroAssemblerCodeRef<JSEntryPtrTag> entry = generator(vm).retagged<JSEntryPtrTag>();
-        forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITCode::HostCallThunk, intrinsic));
+        forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITType::HostCallThunk, intrinsic));
     } else if (signature)
-        forCall = adoptRef(new NativeDOMJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITCode::HostCallThunk, intrinsic, signature));
+        forCall = adoptRef(new NativeDOMJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, intrinsic, signature));
     else
-        forCall = adoptRef(new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITCode::HostCallThunk, intrinsic));
+        forCall = adoptRef(new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, intrinsic));
     
-    Ref<JITCode> forConstruct = adoptRef(*new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeConstruct(vm).retagged<JSEntryPtrTag>()), JITCode::HostCallThunk, NoIntrinsic));
+    Ref<JITCode> forConstruct = adoptRef(*new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeConstruct(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, NoIntrinsic));
     
     NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, forCall.releaseNonNull(), function, WTFMove(forConstruct), constructor, name);

trunk/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp

@@ -46 +46 @@
 {
     ASSERT_UNUSED(profiledDFGCodeBlock, !profiledDFGCodeBlock);
-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
     
     if (Options::verboseOSR())
@@ -58 +58 @@
 {
     ASSERT(!profiledDFGCodeBlock);
-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
     
     if (Options::verboseOSR())

trunk/Source/JavaScriptCore/jit/JITWorklist.cpp

@@ -232 +232 @@
 {
     DeferGC deferGC(codeBlock->vm()->heap);
-    RELEASE_ASSERT(codeBlock->jitType() == JITCode::InterpreterThunk);
+    RELEASE_ASSERT(codeBlock->jitType() == JITType::InterpreterThunk);
     
     if (codeBlock->m_didFailJITCompilation) {
@@ -285 +285 @@
     VM* vm = codeBlock->vm();
     DeferGC deferGC(vm->heap);
-    if (codeBlock->jitType() != JITCode::InterpreterThunk)
+    if (codeBlock->jitType() != JITType::InterpreterThunk)
         return;
     
@@ -301 +301 @@
     
     // Now it might be compiled!
-    if (codeBlock->jitType() != JITCode::InterpreterThunk)
+    if (codeBlock->jitType() != JITType::InterpreterThunk)
         return;
     

trunk/Source/JavaScriptCore/jit/Repatch.cpp

@@ -73 +73 @@
     FunctionPtr<OperationPtrTag> target = MacroAssembler::readCallTarget<OperationPtrTag>(call);
 #if ENABLE(FTL_JIT)
-    if (codeBlock->jitType() == JITCode::FTLJIT) {
+    if (codeBlock->jitType() == JITType::FTLJIT) {
         MacroAssemblerCodePtr<JITThunkPtrTag> thunk = MacroAssemblerCodePtr<OperationPtrTag>::createFromExecutableAddress(target.executableAddress()).retagged<JITThunkPtrTag>();
         return codeBlock->vm()->ftlThunks->keyForSlowPathCallThunk(thunk).callTarget().retagged<CFunctionPtrTag>();
@@ -86 +86 @@
 {
 #if ENABLE(FTL_JIT)
-    if (codeBlock->jitType() == JITCode::FTLJIT) {
+    if (codeBlock->jitType() == JITType::FTLJIT) {
         VM& vm = *codeBlock->vm();
         FTL::Thunks& thunks = *vm.ftlThunks;

trunk/Source/JavaScriptCore/llint/LLIntEntrypoint.cpp

@@ -52 +52 @@
                 auto callRef = functionForCallEntryThunk().retagged<JSEntryPtrTag>();
                 auto callArityCheckRef = functionForCallArityCheckThunk().retaggedCode<JSEntryPtrTag>();
-                jitCode = new DirectJITCode(callRef, callArityCheckRef, JITCode::InterpreterThunk, JITCode::ShareAttribute::Shared);
+                jitCode = new DirectJITCode(callRef, callArityCheckRef, JITType::InterpreterThunk, JITCode::ShareAttribute::Shared);
             });
 
@@ -65 +65 @@
             auto constructRef = functionForConstructEntryThunk().retagged<JSEntryPtrTag>();
             auto constructArityCheckRef = functionForConstructArityCheckThunk().retaggedCode<JSEntryPtrTag>();
-            jitCode = new DirectJITCode(constructRef, constructArityCheckRef, JITCode::InterpreterThunk, JITCode::ShareAttribute::Shared);
+            jitCode = new DirectJITCode(constructRef, constructArityCheckRef, JITType::InterpreterThunk, JITCode::ShareAttribute::Shared);
         });
 
@@ -77 +77 @@
         static std::once_flag onceKey;
         std::call_once(onceKey, [&] {
-            jitCode = new DirectJITCode(getCodeRef<JSEntryPtrTag>(llint_function_for_call_prologue), getCodePtr<JSEntryPtrTag>(llint_function_for_call_arity_check), JITCode::InterpreterThunk, JITCode::ShareAttribute::Shared);
+            jitCode = new DirectJITCode(getCodeRef<JSEntryPtrTag>(llint_function_for_call_prologue), getCodePtr<JSEntryPtrTag>(llint_function_for_call_arity_check), JITType::InterpreterThunk, JITCode::ShareAttribute::Shared);
         });
         codeBlock->setJITCode(makeRef(*jitCode));
@@ -84 +84 @@
         static std::once_flag onceKey;
         std::call_once(onceKey, [&] {
-            jitCode = new DirectJITCode(getCodeRef<JSEntryPtrTag>(llint_function_for_construct_prologue), getCodePtr<JSEntryPtrTag>(llint_function_for_construct_arity_check), JITCode::InterpreterThunk, JITCode::ShareAttribute::Shared);
+            jitCode = new DirectJITCode(getCodeRef<JSEntryPtrTag>(llint_function_for_construct_prologue), getCodePtr<JSEntryPtrTag>(llint_function_for_construct_arity_check), JITType::InterpreterThunk, JITCode::ShareAttribute::Shared);
         });
         codeBlock->setJITCode(makeRef(*jitCode));
@@ -98 +98 @@
         std::call_once(onceKey, [&] {
             MacroAssemblerCodeRef<JSEntryPtrTag> codeRef = evalEntryThunk().retagged<JSEntryPtrTag>();
-            jitCode = new NativeJITCode(codeRef, JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+            jitCode = new NativeJITCode(codeRef, JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
         });
         codeBlock->setJITCode(makeRef(*jitCode));
@@ -108 +108 @@
     static std::once_flag onceKey;
     std::call_once(onceKey, [&] {
-        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_eval_prologue), JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_eval_prologue), JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
     });
     codeBlock->setJITCode(makeRef(*jitCode));
@@ -121 +121 @@
         std::call_once(onceKey, [&] {
             MacroAssemblerCodeRef<JSEntryPtrTag> codeRef = programEntryThunk().retagged<JSEntryPtrTag>();
-            jitCode = new NativeJITCode(codeRef, JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+            jitCode = new NativeJITCode(codeRef, JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
         });
         codeBlock->setJITCode(makeRef(*jitCode));
@@ -131 +131 @@
     static std::once_flag onceKey;
     std::call_once(onceKey, [&] {
-        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_program_prologue), JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_program_prologue), JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
     });
     codeBlock->setJITCode(makeRef(*jitCode));
@@ -144 +144 @@
         std::call_once(onceKey, [&] {
             MacroAssemblerCodeRef<JSEntryPtrTag> codeRef = moduleProgramEntryThunk().retagged<JSEntryPtrTag>();
-            jitCode = new NativeJITCode(codeRef, JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+            jitCode = new NativeJITCode(codeRef, JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
         });
         codeBlock->setJITCode(makeRef(*jitCode));
@@ -154 +154 @@
     static std::once_flag onceKey;
     std::call_once(onceKey, [&] {
-        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_module_program_prologue), JITCode::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
+        jitCode = new NativeJITCode(getCodeRef<JSEntryPtrTag>(llint_module_program_prologue), JITType::InterpreterThunk, Intrinsic::NoIntrinsic, JITCode::ShareAttribute::Shared);
     });
     codeBlock->setJITCode(makeRef(*jitCode));

trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

@@ -384 +384 @@
     
     switch (codeBlock->jitType()) {
-    case JITCode::BaselineJIT: {
+    case JITType::BaselineJIT: {
         if (Options::verboseOSR())
             dataLogF("    Code was already compiled.\n");
@@ -390 +390 @@
         return true;
     }
-    case JITCode::InterpreterThunk: {
+    case JITType::InterpreterThunk: {
         JITWorklist::ensureGlobalWorklist().compileLater(codeBlock, loopOSREntryBytecodeOffset);
-        return codeBlock->jitType() == JITCode::BaselineJIT;
+        return codeBlock->jitType() == JITType::BaselineJIT;
     }
     default:
@@ -481 +481 @@
     CODEBLOCK_LOG_EVENT(codeBlock, "osrEntry", ("at bc#", loopOSREntryBytecodeOffset));
 
-    ASSERT(codeBlock->jitType() == JITCode::BaselineJIT);
+    ASSERT(codeBlock->jitType() == JITType::BaselineJIT);
 
     const JITCodeMap& codeMap = codeBlock->jitCodeMap();

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.cpp

@@ -591 +591 @@
                 // by ignoring it.
                 unsigned bytecodeIndex = 0;
-                if (topCodeBlock->jitType() == JITCode::InterpreterThunk || topCodeBlock->jitType() == JITCode::BaselineJIT) {
+                if (topCodeBlock->jitType() == JITType::InterpreterThunk || topCodeBlock->jitType() == JITType::BaselineJIT) {
                     bool isValidPC;
                     unsigned bits;

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.h

@@ -109 +109 @@
             unsigned bytecodeIndex { std::numeric_limits<unsigned>::max() };
             CodeBlockHash codeBlockHash;
-            JITCode::JITType jitType { JITCode::None };
+            JITType jitType { JITType::None };
         };
 

trunk/Source/JavaScriptCore/runtime/VM.cpp

@@ -690 +690 @@
     static std::once_flag onceKey;
     std::call_once(onceKey, [&] {
-        result = new NativeJITCode(LLInt::getCodeRef<JSEntryPtrTag>(llint_native_call_trampoline), JITCode::HostCallThunk, NoIntrinsic);
+        result = new NativeJITCode(LLInt::getCodeRef<JSEntryPtrTag>(llint_native_call_trampoline), JITType::HostCallThunk, NoIntrinsic);
     });
     return makeRef(*result);
@@ -700 +700 @@
     static std::once_flag onceKey;
     std::call_once(onceKey, [&] {
-        result = new NativeJITCode(LLInt::getCodeRef<JSEntryPtrTag>(llint_native_construct_trampoline), JITCode::HostCallThunk, NoIntrinsic);
+        result = new NativeJITCode(LLInt::getCodeRef<JSEntryPtrTag>(llint_native_construct_trampoline), JITType::HostCallThunk, NoIntrinsic);
     });
     return makeRef(*result);

trunk/Source/JavaScriptCore/tools/CodeProfile.cpp

@@ -83 +83 @@
         else {
             CodeBlock* codeBlock = static_cast<CodeBlock*>(ownerUID);
-            if (codeBlock->jitType() == JITCode::DFGJIT)
+            if (codeBlock->jitType() == JITType::DFGJIT)
                 type = DFGJIT;
             else if (!canCompile(codeBlock->capabilityLevelState()))

trunk/Source/JavaScriptCore/tools/JSDollarVM.cpp

@@ -1301 +1301 @@
     CallerFrameJITTypeFunctor()
         : m_currentFrame(0)
-        , m_jitType(JITCode::None)
+        , m_jitType(JITType::None)
     {
     }
@@ -1314 +1314 @@
     }
     
-    JITCode::JITType jitType() { return m_jitType; }
+    JITType jitType() { return m_jitType; }
 
 private:
     mutable unsigned m_currentFrame;
-    mutable JITCode::JITType m_jitType;
+    mutable JITType m_jitType;
 };
 
@@ -1345 +1345 @@
     CallerFrameJITTypeFunctor functor;
     exec->iterate(functor);
-    return JSValue::encode(jsBoolean(functor.jitType() == JITCode::InterpreterThunk));
+    return JSValue::encode(jsBoolean(functor.jitType() == JITType::InterpreterThunk));
 }
 
@@ -1356 +1356 @@
     CallerFrameJITTypeFunctor functor;
     exec->iterate(functor);
-    return JSValue::encode(jsBoolean(functor.jitType() == JITCode::BaselineJIT));
+    return JSValue::encode(jsBoolean(functor.jitType() == JITType::BaselineJIT));
 }