Changeset 153147 in webkit for trunk/Source/JavaScriptCore/jit/JITDriver.h

Timestamp:

Jul 24, 2013, 8:59:47 PM (12 years ago)

Author:

[email protected]

Message:

fourthTier: CodeBlock should be RefCounted
​https://bugs.webkit.org/show_bug.cgi?id=115594

Reviewed by Geoffrey Garen.

This makes it possible to have the currently-being-compiled CodeBlock not be
installed in Executable, while also allowing it to point to its intended
alternative(). So long as we were using ownership and not reference counting, it
would have been difficult to have both CodeBlock::m_alternative and
Executable::m_codeBlockForBlah point to the previous CodeBlock.

I also took the opportunity to clean up a bunch of code that appears to have
rotted.

• assembler/MacroAssemblerCodeRef.h:

(MacroAssemblerCodePtr):
(JSC::MacroAssemblerCodePtr::operator==):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::releaseAlternative):
(JSC::CodeBlock::setAlternative):
(CodeBlock):
(JSC::GlobalCodeBlock::GlobalCodeBlock):
(JSC::ProgramCodeBlock::ProgramCodeBlock):
(JSC::EvalCodeBlock::EvalCodeBlock):
(JSC::FunctionCodeBlock::FunctionCodeBlock):

• heap/DFGCodeBlocks.cpp:

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

• heap/DFGCodeBlocks.h:

(DFGCodeBlocks):

• heap/Heap.cpp:

(JSC::Heap::jettisonDFGCodeBlock):

• heap/Heap.h:
• jit/JITDriver.h:

(JSC::jitCompileIfAppropriate):
(JSC::jitCompileFunctionIfAppropriate):

• runtime/Executable.cpp:

(JSC::jettisonCodeBlock):
(JSC::EvalExecutable::jitCompile):
(JSC::EvalExecutable::compileInternal):
(JSC::ProgramExecutable::jitCompile):
(JSC::ProgramExecutable::compileInternal):
(JSC::FunctionExecutable::jitCompileForCall):
(JSC::FunctionExecutable::jitCompileForConstruct):
(JSC::FunctionExecutable::produceCodeBlockFor):
(JSC::FunctionExecutable::compileForCallInternal):
(JSC::FunctionExecutable::compileForConstructInternal):

• runtime/Executable.h:

(EvalExecutable):
(FunctionExecutable):
(JSC::FunctionExecutable::codeBlockFor):

• runtime/ExecutionHarness.h:

(JSC::prepareForExecution):
(JSC::prepareFunctionForExecution):

File:

• trunk/Source/JavaScriptCore/jit/JITDriver.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/jit/JITDriver.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39 +39 @@
 
 template<typename CodeBlockType>
-inline bool jitCompileIfAppropriate(ExecState* exec, OwnPtr<CodeBlockType>& codeBlock, RefPtr<JITCode>& jitCode, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
+inline bool jitCompileIfAppropriate(ExecState* exec, CodeBlockType* codeBlock, RefPtr<JITCode>& jitCode, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
 {
     VM& vm = exec->vm();
@@ -53 +53 @@
     RefPtr<JITCode> oldJITCode = jitCode;
     
-    bool dfgCompiled = false;
-    if (JITCode::isOptimizingJIT(jitType))
-        dfgCompiled = DFG::tryCompile(exec, codeBlock.get(), jitCode, bytecodeIndex);
-    if (dfgCompiled) {
-        if (codeBlock->alternative())
+    if (JITCode::isOptimizingJIT(jitType)) {
+        if (DFG::tryCompile(exec, codeBlock, jitCode, bytecodeIndex))
             codeBlock->alternative()->unlinkIncomingCalls();
-    } else {
-        if (codeBlock->alternative()) {
-            codeBlock = static_pointer_cast<CodeBlockType>(codeBlock->releaseAlternative());
-            jitCode = oldJITCode;
+        else {
+            ASSERT(oldJITCode == jitCode);
             return false;
         }
-        jitCode = JIT::compile(&vm, codeBlock.get(), effort);
-        if (!jitCode) {
-            jitCode = oldJITCode;
+    } else {
+        RefPtr<JITCode> result = JIT::compile(&vm, codeBlock, effort);
+        if (result)
+            jitCode = result;
+        else
             return false;
-        }
     }
+    
     codeBlock->setJITCode(jitCode, MacroAssemblerCodePtr());
     
@@ -76 +73 @@
 }
 
-inline bool jitCompileFunctionIfAppropriate(ExecState* exec, OwnPtr<FunctionCodeBlock>& codeBlock, RefPtr<JITCode>& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
+inline bool jitCompileFunctionIfAppropriate(ExecState* exec, FunctionCodeBlock* codeBlock, RefPtr<JITCode>& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
 {
     VM& vm = exec->vm();
@@ -91 +88 @@
     MacroAssemblerCodePtr oldJITCodeWithArityCheck = jitCodeWithArityCheck;
     
-    bool dfgCompiled = false;
-    if (JITCode::isOptimizingJIT(jitType))
-        dfgCompiled = DFG::tryCompileFunction(exec, codeBlock.get(), jitCode, jitCodeWithArityCheck, bytecodeIndex);
-    if (dfgCompiled) {
-        if (codeBlock->alternative())
+    if (JITCode::isOptimizingJIT(jitType)) {
+        if (DFG::tryCompileFunction(exec, codeBlock, jitCode, jitCodeWithArityCheck, bytecodeIndex))
             codeBlock->alternative()->unlinkIncomingCalls();
-    } else {
-        if (codeBlock->alternative()) {
-            codeBlock = static_pointer_cast<FunctionCodeBlock>(codeBlock->releaseAlternative());
-            jitCode = oldJITCode;
-            jitCodeWithArityCheck = oldJITCodeWithArityCheck;
+        else {
+            ASSERT(oldJITCode == jitCode);
+            ASSERT_UNUSED(oldJITCodeWithArityCheck, oldJITCodeWithArityCheck == jitCodeWithArityCheck);
             return false;
         }
-        jitCode = JIT::compile(&vm, codeBlock.get(), effort, &jitCodeWithArityCheck);
-        if (!jitCode) {
-            jitCode = oldJITCode;
-            jitCodeWithArityCheck = oldJITCodeWithArityCheck;
+    } else {
+        RefPtr<JITCode> result =
+            JIT::compile(&vm, codeBlock, effort, &jitCodeWithArityCheck);
+        if (result)
+            jitCode = result;
+        else {
+            ASSERT_UNUSED(oldJITCodeWithArityCheck, oldJITCodeWithArityCheck == jitCodeWithArityCheck);
             return false;
         }
     }
+
     codeBlock->setJITCode(jitCode, jitCodeWithArityCheck);