Attachment 368526 Details for Bug 197394 – patch

[patch] patch

a-backup.diff (text/plain), 74.98 KB, created by Saam Barati on 2019-04-29 18:35:46 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Saam Barati

Created: 2019-04-29 18:35:46 PDT

Size: 74.98 KB

patch

obsolete

>Index: Source/JavaScriptCore/ChangeLog
>===================================================================
>--- Source/JavaScriptCore/ChangeLog	(revision 244762)
>+++ Source/JavaScriptCore/ChangeLog	(working copy)
>@@ -1,3 +1,147 @@
>+2019-04-29  Saam Barati  <sbarati@apple.com>
>+
>+        Make JITType an enum class
>+        https://bugs.webkit.org/show_bug.cgi?id=197394
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        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>
> 
>         normalizeMapKey should normalize NaN to one PureNaN bit pattern to make MapHash same
>Index: Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/CallLinkStatus.cpp	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/CallLinkStatus.cpp	(working copy)
>@@ -342,7 +342,7 @@ CallLinkStatus CallLinkStatus::computeFo
>         // fast-path-slow-path control-flow-diamond style of IC inlining. It's either all fast
>         // 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) {
>             if (!context->isInlined(codeOrigin))
>Index: Source/JavaScriptCore/bytecode/CodeBlock.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/CodeBlock.cpp	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/CodeBlock.cpp	(working copy)
>@@ -180,7 +180,7 @@ CString CodeBlock::hashAsStringIfPossibl
>     return "<no-hash>";
> }
> 
>-void CodeBlock::dumpAssumingJITType(PrintStream& out, JITCode::JITType jitType) const
>+void CodeBlock::dumpAssumingJITType(PrintStream& out, JITType jitType) const
> {
>     out.print(inferredName(), "#", hashAsStringIfPossible());
>     out.print(":[", RawPointer(this), "->");
>@@ -191,7 +191,7 @@ void CodeBlock::dumpAssumingJITType(Prin
>     if (codeType() == FunctionCode)
>         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())
>         out.print(" (NeverInline)");
>@@ -205,9 +205,9 @@ void CodeBlock::dumpAssumingJITType(Prin
>         out.print(" (StrictMode)");
>     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("]");
> }
>@@ -929,7 +929,7 @@ void CodeBlock::setNumParameters(int new
> CodeBlock* CodeBlock::specialOSREntryBlockOrNull()
> {
> #if ENABLE(FTL_JIT)
>-    if (jitType() != JITCode::DFGJIT)
>+    if (jitType() != JITType::DFGJIT)
>         return 0;
>     DFG::JITCode* jitCode = m_jitCode->dfg();
>     return jitCode->osrEntryBlock();
>@@ -1002,17 +1002,17 @@ bool CodeBlock::shouldJettisonDueToWeakR
>     return !vm.heap.isMarked(this);
> }
> 
>-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:
>             return Seconds::infinity();
>@@ -1020,15 +1020,15 @@ static Seconds timeToLive(JITCode::JITTy
>     }
> 
>     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:
>         return Seconds::infinity();
>@@ -1068,7 +1068,7 @@ void CodeBlock::propagateTransitions(con
> 
>     VM& vm = *m_vm;
> 
>-    if (jitType() == JITCode::InterpreterThunk) {
>+    if (jitType() == JITType::InterpreterThunk) {
>         const Vector<InstructionStream::Offset>& propertyAccessInstructions = m_unlinkedCode->propertyAccessInstructions();
>         const InstructionStream& instructionStream = instructions();
>         for (size_t i = 0; i < propertyAccessInstructions.size(); ++i) {
>@@ -1630,7 +1630,7 @@ CodeBlock* CodeBlock::baselineAlternativ
>     while (result->alternative())
>         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
>     return this;
>@@ -1640,7 +1640,7 @@ CodeBlock* CodeBlock::baselineAlternativ
> CodeBlock* CodeBlock::baselineVersion()
> {
> #if ENABLE(JIT)
>-    JITCode::JITType selfJITType = jitType();
>+    JITType selfJITType = jitType();
>     if (JITCode::isBaselineCode(selfJITType))
>         return this;
>     CodeBlock* result = replacement();
>@@ -1654,7 +1654,7 @@ CodeBlock* CodeBlock::baselineVersion()
>         } else {
>             // 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;
>         }
>     }
>@@ -1667,7 +1667,7 @@ CodeBlock* CodeBlock::baselineVersion()
> }
> 
> #if ENABLE(JIT)
>-bool CodeBlock::hasOptimizedReplacement(JITCode::JITType typeToReplace)
>+bool CodeBlock::hasOptimizedReplacement(JITType typeToReplace)
> {
>     CodeBlock* replacement = this->replacement();
>     return replacement && JITCode::isHigherTier(replacement->jitType(), typeToReplace);
>@@ -2147,7 +2147,7 @@ void CodeBlock::noticeIncomingCall(ExecS
>         return;
>     }
> 
>-    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
>         // ensures that a function is SABI only if it is called no more frequently than
>@@ -2489,10 +2489,10 @@ void CodeBlock::forceOptimizationSlowPat
> #if ENABLE(DFG_JIT)
> 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));
>     }
>     
>     CodeBlock* replacement = this->replacement();
>@@ -2723,12 +2723,12 @@ bool CodeBlock::shouldOptimizeNow()
> void CodeBlock::tallyFrequentExitSites()
> {
>     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)
>             exit.considerAddingAsFrequentExitSite(profiledBlock);
>@@ -2736,7 +2736,7 @@ void CodeBlock::tallyFrequentExitSites()
>     }
> 
> #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
>         // DFG::JITCode::osrExit.
>@@ -2824,17 +2824,17 @@ void CodeBlock::dumpValueProfiles()
> unsigned CodeBlock::frameRegisterCount()
> {
>     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)
>         
>@@ -3175,15 +3175,15 @@ Optional<CodeOrigin> CodeBlock::findPC(v
> Optional<unsigned> CodeBlock::bytecodeOffsetFromCallSiteIndex(CallSiteIndex callSiteIndex)
> {
>     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();
> #else
>         Instruction* instruction = bitwise_cast<Instruction*>(callSiteIndex.bits());
>         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));
>         CodeOrigin origin = codeOrigin(callSiteIndex);
>Index: Source/JavaScriptCore/bytecode/CodeBlock.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/CodeBlock.h	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/CodeBlock.h	(working copy)
>@@ -142,7 +142,7 @@ public:
>     CString hashAsStringIfPossible() const;
>     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;
> 
>     int numParameters() const { return m_numParameters; }
>@@ -402,18 +402,18 @@ public:
> 
>     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;
>     }
> 
>     bool hasBaselineJITProfiling() const
>     {
>-        return jitType() == JITCode::BaselineJIT;
>+        return jitType() == JITType::BaselineJIT;
>     }
>     
> #if ENABLE(JIT)
>@@ -423,7 +423,7 @@ public:
>     DFG::CapabilityLevel capabilityLevel();
>     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
> 
>Index: Source/JavaScriptCore/bytecode/CodeBlockWithJITType.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/CodeBlockWithJITType.h	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/CodeBlockWithJITType.h	(working copy)
>@@ -34,7 +34,7 @@ namespace JSC {
> 
> class CodeBlockWithJITType {
> public:
>-    CodeBlockWithJITType(CodeBlock* codeBlock, JITCode::JITType jitType)
>+    CodeBlockWithJITType(CodeBlock* codeBlock, JITType jitType)
>         : m_codeBlock(codeBlock)
>         , m_jitType(jitType)
>     {
>@@ -46,7 +46,7 @@ public:
>     }
> private:
>     CodeBlock* m_codeBlock;
>-    JITCode::JITType m_jitType;
>+    JITType m_jitType;
> };
> 
> } // namespace JSC
>Index: Source/JavaScriptCore/bytecode/DeferredSourceDump.cpp
>===================================================================
>--- Source/JavaScriptCore/bytecode/DeferredSourceDump.cpp	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/DeferredSourceDump.cpp	(working copy)
>@@ -34,11 +34,11 @@ namespace JSC {
> 
> 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)
>     , m_rootJITType(rootJITType)
>Index: Source/JavaScriptCore/bytecode/DeferredSourceDump.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/DeferredSourceDump.h	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/DeferredSourceDump.h	(working copy)
>@@ -35,14 +35,14 @@ class CodeBlock;
> class DeferredSourceDump {
> public:
>     DeferredSourceDump(CodeBlock*);
>-    DeferredSourceDump(CodeBlock*, CodeBlock* rootCodeBlock, JITCode::JITType rootJITType, unsigned callerBytecodeIndex);
>+    DeferredSourceDump(CodeBlock*, CodeBlock* rootCodeBlock, JITType rootJITType, unsigned callerBytecodeIndex);
> 
>     void dump();
> 
> private:
>     Strong<CodeBlock> m_codeBlock;
>     Strong<CodeBlock> m_rootCodeBlock;
>-    JITCode::JITType m_rootJITType;
>+    JITType m_rootJITType;
>     unsigned m_callerBytecodeIndex { UINT_MAX };
> };
> 
>Index: Source/JavaScriptCore/bytecode/ExitingJITType.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/ExitingJITType.h	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/ExitingJITType.h	(working copy)
>@@ -35,12 +35,12 @@ enum ExitingJITType : uint8_t {
>     ExitFromFTL
> };
> 
>-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:
>         RELEASE_ASSERT_NOT_REACHED();
>Index: Source/JavaScriptCore/bytecode/InlineCallFrame.h
>===================================================================
>--- Source/JavaScriptCore/bytecode/InlineCallFrame.h	(revision 244761)
>+++ Source/JavaScriptCore/bytecode/InlineCallFrame.h	(working copy)
>@@ -240,7 +240,7 @@ inline CodeBlock* baselineCodeBlockForIn
> 
> inline CodeBlock* baselineCodeBlockForOriginAndBaselineCodeBlock(const CodeOrigin& codeOrigin, CodeBlock* baselineCodeBlock)
> {
>-    ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
>+    ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
>     auto* inlineCallFrame = codeOrigin.inlineCallFrame();
>     if (inlineCallFrame)
>         return baselineCodeBlockForInlineCallFrame(inlineCallFrame);
>Index: Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp	(working copy)
>@@ -7094,7 +7094,7 @@ void ByteCodeParser::parseCodeBlock()
>     if (UNLIKELY(Options::dumpSourceAtDFGTime())) {
>         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
>             deferredSourceDump.append(DeferredSourceDump(codeBlock->baselineVersion()));
>@@ -7104,7 +7104,7 @@ void ByteCodeParser::parseCodeBlock()
>         dataLog("Parsing ", *codeBlock);
>         if (inlineCallFrame()) {
>             dataLog(
>-                " for inlining at ", CodeBlockWithJITType(m_codeBlock, JITCode::DFGJIT),
>+                " for inlining at ", CodeBlockWithJITType(m_codeBlock, JITType::DFGJIT),
>                 " ", inlineCallFrame()->directCaller);
>         }
>         dataLog(
>Index: Source/JavaScriptCore/dfg/DFGDisassembler.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGDisassembler.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGDisassembler.cpp	(working copy)
>@@ -74,7 +74,7 @@ void Disassembler::reportToProfiler(Prof
> 
> 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");
> }
>Index: Source/JavaScriptCore/dfg/DFGDriver.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGDriver.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGDriver.cpp	(working copy)
>@@ -81,8 +81,8 @@ static CompilationResult compileImpl(
>     
>     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))
>         dataLog("DFG(Driver) compiling ", *codeBlock, " with ", mode, ", number of instructions = ", codeBlock->instructionCount(), "\n");
>Index: Source/JavaScriptCore/dfg/DFGGraph.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGGraph.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGGraph.cpp	(working copy)
>@@ -525,7 +525,7 @@ void Graph::dump(PrintStream& out, DumpC
>         context = &myContext;
>     
>     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) {
>         for (unsigned entrypointIndex = 0; entrypointIndex < m_argumentFormats.size(); ++entrypointIndex)
>Index: Source/JavaScriptCore/dfg/DFGJITCode.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGJITCode.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGJITCode.cpp	(working copy)
>@@ -36,7 +36,7 @@
> namespace JSC { namespace DFG {
> 
> JITCode::JITCode()
>-    : DirectJITCode(DFGJIT)
>+    : DirectJITCode(JITType::DFGJIT)
> #if ENABLE(FTL_JIT)
>     , osrEntryRetry(0)
>     , abandonOSREntry(false)
>@@ -123,13 +123,13 @@ RegisterSet JITCode::liveRegistersToPres
> #if ENABLE(FTL_JIT)
> bool JITCode::checkIfOptimizationThresholdReached(CodeBlock* codeBlock)
> {
>-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
>+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
>     return tierUpCounter.checkIfThresholdCrossedAndSet(codeBlock);
> }
> 
> 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");
>     tierUpCounter.setNewThreshold(0, codeBlock);
>@@ -137,7 +137,7 @@ void JITCode::optimizeNextInvocation(Cod
> 
> 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");
>     tierUpCounter.deferIndefinitely();
>@@ -145,7 +145,7 @@ void JITCode::dontOptimizeAnytimeSoon(Co
> 
> 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");
>     CodeBlock* baseline = codeBlock->baselineVersion();
>@@ -156,7 +156,7 @@ void JITCode::optimizeAfterWarmUp(CodeBl
> 
> void JITCode::optimizeSoon(CodeBlock* codeBlock)
> {
>-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
>+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
>     if (Options::verboseOSR())
>         dataLog(*codeBlock, ": FTL-optimizing soon.\n");
>     CodeBlock* baseline = codeBlock->baselineVersion();
>@@ -167,7 +167,7 @@ void JITCode::optimizeSoon(CodeBlock* co
> 
> 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");
>     tierUpCounter.forceSlowPathConcurrently();
>@@ -176,7 +176,7 @@ void JITCode::forceOptimizationSlowPathC
> void JITCode::setOptimizationThresholdBasedOnCompilationResult(
>     CodeBlock* codeBlock, CompilationResult result)
> {
>-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
>+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
>     switch (result) {
>     case CompilationSuccessful:
>         optimizeNextInvocation(codeBlock);
>Index: Source/JavaScriptCore/dfg/DFGJITFinalizer.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGJITFinalizer.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGJITFinalizer.cpp	(working copy)
>@@ -56,7 +56,7 @@ size_t JITFinalizer::codeSize()
> 
> 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());
> 
>     m_plan.codeBlock()->setJITCode(m_jitCode.copyRef());
>@@ -70,7 +70,7 @@ bool JITFinalizer::finalizeFunction()
> {
>     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());
> 
>Index: Source/JavaScriptCore/dfg/DFGOSREntry.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOSREntry.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGOSREntry.cpp	(working copy)
>@@ -96,7 +96,7 @@ void* prepareOSREntry(ExecState* exec, C
> {
>     ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));
>     ASSERT(codeBlock->alternative());
>-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
>+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
>     ASSERT(!codeBlock->jitCodeMap());
> 
>     if (!Options::useOSREntryToDFG())
>@@ -115,8 +115,8 @@ void* prepareOSREntry(ExecState* exec, C
>     if (bytecodeIndex)
>         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:
>         //
>@@ -341,11 +341,11 @@ void* prepareOSREntry(ExecState* exec, C
> 
> MacroAssemblerCodePtr<ExceptionHandlerPtrTag> prepareCatchOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
> { 
>-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT || codeBlock->jitType() == JITCode::FTLJIT);
>+    ASSERT(codeBlock->jitType() == JITType::DFGJIT || codeBlock->jitType() == JITType::FTLJIT);
> 
>-    if (!Options::useOSREntryToDFG() && codeBlock->jitCode()->jitType() == JITCode::DFGJIT)
>+    if (!Options::useOSREntryToDFG() && codeBlock->jitCode()->jitType() == JITType::DFGJIT)
>         return nullptr;
>-    if (!Options::useOSREntryToFTL() && codeBlock->jitCode()->jitType() == JITCode::FTLJIT)
>+    if (!Options::useOSREntryToFTL() && codeBlock->jitCode()->jitType() == JITType::FTLJIT)
>         return nullptr;
> 
>     VM& vm = exec->vm();
>Index: Source/JavaScriptCore/dfg/DFGOSRExit.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOSRExit.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGOSRExit.cpp	(working copy)
>@@ -351,7 +351,7 @@ void OSRExit::executeOSRExit(Context& co
> 
>     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
>     // really be profitable.
>@@ -375,7 +375,7 @@ void OSRExit::executeOSRExit(Context& co
>         prepareCodeOriginForOSRExit(exec, exit.m_codeOrigin);
> 
>         CodeBlock* baselineCodeBlock = codeBlock->baselineAlternative();
>-        ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
>+        ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
> 
>         SpeculationRecovery* recovery = nullptr;
>         if (exit.m_recoveryIndex != UINT_MAX) {
>@@ -445,7 +445,7 @@ void OSRExit::executeOSRExit(Context& co
> 
>     OSRExitState& exitState = *exit.exitState.get();
>     CodeBlock* baselineCodeBlock = exitState.baselineCodeBlock;
>-    ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
>+    ASSERT(baselineCodeBlock->jitType() == JITType::BaselineJIT);
> 
>     Operands<ValueRecovery>& operands = exitState.operands;
>     Vector<UndefinedOperandSpan>& undefinedOperandSpans = exitState.undefinedOperandSpans;
>@@ -752,7 +752,7 @@ static void reifyInlinedCallFrames(Conte
>     // FIXME: We shouldn't leave holes on the stack when performing an OSR exit
>     // 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);
> 
>     const CodeOrigin* codeOrigin;
>@@ -1035,7 +1035,7 @@ void JIT_OPERATION OSRExit::compileOSREx
> 
>     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
>     // really be profitable.
>Index: Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp	(working copy)
>@@ -116,10 +116,10 @@ void handleExitCounts(CCallHelpers& jit,
>         activeThreshold, jit.baselineCodeBlock());
>     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;
>     default:
>@@ -141,7 +141,7 @@ void reifyInlinedCallFrames(CCallHelpers
>     // FIXME: We shouldn't leave holes on the stack when performing an OSR exit
>     // 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));
> 
>     const CodeOrigin* codeOrigin;
>@@ -310,7 +310,7 @@ void adjustAndJumpToTarget(VM& vm, CCall
> 
>     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);
> 
>Index: Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h	(working copy)
>@@ -41,11 +41,11 @@ void reifyInlinedCallFrames(CCallHelpers
> void adjustAndJumpToTarget(VM&, CCallHelpers&, const OSRExitBase&);
> 
> 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);
>     if (isFTLOSRExit) {
>Index: Source/JavaScriptCore/dfg/DFGOperations.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGOperations.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGOperations.cpp	(working copy)
>@@ -3167,7 +3167,7 @@ void JIT_OPERATION triggerTierUpNow(Exec
>     
>     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();
>     }
>@@ -3433,7 +3433,7 @@ void JIT_OPERATION triggerTierUpNowInLoo
> 
>     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();
>     }
>@@ -3467,7 +3467,7 @@ char* JIT_OPERATION triggerOSREntryNow(E
> 
>     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();
>     }
>Index: Source/JavaScriptCore/dfg/DFGThunks.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGThunks.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGThunks.cpp	(working copy)
>@@ -53,7 +53,7 @@ MacroAssemblerCodeRef<JITThunkPtrTag> os
>     MacroAssembler jit;
> 
>     // 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);
>     ScratchBuffer* scratchBuffer = vm->scratchBufferForSize(scratchSize);
>Index: Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp
>===================================================================
>--- Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp	(revision 244761)
>+++ Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp	(working copy)
>@@ -119,7 +119,7 @@ unsigned VariableEventStream::reconstruc
>     CodeBlock* codeBlock, CodeOrigin codeOrigin, MinifiedGraph& graph,
>     unsigned index, Operands<ValueRecovery>& valueRecoveries, Vector<UndefinedOperandSpan>* undefinedOperandSpans) const
> {
>-    ASSERT(codeBlock->jitType() == JITCode::DFGJIT);
>+    ASSERT(codeBlock->jitType() == JITType::DFGJIT);
>     CodeBlock* baselineCodeBlock = codeBlock->baselineVersion();
> 
>     unsigned numVariables;
>Index: Source/JavaScriptCore/ftl/FTLCompile.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLCompile.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLCompile.cpp	(working copy)
>@@ -79,7 +79,7 @@ void compile(State& state, Safepoint::Re
>     std::unique_ptr<RegisterAtOffsetList> registerOffsets =
>         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)));
>     state.jitCode->common.frameRegisterCount = state.proc->frameSize() / sizeof(EncodedJSValue);
>@@ -168,7 +168,7 @@ void compile(State& state, Safepoint::Re
>     if (B3::Air::Disassembler* disassembler = state.proc->code().disassembler()) {
>         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;
>         B3::Value* currentB3Value = nullptr;
>Index: Source/JavaScriptCore/ftl/FTLJITCode.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLJITCode.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLJITCode.cpp	(working copy)
>@@ -36,7 +36,7 @@ namespace JSC { namespace FTL {
> using namespace B3;
> 
> JITCode::JITCode()
>-    : JSC::JITCode(FTLJIT)
>+    : JSC::JITCode(JITType::FTLJIT)
> {
> }
> 
>Index: Source/JavaScriptCore/ftl/FTLJITFinalizer.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLJITFinalizer.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLJITFinalizer.cpp	(working copy)
>@@ -75,11 +75,11 @@ bool JITFinalizer::finalizeCommon()
>     
>     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());
> 
>     jitCode->initializeB3Code(b3CodeRef);
>Index: Source/JavaScriptCore/ftl/FTLLink.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLLink.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLLink.cpp	(working copy)
>@@ -71,7 +71,7 @@ void link(State& state)
>     if (UNLIKELY(compilation)) {
>         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();
>         graph.ensureSSANaturalLoops();
>Index: Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp	(working copy)
>@@ -506,7 +506,7 @@ extern "C" void* compileFTLOSRExit(ExecS
>     CodeBlock* codeBlock = exec->codeBlock();
>     
>     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
>     // really be profitable.
>Index: Source/JavaScriptCore/ftl/FTLThunks.cpp
>===================================================================
>--- Source/JavaScriptCore/ftl/FTLThunks.cpp	(revision 244761)
>+++ Source/JavaScriptCore/ftl/FTLThunks.cpp	(working copy)
>@@ -53,7 +53,7 @@ static MacroAssemblerCodeRef<JITThunkPtr
> 
>     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);
>     }
>     
>     // Note that the "return address" will be the ID that we pass to the generation function.
>Index: Source/JavaScriptCore/interpreter/CallFrame.cpp
>===================================================================
>--- Source/JavaScriptCore/interpreter/CallFrame.cpp	(revision 244761)
>+++ Source/JavaScriptCore/interpreter/CallFrame.cpp	(working copy)
>@@ -52,11 +52,11 @@ bool CallFrame::callSiteBitsAreBytecodeO
> {
>     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;
>     default:
>@@ -71,11 +71,11 @@ bool CallFrame::callSiteBitsAreCodeOrigi
> {
>     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;
>     default:
>Index: Source/JavaScriptCore/interpreter/StackVisitor.cpp
>===================================================================
>--- Source/JavaScriptCore/interpreter/StackVisitor.cpp	(revision 244761)
>+++ Source/JavaScriptCore/interpreter/StackVisitor.cpp	(working copy)
>@@ -492,8 +492,8 @@ void StackVisitor::Frame::dump(PrintStre
>                     CallSiteIndex callSiteIndex = callFrame->callSiteIndex();
>                     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),
>                             " start ", RawPointer(jitCode->start()),
>Index: Source/JavaScriptCore/jit/AssemblyHelpers.h
>===================================================================
>--- Source/JavaScriptCore/jit/AssemblyHelpers.h	(revision 244761)
>+++ Source/JavaScriptCore/jit/AssemblyHelpers.h	(working copy)
>@@ -57,7 +57,7 @@ public:
>         if (m_codeBlock) {
>             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()));
>         }
>     }
> 
>Index: Source/JavaScriptCore/jit/JIT.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JIT.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JIT.cpp	(working copy)
>@@ -903,7 +903,7 @@ CompilationResult JIT::link()
>     
>     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(
>         static_cast<double>(result.size()) /
>@@ -911,7 +911,7 @@ CompilationResult JIT::link()
> 
>     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)
>         dataLogF("JIT generated code for %p at [%p, %p).\n", m_codeBlock, result.executableMemory()->start().untaggedPtr(), result.executableMemory()->end().untaggedPtr());
>Index: Source/JavaScriptCore/jit/JITCode.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITCode.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITCode.cpp	(working copy)
>@@ -45,17 +45,17 @@ JITCode::~JITCode()
> const char* JITCode::typeName(JITType jitType)
> {
>     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:
>         CRASH();
>@@ -241,7 +241,7 @@ RegisterSet JITCode::liveRegistersToPres
> 
> namespace WTF {
> 
>-void printInternal(PrintStream& out, JSC::JITCode::JITType type)
>+void printInternal(PrintStream& out, JSC::JITType type)
> {
>     out.print(JSC::JITCode::typeName(type));
> }
>Index: Source/JavaScriptCore/jit/JITCode.h
>===================================================================
>--- Source/JavaScriptCore/jit/JITCode.h	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITCode.h	(working copy)
>@@ -51,50 +51,50 @@ struct ProtoCallFrame;
> class TrackedReferences;
> class VM;
> 
>+enum class JITType : uint8_t {
>+    None,
>+    HostCallThunk,
>+    InterpreterThunk,
>+    BaselineJIT,
>+    DFGJIT,
>+    FTLJIT
>+};
>+
> class JITCode : public ThreadSafeRefCounted<JITCode> {
> public:
>     template<PtrTag tag> using CodePtr = MacroAssemblerCodePtr<tag>;
>     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;
>     }
>     
>     static JITType nextTierJIT(JITType jitType)
>     {
>         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;
>         }
>     }
>     
>     static bool isExecutableScript(JITType jitType)
>     {
>         switch (jitType) {
>-        case None:
>-        case HostCallThunk:
>+        case JITType::None:
>+        case JITType::HostCallThunk:
>             return false;
>         default:
>             return true;
>@@ -104,8 +104,8 @@ public:
>     static bool couldBeInterpreted(JITType jitType)
>     {
>         switch (jitType) {
>-        case InterpreterThunk:
>-        case BaselineJIT:
>+        case JITType::InterpreterThunk:
>+        case JITType::BaselineJIT:
>             return true;
>         default:
>             return false;
>@@ -115,9 +115,9 @@ public:
>     static bool isJIT(JITType jitType)
>     {
>         switch (jitType) {
>-        case BaselineJIT:
>-        case DFGJIT:
>-        case FTLJIT:
>+        case JITType::BaselineJIT:
>+        case JITType::DFGJIT:
>+        case JITType::FTLJIT:
>             return true;
>         default:
>             return false;
>@@ -148,12 +148,12 @@ public:
>     
>     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;
>     }
> 
>     virtual const DOMJIT::Signature* signature() const { return nullptr; }
>@@ -178,7 +178,7 @@ public:
>     static JITType jitTypeFor(PointerType jitCode)
>     {
>         if (!jitCode)
>-            return None;
>+            return JITType::None;
>         return jitCode->jitType();
>     }
>     
>@@ -278,6 +278,6 @@ private:
> namespace WTF {
> 
> class PrintStream;
>-void printInternal(PrintStream&, JSC::JITCode::JITType);
>+void printInternal(PrintStream&, JSC::JITType);
> 
> } // namespace WTF
>Index: Source/JavaScriptCore/jit/JITDisassembler.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITDisassembler.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITDisassembler.cpp	(working copy)
>@@ -89,7 +89,7 @@ void JITDisassembler::reportToProfiler(P
> 
> 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");
> }
>Index: Source/JavaScriptCore/jit/JITOperations.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITOperations.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITOperations.cpp	(working copy)
>@@ -1427,7 +1427,7 @@ SlowPathReturnType JIT_OPERATION operati
>     DeferGCForAWhile deferGC(vm.heap);
>     
>     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();
>     }
>@@ -1660,8 +1660,8 @@ char* JIT_OPERATION operationTryOSREnter
>         return nullptr;
> 
>     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*>();
>     }
>@@ -1682,8 +1682,8 @@ char* JIT_OPERATION operationTryOSREnter
>         return nullptr;
> 
>     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*>();
>     }
>Index: Source/JavaScriptCore/jit/JITThunks.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITThunks.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITThunks.cpp	(working copy)
>@@ -124,13 +124,13 @@ NativeExecutable* JITThunks::hostFunctio
>     RefPtr<JITCode> forCall;
>     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);
>     weakAdd(*m_hostFunctionStubMap, std::make_tuple(function, constructor, name), Weak<NativeExecutable>(nativeExecutable, this));
>Index: Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp	(working copy)
>@@ -45,7 +45,7 @@ void JITToDFGDeferredCompilationCallback
>     CodeBlock* codeBlock, CodeBlock* profiledDFGCodeBlock)
> {
>     ASSERT_UNUSED(profiledDFGCodeBlock, !profiledDFGCodeBlock);
>-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
>+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
>     
>     if (Options::verboseOSR())
>         dataLog("Optimizing compilation of ", *codeBlock, " did become ready.\n");
>@@ -57,7 +57,7 @@ void JITToDFGDeferredCompilationCallback
>     CodeBlock* codeBlock, CodeBlock* profiledDFGCodeBlock, CompilationResult result)
> {
>     ASSERT(!profiledDFGCodeBlock);
>-    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
>+    ASSERT(codeBlock->alternative()->jitType() == JITType::BaselineJIT);
>     
>     if (Options::verboseOSR())
>         dataLog("Optimizing compilation of ", *codeBlock, " result: ", result, "\n");
>Index: Source/JavaScriptCore/jit/JITWorklist.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/JITWorklist.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/JITWorklist.cpp	(working copy)
>@@ -231,7 +231,7 @@ void JITWorklist::poll(VM& vm)
> void JITWorklist::compileLater(CodeBlock* codeBlock, unsigned loopOSREntryBytecodeOffset)
> {
>     DeferGC deferGC(codeBlock->vm()->heap);
>-    RELEASE_ASSERT(codeBlock->jitType() == JITCode::InterpreterThunk);
>+    RELEASE_ASSERT(codeBlock->jitType() == JITType::InterpreterThunk);
>     
>     if (codeBlock->m_didFailJITCompilation) {
>         codeBlock->dontJITAnytimeSoon();
>@@ -284,7 +284,7 @@ void JITWorklist::compileNow(CodeBlock* 
> {
>     VM* vm = codeBlock->vm();
>     DeferGC deferGC(vm->heap);
>-    if (codeBlock->jitType() != JITCode::InterpreterThunk)
>+    if (codeBlock->jitType() != JITType::InterpreterThunk)
>         return;
>     
>     bool isPlanned;
>@@ -300,7 +300,7 @@ void JITWorklist::compileNow(CodeBlock* 
>     }
>     
>     // Now it might be compiled!
>-    if (codeBlock->jitType() != JITCode::InterpreterThunk)
>+    if (codeBlock->jitType() != JITType::InterpreterThunk)
>         return;
>     
>     // We do this in case we had previously attempted, and then failed, to compile with the
>Index: Source/JavaScriptCore/jit/Repatch.cpp
>===================================================================
>--- Source/JavaScriptCore/jit/Repatch.cpp	(revision 244761)
>+++ Source/JavaScriptCore/jit/Repatch.cpp	(working copy)
>@@ -72,7 +72,7 @@ static FunctionPtr<CFunctionPtrTag> read
> {
>     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>();
>     }
>@@ -85,7 +85,7 @@ static FunctionPtr<CFunctionPtrTag> read
> void ftlThunkAwareRepatchCall(CodeBlock* codeBlock, CodeLocationCall<JSInternalPtrTag> call, FunctionPtr<CFunctionPtrTag> newCalleeFunction)
> {
> #if ENABLE(FTL_JIT)
>-    if (codeBlock->jitType() == JITCode::FTLJIT) {
>+    if (codeBlock->jitType() == JITType::FTLJIT) {
>         VM& vm = *codeBlock->vm();
>         FTL::Thunks& thunks = *vm.ftlThunks;
>         FunctionPtr<OperationPtrTag> target = MacroAssembler::readCallTarget<OperationPtrTag>(call);
>Index: Source/JavaScriptCore/llint/LLIntEntrypoint.cpp
>===================================================================
>--- Source/JavaScriptCore/llint/LLIntEntrypoint.cpp	(revision 244761)
>+++ Source/JavaScriptCore/llint/LLIntEntrypoint.cpp	(working copy)
>@@ -51,7 +51,7 @@ static void setFunctionEntrypoint(CodeBl
>             std::call_once(onceKey, [&] {
>                 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);
>             });
> 
>             codeBlock->setJITCode(makeRef(*jitCode));
>@@ -64,7 +64,7 @@ static void setFunctionEntrypoint(CodeBl
>         std::call_once(onceKey, [&] {
>             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);
>         });
> 
>         codeBlock->setJITCode(makeRef(*jitCode));
>@@ -76,14 +76,14 @@ static void setFunctionEntrypoint(CodeBl
>         static DirectJITCode* jitCode;
>         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));
>     } else {
>         static DirectJITCode* jitCode;
>         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));
>     }
>@@ -97,7 +97,7 @@ static void setEvalEntrypoint(CodeBlock*
>         static std::once_flag onceKey;
>         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));
>         return;
>@@ -107,7 +107,7 @@ static void setEvalEntrypoint(CodeBlock*
>     static NativeJITCode* jitCode;
>     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));
> }
>@@ -120,7 +120,7 @@ static void setProgramEntrypoint(CodeBlo
>         static std::once_flag onceKey;
>         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));
>         return;
>@@ -130,7 +130,7 @@ static void setProgramEntrypoint(CodeBlo
>     static NativeJITCode* jitCode;
>     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));
> }
>@@ -143,7 +143,7 @@ static void setModuleProgramEntrypoint(C
>         static std::once_flag onceKey;
>         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));
>         return;
>@@ -153,7 +153,7 @@ static void setModuleProgramEntrypoint(C
>     static NativeJITCode* jitCode;
>     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));
> }
>Index: Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
>===================================================================
>--- Source/JavaScriptCore/llint/LLIntSlowPaths.cpp	(revision 244761)
>+++ Source/JavaScriptCore/llint/LLIntSlowPaths.cpp	(working copy)
>@@ -383,15 +383,15 @@ inline bool jitCompileAndSetHeuristics(C
>     JITWorklist::ensureGlobalWorklist().poll(vm);
>     
>     switch (codeBlock->jitType()) {
>-    case JITCode::BaselineJIT: {
>+    case JITType::BaselineJIT: {
>         if (Options::verboseOSR())
>             dataLogF("    Code was already compiled.\n");
>         codeBlock->jitSoon();
>         return true;
>     }
>-    case JITCode::InterpreterThunk: {
>+    case JITType::InterpreterThunk: {
>         JITWorklist::ensureGlobalWorklist().compileLater(codeBlock, loopOSREntryBytecodeOffset);
>-        return codeBlock->jitType() == JITCode::BaselineJIT;
>+        return codeBlock->jitType() == JITType::BaselineJIT;
>     }
>     default:
>         dataLog("Unexpected code block in LLInt: ", *codeBlock, "\n");
>@@ -480,7 +480,7 @@ LLINT_SLOW_PATH_DECL(loop_osr)
>     
>     CODEBLOCK_LOG_EVENT(codeBlock, "osrEntry", ("at bc#", loopOSREntryBytecodeOffset));
> 
>-    ASSERT(codeBlock->jitType() == JITCode::BaselineJIT);
>+    ASSERT(codeBlock->jitType() == JITType::BaselineJIT);
> 
>     const JITCodeMap& codeMap = codeBlock->jitCodeMap();
>     CodeLocationLabel<JSEntryPtrTag> codeLocation = codeMap.find(loopOSREntryBytecodeOffset);
>Index: Source/JavaScriptCore/runtime/SamplingProfiler.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/SamplingProfiler.cpp	(revision 244761)
>+++ Source/JavaScriptCore/runtime/SamplingProfiler.cpp	(working copy)
>@@ -590,7 +590,7 @@ void SamplingProfiler::processUnverified
>                 // inside the LLInt's handleUncaughtException. So we just protect against this
>                 // 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;
> #if USE(JSVALUE64)
>Index: Source/JavaScriptCore/runtime/SamplingProfiler.h
>===================================================================
>--- Source/JavaScriptCore/runtime/SamplingProfiler.h	(revision 244761)
>+++ Source/JavaScriptCore/runtime/SamplingProfiler.h	(working copy)
>@@ -108,7 +108,7 @@ public:
>             unsigned columnNumber { std::numeric_limits<unsigned>::max() };
>             unsigned bytecodeIndex { std::numeric_limits<unsigned>::max() };
>             CodeBlockHash codeBlockHash;
>-            JITCode::JITType jitType { JITCode::None };
>+            JITType jitType { JITType::None };
>         };
> 
>         CodeLocation semanticLocation;
>Index: Source/JavaScriptCore/runtime/VM.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/VM.cpp	(revision 244761)
>+++ Source/JavaScriptCore/runtime/VM.cpp	(working copy)
>@@ -689,7 +689,7 @@ static Ref<NativeJITCode> jitCodeForCall
>     static NativeJITCode* result;
>     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);
> }
>@@ -699,7 +699,7 @@ static Ref<NativeJITCode> jitCodeForCons
>     static NativeJITCode* result;
>     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);
> }
>Index: Source/JavaScriptCore/tools/CodeProfile.cpp
>===================================================================
>--- Source/JavaScriptCore/tools/CodeProfile.cpp	(revision 244761)
>+++ Source/JavaScriptCore/tools/CodeProfile.cpp	(working copy)
>@@ -82,7 +82,7 @@ void CodeProfile::sample(void* pc, void*
>             type = RegExpCode;
>         else {
>             CodeBlock* codeBlock = static_cast<CodeBlock*>(ownerUID);
>-            if (codeBlock->jitType() == JITCode::DFGJIT)
>+            if (codeBlock->jitType() == JITType::DFGJIT)
>                 type = DFGJIT;
>             else if (!canCompile(codeBlock->capabilityLevelState()))
>                 type = BaselineOnly;
>Index: Source/JavaScriptCore/tools/JSDollarVM.cpp
>===================================================================
>--- Source/JavaScriptCore/tools/JSDollarVM.cpp	(revision 244761)
>+++ Source/JavaScriptCore/tools/JSDollarVM.cpp	(working copy)
>@@ -1300,7 +1300,7 @@ class CallerFrameJITTypeFunctor {
> public:
>     CallerFrameJITTypeFunctor()
>         : m_currentFrame(0)
>-        , m_jitType(JITCode::None)
>+        , m_jitType(JITType::None)
>     {
>     }
> 
>@@ -1313,11 +1313,11 @@ public:
>         return StackVisitor::Continue;
>     }
>     
>-    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;
> };
> 
> static FunctionExecutable* getExecutableForFunction(JSValue theFunctionValue)
>@@ -1344,7 +1344,7 @@ static EncodedJSValue JSC_HOST_CALL func
>         return JSValue::encode(jsUndefined());
>     CallerFrameJITTypeFunctor functor;
>     exec->iterate(functor);
>-    return JSValue::encode(jsBoolean(functor.jitType() == JITCode::InterpreterThunk));
>+    return JSValue::encode(jsBoolean(functor.jitType() == JITType::InterpreterThunk));
> }
> 
> // Returns true if the current frame is a baseline JIT frame.
>@@ -1355,7 +1355,7 @@ static EncodedJSValue JSC_HOST_CALL func
>         return JSValue::encode(jsUndefined());
>     CallerFrameJITTypeFunctor functor;
>     exec->iterate(functor);
>-    return JSValue::encode(jsBoolean(functor.jitType() == JITCode::BaselineJIT));
>+    return JSValue::encode(jsBoolean(functor.jitType() == JITType::BaselineJIT));
> }
> 
> // Set that the argument function should not be inlined.

Actions: View | Formatted Diff | Diff

Attachments on bug 197394: 368526