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