Polymorphic call inlining should be based on polymorphic call inline caching rather...
[WebKit-https.git] / Source / JavaScriptCore / bytecode / CallLinkStatus.h
1 /*
2  * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef CallLinkStatus_h
27 #define CallLinkStatus_h
28
29 #include "CallLinkInfo.h"
30 #include "CallVariant.h"
31 #include "CodeOrigin.h"
32 #include "CodeSpecializationKind.h"
33 #include "ConcurrentJITLock.h"
34 #include "ExitingJITType.h"
35 #include "Intrinsic.h"
36 #include "JSCJSValue.h"
37
38 namespace JSC {
39
40 class CodeBlock;
41 class ExecutableBase;
42 class InternalFunction;
43 class JSFunction;
44 class Structure;
45 struct CallLinkInfo;
46
47 class CallLinkStatus {
48 public:
49     CallLinkStatus()
50         : m_couldTakeSlowPath(false)
51         , m_isProved(false)
52     {
53     }
54     
55     static CallLinkStatus takesSlowPath()
56     {
57         CallLinkStatus result;
58         result.m_couldTakeSlowPath = true;
59         return result;
60     }
61     
62     explicit CallLinkStatus(JSValue);
63     
64     CallLinkStatus(CallVariant variant)
65         : m_variants(1, variant)
66         , m_couldTakeSlowPath(false)
67         , m_isProved(false)
68     {
69     }
70     
71     CallLinkStatus& setIsProved(bool isProved)
72     {
73         m_isProved = isProved;
74         return *this;
75     }
76     
77     static CallLinkStatus computeFor(
78         CodeBlock*, unsigned bytecodeIndex, const CallLinkInfoMap&);
79
80     struct ExitSiteData {
81         ExitSiteData()
82             : m_takesSlowPath(false)
83             , m_badFunction(false)
84         {
85         }
86         
87         bool m_takesSlowPath;
88         bool m_badFunction;
89     };
90     static ExitSiteData computeExitSiteData(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex, ExitingJITType = ExitFromAnything);
91     
92 #if ENABLE(JIT)
93     // Computes the status assuming that we never took slow path and never previously
94     // exited.
95     static CallLinkStatus computeFor(const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&);
96     static CallLinkStatus computeFor(
97         const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&, ExitSiteData);
98 #endif
99     
100     typedef HashMap<CodeOrigin, CallLinkStatus, CodeOriginApproximateHash> ContextMap;
101     
102     // Computes all of the statuses of the DFG code block. Doesn't include statuses that had
103     // no information. Currently we use this when compiling FTL code, to enable polyvariant
104     // inlining.
105     static void computeDFGStatuses(CodeBlock* dfgCodeBlock, ContextMap&);
106     
107     // Helper that first consults the ContextMap and then does computeFor().
108     static CallLinkStatus computeFor(
109         CodeBlock*, CodeOrigin, const CallLinkInfoMap&, const ContextMap&);
110     
111     bool isSet() const { return !m_variants.isEmpty() || m_couldTakeSlowPath; }
112     
113     bool operator!() const { return !isSet(); }
114     
115     bool couldTakeSlowPath() const { return m_couldTakeSlowPath; }
116     
117     CallVariantList variants() const { return m_variants; }
118     unsigned size() const { return m_variants.size(); }
119     CallVariant at(unsigned i) const { return m_variants[i]; }
120     CallVariant operator[](unsigned i) const { return at(i); }
121     bool isProved() const { return m_isProved; }
122     bool canOptimize() const { return !m_variants.isEmpty(); }
123     
124     bool isClosureCall() const; // Returns true if any callee is a closure call.
125     
126     void dump(PrintStream&) const;
127     
128 private:
129     void makeClosureCall();
130     
131     static CallLinkStatus computeFromLLInt(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
132 #if ENABLE(JIT)
133     static CallLinkStatus computeFromCallLinkInfo(
134         const ConcurrentJITLocker&, CallLinkInfo&);
135 #endif
136     
137     CallVariantList m_variants;
138     bool m_couldTakeSlowPath;
139     bool m_isProved;
140 };
141
142 } // namespace JSC
143
144 #endif // CallLinkStatus_h
145