Fix endless OSR exits when creating a rope that contains an object that ToPrimitive...
[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 SpecPrimitive          = 0x3bbf0000; // It's any non-Object JSValue. This is (~SpecObject & SpecHeapTop)
89 static const SpeculatedType SpecEmpty              = 0x40000000; // It's definitely an empty value marker.
90 static const SpeculatedType SpecBytecodeTop        = 0x7bbfffff; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN. This is (SpecHeapTop | SpecEmpty).
91 static const SpeculatedType SpecFullTop            = 0x7fffffff; // It can be any of the above plus anything the DFG chooses.
92
93 typedef bool (*SpeculatedTypeChecker)(SpeculatedType);
94
95 // Dummy prediction checker, only useful if someone insists on requiring a prediction checker.
96 inline bool isAnySpeculation(SpeculatedType)
97 {
98     return true;
99 }
100
101 inline bool isCellSpeculation(SpeculatedType value)
102 {
103     return !!(value & SpecCell) && !(value & ~SpecCell);
104 }
105
106 inline bool isNotCellSpeculation(SpeculatedType value)
107 {
108     return !(value & SpecCell) && value;
109 }
110
111 inline bool isObjectSpeculation(SpeculatedType value)
112 {
113     return !!(value & SpecObject) && !(value & ~SpecObject);
114 }
115
116 inline bool isObjectOrOtherSpeculation(SpeculatedType value)
117 {
118     return !!(value & (SpecObject | SpecOther)) && !(value & ~(SpecObject | SpecOther));
119 }
120
121 inline bool isFinalObjectSpeculation(SpeculatedType value)
122 {
123     return value == SpecFinalObject;
124 }
125
126 inline bool isFinalObjectOrOtherSpeculation(SpeculatedType value)
127 {
128     return !!(value & (SpecFinalObject | SpecOther)) && !(value & ~(SpecFinalObject | SpecOther));
129 }
130
131 inline bool isStringIdentSpeculation(SpeculatedType value)
132 {
133     return value == SpecStringIdent;
134 }
135
136 inline bool isNotStringVarSpeculation(SpeculatedType value)
137 {
138     return !(value & SpecStringVar);
139 }
140
141 inline bool isStringSpeculation(SpeculatedType value)
142 {
143     return !!value && (value & SpecString) == value;
144 }
145
146 inline bool isSymbolSpeculation(SpeculatedType value)
147 {
148     return value == SpecSymbol;
149 }
150
151 inline bool isArraySpeculation(SpeculatedType value)
152 {
153     return value == SpecArray;
154 }
155
156 inline bool isFunctionSpeculation(SpeculatedType value)
157 {
158     return value == SpecFunction;
159 }
160
161 inline bool isInt8ArraySpeculation(SpeculatedType value)
162 {
163     return value == SpecInt8Array;
164 }
165
166 inline bool isInt16ArraySpeculation(SpeculatedType value)
167 {
168     return value == SpecInt16Array;
169 }
170
171 inline bool isInt32ArraySpeculation(SpeculatedType value)
172 {
173     return value == SpecInt32Array;
174 }
175
176 inline bool isUint8ArraySpeculation(SpeculatedType value)
177 {
178     return value == SpecUint8Array;
179 }
180
181 inline bool isUint8ClampedArraySpeculation(SpeculatedType value)
182 {
183     return value == SpecUint8ClampedArray;
184 }
185
186 inline bool isUint16ArraySpeculation(SpeculatedType value)
187 {
188     return value == SpecUint16Array;
189 }
190
191 inline bool isUint32ArraySpeculation(SpeculatedType value)
192 {
193     return value == SpecUint32Array;
194 }
195
196 inline bool isFloat32ArraySpeculation(SpeculatedType value)
197 {
198     return value == SpecFloat32Array;
199 }
200
201 inline bool isFloat64ArraySpeculation(SpeculatedType value)
202 {
203     return value == SpecFloat64Array;
204 }
205
206 inline bool isDirectArgumentsSpeculation(SpeculatedType value)
207 {
208     return value == SpecDirectArguments;
209 }
210
211 inline bool isScopedArgumentsSpeculation(SpeculatedType value)
212 {
213     return value == SpecScopedArguments;
214 }
215
216 inline bool isActionableIntMutableArraySpeculation(SpeculatedType value)
217 {
218     return isInt8ArraySpeculation(value)
219         || isInt16ArraySpeculation(value)
220         || isInt32ArraySpeculation(value)
221         || isUint8ArraySpeculation(value)
222         || isUint8ClampedArraySpeculation(value)
223         || isUint16ArraySpeculation(value)
224         || isUint32ArraySpeculation(value);
225 }
226
227 inline bool isActionableFloatMutableArraySpeculation(SpeculatedType value)
228 {
229     return isFloat32ArraySpeculation(value)
230         || isFloat64ArraySpeculation(value);
231 }
232
233 inline bool isActionableTypedMutableArraySpeculation(SpeculatedType value)
234 {
235     return isActionableIntMutableArraySpeculation(value)
236         || isActionableFloatMutableArraySpeculation(value);
237 }
238
239 inline bool isActionableMutableArraySpeculation(SpeculatedType value)
240 {
241     return isArraySpeculation(value)
242         || isActionableTypedMutableArraySpeculation(value);
243 }
244
245 inline bool isActionableArraySpeculation(SpeculatedType value)
246 {
247     return isStringSpeculation(value)
248         || isDirectArgumentsSpeculation(value)
249         || isScopedArgumentsSpeculation(value)
250         || isActionableMutableArraySpeculation(value);
251 }
252
253 inline bool isArrayOrOtherSpeculation(SpeculatedType value)
254 {
255     return !!(value & (SpecArray | SpecOther)) && !(value & ~(SpecArray | SpecOther));
256 }
257
258 inline bool isStringObjectSpeculation(SpeculatedType value)
259 {
260     return value == SpecStringObject;
261 }
262
263 inline bool isStringOrStringObjectSpeculation(SpeculatedType value)
264 {
265     return !!value && !(value & ~(SpecString | SpecStringObject));
266 }
267
268 inline bool isBoolInt32Speculation(SpeculatedType value)
269 {
270     return value == SpecBoolInt32;
271 }
272
273 inline bool isInt32Speculation(SpeculatedType value)
274 {
275     return value && !(value & ~SpecInt32);
276 }
277
278 inline bool isInt32OrBooleanSpeculation(SpeculatedType value)
279 {
280     return value && !(value & ~(SpecBoolean | SpecInt32));
281 }
282
283 inline bool isInt32SpeculationForArithmetic(SpeculatedType value)
284 {
285     return !(value & (SpecFullDouble | SpecInt52));
286 }
287
288 inline bool isInt32OrBooleanSpeculationForArithmetic(SpeculatedType value)
289 {
290     return !(value & (SpecFullDouble | SpecInt52));
291 }
292
293 inline bool isInt32OrBooleanSpeculationExpectingDefined(SpeculatedType value)
294 {
295     return isInt32OrBooleanSpeculation(value & ~SpecOther);
296 }
297
298 inline bool isInt52Speculation(SpeculatedType value)
299 {
300     return value == SpecInt52;
301 }
302
303 inline bool isMachineIntSpeculation(SpeculatedType value)
304 {
305     return !!value && (value & SpecMachineInt) == value;
306 }
307
308 inline bool isInt52AsDoubleSpeculation(SpeculatedType value)
309 {
310     return value == SpecInt52AsDouble;
311 }
312
313 inline bool isIntegerSpeculation(SpeculatedType value)
314 {
315     return !!value && (value & SpecInteger) == value;
316 }
317
318 inline bool isDoubleRealSpeculation(SpeculatedType value)
319 {
320     return !!value && (value & SpecDoubleReal) == value;
321 }
322
323 inline bool isDoubleSpeculation(SpeculatedType value)
324 {
325     return !!value && (value & SpecFullDouble) == value;
326 }
327
328 inline bool isDoubleSpeculationForArithmetic(SpeculatedType value)
329 {
330     return !!(value & SpecFullDouble);
331 }
332
333 inline bool isBytecodeRealNumberSpeculation(SpeculatedType value)
334 {
335     return !!(value & SpecBytecodeRealNumber) && !(value & ~SpecBytecodeRealNumber);
336 }
337
338 inline bool isFullRealNumberSpeculation(SpeculatedType value)
339 {
340     return !!(value & SpecFullRealNumber) && !(value & ~SpecFullRealNumber);
341 }
342
343 inline bool isBytecodeNumberSpeculation(SpeculatedType value)
344 {
345     return !!(value & SpecBytecodeNumber) && !(value & ~SpecBytecodeNumber);
346 }
347
348 inline bool isFullNumberSpeculation(SpeculatedType value)
349 {
350     return !!(value & SpecFullNumber) && !(value & ~SpecFullNumber);
351 }
352
353 inline bool isFullNumberOrBooleanSpeculation(SpeculatedType value)
354 {
355     return value && !(value & ~(SpecFullNumber | SpecBoolean));
356 }
357
358 inline bool isFullNumberOrBooleanSpeculationExpectingDefined(SpeculatedType value)
359 {
360     return isFullNumberOrBooleanSpeculation(value & ~SpecOther);
361 }
362
363 inline bool isBooleanSpeculation(SpeculatedType value)
364 {
365     return value == SpecBoolean;
366 }
367
368 inline bool isOtherSpeculation(SpeculatedType value)
369 {
370     return value == SpecOther;
371 }
372
373 inline bool isMiscSpeculation(SpeculatedType value)
374 {
375     return !!value && !(value & ~SpecMisc);
376 }
377
378 inline bool isOtherOrEmptySpeculation(SpeculatedType value)
379 {
380     return !value || value == SpecOther;
381 }
382
383 inline bool isEmptySpeculation(SpeculatedType value)
384 {
385     return value == SpecEmpty;
386 }
387
388 inline bool isUntypedSpeculationForArithmetic(SpeculatedType value)
389 {
390     return !(value & (SpecFullNumber | SpecBoolean));
391 }
392
393 void dumpSpeculation(PrintStream&, SpeculatedType);
394 void dumpSpeculationAbbreviated(PrintStream&, SpeculatedType);
395
396 MAKE_PRINT_ADAPTOR(SpeculationDump, SpeculatedType, dumpSpeculation);
397 MAKE_PRINT_ADAPTOR(AbbreviatedSpeculationDump, SpeculatedType, dumpSpeculationAbbreviated);
398
399 // Merge two predictions. Note that currently this just does left | right. It may
400 // seem tempting to do so directly, but you would be doing so at your own peril,
401 // since the merging protocol SpeculatedType may change at any time (and has already
402 // changed several times in its history).
403 inline SpeculatedType mergeSpeculations(SpeculatedType left, SpeculatedType right)
404 {
405     return left | right;
406 }
407
408 template<typename T>
409 inline bool mergeSpeculation(T& left, SpeculatedType right)
410 {
411     SpeculatedType newSpeculation = static_cast<T>(mergeSpeculations(static_cast<SpeculatedType>(left), right));
412     bool result = newSpeculation != static_cast<SpeculatedType>(left);
413     left = newSpeculation;
414     return result;
415 }
416
417 inline bool speculationChecked(SpeculatedType actual, SpeculatedType desired)
418 {
419     return (actual | desired) == desired;
420 }
421
422 SpeculatedType speculationFromClassInfo(const ClassInfo*);
423 SpeculatedType speculationFromStructure(Structure*);
424 SpeculatedType speculationFromCell(JSCell*);
425 SpeculatedType speculationFromValue(JSValue);
426
427 SpeculatedType speculationFromTypedArrayType(TypedArrayType); // only valid for typed views.
428 TypedArrayType typedArrayTypeFromSpeculation(SpeculatedType);
429
430 SpeculatedType leastUpperBoundOfStrictlyEquivalentSpeculations(SpeculatedType);
431
432 bool valuesCouldBeEqual(SpeculatedType, SpeculatedType);
433
434 // Precise computation of the type of the result of a double computation after we
435 // already know that the inputs are doubles and that the result must be a double. Use
436 // the closest one of these that applies.
437 SpeculatedType typeOfDoubleSum(SpeculatedType, SpeculatedType);
438 SpeculatedType typeOfDoubleDifference(SpeculatedType, SpeculatedType);
439 SpeculatedType typeOfDoubleProduct(SpeculatedType, SpeculatedType);
440 SpeculatedType typeOfDoubleQuotient(SpeculatedType, SpeculatedType);
441 SpeculatedType typeOfDoubleMinMax(SpeculatedType, SpeculatedType);
442 SpeculatedType typeOfDoubleNegation(SpeculatedType);
443 SpeculatedType typeOfDoubleAbs(SpeculatedType);
444 SpeculatedType typeOfDoubleRounding(SpeculatedType);
445 SpeculatedType typeOfDoublePow(SpeculatedType, SpeculatedType);
446
447 // This conservatively models the behavior of arbitrary double operations.
448 SpeculatedType typeOfDoubleBinaryOp(SpeculatedType, SpeculatedType);
449 SpeculatedType typeOfDoubleUnaryOp(SpeculatedType);
450
451 } // namespace JSC
452
453 #endif // SpeculatedType_h