Changeset 172961 in webkit for trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp

Timestamp:

Aug 26, 2014, 9:46:10 AM (11 years ago)

Author:

[email protected]

Message:

Unreviewed, rolling out r172940.
​https://bugs.webkit.org/show_bug.cgi?id=136256

Caused assertions on fast/storage/serialized-script-
value.html, and possibly flakiness on more tests (Requested by
ap on #webkit).

Reverted changeset:

"FTL should be able to do polymorphic call inlining"
​https://bugs.webkit.org/show_bug.cgi?id=135145
​http://trac.webkit.org/changeset/172940

File:

• trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp (modified) (11 diffs)

trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp

@@ -33 +33 @@
 #include "JSCInlines.h"
 #include <wtf/CommaPrinter.h>
-#include <wtf/ListDump.h>
 
 namespace JSC {
@@ -40 +39 @@
 
 CallLinkStatus::CallLinkStatus(JSValue value)
-    : m_couldTakeSlowPath(false)
+    : m_callTarget(value)
+    , m_executable(0)
+    , m_couldTakeSlowPath(false)
     , m_isProved(false)
 {
-    if (!value || !value.isCell()) {
-        m_couldTakeSlowPath = true;
+    if (!value || !value.isCell())
         return;
-    }
-    
-    m_edges.append(CallEdge(CallVariant(value.asCell()), 1));
+    
+    if (!value.asCell()->inherits(JSFunction::info()))
+        return;
+    
+    m_executable = jsCast<JSFunction*>(value.asCell())->executable();
+}
+
+JSFunction* CallLinkStatus::function() const
+{
+    if (!m_callTarget || !m_callTarget.isCell())
+        return 0;
+    
+    if (!m_callTarget.asCell()->inherits(JSFunction::info()))
+        return 0;
+    
+    return jsCast<JSFunction*>(m_callTarget.asCell());
+}
+
+InternalFunction* CallLinkStatus::internalFunction() const
+{
+    if (!m_callTarget || !m_callTarget.isCell())
+        return 0;
+    
+    if (!m_callTarget.asCell()->inherits(InternalFunction::info()))
+        return 0;
+    
+    return jsCast<InternalFunction*>(m_callTarget.asCell());
+}
+
+Intrinsic CallLinkStatus::intrinsicFor(CodeSpecializationKind kind) const
+{
+    if (!m_executable)
+        return NoIntrinsic;
+    
+    return m_executable->intrinsicFor(kind);
 }
 
@@ -56 +88 @@
     UNUSED_PARAM(bytecodeIndex);
 #if ENABLE(DFG_JIT)
-    if (profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadCell))) {
+    if (profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadFunction))) {
         // We could force this to be a closure call, but instead we'll just assume that it
         // takes slow path.
@@ -94 +126 @@
         return computeFromLLInt(locker, profiledBlock, bytecodeIndex);
     
-    return computeFor(locker, profiledBlock, *callLinkInfo, exitSiteData);
+    return computeFor(locker, *callLinkInfo, exitSiteData);
 #else
     return CallLinkStatus();
@@ -108 +140 @@
 #if ENABLE(DFG_JIT)
     exitSiteData.m_takesSlowPath =
-        profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadType, exitingJITType))
+        profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadCache, exitingJITType))
         || profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadExecutable, exitingJITType));
     exitSiteData.m_badFunction =
-        profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadCell, exitingJITType));
+        profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadFunction, exitingJITType));
 #else
     UNUSED_PARAM(locker);
@@ -123 +155 @@
 
 #if ENABLE(JIT)
-CallLinkStatus CallLinkStatus::computeFor(
-    const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo)
-{
-    // We don't really need this, but anytime we have to debug this code, it becomes indispensable.
-    UNUSED_PARAM(profiledBlock);
-    
-    if (Options::callStatusShouldUseCallEdgeProfile()) {
-        // Always trust the call edge profile over anything else since this has precise counts.
-        // It can make the best possible decision because it never "forgets" what happened for any
-        // call, with the exception of fading out the counts of old calls (for example if the
-        // counter type is 16-bit then calls that happened more than 2^16 calls ago are given half
-        // weight, and this compounds for every 2^15 [sic] calls after that). The combination of
-        // high fidelity for recent calls and fading for older calls makes this the most useful
-        // mechamism of choosing how to optimize future calls.
-        CallEdgeProfile* edgeProfile = callLinkInfo.callEdgeProfile.get();
-        WTF::loadLoadFence();
-        if (edgeProfile) {
-            CallLinkStatus result = computeFromCallEdgeProfile(edgeProfile);
-            if (!!result)
-                return result;
-        }
-    }
-    
-    return computeFromCallLinkInfo(locker, callLinkInfo);
-}
-
-CallLinkStatus CallLinkStatus::computeFromCallLinkInfo(
-    const ConcurrentJITLocker&, CallLinkInfo& callLinkInfo)
+CallLinkStatus CallLinkStatus::computeFor(const ConcurrentJITLocker&, CallLinkInfo& callLinkInfo)
 {
     // Note that despite requiring that the locker is held, this code is racy with respect
@@ -173 +178 @@
     JSFunction* target = callLinkInfo.lastSeenCallee.get();
     if (!target)
-        return takesSlowPath();
+        return CallLinkStatus();
     
     if (callLinkInfo.hasSeenClosure)
@@ -181 +186 @@
 }
 
-CallLinkStatus CallLinkStatus::computeFromCallEdgeProfile(CallEdgeProfile* edgeProfile)
-{
-    // In cases where the call edge profile saw nothing, use the CallLinkInfo instead.
-    if (!edgeProfile->totalCalls())
-        return CallLinkStatus();
-    
-    // To do anything meaningful, we require that the majority of calls are to something we
-    // know how to handle.
-    unsigned numCallsToKnown = edgeProfile->numCallsToKnownCells();
-    unsigned numCallsToUnknown = edgeProfile->numCallsToNotCell() + edgeProfile->numCallsToUnknownCell();
-    
-    // We require that the majority of calls were to something that we could possibly inline.
-    if (numCallsToKnown <= numCallsToUnknown)
-        return takesSlowPath();
-    
-    // We require that the number of such calls is greater than some minimal threshold, so that we
-    // avoid inlining completely cold calls.
-    if (numCallsToKnown < Options::frequentCallThreshold())
-        return takesSlowPath();
-    
-    CallLinkStatus result;
-    result.m_edges = edgeProfile->callEdges();
-    result.m_couldTakeSlowPath = !!numCallsToUnknown;
-    result.m_canTrustCounts = true;
-    
-    return result;
-}
-
 CallLinkStatus CallLinkStatus::computeFor(
-    const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo,
-    ExitSiteData exitSiteData)
-{
-    CallLinkStatus result = computeFor(locker, profiledBlock, callLinkInfo);
+    const ConcurrentJITLocker& locker, CallLinkInfo& callLinkInfo, ExitSiteData exitSiteData)
+{
+    if (exitSiteData.m_takesSlowPath)
+        return takesSlowPath();
+    
+    CallLinkStatus result = computeFor(locker, callLinkInfo);
     if (exitSiteData.m_badFunction)
         result.makeClosureCall();
-    if (exitSiteData.m_takesSlowPath)
-        result.m_couldTakeSlowPath = true;
     
     return result;
@@ -251 +228 @@
         {
             ConcurrentJITLocker locker(dfgCodeBlock->m_lock);
-            map.add(info.codeOrigin, computeFor(locker, dfgCodeBlock, info, exitSiteData));
+            map.add(info.codeOrigin, computeFor(locker, info, exitSiteData));
         }
     }
@@ -280 +257 @@
 }
 
-bool CallLinkStatus::isClosureCall() const
-{
-    for (unsigned i = m_edges.size(); i--;) {
-        if (m_edges[i].callee().isClosureCall())
-            return true;
-    }
-    return false;
-}
-
-void CallLinkStatus::makeClosureCall()
-{
-    ASSERT(!m_isProved);
-    for (unsigned i = m_edges.size(); i--;)
-        m_edges[i] = m_edges[i].despecifiedClosure();
-    
-    if (!ASSERT_DISABLED) {
-        // Doing this should not have created duplicates, because the CallEdgeProfile
-        // should despecify closures if doing so would reduce the number of known callees.
-        for (unsigned i = 0; i < m_edges.size(); ++i) {
-            for (unsigned j = i + 1; j < m_edges.size(); ++j)
-                ASSERT(m_edges[i].callee() != m_edges[j].callee());
-        }
-    }
-}
-
 void CallLinkStatus::dump(PrintStream& out) const
 {
@@ -320 +272 @@
         out.print(comma, "Could Take Slow Path");
     
-    out.print(listDump(m_edges));
+    if (m_callTarget)
+        out.print(comma, "Known target: ", m_callTarget);
+    
+    if (m_executable) {
+        out.print(comma, "Executable/CallHash: ", RawPointer(m_executable));
+        if (!isCompilationThread())
+            out.print("/", m_executable->hashFor(CodeForCall));
+    }
 }