Changeset 109307 in webkit for trunk/Source/JavaScriptCore/assembler/LinkBuffer.h

Timestamp:

Feb 29, 2012, 9:46:20 PM (13 years ago)

Author:

[email protected]

Message:

The JIT should not crash the entire process just because there is not
enough executable memory, if the LLInt is enabled
​https://bugs.webkit.org/show_bug.cgi?id=79962
<rdar://problem/10922215>

Reviewed by Gavin Barraclough.

Added the notion of JITCompilationEffort. If we're JIT'ing as a result of
a tier-up, then we set it to JITCompilationCanFail. Otherwise it's
JITCompilationMustSucceed. This preserves the old behavior of LLInt is
disabled or if we're compiling something that can't be interpreted (like
an OSR exit stub).

• JavaScriptCore.xcodeproj/project.pbxproj:
• assembler/ARMAssembler.cpp:

(JSC::ARMAssembler::executableCopy):

• assembler/ARMAssembler.h:

(ARMAssembler):

• assembler/AssemblerBuffer.h:

(JSC::AssemblerBuffer::executableCopy):

• assembler/LinkBuffer.h:

(JSC::LinkBuffer::LinkBuffer):
(JSC::LinkBuffer::~LinkBuffer):
(LinkBuffer):
(JSC::LinkBuffer::didFailToAllocate):
(JSC::LinkBuffer::isValid):
(JSC::LinkBuffer::linkCode):
(JSC::LinkBuffer::performFinalization):

• assembler/MIPSAssembler.h:

(JSC::MIPSAssembler::executableCopy):

• assembler/SH4Assembler.h:

(JSC::SH4Assembler::executableCopy):

• assembler/X86Assembler.h:

(JSC::X86Assembler::executableCopy):
(JSC::X86Assembler::X86InstructionFormatter::executableCopy):

• bytecode/CodeBlock.cpp:

(JSC::ProgramCodeBlock::jitCompileImpl):
(JSC::EvalCodeBlock::jitCompileImpl):
(JSC::FunctionCodeBlock::jitCompileImpl):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::jitCompile):
(CodeBlock):
(ProgramCodeBlock):
(EvalCodeBlock):
(FunctionCodeBlock):

• dfg/DFGDriver.cpp:

(JSC::DFG::compile):

• dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):

• dfg/DFGJITCompiler.h:

(JITCompiler):

• jit/ExecutableAllocator.cpp:

(JSC::DemandExecutableAllocator::allocateNewSpace):
(JSC::ExecutableAllocator::allocate):

• jit/ExecutableAllocator.h:

(ExecutableAllocator):

• jit/ExecutableAllocatorFixedVMPool.cpp:

(JSC::ExecutableAllocator::allocate):

• jit/JIT.cpp:

(JSC::JIT::privateCompile):

• jit/JIT.h:

(JSC::JIT::compile):
(JIT):

• jit/JITCompilationEffort.h: Added.

(JSC):

• jit/JITDriver.h:

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

• llint/LLIntSlowPaths.cpp:

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

• runtime/Executable.cpp:

(JSC::EvalExecutable::jitCompile):
(JSC::ProgramExecutable::jitCompile):
(JSC::FunctionExecutable::jitCompileForCall):
(JSC::FunctionExecutable::jitCompileForConstruct):

• runtime/Executable.h:

(EvalExecutable):
(ProgramExecutable):
(FunctionExecutable):
(JSC::FunctionExecutable::jitCompileFor):

• runtime/ExecutionHarness.h:

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

File:

• trunk/Source/JavaScriptCore/assembler/LinkBuffer.h (modified) (7 diffs)

trunk/Source/JavaScriptCore/assembler/LinkBuffer.h

@@ -35 +35 @@
 #define REGEXP_CODE_ID reinterpret_cast<void*>(static_cast<intptr_t>(-2))
 
+#include "JITCompilationEffort.h"
 #include "MacroAssembler.h"
 #include <wtf/DataLog.h>
@@ -74 +75 @@
 
 public:
-    LinkBuffer(JSGlobalData& globalData, MacroAssembler* masm, void* ownerUID)
+    LinkBuffer(JSGlobalData& globalData, MacroAssembler* masm, void* ownerUID, JITCompilationEffort effort = JITCompilationMustSucceed)
         : m_size(0)
 #if ENABLE(BRANCH_COMPACTION)
@@ -84 +85 @@
 #ifndef NDEBUG
         , m_completed(false)
-#endif
-    {
-        linkCode(ownerUID);
+        , m_effort(effort)
+#endif
+    {
+        linkCode(ownerUID, effort);
     }
 
     ~LinkBuffer()
     {
-        ASSERT(m_completed);
-    }
-
+        ASSERT(m_completed || (!m_executableMemory && m_effort == JITCompilationCanFail));
+    }
+    
+    bool didFailToAllocate() const
+    {
+        return !m_executableMemory;
+    }
+
+    bool isValid() const
+    {
+        return !didFailToAllocate();
+    }
+    
     // These methods are used to link or set values at code generation time.
 
@@ -219 +231 @@
     }
 
-    void linkCode(void* ownerUID)
+    void linkCode(void* ownerUID, JITCompilationEffort effort)
     {
         ASSERT(!m_code);
 #if !ENABLE(BRANCH_COMPACTION)
-        m_executableMemory = m_assembler->m_assembler.executableCopy(*m_globalData, ownerUID);
+        m_executableMemory = m_assembler->m_assembler.executableCopy(*m_globalData, ownerUID, effort);
         if (!m_executableMemory)
             return;
@@ -231 +243 @@
 #else
         m_initialSize = m_assembler->m_assembler.codeSize();
-        m_executableMemory = m_globalData->executableAllocator.allocate(*m_globalData, m_initialSize, ownerUID);
+        m_executableMemory = m_globalData->executableAllocator.allocate(*m_globalData, m_initialSize, ownerUID, effort);
         if (!m_executableMemory)
             return;
@@ -308 +320 @@
 #ifndef NDEBUG
         ASSERT(!m_completed);
+        ASSERT(isValid());
         m_completed = true;
 #endif
@@ -376 +389 @@
 #ifndef NDEBUG
     bool m_completed;
+    JITCompilationEffort m_effort;
 #endif
 };