JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / dfg / DFGOSREntry.cpp

diff --git a/dfg/DFGOSREntry.cpp b/dfg/DFGOSREntry.cpp
index 21c76c6fe67524d4a2bf1aae04ca4d14ff954680..a2142e8ad1592659e8f4ebd5d54e55323149bd7f 100644 (file)
--- a/dfg/DFGOSREntry.cpp
+++ b/dfg/DFGOSREntry.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2013, 2014, 2015 Apple Inc. All rights reserved.

  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -30,26 +30,122 @@
 
 #include "CallFrame.h"
 #include "CodeBlock.h"
 
 #include "CallFrame.h"
 #include "CodeBlock.h"

+#include "DFGJITCode.h"

 #include "DFGNode.h"
 #include "JIT.h"
 #include "DFGNode.h"
 #include "JIT.h"

+#include "JSStackInlines.h"
+#include "JSCInlines.h"
+#include <wtf/CommaPrinter.h>

 
 namespace JSC { namespace DFG {
 
 
 namespace JSC { namespace DFG {
 

+void OSREntryData::dumpInContext(PrintStream& out, DumpContext* context) const
+{
+    out.print("bc#", m_bytecodeIndex, ", machine code offset = ", m_machineCodeOffset);
+    out.print(", stack rules = [");
+    
+    auto printOperand = [&] (VirtualRegister reg) {
+        out.print(inContext(m_expectedValues.operand(reg), context), " (");
+        VirtualRegister toReg;
+        bool overwritten = false;
+        for (OSREntryReshuffling reshuffling : m_reshufflings) {
+            if (reg == VirtualRegister(reshuffling.fromOffset)) {
+                toReg = VirtualRegister(reshuffling.toOffset);
+                break;
+            }
+            if (reg == VirtualRegister(reshuffling.toOffset))
+                overwritten = true;
+        }
+        if (!overwritten && !toReg.isValid())
+            toReg = reg;
+        if (toReg.isValid()) {
+            if (toReg.isLocal() && !m_machineStackUsed.get(toReg.toLocal()))
+                out.print("ignored");
+            else
+                out.print("maps to ", toReg);
+        } else
+            out.print("overwritten");
+        if (reg.isLocal() && m_localsForcedDouble.get(reg.toLocal()))
+            out.print(", forced double");
+        if (reg.isLocal() && m_localsForcedMachineInt.get(reg.toLocal()))
+            out.print(", forced machine int");
+        out.print(")");
+    };
+    
+    CommaPrinter comma;
+    for (size_t argumentIndex = m_expectedValues.numberOfArguments(); argumentIndex--;) {
+        out.print(comma, "arg", argumentIndex, ":");
+        printOperand(virtualRegisterForArgument(argumentIndex));
+    }
+    for (size_t localIndex = 0; localIndex < m_expectedValues.numberOfLocals(); ++localIndex) {
+        out.print(comma, "loc", localIndex, ":");
+        printOperand(virtualRegisterForLocal(localIndex));
+    }
+    
+    out.print("], machine stack used = ", m_machineStackUsed);
+}
+
+void OSREntryData::dump(PrintStream& out) const
+{
+    dumpInContext(out, nullptr);
+}
+

 void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
 {
 void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
 {

-#if DFG_ENABLE(OSR_ENTRY)
-    ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
+    ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));

     ASSERT(codeBlock->alternative());
     ASSERT(codeBlock->alternative());

-    ASSERT(codeBlock->alternative()->getJITType() == JITCode::BaselineJIT);
+    ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);

     ASSERT(!codeBlock->jitCodeMap());
     ASSERT(!codeBlock->jitCodeMap());

-    ASSERT(codeBlock->numberOfDFGOSREntries());

 
 

-#if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("OSR in %p(%p) from bc#%u\n", codeBlock, codeBlock->alternative(), bytecodeIndex);
-#endif
+    if (!Options::enableOSREntryToDFG())
+        return 0;
+
+    if (Options::verboseOSR()) {
+        dataLog(
+            "DFG OSR in ", *codeBlock->alternative(), " -> ", *codeBlock,
+            " from bc#", bytecodeIndex, "\n");
+    }
+    
+    VM* vm = &exec->vm();
+
+    sanitizeStackForVM(vm);
+    
+    if (bytecodeIndex)
+        codeBlock->ownerExecutable()->setDidTryToEnterInLoop(true);
+    
+    if (codeBlock->jitType() != JITCode::DFGJIT) {
+        RELEASE_ASSERT(codeBlock->jitType() == JITCode::FTLJIT);
+        
+        // When will this happen? We could have:
+        //
+        // - An exit from the FTL JIT into the baseline JIT followed by an attempt
+        //   to reenter. We're fine with allowing this to fail. If it happens
+        //   enough we'll just reoptimize. It basically means that the OSR exit cost
+        //   us dearly and so reoptimizing is the right thing to do.
+        //
+        // - We have recursive code with hot loops. Consider that foo has a hot loop
+        //   that calls itself. We have two foo's on the stack, lets call them foo1
+        //   and foo2, with foo1 having called foo2 from foo's hot loop. foo2 gets
+        //   optimized all the way into the FTL. Then it returns into foo1, and then
+        //   foo1 wants to get optimized. It might reach this conclusion from its
+        //   hot loop and attempt to OSR enter. And we'll tell it that it can't. It
+        //   might be worth addressing this case, but I just think this case will
+        //   be super rare. For now, if it does happen, it'll cause some compilation
+        //   thrashing.
+        
+        if (Options::verboseOSR())
+            dataLog("    OSR failed because the target code block is not DFG.\n");
+        return 0;
+    }
+    
+    JITCode* jitCode = codeBlock->jitCode()->dfg();
+    OSREntryData* entry = jitCode->osrEntryDataForBytecodeIndex(bytecodeIndex);

     
     

-    JSGlobalData* globalData = &exec->globalData();
-    OSREntryData* entry = codeBlock->dfgOSREntryDataForBytecodeIndex(bytecodeIndex);
+    if (!entry) {
+        if (Options::verboseOSR())
+            dataLogF("    OSR failed because the entrypoint was optimized out.\n");
+        return 0;
+    }

     
     ASSERT(entry->m_bytecodeIndex == bytecodeIndex);
     
     
     ASSERT(entry->m_bytecodeIndex == bytecodeIndex);
     


@@ -79,46 +175,62 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     
     for (size_t argument = 0; argument < entry->m_expectedValues.numberOfArguments(); ++argument) {
         if (argument >= exec->argumentCountIncludingThis()) {
     
     for (size_t argument = 0; argument < entry->m_expectedValues.numberOfArguments(); ++argument) {
         if (argument >= exec->argumentCountIncludingThis()) {

-#if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because argument %zu was not passed, expected ", argument);
-            entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
-            dataLog(".\n");
-#endif
+            if (Options::verboseOSR()) {
+                dataLogF("    OSR failed because argument %zu was not passed, expected ", argument);
+                entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
+                dataLogF(".\n");
+            }

             return 0;
         }
         
         JSValue value;
         if (!argument)
             return 0;
         }
         
         JSValue value;
         if (!argument)

-            value = exec->hostThisValue();
+            value = exec->thisValue();

         else
             value = exec->argument(argument - 1);
         
         if (!entry->m_expectedValues.argument(argument).validate(value)) {
         else
             value = exec->argument(argument - 1);
         
         if (!entry->m_expectedValues.argument(argument).validate(value)) {

-#if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because argument %zu is %s, expected ", argument, value.description());
-            entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
-            dataLog(".\n");
-#endif
+            if (Options::verboseOSR()) {
+                dataLog(
+                    "    OSR failed because argument ", argument, " is ", value,
+                    ", expected ", entry->m_expectedValues.argument(argument), ".\n");
+            }

             return 0;
         }
     }
     
     for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
             return 0;
         }
     }
     
     for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {

+        int localOffset = virtualRegisterForLocal(local).offset();

         if (entry->m_localsForcedDouble.get(local)) {
         if (entry->m_localsForcedDouble.get(local)) {

-            if (!exec->registers()[local].jsValue().isNumber()) {
-#if ENABLE(JIT_VERBOSE_OSR)
-                dataLog("    OSR failed because variable %zu is %s, expected number.\n", local, exec->registers()[local].jsValue().description());
-#endif
+            if (!exec->registers()[localOffset].jsValue().isNumber()) {
+                if (Options::verboseOSR()) {
+                    dataLog(
+                        "    OSR failed because variable ", localOffset, " is ",
+                        exec->registers()[localOffset].jsValue(), ", expected number.\n");
+                }

                 return 0;
             }
             continue;
         }
                 return 0;
             }
             continue;
         }

-        if (!entry->m_expectedValues.local(local).validate(exec->registers()[local].jsValue())) {
-#if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because variable %zu is %s, expected ", local, exec->registers()[local].jsValue().description());
-            entry->m_expectedValues.local(local).dump(WTF::dataFile());
-            dataLog(".\n");
-#endif
+        if (entry->m_localsForcedMachineInt.get(local)) {
+            if (!exec->registers()[localOffset].jsValue().isMachineInt()) {
+                if (Options::verboseOSR()) {
+                    dataLog(
+                        "    OSR failed because variable ", localOffset, " is ",
+                        exec->registers()[localOffset].jsValue(), ", expected ",
+                        "machine int.\n");
+                }
+                return 0;
+            }
+            continue;
+        }
+        if (!entry->m_expectedValues.local(local).validate(exec->registers()[localOffset].jsValue())) {
+            if (Options::verboseOSR()) {
+                dataLog(
+                    "    OSR failed because variable ", localOffset, " is ",
+                    exec->registers()[localOffset].jsValue(), ", expected ",
+                    entry->m_expectedValues.local(local), ".\n");
+            }

             return 0;
         }
     }
             return 0;
         }
     }


@@ -130,42 +242,79 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     //    it seems silly: you'd be diverting the program to error handling when it
     //    would have otherwise just kept running albeit less quickly.
     
     //    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)
-        dataLog("    OSR failed because stack growth failed.\n");
-#endif
+    unsigned frameSizeForCheck = jitCode->common.requiredRegisterCountForExecutionAndExit();
+    if (!vm->interpreter->stack().ensureCapacityFor(&exec->registers()[virtualRegisterForLocal(frameSizeForCheck - 1).offset()])) {
+        if (Options::verboseOSR())
+            dataLogF("    OSR failed because stack growth failed.\n");

         return 0;
     }
     
         return 0;
     }
     

-#if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("    OSR should succeed.\n");
-#endif
+    if (Options::verboseOSR())
+        dataLogF("    OSR should succeed.\n");
+
+    // At this point we're committed to entering. We will do some work to set things up,
+    // but we also rely on our caller recognizing that when we return a non-null pointer,
+    // that means that we're already past the point of no return and we must succeed at
+    // entering.

     
     

-    // 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();
-    }
+    // 3) Set up the data in the scratch buffer and perform data format conversions.
+
+    unsigned frameSize = jitCode->common.frameRegisterCount;
+    unsigned baselineFrameSize = entry->m_expectedValues.numberOfLocals();
+    unsigned maxFrameSize = std::max(frameSize, baselineFrameSize);
+
+    Register* scratch = bitwise_cast<Register*>(vm->scratchBufferForSize(sizeof(Register) * (2 + JSStack::CallFrameHeaderSize + maxFrameSize))->dataBuffer());
+    
+    *bitwise_cast<size_t*>(scratch + 0) = frameSize;
+    
+    void* targetPC = codeBlock->jitCode()->executableAddressAtOffset(entry->m_machineCodeOffset);
+    if (Options::verboseOSR())
+        dataLogF("    OSR using target PC %p.\n", targetPC);
+    RELEASE_ASSERT(targetPC);
+    *bitwise_cast<void**>(scratch + 1) = targetPC;

     
     

-    // 4) Fix the call frame.
+    Register* pivot = scratch + 2 + JSStack::CallFrameHeaderSize;
+    
+    for (int index = -JSStack::CallFrameHeaderSize; index < static_cast<int>(baselineFrameSize); ++index) {
+        VirtualRegister reg(-1 - index);
+        
+        if (reg.isLocal()) {
+            if (entry->m_localsForcedDouble.get(reg.toLocal())) {
+                *bitwise_cast<double*>(pivot + index) = exec->registers()[reg.offset()].jsValue().asNumber();
+                continue;
+            }
+            
+            if (entry->m_localsForcedMachineInt.get(reg.toLocal())) {
+                *bitwise_cast<int64_t*>(pivot + index) = exec->registers()[reg.offset()].jsValue().asMachineInt() << JSValue::int52ShiftAmount;
+                continue;
+            }
+        }
+        
+        pivot[index] = exec->registers()[reg.offset()].jsValue();
+    }

     
     

-    exec->setCodeBlock(codeBlock);
+    // 4) Reshuffle those registers that need reshuffling.
+    Vector<JSValue> temporaryLocals(entry->m_reshufflings.size());
+    for (unsigned i = entry->m_reshufflings.size(); i--;)
+        temporaryLocals[i] = pivot[VirtualRegister(entry->m_reshufflings[i].fromOffset).toLocal()].jsValue();
+    for (unsigned i = entry->m_reshufflings.size(); i--;)
+        pivot[VirtualRegister(entry->m_reshufflings[i].toOffset).toLocal()] = temporaryLocals[i];

     
     

-    // 5) Find and return the destination machine code address.
+    // 5) Clear those parts of the call frame that the DFG ain't using. This helps GC on
+    //    some programs by eliminating some stale pointer pathologies.
+    for (unsigned i = frameSize; i--;) {
+        if (entry->m_machineStackUsed.get(i))
+            continue;
+        pivot[i] = JSValue();
+    }

     
     

-    void* result = codeBlock->getJITCode().executableAddressAtOffset(entry->m_machineCodeOffset);
+    // 6) Fix the call frame to have the right code block.

     
     

-#if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("    OSR returning machine code address %p.\n", result);
-#endif
+    *bitwise_cast<CodeBlock**>(pivot - 1 - JSStack::CodeBlock) = codeBlock;

     
     

-    return result;
-#else // DFG_ENABLE(OSR_ENTRY)
-    UNUSED_PARAM(exec);
-    UNUSED_PARAM(codeBlock);
-    UNUSED_PARAM(bytecodeIndex);
-    return 0;
-#endif
+    if (Options::verboseOSR())
+        dataLogF("    OSR returning data buffer %p.\n", scratch);
+    return scratch;

 }
 
 } } // namespace JSC::DFG
 }
 
 } } // namespace JSC::DFG