DFG should not speculate array even when predictions say that the base is not an...
[WebKit-https.git] / Source / JavaScriptCore / bytecode / PredictedType.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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef PredictedType_h
30 #define PredictedType_h
31
32 #include "JSValue.h"
33
34 namespace JSC {
35
36 class Structure;
37
38 typedef uint32_t PredictedType;
39 static const PredictedType PredictNone          = 0x00000000; // We don't know anything yet.
40 static const PredictedType PredictFinalObject   = 0x00000001; // It's definitely a JSFinalObject.
41 static const PredictedType PredictArray         = 0x00000002; // It's definitely a JSArray.
42 static const PredictedType PredictByteArray     = 0x00000004; // It's definitely a JSByteArray or one of its subclasses.
43 static const PredictedType PredictFunction      = 0x00000008; // It's definitely a JSFunction or one of its subclasses.
44 static const PredictedType PredictInt8Array     = 0x00000010; // It's definitely an Int8Array or one of its subclasses.
45 static const PredictedType PredictInt16Array    = 0x00000020; // It's definitely an Int16Array or one of its subclasses.
46 static const PredictedType PredictInt32Array    = 0x00000040; // It's definitely an Int32Array or one of its subclasses.
47 static const PredictedType PredictUint8Array    = 0x00000080; // It's definitely an Uint8Array or one of its subclasses.
48 static const PredictedType PredictUint16Array   = 0x00000100; // It's definitely an Uint16Array or one of its subclasses.
49 static const PredictedType PredictUint32Array   = 0x00000200; // It's definitely an Uint32Array or one of its subclasses.
50 static const PredictedType PredictFloat32Array  = 0x00000400; // It's definitely an Uint16Array or one of its subclasses.
51 static const PredictedType PredictFloat64Array  = 0x00000800; // It's definitely an Uint16Array or one of its subclasses.
52 static const PredictedType PredictObjectOther   = 0x00001000; // It's definitely an object but not JSFinalObject, JSArray, JSByteArray, or JSFunction.
53 static const PredictedType PredictObjectMask    = 0x00001fff; // Bitmask used for testing for any kind of object prediction.
54 static const PredictedType PredictString        = 0x00002000; // It's definitely a JSString.
55 static const PredictedType PredictCellOther     = 0x00004000; // It's definitely a JSCell but not a subclass of JSObject and definitely not a JSString.
56 static const PredictedType PredictCell          = 0x00007fff; // It's definitely a JSCell.
57 static const PredictedType PredictInt32         = 0x00008000; // It's definitely an Int32.
58 static const PredictedType PredictDoubleReal    = 0x00010000; // It's definitely a non-NaN double.
59 static const PredictedType PredictDoubleNaN     = 0x00020000; // It's definitely a NaN.
60 static const PredictedType PredictDouble        = 0x00030000; // It's either a non-NaN or a NaN double.
61 static const PredictedType PredictNumber        = 0x00038000; // It's either an Int32 or a Double.
62 static const PredictedType PredictBoolean       = 0x00040000; // It's definitely a Boolean.
63 static const PredictedType PredictOther         = 0x40000000; // It's definitely none of the above.
64 static const PredictedType PredictTop           = 0x7fffffff; // It can be any of the above.
65 static const PredictedType FixedIndexedStorageMask = PredictByteArray | PredictInt8Array | PredictInt16Array | PredictInt32Array | PredictUint8Array | PredictUint16Array | PredictUint32Array | PredictFloat32Array | PredictFloat64Array;
66
67 typedef bool (*PredictionChecker)(PredictedType);
68
69 inline bool isCellPrediction(PredictedType value)
70 {
71     return !!(value & PredictCell) && !(value & ~PredictCell);
72 }
73
74 inline bool isObjectPrediction(PredictedType value)
75 {
76     return !!(value & PredictObjectMask) && !(value & ~PredictObjectMask);
77 }
78
79 inline bool isFinalObjectPrediction(PredictedType value)
80 {
81     return value == PredictFinalObject;
82 }
83
84 inline bool isFinalObjectOrOtherPrediction(PredictedType value)
85 {
86     return !!(value & (PredictFinalObject | PredictOther)) && !(value & ~(PredictFinalObject | PredictOther));
87 }
88
89 inline bool isFixedIndexedStorageObjectPrediction(PredictedType value)
90 {
91     return (value & FixedIndexedStorageMask) == value;
92 }
93
94 inline bool isStringPrediction(PredictedType value)
95 {
96     return value == PredictString;
97 }
98
99 inline bool isArrayPrediction(PredictedType value)
100 {
101     return value == PredictArray;
102 }
103
104 inline bool isFunctionPrediction(PredictedType value)
105 {
106     return value == PredictFunction;
107 }
108
109 inline bool isByteArrayPrediction(PredictedType value)
110 {
111     return value == PredictByteArray;
112 }
113
114 inline bool isInt8ArrayPrediction(PredictedType value)
115 {
116     return value == PredictInt8Array;
117 }
118
119 inline bool isInt16ArrayPrediction(PredictedType value)
120 {
121     return value == PredictInt16Array;
122 }
123
124 inline bool isInt32ArrayPrediction(PredictedType value)
125 {
126     return value == PredictInt32Array;
127 }
128
129 inline bool isUint8ArrayPrediction(PredictedType value)
130 {
131     return value == PredictUint8Array;
132 }
133
134 inline bool isUint16ArrayPrediction(PredictedType value)
135 {
136     return value == PredictUint16Array;
137 }
138
139 inline bool isUint32ArrayPrediction(PredictedType value)
140 {
141     return value == PredictUint32Array;
142 }
143
144 inline bool isFloat32ArrayPrediction(PredictedType value)
145 {
146     return value == PredictFloat32Array;
147 }
148
149 inline bool isFloat64ArrayPrediction(PredictedType value)
150 {
151     return value == PredictFloat64Array;
152 }
153
154 inline bool isActionableMutableArrayPrediction(PredictedType value)
155 {
156     return isArrayPrediction(value)
157         || isByteArrayPrediction(value)
158         || isInt8ArrayPrediction(value)
159         || isInt16ArrayPrediction(value)
160         || isInt32ArrayPrediction(value)
161         || isUint8ArrayPrediction(value)
162         || isUint16ArrayPrediction(value)
163         || isUint32ArrayPrediction(value)
164 #if CPU(X86) || CPU(X86_64)
165         || isFloat32ArrayPrediction(value)
166 #endif
167         || isFloat64ArrayPrediction(value);
168 }
169
170 inline bool isActionableArrayPrediction(PredictedType value)
171 {
172     return isStringPrediction(value)
173         || isActionableMutableArrayPrediction(value);
174 }
175
176 inline bool isArrayOrOtherPrediction(PredictedType value)
177 {
178     return !!(value & (PredictArray | PredictOther)) && !(value & ~(PredictArray | PredictOther));
179 }
180
181 inline bool isInt32Prediction(PredictedType value)
182 {
183     return value == PredictInt32;
184 }
185
186 inline bool isDoubleRealPrediction(PredictedType value)
187 {
188     return value == PredictDoubleReal;
189 }
190
191 inline bool isDoublePrediction(PredictedType value)
192 {
193     return (value & PredictDouble) == value;
194 }
195
196 inline bool isNumberPrediction(PredictedType value)
197 {
198     return !!(value & PredictNumber) && !(value & ~PredictNumber);
199 }
200
201 inline bool isBooleanPrediction(PredictedType value)
202 {
203     return value == PredictBoolean;
204 }
205
206 inline bool isOtherPrediction(PredictedType value)
207 {
208     return value == PredictOther;
209 }
210
211 #ifndef NDEBUG
212 const char* predictionToString(PredictedType value);
213 #endif
214
215 // Merge two predictions. Note that currently this just does left | right. It may
216 // seem tempting to do so directly, but you would be doing so at your own peril,
217 // since the merging protocol PredictedType may change at any time (and has already
218 // changed several times in its history).
219 inline PredictedType mergePredictions(PredictedType left, PredictedType right)
220 {
221     return left | right;
222 }
223
224 template<typename T>
225 inline bool mergePrediction(T& left, PredictedType right)
226 {
227     PredictedType newPrediction = static_cast<T>(mergePredictions(static_cast<PredictedType>(left), right));
228     bool result = newPrediction != static_cast<PredictedType>(left);
229     left = newPrediction;
230     return result;
231 }
232
233 PredictedType predictionFromClassInfo(const ClassInfo*);
234 PredictedType predictionFromStructure(Structure*);
235 PredictedType predictionFromCell(JSCell*);
236 PredictedType predictionFromValue(JSValue);
237
238 } // namespace JSC
239
240 #endif // PredictedType_h