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
35namespace 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
472