09f9ee0757b6965723654fa0b0cde431ebc6a6df
[WebKit-https.git] / Source / JavaScriptCore / bytecode / DFGExitProfile.h
1 /*
2  * Copyright (C) 2011 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 DFGExitProfile_h
27 #define DFGExitProfile_h
28
29 #include <wtf/HashSet.h>
30 #include <wtf/OwnPtr.h>
31 #include <wtf/Vector.h>
32
33 namespace JSC { namespace DFG {
34
35 enum ExitKind {
36     ExitKindUnset,
37     BadType, // We exited because a type prediction was wrong.
38     BadCache, // We exited because an inline cache was wrong.
39     Overflow, // We exited because of overflow.
40     NegativeZero, // We exited because we encountered negative zero.
41     InadequateCoverage, // We exited because we ended up in code that didn't have profiling coverage.
42     ArgumentsEscaped, // We exited because arguments escaped but we didn't expect them to.
43     Uncountable, // We exited for none of the above reasons, and we should not count it. Most uses of this should be viewed as a FIXME.
44 };
45
46 inline const char* exitKindToString(ExitKind kind)
47 {
48     switch (kind) {
49     case ExitKindUnset:
50         return "Unset";
51     case BadType:
52         return "BadType";
53     case BadCache:
54         return "BadCache";
55     case Overflow:
56         return "Overflow";
57     case NegativeZero:
58         return "NegativeZero";
59     case InadequateCoverage:
60         return "InadequateCoverage";
61     default:
62         return "Unknown";
63     }
64 }
65
66 inline bool exitKindIsCountable(ExitKind kind)
67 {
68     switch (kind) {
69     case ExitKindUnset:
70         ASSERT_NOT_REACHED();
71     case BadType:
72     case Uncountable:
73         return false;
74     default:
75         return true;
76     }
77 }
78
79 class FrequentExitSite {
80 public:
81     FrequentExitSite()
82         : m_bytecodeOffset(0) // 0 = empty value
83         , m_kind(ExitKindUnset)
84     {
85     }
86     
87     FrequentExitSite(WTF::HashTableDeletedValueType)
88         : m_bytecodeOffset(1) // 1 = deleted value
89         , m_kind(ExitKindUnset)
90     {
91     }
92     
93     explicit FrequentExitSite(unsigned bytecodeOffset, ExitKind kind)
94         : m_bytecodeOffset(bytecodeOffset)
95         , m_kind(kind)
96     {
97         ASSERT(exitKindIsCountable(kind));
98     }
99     
100     // Use this constructor if you wish for the exit site to be counted globally within its
101     // code block.
102     explicit FrequentExitSite(ExitKind kind)
103         : m_bytecodeOffset(0)
104         , m_kind(kind)
105     {
106         ASSERT(exitKindIsCountable(kind));
107     }
108     
109     bool operator!() const
110     {
111         return m_kind == ExitKindUnset;
112     }
113     
114     bool operator==(const FrequentExitSite& other) const
115     {
116         return m_bytecodeOffset == other.m_bytecodeOffset
117             && m_kind == other.m_kind;
118     }
119     
120     unsigned hash() const
121     {
122         return WTF::intHash(m_bytecodeOffset) + m_kind;
123     }
124     
125     unsigned bytecodeOffset() const { return m_bytecodeOffset; }
126     ExitKind kind() const { return m_kind; }
127
128     bool isHashTableDeletedValue() const
129     {
130         return m_kind == ExitKindUnset && m_bytecodeOffset;
131     }
132
133 private:
134     unsigned m_bytecodeOffset;
135     ExitKind m_kind;
136 };
137
138 struct FrequentExitSiteHash {
139     static unsigned hash(const FrequentExitSite& key) { return key.hash(); }
140     static bool equal(const FrequentExitSite& a, const FrequentExitSite& b) { return a == b; }
141     static const bool safeToCompareToEmptyOrDeleted = true;
142 };
143
144 } } // namespace JSC::DFG
145
146 namespace WTF {
147
148 template<typename T> struct DefaultHash;
149 template<> struct DefaultHash<JSC::DFG::FrequentExitSite> {
150     typedef JSC::DFG::FrequentExitSiteHash Hash;
151 };
152
153 template<typename T> struct HashTraits;
154 template<> struct HashTraits<JSC::DFG::FrequentExitSite> : SimpleClassHashTraits<JSC::DFG::FrequentExitSite> { };
155
156 } // namespace WTF
157
158 namespace JSC { namespace DFG {
159
160 class QueryableExitProfile;
161
162 class ExitProfile {
163 public:
164     ExitProfile();
165     ~ExitProfile();
166     
167     // Add a new frequent exit site. Return true if this is a new one, or false
168     // if we already knew about it. This is an O(n) operation, because it errs
169     // on the side of keeping the data structure compact. Also, this will only
170     // be called a fixed number of times per recompilation. Recompilation is
171     // rare to begin with, and implies doing O(n) operations on the CodeBlock
172     // anyway.
173     bool add(const FrequentExitSite&);
174     
175 private:
176     friend class QueryableExitProfile;
177     
178     OwnPtr<Vector<FrequentExitSite> > m_frequentExitSites;
179 };
180
181 class QueryableExitProfile {
182 public:
183     explicit QueryableExitProfile(const ExitProfile&);
184     ~QueryableExitProfile();
185     
186     bool hasExitSite(const FrequentExitSite& site) const
187     {
188         return m_frequentExitSites.find(site) != m_frequentExitSites.end();
189     }
190     
191     bool hasExitSite(ExitKind kind) const
192     {
193         return hasExitSite(FrequentExitSite(kind));
194     }
195     
196     bool hasExitSite(unsigned bytecodeIndex, ExitKind kind) const
197     {
198         return hasExitSite(FrequentExitSite(bytecodeIndex, kind));
199     }
200 private:
201     HashSet<FrequentExitSite> m_frequentExitSites;
202 };
203
204 } } // namespace JSC::DFG
205
206 #endif // DFGExitProfile_h