runtime/JSValue.h

   1 /*
   2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   4  *  Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 Apple Inc. All rights reserved.
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public License
  17  *  along with this library; see the file COPYING.LIB.  If not, write to
  18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #ifndef JSValue_h
  24 #define JSValue_h
  25
  26 #include <math.h>
  27 #include <stddef.h> // for size_t
  28 #include <stdint.h>
  29 #include <wtf/AlwaysInline.h>
  30 #include <wtf/Assertions.h>
  31 #include <wtf/HashTraits.h>
  32 #include <wtf/MathExtras.h>
  33 #include <wtf/StdLibExtras.h>
  34
  35 namespace JSC {
  36
  37     extern const double NaN;
  38     extern const double Inf;
  39
  40     class ExecState;
  41     class Identifier;
  42     class JSCell;
  43     class JSGlobalData;
  44     class JSGlobalObject;
  45     class JSObject;
  46     class JSString;
  47     class PropertySlot;
  48     class PutPropertySlot;
  49     class UString;
  50
  51     struct ClassInfo;
  52     struct Instruction;
  53
  54     template <class T> class WriteBarrierBase;
  55
  56     enum PreferredPrimitiveType { NoPreference, PreferNumber, PreferString };
  57
  58
  59 #if USE(JSVALUE32_64)
  60     typedef int64_t EncodedJSValue;
  61 #else
  62     typedef void* EncodedJSValue;
  63 #endif
  64
  65     union EncodedValueDescriptor {
  66         int64_t asInt64;
  67 #if USE(JSVALUE32_64)
  68         double asDouble;
  69 #elif USE(JSVALUE64)
  70         JSCell* ptr;
  71 #endif
  72
  73 #if CPU(BIG_ENDIAN)
  74         struct {
  75             int32_t tag;
  76             int32_t payload;
  77         } asBits;
  78 #else
  79         struct {
  80             int32_t payload;
  81             int32_t tag;
  82         } asBits;
  83 #endif
  84     };
  85
  86     double nonInlineNaN();
  87
  88     // This implements ToInt32, defined in ECMA-262 9.5.
  89     int32_t toInt32(double);
  90
  91     // This implements ToUInt32, defined in ECMA-262 9.6.
  92     inline uint32_t toUInt32(double number)
  93     {
  94         // As commented in the spec, the operation of ToInt32 and ToUint32 only differ
  95         // in how the result is interpreted; see NOTEs in sections 9.5 and 9.6.
  96         return toInt32(number);
  97     }
  98
  99     class JSValue {
 100         friend struct EncodedJSValueHashTraits;
 101         friend class JIT;
 102         friend class JITStubs;
 103         friend class JITStubCall;
 104         friend class JSInterfaceJIT;
 105         friend class SpecializedThunkJIT;
 106
 107     public:
 108         static EncodedJSValue encode(JSValue);
 109         static JSValue decode(EncodedJSValue);
 110
 111         enum JSNullTag { JSNull };
 112         enum JSUndefinedTag { JSUndefined };
 113         enum JSTrueTag { JSTrue };
 114         enum JSFalseTag { JSFalse };
 115         enum EncodeAsDoubleTag { EncodeAsDouble };
 116
 117         JSValue();
 118         JSValue(JSNullTag);
 119         JSValue(JSUndefinedTag);
 120         JSValue(JSTrueTag);
 121         JSValue(JSFalseTag);
 122         JSValue(JSCell* ptr);
 123         JSValue(const JSCell* ptr);
 124
 125         // Numbers
 126         JSValue(EncodeAsDoubleTag, double);
 127         explicit JSValue(double);
 128         explicit JSValue(char);
 129         explicit JSValue(unsigned char);
 130         explicit JSValue(short);
 131         explicit JSValue(unsigned short);
 132         explicit JSValue(int);
 133         explicit JSValue(unsigned);
 134         explicit JSValue(long);
 135         explicit JSValue(unsigned long);
 136         explicit JSValue(long long);
 137         explicit JSValue(unsigned long long);
 138
 139         operator bool() const;
 140         bool operator==(const JSValue& other) const;
 141         bool operator!=(const JSValue& other) const;
 142
 143         bool isInt32() const;
 144         bool isUInt32() const;
 145         bool isDouble() const;
 146         bool isTrue() const;
 147         bool isFalse() const;
 148
 149         int32_t asInt32() const;
 150         uint32_t asUInt32() const;
 151         double asDouble() const;
 152
 153         // Querying the type.
 154         bool isUndefined() const;
 155         bool isNull() const;
 156         bool isUndefinedOrNull() const;
 157         bool isBoolean() const;
 158         bool isNumber() const;
 159         bool isString() const;
 160         bool isGetterSetter() const;
 161         bool isObject() const;
 162         bool inherits(const ClassInfo*) const;
 163
 164         // Extracting the value.
 165         bool getBoolean(bool&) const;
 166         bool getBoolean() const; // false if not a boolean
 167         bool getNumber(double&) const;
 168         double uncheckedGetNumber() const;
 169         bool getString(ExecState* exec, UString&) const;
 170         UString getString(ExecState* exec) const; // null string if not a string
 171         JSObject* getObject() const; // 0 if not an object
 172
 173         // Extracting integer values.
 174         bool getUInt32(uint32_t&) const;
 175
 176         // Basic conversions.
 177         JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
 178         bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
 179
 180         bool toBoolean(ExecState*) const;
 181
 182         // toNumber conversion is expected to be side effect free if an exception has
 183         // been set in the ExecState already.
 184         double toNumber(ExecState*) const;
 185         JSValue toJSNumber(ExecState*) const; // Fast path for when you expect that the value is an immediate number.
 186         UString toString(ExecState*) const;
 187         UString toPrimitiveString(ExecState*) const;
 188         JSObject* toObject(ExecState*) const;
 189         JSObject* toObject(ExecState*, JSGlobalObject*) const;
 190
 191         // Integer conversions.
 192         double toInteger(ExecState*) const;
 193         double toIntegerPreserveNaN(ExecState*) const;
 194         int32_t toInt32(ExecState*) const;
 195         uint32_t toUInt32(ExecState*) const;
 196
 197 #if ENABLE(JSC_ZOMBIES)
 198         bool isZombie() const;
 199 #endif
 200
 201         // Floating point conversions (this is a convenience method for webcore;
 202         // signle precision float is not a representation used in JS or JSC).
 203         float toFloat(ExecState* exec) const { return static_cast<float>(toNumber(exec)); }
 204
 205         // Object operations, with the toObject operation included.
 206         JSValue get(ExecState*, const Identifier& propertyName) const;
 207         JSValue get(ExecState*, const Identifier& propertyName, PropertySlot&) const;
 208         JSValue get(ExecState*, unsigned propertyName) const;
 209         JSValue get(ExecState*, unsigned propertyName, PropertySlot&) const;
 210         void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
 211         void putDirect(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
 212         void put(ExecState*, unsigned propertyName, JSValue);
 213
 214         bool needsThisConversion() const;
 215         JSObject* toThisObject(ExecState*) const;
 216         JSValue toStrictThisObject(ExecState*) const;
 217         UString toThisString(ExecState*) const;
 218         JSString* toThisJSString(ExecState*) const;
 219
 220         static bool equal(ExecState* exec, JSValue v1, JSValue v2);
 221         static bool equalSlowCase(ExecState* exec, JSValue v1, JSValue v2);
 222         static bool equalSlowCaseInline(ExecState* exec, JSValue v1, JSValue v2);
 223         static bool strictEqual(ExecState* exec, JSValue v1, JSValue v2);
 224         static bool strictEqualSlowCase(ExecState* exec, JSValue v1, JSValue v2);
 225         static bool strictEqualSlowCaseInline(ExecState* exec, JSValue v1, JSValue v2);
 226
 227         JSValue getJSNumber(); // JSValue() if this is not a JSNumber or number object
 228
 229         bool isCell() const;
 230         JSCell* asCell() const;
 231         bool isValidCallee();
 232
 233 #ifndef NDEBUG
 234         char* description();
 235 #endif
 236
 237     private:
 238         template <class T> JSValue(WriteBarrierBase<T>);
 239
 240         enum HashTableDeletedValueTag { HashTableDeletedValue };
 241         JSValue(HashTableDeletedValueTag);
 242
 243         inline const JSValue asValue() const { return *this; }
 244         JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
 245         JSObject* toThisObjectSlowCase(ExecState*) const;
 246
 247         JSObject* synthesizePrototype(ExecState*) const;
 248         JSObject* synthesizeObject(ExecState*) const;
 249
 250 #if USE(JSVALUE32_64)
 251         /*
 252          * On 32-bit platforms USE(JSVALUE32_64) should be defined, and we use a NaN-encoded
 253          * form for immediates.
 254          *
 255          * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value
 256          * with the top 13 bits set represents a QNaN (with the sign bit set).  QNaN values
 257          * can encode a 51-bit payload.  Hardware produced and C-library payloads typically
 258          * have a payload of zero.  We assume that non-zero payloads are available to encode
 259          * pointer and integer values.  Since any 64-bit bit pattern where the top 15 bits are
 260          * all set represents a NaN with a non-zero payload, we can use this space in the NaN
 261          * ranges to encode other values (however there are also other ranges of NaN space that
 262          * could have been selected).
 263          *
 264          * For JSValues that do not contain a double value, the high 32 bits contain the tag
 265          * values listed in the enums below, which all correspond to NaN-space. In the case of
 266          * cell, integer and bool values the lower 32 bits (the 'payload') contain the pointer
 267          * integer or boolean value; in the case of all other tags the payload is 0.
 268          */
 269         enum { Int32Tag =        0xffffffff };
 270         enum { BooleanTag =      0xfffffffe };
 271         enum { NullTag =         0xfffffffd };
 272         enum { UndefinedTag =    0xfffffffc };
 273         enum { CellTag =         0xfffffffb };
 274         enum { EmptyValueTag =   0xfffffffa };
 275         enum { DeletedValueTag = 0xfffffff9 };
 276
 277         enum { LowestTag =  DeletedValueTag };
 278
 279         uint32_t tag() const;
 280         int32_t payload() const;
 281 #elif USE(JSVALUE64)
 282         /*
 283          * On 64-bit platforms USE(JSVALUE64) should be defined, and we use a NaN-encoded
 284          * form for immediates.
 285          *
 286          * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value
 287          * with the top 13 bits set represents a QNaN (with the sign bit set).  QNaN values
 288          * can encode a 51-bit payload.  Hardware produced and C-library payloads typically
 289          * have a payload of zero.  We assume that non-zero payloads are available to encode
 290          * pointer and integer values.  Since any 64-bit bit pattern where the top 15 bits are
 291          * all set represents a NaN with a non-zero payload, we can use this space in the NaN
 292          * ranges to encode other values (however there are also other ranges of NaN space that
 293          * could have been selected).
 294          *
 295          * This range of NaN space is represented by 64-bit numbers begining with the 16-bit
 296          * hex patterns 0xFFFE and 0xFFFF - we rely on the fact that no valid double-precision
 297          * numbers will begin fall in these ranges.
 298          *
 299          * The top 16-bits denote the type of the encoded JSValue:
 300          *
 301          *     Pointer {  0000:PPPP:PPPP:PPPP
 302          *              / 0001:****:****:****
 303          *     Double  {         ...
 304          *              \ FFFE:****:****:****
 305          *     Integer {  FFFF:0000:IIII:IIII
 306          *
 307          * The scheme we have implemented encodes double precision values by performing a
 308          * 64-bit integer addition of the value 2^48 to the number. After this manipulation
 309          * no encoded double-precision value will begin with the pattern 0x0000 or 0xFFFF.
 310          * Values must be decoded by reversing this operation before subsequent floating point
 311          * operations my be peformed.
 312          *
 313          * 32-bit signed integers are marked with the 16-bit tag 0xFFFF.
 314          *
 315          * The tag 0x0000 denotes a pointer, or another form of tagged immediate. Boolean,
 316          * null and undefined values are represented by specific, invalid pointer values:
 317          *
 318          *     False:     0x06
 319          *     True:      0x07
 320          *     Undefined: 0x0a
 321          *     Null:      0x02
 322          *
 323          * These values have the following properties:
 324          * - Bit 1 (TagBitTypeOther) is set for all four values, allowing real pointers to be
 325          *   quickly distinguished from all immediate values, including these invalid pointers.
 326          * - With bit 3 is masked out (TagBitUndefined) Undefined and Null share the
 327          *   same value, allowing null & undefined to be quickly detected.
 328          *
 329          * No valid JSValue will have the bit pattern 0x0, this is used to represent array
 330          * holes, and as a C++ 'no value' result (e.g. JSValue() has an internal value of 0).
 331          */
 332
 333         // These values are #defines since using static const integers here is a ~1% regression!
 334
 335         // This value is 2^48, used to encode doubles such that the encoded value will begin
 336         // with a 16-bit pattern within the range 0x0001..0xFFFE.
 337         #define DoubleEncodeOffset 0x1000000000000ll
 338         // If all bits in the mask are set, this indicates an integer number,
 339         // if any but not all are set this value is a double precision number.
 340         #define TagTypeNumber 0xffff000000000000ll
 341
 342         // All non-numeric (bool, null, undefined) immediates have bit 2 set.
 343         #define TagBitTypeOther 0x2ll
 344         #define TagBitBool      0x4ll
 345         #define TagBitUndefined 0x8ll
 346         // Combined integer value for non-numeric immediates.
 347         #define ValueFalse     (TagBitTypeOther | TagBitBool | false)
 348         #define ValueTrue      (TagBitTypeOther | TagBitBool | true)
 349         #define ValueUndefined (TagBitTypeOther | TagBitUndefined)
 350         #define ValueNull      (TagBitTypeOther)
 351
 352         // TagMask is used to check for all types of immediate values (either number or 'other').
 353         #define TagMask (TagTypeNumber | TagBitTypeOther)
 354
 355         // These special values are never visible to JavaScript code; Empty is used to represent
 356         // Array holes, and for uninitialized JSValues. Deleted is used in hash table code.
 357         // These values would map to cell types in the JSValue encoding, but not valid GC cell
 358         // pointer should have either of these values (Empty is null, deleted is at an invalid
 359         // alignment for a GC cell, and in the zero page).
 360         #define ValueEmpty   0x0ll
 361         #define ValueDeleted 0x4ll
 362 #endif
 363
 364         EncodedValueDescriptor u;
 365     };
 366
 367 #if USE(JSVALUE32_64)
 368     typedef IntHash<EncodedJSValue> EncodedJSValueHash;
 369
 370     struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
 371         static const bool emptyValueIsZero = false;
 372         static EncodedJSValue emptyValue() { return JSValue::encode(JSValue()); }
 373         static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 374         static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 375     };
 376 #else
 377     typedef PtrHash<EncodedJSValue> EncodedJSValueHash;
 378
 379     struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
 380         static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 381         static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 382     };
 383 #endif
 384
 385     // Stand-alone helper functions.
 386     inline JSValue jsNull()
 387     {
 388         return JSValue(JSValue::JSNull);
 389     }
 390
 391     inline JSValue jsUndefined()
 392     {
 393         return JSValue(JSValue::JSUndefined);
 394     }
 395
 396     inline JSValue jsBoolean(bool b)
 397     {
 398         return b ? JSValue(JSValue::JSTrue) : JSValue(JSValue::JSFalse);
 399     }
 400
 401     ALWAYS_INLINE JSValue jsDoubleNumber(double d)
 402     {
 403         return JSValue(JSValue::EncodeAsDouble, d);
 404     }
 405
 406     ALWAYS_INLINE JSValue jsNumber(double d)
 407     {
 408         return JSValue(d);
 409     }
 410
 411     ALWAYS_INLINE JSValue jsNumber(char i)
 412     {
 413         return JSValue(i);
 414     }
 415
 416     ALWAYS_INLINE JSValue jsNumber(unsigned char i)
 417     {
 418         return JSValue(i);
 419     }
 420
 421     ALWAYS_INLINE JSValue jsNumber(short i)
 422     {
 423         return JSValue(i);
 424     }
 425
 426     ALWAYS_INLINE JSValue jsNumber(unsigned short i)
 427     {
 428         return JSValue(i);
 429     }
 430
 431     ALWAYS_INLINE JSValue jsNumber(int i)
 432     {
 433         return JSValue(i);
 434     }
 435
 436     ALWAYS_INLINE JSValue jsNumber(unsigned i)
 437     {
 438         return JSValue(i);
 439     }
 440
 441     ALWAYS_INLINE JSValue jsNumber(long i)
 442     {
 443         return JSValue(i);
 444     }
 445
 446     ALWAYS_INLINE JSValue jsNumber(unsigned long i)
 447     {
 448         return JSValue(i);
 449     }
 450
 451     ALWAYS_INLINE JSValue jsNumber(long long i)
 452     {
 453         return JSValue(i);
 454     }
 455
 456     ALWAYS_INLINE JSValue jsNumber(unsigned long long i)
 457     {
 458         return JSValue(i);
 459     }
 460
 461     inline bool operator==(const JSValue a, const JSCell* b) { return a == JSValue(b); }
 462     inline bool operator==(const JSCell* a, const JSValue b) { return JSValue(a) == b; }
 463
 464     inline bool operator!=(const JSValue a, const JSCell* b) { return a != JSValue(b); }
 465     inline bool operator!=(const JSCell* a, const JSValue b) { return JSValue(a) != b; }
 466
 467     bool isZombie(const JSCell*);
 468
 469 } // namespace JSC
 470
 471 #endif // JSValue_h