dac8bcc31708a97b1239689855db16126517799e
[WebKit-https.git] / Source / JavaScriptCore / bytecode / SpeculatedType.h
1 /*
2  * Copyright (C) 2011-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  *
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 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 SpeculatedType_h
30 #define SpeculatedType_h
31
32 #include "JSCJSValue.h"
33 #include "TypedArrayType.h"
34 #include <wtf/PrintStream.h>
35
36 namespace JSC {
37
38 class Structure;
39
40 typedef uint32_t SpeculatedType;
41 static const SpeculatedType SpecNone               = 0x00000000; // We don't know anything yet.
42 static const SpeculatedType SpecFinalObject        = 0x00000001; // It's definitely a JSFinalObject.
43 static const SpeculatedType SpecArray              = 0x00000002; // It's definitely a JSArray.
44 static const SpeculatedType SpecFunction           = 0x00000004; // It's definitely a JSFunction.
45 static const SpeculatedType SpecInt8Array          = 0x00000008; // It's definitely an Int8Array or one of its subclasses.
46 static const SpeculatedType SpecInt16Array         = 0x00000010; // It's definitely an Int16Array or one of its subclasses.
47 static const SpeculatedType SpecInt32Array         = 0x00000020; // It's definitely an Int32Array or one of its subclasses.
48 static const SpeculatedType SpecUint8Array         = 0x00000040; // It's definitely an Uint8Array or one of its subclasses.
49 static const SpeculatedType SpecUint8ClampedArray  = 0x00000080; // It's definitely an Uint8ClampedArray or one of its subclasses.
50 static const SpeculatedType SpecUint16Array        = 0x00000100; // It's definitely an Uint16Array or one of its subclasses.
51 static const SpeculatedType SpecUint32Array        = 0x00000200; // It's definitely an Uint32Array or one of its subclasses.
52 static const SpeculatedType SpecFloat32Array       = 0x00000400; // It's definitely an Uint16Array or one of its subclasses.
53 static const SpeculatedType SpecFloat64Array       = 0x00000800; // It's definitely an Uint16Array or one of its subclasses.
54 static const SpeculatedType SpecTypedArrayView     = SpecInt8Array | SpecInt16Array | SpecInt32Array | SpecUint8Array | SpecUint8ClampedArray | SpecUint16Array | SpecUint32Array | SpecFloat32Array | SpecFloat64Array;
55 static const SpeculatedType SpecDirectArguments    = 0x00001000; // It's definitely a DirectArguments object.
56 static const SpeculatedType SpecScopedArguments    = 0x00002000; // It's definitely a ScopedArguments object.
57 static const SpeculatedType SpecStringObject       = 0x00004000; // It's definitely a StringObject.
58 static const SpeculatedType SpecObjectOther        = 0x00008000; // It's definitely an object but not JSFinalObject, JSArray, or JSFunction.
59 static const SpeculatedType SpecObject             = 0x0000ffff; // Bitmask used for testing for any kind of object prediction.
60 static const SpeculatedType SpecStringIdent        = 0x00010000; // It's definitely a JSString, and it's an identifier.
61 static const SpeculatedType SpecStringVar          = 0x00020000; // It's definitely a JSString, and it's not an identifier.
62 static const SpeculatedType SpecString             = 0x00030000; // It's definitely a JSString.
63 static const SpeculatedType SpecSymbol             = 0x00040000; // It's definitely a Symbol.
64 static const SpeculatedType SpecCellOther          = 0x00080000; // It's definitely a JSCell but not a subclass of JSObject and definitely not a JSString or a Symbol. FIXME: This shouldn't be part of heap-top or bytecode-top. https://bugs.webkit.org/show_bug.cgi?id=133078
65 static const SpeculatedType SpecCell               = 0x000fffff; // It's definitely a JSCell.
66 static const SpeculatedType SpecBoolInt32          = 0x00100000; // It's definitely an Int32 with value 0 or 1.
67 static const SpeculatedType SpecNonBoolInt32       = 0x00200000; // It's definitely an Int32 with value other than 0 or 1.
68 static const SpeculatedType SpecInt32              = 0x00300000; // It's definitely an Int32.
69 static const SpeculatedType SpecInt52              = 0x00400000; // It's definitely an Int52 and we intend it to unbox it.
70 static const SpeculatedType SpecMachineInt         = 0x00700000; // It's something that we can do machine int arithmetic on.
71 static const SpeculatedType SpecInt52AsDouble      = 0x00800000; // It's definitely an Int52 and it's inside a double.
72 static const SpeculatedType SpecInteger            = 0x00f00000; // It's definitely some kind of integer.
73 static const SpeculatedType SpecNonIntAsDouble     = 0x01000000; // It's definitely not an Int52 but it's a real number and it's a double.
74 static const SpeculatedType SpecDoubleReal         = 0x01800000; // It's definitely a non-NaN double.
75 static const SpeculatedType SpecDoublePureNaN      = 0x02000000; // It's definitely a NaN that is sae to tag (i.e. pure).
76 static const SpeculatedType SpecDoubleImpureNaN    = 0x04000000; // It's definitely a NaN that is unsafe to tag (i.e. impure).
77 static const SpeculatedType SpecDoubleNaN          = 0x06000000; // It's definitely some kind of NaN.
78 static const SpeculatedType SpecBytecodeDouble     = 0x03800000; // It's either a non-NaN or a NaN double, but it's definitely not impure NaN.
79 static const SpeculatedType SpecFullDouble         = 0x07800000; // It's either a non-NaN or a NaN double.
80 static const SpeculatedType SpecBytecodeRealNumber = 0x01b00000; // It's either an Int32 or a DoubleReal.
81 static const SpeculatedType SpecFullRealNumber     = 0x01f00000; // It's either an Int32 or a DoubleReal, or a Int52.
82 static const SpeculatedType SpecBytecodeNumber     = 0x03b00000; // It's either an Int32 or a Double, and the Double cannot be an impure NaN.
83 static const SpeculatedType SpecFullNumber         = 0x07f00000; // It's either an Int32, Int52, or a Double, and the Double can be impure NaN.
84 static const SpeculatedType SpecBoolean            = 0x10000000; // It's definitely a Boolean.
85 static const SpeculatedType SpecOther              = 0x20000000; // It's definitely either Null or Undefined.
86 static const SpeculatedType SpecMisc               = 0x30000000; // It's definitely either a boolean, Null, or Undefined.
87 static const SpeculatedType SpecHeapTop            = 0x3bbfffff; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN.
88 static const SpeculatedType SpecEmpty              = 0x40000000; // It's definitely an empty value marker.
89 static const SpeculatedType SpecBytecodeTop        = 0x7bbfffff; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN. This is (SpecHeapTop | SpecEmpty).
90 static const SpeculatedType SpecFullTop            = 0x7fffffff; // It can be any of the above plus anything the DFG chooses.
91
92 typedef bool (*SpeculatedTypeChecker)(SpeculatedType);
93
94 // Dummy prediction checker, only useful if someone insists on requiring a prediction checker.
95 inline bool isAnySpeculation(SpeculatedType)
96 {
97     return true;
98 }
99
100 inline bool isCellSpeculation(SpeculatedType value)
101 {
102     return !!(value & SpecCell) && !(value & ~SpecCell);
103 }
104
105 inline bool isNotCellSpeculation(SpeculatedType value)
106 {
107     return !(value & SpecCell) && value;
108 }
109
110 inline bool isObjectSpeculation(SpeculatedType value)
111 {
112     return !!(value & SpecObject) && !(value & ~SpecObject);
113 }
114
115 inline bool isObjectOrOtherSpeculation(SpeculatedType value)
116 {
117     return !!(value & (SpecObject | SpecOther)) && !(value & ~(SpecObject | SpecOther));
118 }
119
120 inline bool isFinalObjectSpeculation(SpeculatedType value)
121 {
122     return value == SpecFinalObject;
123 }
124
125 inline bool isFinalObjectOrOtherSpeculation(SpeculatedType value)
126 {
127     return !!(value & (SpecFinalObject | SpecOther)) && !(value & ~(SpecFinalObject | SpecOther));
128 }
129
130 inline bool isStringIdentSpeculation(SpeculatedType value)
131 {
132     return value == SpecStringIdent;
133 }
134
135 inline bool isNotStringVarSpeculation(SpeculatedType value)
136 {
137     return !(value & SpecStringVar);
138 }
139
140 inline bool isStringSpeculation(SpeculatedType value)
141 {
142     return !!value && (value & SpecString) == value;
143 }
144
145 inline bool isSymbolSpeculation(SpeculatedType value)
146 {
147     return value == SpecSymbol;
148 }
149
150 inline bool isArraySpeculation(SpeculatedType value)
151 {
152     return value == SpecArray;
153 }
154
155 inline bool isFunctionSpeculation(SpeculatedType value)
156 {
157     return value == SpecFunction;
158 }
159
160 inline bool isInt8ArraySpeculation(SpeculatedType value)
161 {
162     return value == SpecInt8Array;
163 }
164
165 inline bool isInt16ArraySpeculation(SpeculatedType value)
166 {
167     return value == SpecInt16Array;
168 }
169
170 inline bool isInt32ArraySpeculation(SpeculatedType value)
171 {
172     return value == SpecInt32Array;
173 }
174
175 inline bool isUint8ArraySpeculation(SpeculatedType value)
176 {
177     return value == SpecUint8Array;
178 }
179
180 inline bool isUint8ClampedArraySpeculation(SpeculatedType value)
181 {
182     return value == SpecUint8ClampedArray;
183 }
184
185 inline bool isUint16ArraySpeculation(SpeculatedType value)
186 {
187     return value == SpecUint16Array;
188 }
189
190 inline bool isUint32ArraySpeculation(SpeculatedType value)
191 {
192     return value == SpecUint32Array;
193 }
194
195 inline bool isFloat32ArraySpeculation(SpeculatedType value)
196 {
197     return value == SpecFloat32Array;
198 }
199
200 inline bool isFloat64ArraySpeculation(SpeculatedType value)
201 {
202     return value == SpecFloat64Array;
203 }
204
205 inline bool isDirectArgumentsSpeculation(SpeculatedType value)
206 {
207     return value == SpecDirectArguments;
208 }
209
210 inline bool isScopedArgumentsSpeculation(SpeculatedType value)
211 {
212     return value == SpecScopedArguments;
213 }
214
215 inline bool isActionableIntMutableArraySpeculation(SpeculatedType value)
216 {
217     return isInt8ArraySpeculation(value)
218         || isInt16ArraySpeculation(value)
219         || isInt32ArraySpeculation(value)
220         || isUint8ArraySpeculation(value)
221         || isUint8ClampedArraySpeculation(value)
222         || isUint16ArraySpeculation(value)
223         || isUint32ArraySpeculation(value);
224 }
225
226 inline bool isActionableFloatMutableArraySpeculation(SpeculatedType value)
227 {
228     return isFloat32ArraySpeculation(value)
229         || isFloat64ArraySpeculation(value);
230 }
231
232 inline bool isActionableTypedMutableArraySpeculation(SpeculatedType value)
233 {
234     return isActionableIntMutableArraySpeculation(value)
235         || isActionableFloatMutableArraySpeculation(value);
236 }
237
238 inline bool isActionableMutableArraySpeculation(SpeculatedType value)
239 {
240     return isArraySpeculation(value)
241         || isActionableTypedMutableArraySpeculation(value);
242 }
243
244 inline bool isActionableArraySpeculation(SpeculatedType value)
245 {
246     return isStringSpeculation(value)
247         || isDirectArgumentsSpeculation(value)
248         || isScopedArgumentsSpeculation(value)
249         || isActionableMutableArraySpeculation(value);
250 }
251
252 inline bool isArrayOrOtherSpeculation(SpeculatedType value)
253 {
254     return !!(value & (SpecArray | SpecOther)) && !(value & ~(SpecArray | SpecOther));
255 }
256
257 inline bool isStringObjectSpeculation(SpeculatedType value)
258 {
259     return value == SpecStringObject;
260 }
261
262 inline bool isStringOrStringObjectSpeculation(SpeculatedType value)
263 {
264     return !!value && !(value & ~(SpecString | SpecStringObject));
265 }
266
267 inline bool isBoolInt32Speculation(SpeculatedType value)
268 {
269     return value == SpecBoolInt32;
270 }
271
272 inline bool isInt32Speculation(SpeculatedType value)
273 {
274     return value && !(value & ~SpecInt32);
275 }
276
277 inline bool isInt32OrBooleanSpeculation(SpeculatedType value)
278 {
279     return value && !(value & ~(SpecBoolean | SpecInt32));
280 }
281
282 inline bool isInt32SpeculationForArithmetic(SpeculatedType value)
283 {
284     return !(value & (SpecFullDouble | SpecInt52));
285 }
286
287 inline bool isInt32OrBooleanSpeculationForArithmetic(SpeculatedType value)
288 {
289     return !(value & (SpecFullDouble | SpecInt52));
290 }
291
292 inline bool isInt32OrBooleanSpeculationExpectingDefined(SpeculatedType value)
293 {
294     return isInt32OrBooleanSpeculation(value & ~SpecOther);
295 }
296
297 inline bool isInt52Speculation(SpeculatedType value)
298 {
299     return value == SpecInt52;
300 }
301
302 inline bool isMachineIntSpeculation(SpeculatedType value)
303 {
304     return !!value && (value & SpecMachineInt) == value;
305 }
306
307 inline bool isInt52AsDoubleSpeculation(SpeculatedType value)
308 {
309     return value == SpecInt52AsDouble;
310 }
311
312 inline bool isIntegerSpeculation(SpeculatedType value)
313 {
314     return !!value && (value & SpecInteger) == value;
315 }
316
317 inline bool isDoubleRealSpeculation(SpeculatedType value)
318 {
319     return !!value && (value & SpecDoubleReal) == value;
320 }
321
322 inline bool isDoubleSpeculation(SpeculatedType value)
323 {
324     return !!value && (value & SpecFullDouble) == value;
325 }
326
327 inline bool isDoubleSpeculationForArithmetic(SpeculatedType value)
328 {
329     return !!(value & SpecFullDouble);
330 }
331
332 inline bool isBytecodeRealNumberSpeculation(SpeculatedType value)
333 {
334     return !!(value & SpecBytecodeRealNumber) && !(value & ~SpecBytecodeRealNumber);
335 }
336
337 inline bool isFullRealNumberSpeculation(SpeculatedType value)
338 {
339     return !!(value & SpecFullRealNumber) && !(value & ~SpecFullRealNumber);
340 }
341
342 inline bool isBytecodeNumberSpeculation(SpeculatedType value)
343 {
344     return !!(value & SpecBytecodeNumber) && !(value & ~SpecBytecodeNumber);
345 }
346
347 inline bool isFullNumberSpeculation(SpeculatedType value)
348 {
349     return !!(value & SpecFullNumber) && !(value & ~SpecFullNumber);
350 }
351
352 inline bool isFullNumberOrBooleanSpeculation(SpeculatedType value)
353 {
354     return value && !(value & ~(SpecFullNumber | SpecBoolean));
355 }
356
357 inline bool isFullNumberOrBooleanSpeculationExpectingDefined(SpeculatedType value)
358 {
359     return isFullNumberOrBooleanSpeculation(value & ~SpecOther);
360 }
361
362 inline bool isBooleanSpeculation(SpeculatedType value)
363 {
364     return value == SpecBoolean;
365 }
366
367 inline bool isOtherSpeculation(SpeculatedType value)
368 {
369     return value == SpecOther;
370 }
371
372 inline bool isMiscSpeculation(SpeculatedType value)
373 {
374     return !!value && !(value & ~SpecMisc);
375 }
376
377 inline bool isOtherOrEmptySpeculation(SpeculatedType value)
378 {
379     return !value || value == SpecOther;
380 }
381
382 inline bool isEmptySpeculation(SpeculatedType value)
383 {
384     return value == SpecEmpty;
385 }
386
387 inline bool isUntypedSpeculationForArithmetic(SpeculatedType value)
388 {
389     return !(value & (SpecFullNumber | SpecBoolean));
390 }
391
392 void dumpSpeculation(PrintStream&, SpeculatedType);
393 void dumpSpeculationAbbreviated(PrintStream&, SpeculatedType);
394
395 MAKE_PRINT_ADAPTOR(SpeculationDump, SpeculatedType, dumpSpeculation);
396 MAKE_PRINT_ADAPTOR(AbbreviatedSpeculationDump, SpeculatedType, dumpSpeculationAbbreviated);
397
398 // Merge two predictions. Note that currently this just does left | right. It may
399 // seem tempting to do so directly, but you would be doing so at your own peril,
400 // since the merging protocol SpeculatedType may change at any time (and has already
401 // changed several times in its history).
402 inline SpeculatedType mergeSpeculations(SpeculatedType left, SpeculatedType right)
403 {
404     return left | right;
405 }
406
407 template<typename T>
408 inline bool mergeSpeculation(T& left, SpeculatedType right)
409 {
410     SpeculatedType newSpeculation = static_cast<T>(mergeSpeculations(static_cast<SpeculatedType>(left), right));
411     bool result = newSpeculation != static_cast<SpeculatedType>(left);
412     left = newSpeculation;
413     return result;
414 }
415
416 inline bool speculationChecked(SpeculatedType actual, SpeculatedType desired)
417 {
418     return (actual | desired) == desired;
419 }
420
421 SpeculatedType speculationFromClassInfo(const ClassInfo*);
422 SpeculatedType speculationFromStructure(Structure*);
423 SpeculatedType speculationFromCell(JSCell*);
424 SpeculatedType speculationFromValue(JSValue);
425
426 SpeculatedType speculationFromTypedArrayType(TypedArrayType); // only valid for typed views.
427 TypedArrayType typedArrayTypeFromSpeculation(SpeculatedType);
428
429 SpeculatedType leastUpperBoundOfStrictlyEquivalentSpeculations(SpeculatedType);
430
431 bool valuesCouldBeEqual(SpeculatedType, SpeculatedType);
432
433 // Precise computation of the type of the result of a double computation after we
434 // already know that the inputs are doubles and that the result must be a double. Use
435 // the closest one of these that applies.
436 SpeculatedType typeOfDoubleSum(SpeculatedType, SpeculatedType);
437 SpeculatedType typeOfDoubleDifference(SpeculatedType, SpeculatedType);
438 SpeculatedType typeOfDoubleProduct(SpeculatedType, SpeculatedType);
439 SpeculatedType typeOfDoubleQuotient(SpeculatedType, SpeculatedType);
440 SpeculatedType typeOfDoubleMinMax(SpeculatedType, SpeculatedType);
441 SpeculatedType typeOfDoubleNegation(SpeculatedType);
442 SpeculatedType typeOfDoubleAbs(SpeculatedType);
443 SpeculatedType typeOfDoubleRounding(SpeculatedType);
444 SpeculatedType typeOfDoublePow(SpeculatedType, SpeculatedType);
445
446 // This conservatively models the behavior of arbitrary double operations.
447 SpeculatedType typeOfDoubleBinaryOp(SpeculatedType, SpeculatedType);
448 SpeculatedType typeOfDoubleUnaryOp(SpeculatedType);
449
450 } // namespace JSC
451
452 #endif // SpeculatedType_h