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