c1fa0d12bebf113c6ebb444d78e5cc2af0181891
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSCJSValue.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, 2012 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 JSCJSValue_h
24 #define JSCJSValue_h
25
26 #include <math.h>
27 #include "PureNaN.h"
28 #include <stddef.h> // for size_t
29 #include <stdint.h>
30 #include <wtf/Assertions.h>
31 #include <wtf/Forward.h>
32 #include <wtf/HashMap.h>
33 #include <wtf/HashTraits.h>
34 #include <wtf/MathExtras.h>
35 #include <wtf/MediaTime.h>
36 #include <wtf/StdLibExtras.h>
37 #include <wtf/TriState.h>
38
39 namespace JSC {
40
41 class AssemblyHelpers;
42 class ExecState;
43 class JSCell;
44 class JSValueSource;
45 class VM;
46 class JSGlobalObject;
47 class JSObject;
48 class JSString;
49 class PropertyName;
50 class PropertySlot;
51 class PutPropertySlot;
52 class Structure;
53 #if ENABLE(DFG_JIT)
54 namespace DFG {
55 class JITCompiler;
56 class OSRExitCompiler;
57 class SpeculativeJIT;
58 }
59 #endif
60 #if !ENABLE(JIT)
61 namespace LLInt {
62 class CLoop;
63 }
64 #endif
65
66 struct ClassInfo;
67 struct DumpContext;
68 struct Instruction;
69 struct MethodTable;
70
71 template <class T> class WriteBarrierBase;
72
73 enum PreferredPrimitiveType { NoPreference, PreferNumber, PreferString };
74 enum ECMAMode { StrictMode, NotStrictMode };
75
76 typedef int64_t EncodedJSValue;
77     
78 union EncodedValueDescriptor {
79     int64_t asInt64;
80 #if USE(JSVALUE32_64)
81     double asDouble;
82 #elif USE(JSVALUE64)
83     JSCell* ptr;
84 #endif
85         
86 #if CPU(BIG_ENDIAN)
87     struct {
88         int32_t tag;
89         int32_t payload;
90     } asBits;
91 #else
92     struct {
93         int32_t payload;
94         int32_t tag;
95     } asBits;
96 #endif
97 };
98
99 #define TagOffset (OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag))
100 #define PayloadOffset (OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload))
101
102 #if USE(JSVALUE64)
103 #define CellPayloadOffset 0
104 #else
105 #define CellPayloadOffset PayloadOffset
106 #endif
107
108 enum WhichValueWord {
109     TagWord,
110     PayloadWord
111 };
112
113 // This implements ToInt32, defined in ECMA-262 9.5.
114 JS_EXPORT_PRIVATE int32_t toInt32(double);
115
116 // This implements ToUInt32, defined in ECMA-262 9.6.
117 inline uint32_t toUInt32(double number)
118 {
119     // As commented in the spec, the operation of ToInt32 and ToUint32 only differ
120     // in how the result is interpreted; see NOTEs in sections 9.5 and 9.6.
121     return toInt32(number);
122 }
123
124 int64_t tryConvertToInt52(double);
125 bool isInt52(double);
126
127 class JSValue {
128     friend struct EncodedJSValueHashTraits;
129     friend class AssemblyHelpers;
130     friend class JIT;
131     friend class JITSlowPathCall;
132     friend class JITStubs;
133     friend class JITStubCall;
134     friend class JSInterfaceJIT;
135     friend class JSValueSource;
136     friend class SpecializedThunkJIT;
137 #if ENABLE(DFG_JIT)
138     friend class DFG::JITCompiler;
139     friend class DFG::OSRExitCompiler;
140     friend class DFG::SpeculativeJIT;
141 #endif
142 #if !ENABLE(JIT)
143     friend class LLInt::CLoop;
144 #endif
145
146 public:
147 #if USE(JSVALUE32_64)
148     enum { Int32Tag =        0xffffffff };
149     enum { BooleanTag =      0xfffffffe };
150     enum { NullTag =         0xfffffffd };
151     enum { UndefinedTag =    0xfffffffc };
152     enum { CellTag =         0xfffffffb };
153     enum { EmptyValueTag =   0xfffffffa };
154     enum { DeletedValueTag = 0xfffffff9 };
155
156     enum { LowestTag =  DeletedValueTag };
157 #endif
158
159     static EncodedJSValue encode(JSValue);
160     static JSValue decode(EncodedJSValue);
161
162     enum JSNullTag { JSNull };
163     enum JSUndefinedTag { JSUndefined };
164     enum JSTrueTag { JSTrue };
165     enum JSFalseTag { JSFalse };
166     enum EncodeAsDoubleTag { EncodeAsDouble };
167
168     JSValue();
169     JSValue(JSNullTag);
170     JSValue(JSUndefinedTag);
171     JSValue(JSTrueTag);
172     JSValue(JSFalseTag);
173     JSValue(JSCell* ptr);
174     JSValue(const JSCell* ptr);
175
176     // Numbers
177     JSValue(EncodeAsDoubleTag, double);
178     explicit JSValue(double);
179     explicit JSValue(char);
180     explicit JSValue(unsigned char);
181     explicit JSValue(short);
182     explicit JSValue(unsigned short);
183     explicit JSValue(int);
184     explicit JSValue(unsigned);
185     explicit JSValue(long);
186     explicit JSValue(unsigned long);
187     explicit JSValue(long long);
188     explicit JSValue(unsigned long long);
189
190     typedef void* (JSValue::*UnspecifiedBoolType);
191     operator UnspecifiedBoolType*() const;
192     bool operator==(const JSValue& other) const;
193     bool operator!=(const JSValue& other) const;
194
195     bool isInt32() const;
196     bool isUInt32() const;
197     bool isDouble() const;
198     bool isTrue() const;
199     bool isFalse() const;
200
201     int32_t asInt32() const;
202     uint32_t asUInt32() const;
203     int64_t asMachineInt() const;
204     double asDouble() const;
205     bool asBoolean() const;
206     double asNumber() const;
207     
208     int32_t asInt32ForArithmetic() const; // Boolean becomes an int, but otherwise like asInt32().
209
210     // Querying the type.
211     bool isEmpty() const;
212     bool isFunction() const;
213     bool isUndefined() const;
214     bool isNull() const;
215     bool isUndefinedOrNull() const;
216     bool isBoolean() const;
217     bool isMachineInt() const;
218     bool isNumber() const;
219     bool isString() const;
220     bool isPrimitive() const;
221     bool isGetterSetter() const;
222     bool isCustomGetterSetter() const;
223     bool isObject() const;
224     bool inherits(const ClassInfo*) const;
225         
226     // Extracting the value.
227     bool getString(ExecState*, WTF::String&) const;
228     WTF::String getString(ExecState*) const; // null string if not a string
229     JSObject* getObject() const; // 0 if not an object
230
231     // Extracting integer values.
232     bool getUInt32(uint32_t&) const;
233         
234     // Basic conversions.
235     JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
236     bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
237
238     bool toBoolean(ExecState*) const;
239     TriState pureToBoolean() const;
240
241     // toNumber conversion is expected to be side effect free if an exception has
242     // been set in the ExecState already.
243     double toNumber(ExecState*) const;
244     JSString* toString(ExecState*) const;
245     WTF::String toWTFString(ExecState*) const;
246     WTF::String toWTFStringInline(ExecState*) const;
247     JSObject* toObject(ExecState*) const;
248     JSObject* toObject(ExecState*, JSGlobalObject*) const;
249
250     // Integer conversions.
251     JS_EXPORT_PRIVATE double toInteger(ExecState*) const;
252     JS_EXPORT_PRIVATE double toIntegerPreserveNaN(ExecState*) const;
253     int32_t toInt32(ExecState*) const;
254     uint32_t toUInt32(ExecState*) const;
255
256     // Floating point conversions (this is a convenience method for webcore;
257     // signle precision float is not a representation used in JS or JSC).
258     JS_EXPORT_PRIVATE float toFloat(ExecState* exec) const { return static_cast<float>(toNumber(exec)); }
259
260     // Object operations, with the toObject operation included.
261     JSValue get(ExecState*, PropertyName) const;
262     JSValue get(ExecState*, PropertyName, PropertySlot&) const;
263     JSValue get(ExecState*, unsigned propertyName) const;
264     JSValue get(ExecState*, unsigned propertyName, PropertySlot&) const;
265
266     bool getPropertySlot(ExecState*, PropertyName, PropertySlot&) const;
267
268     void put(ExecState*, PropertyName, JSValue, PutPropertySlot&);
269     JS_EXPORT_PRIVATE void putToPrimitive(ExecState*, PropertyName, JSValue, PutPropertySlot&);
270     JS_EXPORT_PRIVATE void putToPrimitiveByIndex(ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
271     void putByIndex(ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
272
273     JSValue toThis(ExecState*, ECMAMode) const;
274
275     static bool equal(ExecState*, JSValue v1, JSValue v2);
276     static bool equalSlowCase(ExecState*, JSValue v1, JSValue v2);
277     static bool equalSlowCaseInline(ExecState*, JSValue v1, JSValue v2);
278     static bool strictEqual(ExecState*, JSValue v1, JSValue v2);
279     static bool strictEqualSlowCase(ExecState*, JSValue v1, JSValue v2);
280     static bool strictEqualSlowCaseInline(ExecState*, JSValue v1, JSValue v2);
281     static TriState pureStrictEqual(JSValue v1, JSValue v2);
282
283     bool isCell() const;
284     JSCell* asCell() const;
285     JS_EXPORT_PRIVATE bool isValidCallee();
286         
287     JSValue structureOrUndefined() const;
288
289     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
290     void dumpInContext(PrintStream&, DumpContext*) const;
291     void dumpInContextAssumingStructure(PrintStream&, DumpContext*, Structure*) const;
292     void dumpForBacktrace(PrintStream&) const;
293
294     JS_EXPORT_PRIVATE JSObject* synthesizePrototype(ExecState*) const;
295
296     // Constants used for Int52. Int52 isn't part of JSValue right now, but JSValues may be
297     // converted to Int52s and back again.
298     static const unsigned numberOfInt52Bits = 52;
299     static const int64_t notInt52 = static_cast<int64_t>(1) << numberOfInt52Bits;
300     static const unsigned int52ShiftAmount = 12;
301     
302     static ptrdiff_t offsetOfPayload() { return OBJECT_OFFSETOF(JSValue, u.asBits.payload); }
303     static ptrdiff_t offsetOfTag() { return OBJECT_OFFSETOF(JSValue, u.asBits.tag); }
304
305 #if USE(JSVALUE32_64)
306     /*
307      * On 32-bit platforms USE(JSVALUE32_64) should be defined, and we use a NaN-encoded
308      * form for immediates.
309      *
310      * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value
311      * with the top 13 bits set represents a QNaN (with the sign bit set).  QNaN values
312      * can encode a 51-bit payload.  Hardware produced and C-library payloads typically
313      * have a payload of zero.  We assume that non-zero payloads are available to encode
314      * pointer and integer values.  Since any 64-bit bit pattern where the top 15 bits are
315      * all set represents a NaN with a non-zero payload, we can use this space in the NaN
316      * ranges to encode other values (however there are also other ranges of NaN space that
317      * could have been selected).
318      *
319      * For JSValues that do not contain a double value, the high 32 bits contain the tag
320      * values listed in the enums below, which all correspond to NaN-space. In the case of
321      * cell, integer and bool values the lower 32 bits (the 'payload') contain the pointer
322      * integer or boolean value; in the case of all other tags the payload is 0.
323      */
324     uint32_t tag() const;
325     int32_t payload() const;
326
327 #if !ENABLE(JIT)
328     // This should only be used by the LLInt C Loop interpreter who needs
329     // synthesize JSValue from its "register"s holding tag and payload
330     // values.
331     explicit JSValue(int32_t tag, int32_t payload);
332 #endif
333
334 #elif USE(JSVALUE64)
335     /*
336      * On 64-bit platforms USE(JSVALUE64) should be defined, and we use a NaN-encoded
337      * form for immediates.
338      *
339      * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value
340      * with the top 13 bits set represents a QNaN (with the sign bit set).  QNaN values
341      * can encode a 51-bit payload.  Hardware produced and C-library payloads typically
342      * have a payload of zero.  We assume that non-zero payloads are available to encode
343      * pointer and integer values.  Since any 64-bit bit pattern where the top 15 bits are
344      * all set represents a NaN with a non-zero payload, we can use this space in the NaN
345      * ranges to encode other values (however there are also other ranges of NaN space that
346      * could have been selected).
347      *
348      * This range of NaN space is represented by 64-bit numbers begining with the 16-bit
349      * hex patterns 0xFFFE and 0xFFFF - we rely on the fact that no valid double-precision
350      * numbers will fall in these ranges.
351      *
352      * The top 16-bits denote the type of the encoded JSValue:
353      *
354      *     Pointer {  0000:PPPP:PPPP:PPPP
355      *              / 0001:****:****:****
356      *     Double  {         ...
357      *              \ FFFE:****:****:****
358      *     Integer {  FFFF:0000:IIII:IIII
359      *
360      * The scheme we have implemented encodes double precision values by performing a
361      * 64-bit integer addition of the value 2^48 to the number. After this manipulation
362      * no encoded double-precision value will begin with the pattern 0x0000 or 0xFFFF.
363      * Values must be decoded by reversing this operation before subsequent floating point
364      * operations may be peformed.
365      *
366      * 32-bit signed integers are marked with the 16-bit tag 0xFFFF.
367      *
368      * The tag 0x0000 denotes a pointer, or another form of tagged immediate. Boolean,
369      * null and undefined values are represented by specific, invalid pointer values:
370      *
371      *     False:     0x06
372      *     True:      0x07
373      *     Undefined: 0x0a
374      *     Null:      0x02
375      *
376      * These values have the following properties:
377      * - Bit 1 (TagBitTypeOther) is set for all four values, allowing real pointers to be
378      *   quickly distinguished from all immediate values, including these invalid pointers.
379      * - With bit 3 is masked out (TagBitUndefined) Undefined and Null share the
380      *   same value, allowing null & undefined to be quickly detected.
381      *
382      * No valid JSValue will have the bit pattern 0x0, this is used to represent array
383      * holes, and as a C++ 'no value' result (e.g. JSValue() has an internal value of 0).
384      */
385
386     // These values are #defines since using static const integers here is a ~1% regression!
387
388     // This value is 2^48, used to encode doubles such that the encoded value will begin
389     // with a 16-bit pattern within the range 0x0001..0xFFFE.
390     #define DoubleEncodeOffset 0x1000000000000ll
391     // If all bits in the mask are set, this indicates an integer number,
392     // if any but not all are set this value is a double precision number.
393     #define TagTypeNumber 0xffff000000000000ll
394
395     // All non-numeric (bool, null, undefined) immediates have bit 2 set.
396     #define TagBitTypeOther 0x2ll
397     #define TagBitBool      0x4ll
398     #define TagBitUndefined 0x8ll
399     // Combined integer value for non-numeric immediates.
400     #define ValueFalse     (TagBitTypeOther | TagBitBool | false)
401     #define ValueTrue      (TagBitTypeOther | TagBitBool | true)
402     #define ValueUndefined (TagBitTypeOther | TagBitUndefined)
403     #define ValueNull      (TagBitTypeOther)
404
405     // TagMask is used to check for all types of immediate values (either number or 'other').
406     #define TagMask (TagTypeNumber | TagBitTypeOther)
407
408     // These special values are never visible to JavaScript code; Empty is used to represent
409     // Array holes, and for uninitialized JSValues. Deleted is used in hash table code.
410     // These values would map to cell types in the JSValue encoding, but not valid GC cell
411     // pointer should have either of these values (Empty is null, deleted is at an invalid
412     // alignment for a GC cell, and in the zero page).
413     #define ValueEmpty   0x0ll
414     #define ValueDeleted 0x4ll
415 #endif
416
417 private:
418     template <class T> JSValue(WriteBarrierBase<T>);
419
420     enum HashTableDeletedValueTag { HashTableDeletedValue };
421     JSValue(HashTableDeletedValueTag);
422
423     inline const JSValue asValue() const { return *this; }
424     JS_EXPORT_PRIVATE double toNumberSlowCase(ExecState*) const;
425     JS_EXPORT_PRIVATE JSString* toStringSlowCase(ExecState*) const;
426     JS_EXPORT_PRIVATE WTF::String toWTFStringSlowCase(ExecState*) const;
427     JS_EXPORT_PRIVATE JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
428     JS_EXPORT_PRIVATE JSValue toThisSlowCase(ExecState*, ECMAMode) const;
429
430     EncodedValueDescriptor u;
431 };
432
433 typedef IntHash<EncodedJSValue> EncodedJSValueHash;
434
435 #if USE(JSVALUE32_64)
436 struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
437     static const bool emptyValueIsZero = false;
438     static EncodedJSValue emptyValue() { return JSValue::encode(JSValue()); }
439     static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
440     static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
441 };
442 #else
443 struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
444     static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
445     static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
446 };
447 #endif
448
449 typedef HashMap<EncodedJSValue, unsigned, EncodedJSValueHash, EncodedJSValueHashTraits> JSValueMap;
450
451 // Stand-alone helper functions.
452 inline JSValue jsNull()
453 {
454     return JSValue(JSValue::JSNull);
455 }
456
457 inline JSValue jsUndefined()
458 {
459     return JSValue(JSValue::JSUndefined);
460 }
461
462 inline JSValue jsBoolean(bool b)
463 {
464     return b ? JSValue(JSValue::JSTrue) : JSValue(JSValue::JSFalse);
465 }
466
467 ALWAYS_INLINE JSValue jsDoubleNumber(double d)
468 {
469     ASSERT(JSValue(JSValue::EncodeAsDouble, d).isNumber());
470     return JSValue(JSValue::EncodeAsDouble, d);
471 }
472
473 ALWAYS_INLINE JSValue jsNumber(double d)
474 {
475     ASSERT(JSValue(d).isNumber());
476     return JSValue(d);
477 }
478
479 ALWAYS_INLINE JSValue jsNumber(MediaTime t)
480 {
481     return jsNumber(t.toDouble());
482 }
483
484 ALWAYS_INLINE JSValue jsNumber(char i)
485 {
486     return JSValue(i);
487 }
488
489 ALWAYS_INLINE JSValue jsNumber(unsigned char i)
490 {
491     return JSValue(i);
492 }
493
494 ALWAYS_INLINE JSValue jsNumber(short i)
495 {
496     return JSValue(i);
497 }
498
499 ALWAYS_INLINE JSValue jsNumber(unsigned short i)
500 {
501     return JSValue(i);
502 }
503
504 ALWAYS_INLINE JSValue jsNumber(int i)
505 {
506     return JSValue(i);
507 }
508
509 ALWAYS_INLINE JSValue jsNumber(unsigned i)
510 {
511     return JSValue(i);
512 }
513
514 ALWAYS_INLINE JSValue jsNumber(long i)
515 {
516     return JSValue(i);
517 }
518
519 ALWAYS_INLINE JSValue jsNumber(unsigned long i)
520 {
521     return JSValue(i);
522 }
523
524 ALWAYS_INLINE JSValue jsNumber(long long i)
525 {
526     return JSValue(i);
527 }
528
529 ALWAYS_INLINE JSValue jsNumber(unsigned long long i)
530 {
531     return JSValue(i);
532 }
533
534 inline bool operator==(const JSValue a, const JSCell* b) { return a == JSValue(b); }
535 inline bool operator==(const JSCell* a, const JSValue b) { return JSValue(a) == b; }
536
537 inline bool operator!=(const JSValue a, const JSCell* b) { return a != JSValue(b); }
538 inline bool operator!=(const JSCell* a, const JSValue b) { return JSValue(a) != b; }
539
540 } // namespace JSC
541
542 #endif // JSCJSValue_h