Changeset 172961 in webkit for trunk/Source/JavaScriptCore/bytecode

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

Location:

trunk/Source/JavaScriptCore/bytecode

Files:

• CallEdge.cpp (deleted)
• CallEdge.h (deleted)
• CallEdgeProfile.cpp (deleted)
• CallEdgeProfile.h (deleted)
• CallEdgeProfileInlines.h (deleted)
• CallLinkInfo.cpp (modified) (1 diff)
• CallLinkInfo.h (modified) (3 diffs)
• CallLinkStatus.cpp (modified) (11 diffs)
• CallLinkStatus.h (modified) (4 diffs)
• CallVariant.cpp (deleted)
• CallVariant.h (deleted)
• CodeOrigin.h (modified) (1 diff)
• ExitKind.cpp (modified) (1 diff)
• ExitKind.h (modified) (1 diff)
• GetByIdStatus.cpp (modified) (1 diff)
• PutByIdStatus.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/bytecode/CallLinkInfo.cpp

@@ -84 +84 @@
     if (!!lastSeenCallee && !Heap::isMarked(lastSeenCallee.get()))
         lastSeenCallee.clear();
-    
-    if (callEdgeProfile) {
-        WTF::loadLoadFence();
-        callEdgeProfile->visitWeak();
-    }
 }
 

trunk/Source/JavaScriptCore/bytecode/CallLinkInfo.h

@@ -27 +27 @@
 #define CallLinkInfo_h
 
-#include "CallEdgeProfile.h"
 #include "ClosureCallStubRoutine.h"
 #include "CodeLocation.h"
@@ -35 +34 @@
 #include "Opcode.h"
 #include "WriteBarrier.h"
-#include <wtf/OwnPtr.h>
 #include <wtf/SentinelLinkedList.h>
 
@@ -91 +89 @@
     unsigned slowPathCount;
     CodeOrigin codeOrigin;
-    OwnPtr<CallEdgeProfile> callEdgeProfile;
 
     bool isLinked() { return stub || callee; }

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));
+    }
 }
 

trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.h

@@ -47 +47 @@
 public:
     CallLinkStatus()
-        : m_couldTakeSlowPath(false)
+        : m_executable(0)
+        , m_couldTakeSlowPath(false)
         , m_isProved(false)
-        , m_canTrustCounts(false)
     {
     }
@@ -62 +62 @@
     explicit CallLinkStatus(JSValue);
     
-    CallLinkStatus(CallVariant variant)
-        : m_edges(1, CallEdge(variant, 1))
+    CallLinkStatus(ExecutableBase* executable)
+        : m_executable(executable)
         , m_couldTakeSlowPath(false)
         , m_isProved(false)
-        , m_canTrustCounts(false)
     {
     }
@@ -94 +93 @@
     // Computes the status assuming that we never took slow path and never previously
     // exited.
-    static CallLinkStatus computeFor(const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&);
-    static CallLinkStatus computeFor(
-        const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&, ExitSiteData);
+    static CallLinkStatus computeFor(const ConcurrentJITLocker&, CallLinkInfo&);
+    static CallLinkStatus computeFor(const ConcurrentJITLocker&, CallLinkInfo&, ExitSiteData);
 #endif
     
@@ -110 +108 @@
         CodeBlock*, CodeOrigin, const CallLinkInfoMap&, const ContextMap&);
     
-    bool isSet() const { return !m_edges.isEmpty() || m_couldTakeSlowPath; }
+    bool isSet() const { return m_callTarget || m_executable || m_couldTakeSlowPath; }
     
     bool operator!() const { return !isSet(); }
     
     bool couldTakeSlowPath() const { return m_couldTakeSlowPath; }
+    bool isClosureCall() const { return m_executable && !m_callTarget; }
     
-    CallEdgeList edges() const { return m_edges; }
-    unsigned size() const { return m_edges.size(); }
-    CallEdge at(unsigned i) const { return m_edges[i]; }
-    CallEdge operator[](unsigned i) const { return at(i); }
+    JSValue callTarget() const { return m_callTarget; }
+    JSFunction* function() const;
+    InternalFunction* internalFunction() const;
+    Intrinsic intrinsicFor(CodeSpecializationKind) const;
+    ExecutableBase* executable() const { return m_executable; }
     bool isProved() const { return m_isProved; }
-    bool canOptimize() const { return !m_edges.isEmpty(); }
-    bool canTrustCounts() const { return m_canTrustCounts; }
-    
-    bool isClosureCall() const; // Returns true if any callee is a closure call.
+    bool canOptimize() const { return (m_callTarget || m_executable) && !m_couldTakeSlowPath; }
     
     void dump(PrintStream&) const;
     
 private:
-    void makeClosureCall();
+    void makeClosureCall()
+    {
+        ASSERT(!m_isProved);
+        // Turn this into a closure call.
+        m_callTarget = JSValue();
+    }
     
     static CallLinkStatus computeFromLLInt(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
-#if ENABLE(JIT)
-    static CallLinkStatus computeFromCallEdgeProfile(CallEdgeProfile*);
-    static CallLinkStatus computeFromCallLinkInfo(
-        const ConcurrentJITLocker&, CallLinkInfo&);
-#endif
     
-    CallEdgeList m_edges;
+    JSValue m_callTarget;
+    ExecutableBase* m_executable;
     bool m_couldTakeSlowPath;
     bool m_isProved;
-    bool m_canTrustCounts;
 };
 

trunk/Source/JavaScriptCore/bytecode/CodeOrigin.h

@@ -155 +155 @@
     }
     
-    static bool isNormalCall(Kind kind)
-    {
-        switch (kind) {
-        case Call:
-        case Construct:
-            return true;
-        default:
-            return false;
-        }
-    }
-    
     Vector<ValueRecovery> arguments; // Includes 'this'.
     WriteBarrier<ScriptExecutable> executable;

trunk/Source/JavaScriptCore/bytecode/ExitKind.cpp

@@ -39 +39 @@
     case BadType:
         return "BadType";
-    case BadCell:
-        return "BadCell";
+    case BadFunction:
+        return "BadFunction";
     case BadExecutable:
         return "BadExecutable";

trunk/Source/JavaScriptCore/bytecode/ExitKind.h

@@ -32 +32 @@
     ExitKindUnset,
     BadType, // We exited because a type prediction was wrong.
-    BadCell, // We exited because we made an incorrect assumption about what cell we would see. Usually used for function checks.
+    BadFunction, // We exited because we made an incorrect assumption about what function we would see.
     BadExecutable, // We exited because we made an incorrect assumption about what executable we would see.
     BadCache, // We exited because an inline cache was wrong.

trunk/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp

@@ -188 +188 @@
                         list->at(listIndex).stubRoutine());
                     callLinkStatus = std::make_unique<CallLinkStatus>(
-                        CallLinkStatus::computeFor(
-                            locker, profiledBlock, *stub->m_callLinkInfo, callExitSiteData));
+                        CallLinkStatus::computeFor(locker, *stub->m_callLinkInfo, callExitSiteData));
                     break;
                 }

trunk/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp

@@ -248 +248 @@
                         std::make_unique<CallLinkStatus>(
                             CallLinkStatus::computeFor(
-                                locker, profiledBlock, *stub->m_callLinkInfo, callExitSiteData));
+                                locker, *stub->m_callLinkInfo, callExitSiteData));
                     
                     variant = PutByIdVariant::setter(