Imported WebKit commit 2ea9d364d0f6efa8fa64acf19f451504c59be0e4 (http://svn.webkit.org/repository/webkit/trunk@104285)

1 files changed, 175 insertions, 0 deletions

diff --git a/Source/JavaScriptCore/dfg/DFGOSREntry.cpp b/Source/JavaScriptCore/dfg/DFGOSREntry.cpp
new file mode 100644
index 000000000..4510ec7b9
--- /dev/null
+++ b/Source/JavaScriptCore/dfg/DFGOSREntry.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+#include "DFGOSREntry.h"
+
+#if ENABLE(DFG_JIT)
+
+#include "CallFrame.h"
+#include "CodeBlock.h"
+#include "DFGNode.h"
+#include "JIT.h"
+
+namespace JSC { namespace DFG {
+
+void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
+{
+#if DFG_ENABLE(OSR_ENTRY)
+    ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
+    ASSERT(codeBlock->alternative());
+    ASSERT(codeBlock->alternative()->getJITType() == JITCode::BaselineJIT);
+    ASSERT(!codeBlock->jitCodeMap());
+    ASSERT(codeBlock->numberOfDFGOSREntries());
+
+#if ENABLE(JIT_VERBOSE_OSR)
+    printf("OSR in %p(%p) from bc#%u\n", codeBlock, codeBlock->alternative(), bytecodeIndex);
+#endif
+    
+    JSGlobalData* globalData = &exec->globalData();
+    OSREntryData* entry = codeBlock->dfgOSREntryDataForBytecodeIndex(bytecodeIndex);
+    
+    ASSERT(entry->m_bytecodeIndex == bytecodeIndex);
+    
+    // The code below checks if it is safe to perform OSR entry. It may find
+    // that it is unsafe to do so, for any number of reasons, which are documented
+    // below. If the code decides not to OSR then it returns 0, and it's the caller's
+    // responsibility to patch up the state in such a way as to ensure that it's
+    // both safe and efficient to continue executing baseline code for now. This
+    // should almost certainly include calling either codeBlock->optimizeAfterWarmUp()
+    // or codeBlock->dontOptimizeAnytimeSoon().
+    
+    // 1) Verify predictions. If the predictions are inconsistent with the actual
+    //    values, then OSR entry is not possible at this time. It's tempting to
+    //    assume that we could somehow avoid this case. We can certainly avoid it
+    //    for first-time loop OSR - that is, OSR into a CodeBlock that we have just
+    //    compiled. Then we are almost guaranteed that all of the predictions will
+    //    check out. It would be pretty easy to make that a hard guarantee. But
+    //    then there would still be the case where two call frames with the same
+    //    baseline CodeBlock are on the stack at the same time. The top one
+    //    triggers compilation and OSR. In that case, we may no longer have
+    //    accurate value profiles for the one deeper in the stack. Hence, when we
+    //    pop into the CodeBlock that is deeper on the stack, we might OSR and
+    //    realize that the predictions are wrong. Probably, in most cases, this is
+    //    just an anomaly in the sense that the older CodeBlock simply went off
+    //    into a less-likely path. So, the wisest course of action is to simply not
+    //    OSR at this time.
+    
+    for (size_t argument = 0; argument < entry->m_expectedValues.numberOfArguments(); ++argument) {
+        if (argument >= exec->argumentCountIncludingThis()) {
+#if ENABLE(JIT_VERBOSE_OSR)
+            printf("    OSR failed because argument %lu was not passed, expected ", argument);
+            entry->m_expectedValues.argument(argument).dump(stdout);
+            printf(".\n");
+#endif
+            return 0;
+        }
+        
+        JSValue value;
+        if (!argument)
+            value = exec->hostThisValue();
+        else
+            value = exec->argument(argument - 1);
+        
+        if (!entry->m_expectedValues.argument(argument).validate(value)) {
+#if ENABLE(JIT_VERBOSE_OSR)
+            printf("    OSR failed because argument %lu is %s, expected ", argument, value.description());
+            entry->m_expectedValues.argument(argument).dump(stdout);
+            printf(".\n");
+#endif
+            return 0;
+        }
+    }
+    
+    for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
+        if (entry->m_localsForcedDouble.get(local)) {
+            if (!exec->registers()[local].jsValue().isNumber()) {
+#if ENABLE(JIT_VERBOSE_OSR)
+                printf("    OSR failed because variable %lu is %s, expected number.\n", local, exec->registers()[local].jsValue().description());
+#endif
+                return 0;
+            }
+            continue;
+        }
+        if (!entry->m_expectedValues.local(local).validate(exec->registers()[local].jsValue())) {
+#if ENABLE(JIT_VERBOSE_OSR)
+            printf("    OSR failed because variable %lu is %s, expected ", local, exec->registers()[local].jsValue().description());
+            entry->m_expectedValues.local(local).dump(stdout);
+            printf(".\n");
+#endif
+            return 0;
+        }
+    }
+
+    // 2) Check the stack height. The DFG JIT may require a taller stack than the
+    //    baseline JIT, in some cases. If we can't grow the stack, then don't do
+    //    OSR right now. That's the only option we have unless we want basic block
+    //    boundaries to start throwing RangeErrors. Although that would be possible,
+    //    it seems silly: you'd be diverting the program to error handling when it
+    //    would have otherwise just kept running albeit less quickly.
+    
+    if (!globalData->interpreter->registerFile().grow(&exec->registers()[codeBlock->m_numCalleeRegisters])) {
+#if ENABLE(JIT_VERBOSE_OSR)
+        printf("    OSR failed because stack growth failed.\n");
+#endif
+        return 0;
+    }
+    
+#if ENABLE(JIT_VERBOSE_OSR)
+    printf("    OSR should succeed.\n");
+#endif
+    
+#if USE(JSVALUE64)
+    // 3) Perform data format conversions.
+    for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
+        if (entry->m_localsForcedDouble.get(local))
+            *bitwise_cast<double*>(exec->registers() + local) = exec->registers()[local].jsValue().asNumber();
+    }
+#endif
+    
+    // 4) Fix the call frame.
+    
+    exec->setCodeBlock(codeBlock);
+    
+    // 5) Find and return the destination machine code address.
+    
+    void* result = codeBlock->getJITCode().executableAddressAtOffset(entry->m_machineCodeOffset);
+    
+#if ENABLE(JIT_VERBOSE_OSR)
+    printf("    OSR returning machine code address %p.\n", result);
+#endif
+    
+    return result;
+#else // DFG_ENABLE(OSR_ENTRY)
+    UNUSED_PARAM(exec);
+    UNUSED_PARAM(codeBlock);
+    UNUSED_PARAM(bytecodeIndex);
+    return 0;
+#endif
+}
+
+} } // namespace JSC::DFG
+
+#endif // ENABLE(DFG_JIT)