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