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