#ifndef JSImmediate_h
#define JSImmediate_h
+#include <wtf/Platform.h>
+
+#if !USE(JSVALUE32_64)
+
#include <wtf/Assertions.h>
#include <wtf/AlwaysInline.h>
#include <wtf/MathExtras.h>
class JSObject;
class UString;
- JSValuePtr js0();
- JSValuePtr jsNull();
- JSValuePtr jsBoolean(bool b);
- JSValuePtr jsUndefined();
- JSValuePtr jsImpossibleValue();
- JSValuePtr jsNumber(ExecState* exec, double d);
- JSValuePtr jsNumber(ExecState*, char i);
- JSValuePtr jsNumber(ExecState*, unsigned char i);
- JSValuePtr jsNumber(ExecState*, short i);
- JSValuePtr jsNumber(ExecState*, unsigned short i);
- JSValuePtr jsNumber(ExecState* exec, int i);
- JSValuePtr jsNumber(ExecState* exec, unsigned i);
- JSValuePtr jsNumber(ExecState* exec, long i);
- JSValuePtr jsNumber(ExecState* exec, unsigned long i);
- JSValuePtr jsNumber(ExecState* exec, long long i);
- JSValuePtr jsNumber(ExecState* exec, unsigned long long i);
- JSValuePtr jsNumber(JSGlobalData* globalData, double d);
- JSValuePtr jsNumber(JSGlobalData* globalData, short i);
- JSValuePtr jsNumber(JSGlobalData* globalData, unsigned short i);
- JSValuePtr jsNumber(JSGlobalData* globalData, int i);
- JSValuePtr jsNumber(JSGlobalData* globalData, unsigned i);
- JSValuePtr jsNumber(JSGlobalData* globalData, long i);
- JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long i);
- JSValuePtr jsNumber(JSGlobalData* globalData, long long i);
- JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long long i);
-
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
inline intptr_t reinterpretDoubleToIntptr(double value)
{
return WTF::bitwise_cast<intptr_t>(value);
/*
* On 64-bit platforms, we support an alternative encoding form for immediates, if
- * USE(ALTERNATE_JSIMMEDIATE) is defined. When this format is used, double precision
+ * USE(JSVALUE64) is defined. When this format is used, double precision
* floating point values may also be encoded as JSImmediates.
*
* The encoding makes use of unused NaN space in the IEEE754 representation. Any value
class JSImmediate {
private:
friend class JIT;
- friend class JSValuePtr;
+ friend class JSValue;
friend class JSFastMath;
- friend JSValuePtr js0();
- friend JSValuePtr jsNull();
- friend JSValuePtr jsBoolean(bool b);
- friend JSValuePtr jsUndefined();
- friend JSValuePtr jsImpossibleValue();
- friend JSValuePtr jsNumber(ExecState* exec, double d);
- friend JSValuePtr jsNumber(ExecState*, char i);
- friend JSValuePtr jsNumber(ExecState*, unsigned char i);
- friend JSValuePtr jsNumber(ExecState*, short i);
- friend JSValuePtr jsNumber(ExecState*, unsigned short i);
- friend JSValuePtr jsNumber(ExecState* exec, int i);
- friend JSValuePtr jsNumber(ExecState* exec, unsigned i);
- friend JSValuePtr jsNumber(ExecState* exec, long i);
- friend JSValuePtr jsNumber(ExecState* exec, unsigned long i);
- friend JSValuePtr jsNumber(ExecState* exec, long long i);
- friend JSValuePtr jsNumber(ExecState* exec, unsigned long long i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, double d);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, short i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned short i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, int i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, long i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, long long i);
- friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long long i);
-
-#if USE(ALTERNATE_JSIMMEDIATE)
+ friend JSValue jsNumber(ExecState* exec, double d);
+ friend JSValue jsNumber(ExecState*, char i);
+ friend JSValue jsNumber(ExecState*, unsigned char i);
+ friend JSValue jsNumber(ExecState*, short i);
+ friend JSValue jsNumber(ExecState*, unsigned short i);
+ friend JSValue jsNumber(ExecState* exec, int i);
+ friend JSValue jsNumber(ExecState* exec, unsigned i);
+ friend JSValue jsNumber(ExecState* exec, long i);
+ friend JSValue jsNumber(ExecState* exec, unsigned long i);
+ friend JSValue jsNumber(ExecState* exec, long long i);
+ friend JSValue jsNumber(ExecState* exec, unsigned long long i);
+ friend JSValue jsNumber(JSGlobalData* globalData, double d);
+ friend JSValue jsNumber(JSGlobalData* globalData, short i);
+ friend JSValue jsNumber(JSGlobalData* globalData, unsigned short i);
+ friend JSValue jsNumber(JSGlobalData* globalData, int i);
+ friend JSValue jsNumber(JSGlobalData* globalData, unsigned i);
+ friend JSValue jsNumber(JSGlobalData* globalData, long i);
+ friend JSValue jsNumber(JSGlobalData* globalData, unsigned long i);
+ friend JSValue jsNumber(JSGlobalData* globalData, long long i);
+ friend JSValue jsNumber(JSGlobalData* globalData, unsigned long long i);
+
+#if USE(JSVALUE64)
// If all bits in the mask are set, this indicates an integer number,
// if any but not all are set this value is a double precision number.
static const intptr_t TagTypeNumber = 0xffff000000000000ll;
static const intptr_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
static const intptr_t FullTagTypeNull = TagBitTypeOther;
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
static const int32_t IntegerPayloadShift = 0;
#else
static const int32_t IntegerPayloadShift = 1;
static const int32_t signBit = 0x80000000;
- static ALWAYS_INLINE bool isImmediate(JSValuePtr v)
+ static ALWAYS_INLINE bool isImmediate(JSValue v)
{
return rawValue(v) & TagMask;
}
- static ALWAYS_INLINE bool isNumber(JSValuePtr v)
+ static ALWAYS_INLINE bool isNumber(JSValue v)
{
return rawValue(v) & TagTypeNumber;
}
- static ALWAYS_INLINE bool isIntegerNumber(JSValuePtr v)
+ static ALWAYS_INLINE bool isIntegerNumber(JSValue v)
{
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
return (rawValue(v) & TagTypeNumber) == TagTypeNumber;
#else
return isNumber(v);
#endif
}
-#if USE(ALTERNATE_JSIMMEDIATE)
- static ALWAYS_INLINE bool isDoubleNumber(JSValuePtr v)
+#if USE(JSVALUE64)
+ static ALWAYS_INLINE bool isDouble(JSValue v)
{
return isNumber(v) && !isIntegerNumber(v);
}
#endif
- static ALWAYS_INLINE bool isPositiveIntegerNumber(JSValuePtr v)
+ static ALWAYS_INLINE bool isPositiveIntegerNumber(JSValue v)
{
// A single mask to check for the sign bit and the number tag all at once.
return (rawValue(v) & (signBit | TagTypeNumber)) == TagTypeNumber;
}
- static ALWAYS_INLINE bool isBoolean(JSValuePtr v)
+ static ALWAYS_INLINE bool isBoolean(JSValue v)
{
return (rawValue(v) & FullTagTypeMask) == FullTagTypeBool;
}
- static ALWAYS_INLINE bool isUndefinedOrNull(JSValuePtr v)
+ static ALWAYS_INLINE bool isUndefinedOrNull(JSValue v)
{
// Undefined and null share the same value, bar the 'undefined' bit in the extended tag.
return (rawValue(v) & ~ExtendedTagBitUndefined) == FullTagTypeNull;
}
- static JSValuePtr from(char);
- static JSValuePtr from(signed char);
- static JSValuePtr from(unsigned char);
- static JSValuePtr from(short);
- static JSValuePtr from(unsigned short);
- static JSValuePtr from(int);
- static JSValuePtr from(unsigned);
- static JSValuePtr from(long);
- static JSValuePtr from(unsigned long);
- static JSValuePtr from(long long);
- static JSValuePtr from(unsigned long long);
- static JSValuePtr from(double);
+ static JSValue from(char);
+ static JSValue from(signed char);
+ static JSValue from(unsigned char);
+ static JSValue from(short);
+ static JSValue from(unsigned short);
+ static JSValue from(int);
+ static JSValue from(unsigned);
+ static JSValue from(long);
+ static JSValue from(unsigned long);
+ static JSValue from(long long);
+ static JSValue from(unsigned long long);
+ static JSValue from(double);
- static ALWAYS_INLINE bool isEitherImmediate(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool isEitherImmediate(JSValue v1, JSValue v2)
{
return (rawValue(v1) | rawValue(v2)) & TagMask;
}
- static ALWAYS_INLINE bool areBothImmediate(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool areBothImmediate(JSValue v1, JSValue v2)
{
return isImmediate(v1) & isImmediate(v2);
}
- static ALWAYS_INLINE bool areBothImmediateIntegerNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool areBothImmediateIntegerNumbers(JSValue v1, JSValue v2)
{
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
return (rawValue(v1) & rawValue(v2) & TagTypeNumber) == TagTypeNumber;
#else
return rawValue(v1) & rawValue(v2) & TagTypeNumber;
#endif
}
- static double toDouble(JSValuePtr);
- static bool toBoolean(JSValuePtr);
- static JSObject* toObject(JSValuePtr, ExecState*);
- static JSObject* toThisObject(JSValuePtr, ExecState*);
- static UString toString(JSValuePtr);
-
- static bool getUInt32(JSValuePtr, uint32_t&);
- static bool getTruncatedInt32(JSValuePtr, int32_t&);
- static bool getTruncatedUInt32(JSValuePtr, uint32_t&);
+ static double toDouble(JSValue);
+ static bool toBoolean(JSValue);
- static int32_t getTruncatedInt32(JSValuePtr);
- static uint32_t getTruncatedUInt32(JSValuePtr);
+ static bool getUInt32(JSValue, uint32_t&);
+ static bool getTruncatedInt32(JSValue, int32_t&);
+ static bool getTruncatedUInt32(JSValue, uint32_t&);
- static JSValuePtr trueImmediate();
- static JSValuePtr falseImmediate();
- static JSValuePtr undefinedImmediate();
- static JSValuePtr nullImmediate();
- static JSValuePtr zeroImmediate();
- static JSValuePtr oneImmediate();
+ static int32_t getTruncatedInt32(JSValue);
+ static uint32_t getTruncatedUInt32(JSValue);
- static JSValuePtr impossibleValue();
-
- static JSObject* prototype(JSValuePtr, ExecState*);
+ static JSValue trueImmediate();
+ static JSValue falseImmediate();
+ static JSValue undefinedImmediate();
+ static JSValue nullImmediate();
+ static JSValue zeroImmediate();
+ static JSValue oneImmediate();
private:
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
static const int minImmediateInt = ((-INT_MAX) - 1);
static const int maxImmediateInt = INT_MAX;
#else
#endif
static const unsigned maxImmediateUInt = maxImmediateInt;
- static ALWAYS_INLINE JSValuePtr makeValue(intptr_t integer)
+ static ALWAYS_INLINE JSValue makeValue(intptr_t integer)
{
- return JSValuePtr::makeImmediate(integer);
+ return JSValue::makeImmediate(integer);
}
- // With USE(ALTERNATE_JSIMMEDIATE) we want the argument to be zero extended, so the
+ // With USE(JSVALUE64) we want the argument to be zero extended, so the
// integer doesn't interfere with the tag bits in the upper word. In the default encoding,
// if intptr_t id larger then int32_t we sign extend the value through the upper word.
-#if USE(ALTERNATE_JSIMMEDIATE)
- static ALWAYS_INLINE JSValuePtr makeInt(uint32_t value)
+#if USE(JSVALUE64)
+ static ALWAYS_INLINE JSValue makeInt(uint32_t value)
#else
- static ALWAYS_INLINE JSValuePtr makeInt(int32_t value)
+ static ALWAYS_INLINE JSValue makeInt(int32_t value)
#endif
{
return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagTypeNumber);
}
-#if USE(ALTERNATE_JSIMMEDIATE)
- static ALWAYS_INLINE JSValuePtr makeDouble(double value)
+#if USE(JSVALUE64)
+ static ALWAYS_INLINE JSValue makeDouble(double value)
{
return makeValue(reinterpretDoubleToIntptr(value) + DoubleEncodeOffset);
}
#endif
- static ALWAYS_INLINE JSValuePtr makeBool(bool b)
+ static ALWAYS_INLINE JSValue makeBool(bool b)
{
return makeValue((static_cast<intptr_t>(b) << ExtendedPayloadShift) | FullTagTypeBool);
}
- static ALWAYS_INLINE JSValuePtr makeUndefined()
+ static ALWAYS_INLINE JSValue makeUndefined()
{
return makeValue(FullTagTypeUndefined);
}
- static ALWAYS_INLINE JSValuePtr makeNull()
+ static ALWAYS_INLINE JSValue makeNull()
{
return makeValue(FullTagTypeNull);
}
template<typename T>
- static JSValuePtr fromNumberOutsideIntegerRange(T);
+ static JSValue fromNumberOutsideIntegerRange(T);
-#if USE(ALTERNATE_JSIMMEDIATE)
- static ALWAYS_INLINE double doubleValue(JSValuePtr v)
+#if USE(JSVALUE64)
+ static ALWAYS_INLINE double doubleValue(JSValue v)
{
return reinterpretIntptrToDouble(rawValue(v) - DoubleEncodeOffset);
}
#endif
- static ALWAYS_INLINE int32_t intValue(JSValuePtr v)
+ static ALWAYS_INLINE int32_t intValue(JSValue v)
{
return static_cast<int32_t>(rawValue(v) >> IntegerPayloadShift);
}
- static ALWAYS_INLINE uint32_t uintValue(JSValuePtr v)
+ static ALWAYS_INLINE uint32_t uintValue(JSValue v)
{
return static_cast<uint32_t>(rawValue(v) >> IntegerPayloadShift);
}
- static ALWAYS_INLINE bool boolValue(JSValuePtr v)
+ static ALWAYS_INLINE bool boolValue(JSValue v)
{
return rawValue(v) & ExtendedPayloadBitBoolValue;
}
- static ALWAYS_INLINE intptr_t rawValue(JSValuePtr v)
+ static ALWAYS_INLINE intptr_t rawValue(JSValue v)
{
return v.immediateValue();
}
-
- static double nonInlineNaN();
};
- ALWAYS_INLINE JSValuePtr JSImmediate::trueImmediate() { return makeBool(true); }
- ALWAYS_INLINE JSValuePtr JSImmediate::falseImmediate() { return makeBool(false); }
- ALWAYS_INLINE JSValuePtr JSImmediate::undefinedImmediate() { return makeUndefined(); }
- ALWAYS_INLINE JSValuePtr JSImmediate::nullImmediate() { return makeNull(); }
- ALWAYS_INLINE JSValuePtr JSImmediate::zeroImmediate() { return makeInt(0); }
- ALWAYS_INLINE JSValuePtr JSImmediate::oneImmediate() { return makeInt(1); }
-
- // This value is impossible because 0x4 is not a valid pointer but a tag of 0 would indicate non-immediate
- ALWAYS_INLINE JSValuePtr JSImmediate::impossibleValue() { return makeValue(0x4); }
+ ALWAYS_INLINE JSValue JSImmediate::trueImmediate() { return makeBool(true); }
+ ALWAYS_INLINE JSValue JSImmediate::falseImmediate() { return makeBool(false); }
+ ALWAYS_INLINE JSValue JSImmediate::undefinedImmediate() { return makeUndefined(); }
+ ALWAYS_INLINE JSValue JSImmediate::nullImmediate() { return makeNull(); }
+ ALWAYS_INLINE JSValue JSImmediate::zeroImmediate() { return makeInt(0); }
+ ALWAYS_INLINE JSValue JSImmediate::oneImmediate() { return makeInt(1); }
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
inline bool doubleToBoolean(double value)
{
return value < 0.0 || value > 0.0;
}
- ALWAYS_INLINE bool JSImmediate::toBoolean(JSValuePtr v)
+ ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)
{
ASSERT(isImmediate(v));
return isNumber(v) ? isIntegerNumber(v) ? v != zeroImmediate()
: doubleToBoolean(doubleValue(v)) : v == trueImmediate();
}
#else
- ALWAYS_INLINE bool JSImmediate::toBoolean(JSValuePtr v)
+ ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)
{
ASSERT(isImmediate(v));
return isIntegerNumber(v) ? v != zeroImmediate() : v == trueImmediate();
}
#endif
- ALWAYS_INLINE uint32_t JSImmediate::getTruncatedUInt32(JSValuePtr v)
+ ALWAYS_INLINE uint32_t JSImmediate::getTruncatedUInt32(JSValue v)
{
// FIXME: should probably be asserting isPositiveIntegerNumber here.
ASSERT(isIntegerNumber(v));
return intValue(v);
}
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
template<typename T>
- inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T value)
+ inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T value)
{
return makeDouble(static_cast<double>(value));
}
#else
template<typename T>
- inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T)
+ inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T)
{
- return noValue();
+ return JSValue();
}
#endif
- ALWAYS_INLINE JSValuePtr JSImmediate::from(char i)
+ ALWAYS_INLINE JSValue JSImmediate::from(char i)
{
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(signed char i)
+ ALWAYS_INLINE JSValue JSImmediate::from(signed char i)
{
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned char i)
+ ALWAYS_INLINE JSValue JSImmediate::from(unsigned char i)
{
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(short i)
+ ALWAYS_INLINE JSValue JSImmediate::from(short i)
{
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned short i)
+ ALWAYS_INLINE JSValue JSImmediate::from(unsigned short i)
{
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(int i)
+ ALWAYS_INLINE JSValue JSImmediate::from(int i)
{
-#if !USE(ALTERNATE_JSIMMEDIATE)
+#if !USE(JSVALUE64)
if ((i < minImmediateInt) | (i > maxImmediateInt))
return fromNumberOutsideIntegerRange(i);
#endif
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned i)
+ ALWAYS_INLINE JSValue JSImmediate::from(unsigned i)
{
if (i > maxImmediateUInt)
return fromNumberOutsideIntegerRange(i);
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(long i)
+ ALWAYS_INLINE JSValue JSImmediate::from(long i)
{
if ((i < minImmediateInt) | (i > maxImmediateInt))
return fromNumberOutsideIntegerRange(i);
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned long i)
+ ALWAYS_INLINE JSValue JSImmediate::from(unsigned long i)
{
if (i > maxImmediateUInt)
return fromNumberOutsideIntegerRange(i);
return makeInt(i);
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(long long i)
+ ALWAYS_INLINE JSValue JSImmediate::from(long long i)
{
if ((i < minImmediateInt) | (i > maxImmediateInt))
- return noValue();
+ return JSValue();
return makeInt(static_cast<intptr_t>(i));
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned long long i)
+ ALWAYS_INLINE JSValue JSImmediate::from(unsigned long long i)
{
if (i > maxImmediateUInt)
return fromNumberOutsideIntegerRange(i);
return makeInt(static_cast<intptr_t>(i));
}
- ALWAYS_INLINE JSValuePtr JSImmediate::from(double d)
+ ALWAYS_INLINE JSValue JSImmediate::from(double d)
{
const int intVal = static_cast<int>(d);
return from(intVal);
}
- ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(JSValuePtr v)
+ ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(JSValue v)
{
ASSERT(isIntegerNumber(v));
return intValue(v);
}
- ALWAYS_INLINE double JSImmediate::toDouble(JSValuePtr v)
+ ALWAYS_INLINE double JSImmediate::toDouble(JSValue v)
{
ASSERT(isImmediate(v));
if (isIntegerNumber(v))
return intValue(v);
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
if (isNumber(v)) {
- ASSERT(isDoubleNumber(v));
+ ASSERT(isDouble(v));
return doubleValue(v);
}
#else
return rawValue(v) >> ExtendedPayloadShift;
}
- ALWAYS_INLINE bool JSImmediate::getUInt32(JSValuePtr v, uint32_t& i)
+ ALWAYS_INLINE bool JSImmediate::getUInt32(JSValue v, uint32_t& i)
{
i = uintValue(v);
return isPositiveIntegerNumber(v);
}
- ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(JSValuePtr v, int32_t& i)
+ ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(JSValue v, int32_t& i)
{
i = intValue(v);
return isIntegerNumber(v);
}
- ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValuePtr v, uint32_t& i)
+ ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValue v, uint32_t& i)
{
return getUInt32(v, i);
}
- inline JSValuePtr js0()
+ inline JSValue::JSValue(JSNullTag)
{
- return JSImmediate::zeroImmediate();
+ *this = JSImmediate::nullImmediate();
}
-
- inline JSValuePtr jsNull()
+
+ inline JSValue::JSValue(JSUndefinedTag)
{
- return JSImmediate::nullImmediate();
+ *this = JSImmediate::undefinedImmediate();
}
- inline JSValuePtr jsBoolean(bool b)
+ inline JSValue::JSValue(JSTrueTag)
{
- return b ? JSImmediate::trueImmediate() : JSImmediate::falseImmediate();
+ *this = JSImmediate::trueImmediate();
}
- inline JSValuePtr jsUndefined()
+ inline JSValue::JSValue(JSFalseTag)
{
- return JSImmediate::undefinedImmediate();
+ *this = JSImmediate::falseImmediate();
}
- inline JSValuePtr jsImpossibleValue()
- {
- return JSImmediate::impossibleValue();
- }
-
- // These are identical logic to the JSValue functions above, and faster than jsNumber(number).toInt32().
- int32_t toInt32(double);
- uint32_t toUInt32(double);
- int32_t toInt32SlowCase(double, bool& ok);
- uint32_t toUInt32SlowCase(double, bool& ok);
-
- inline bool JSValuePtr::isUndefined() const
+ inline bool JSValue::isUndefinedOrNull() const
{
- return asValue() == jsUndefined();
+ return JSImmediate::isUndefinedOrNull(asValue());
}
- inline bool JSValuePtr::isNull() const
+ inline bool JSValue::isBoolean() const
{
- return asValue() == jsNull();
+ return JSImmediate::isBoolean(asValue());
}
- inline bool JSValuePtr::isUndefinedOrNull() const
+ inline bool JSValue::isTrue() const
{
- return JSImmediate::isUndefinedOrNull(asValue());
+ return asValue() == JSImmediate::trueImmediate();
}
- inline bool JSValuePtr::isBoolean() const
+ inline bool JSValue::isFalse() const
{
- return JSImmediate::isBoolean(asValue());
+ return asValue() == JSImmediate::falseImmediate();
}
- inline bool JSValuePtr::getBoolean(bool& v) const
+ inline bool JSValue::getBoolean(bool& v) const
{
if (JSImmediate::isBoolean(asValue())) {
v = JSImmediate::toBoolean(asValue());
return false;
}
- inline bool JSValuePtr::getBoolean() const
+ inline bool JSValue::getBoolean() const
{
return asValue() == jsBoolean(true);
}
- ALWAYS_INLINE int32_t JSValuePtr::toInt32(ExecState* exec) const
- {
- int32_t i;
- if (getTruncatedInt32(i))
- return i;
- bool ignored;
- return toInt32SlowCase(toNumber(exec), ignored);
- }
-
- inline uint32_t JSValuePtr::toUInt32(ExecState* exec) const
- {
- uint32_t i;
- if (getTruncatedUInt32(i))
- return i;
- bool ignored;
- return toUInt32SlowCase(toNumber(exec), ignored);
- }
-
- inline int32_t toInt32(double val)
- {
- if (!(val >= -2147483648.0 && val < 2147483648.0)) {
- bool ignored;
- return toInt32SlowCase(val, ignored);
- }
- return static_cast<int32_t>(val);
- }
-
- inline uint32_t toUInt32(double val)
- {
- if (!(val >= 0.0 && val < 4294967296.0)) {
- bool ignored;
- return toUInt32SlowCase(val, ignored);
- }
- return static_cast<uint32_t>(val);
- }
-
- inline int32_t JSValuePtr::toInt32(ExecState* exec, bool& ok) const
- {
- int32_t i;
- if (getTruncatedInt32(i)) {
- ok = true;
- return i;
- }
- return toInt32SlowCase(toNumber(exec), ok);
- }
-
- inline uint32_t JSValuePtr::toUInt32(ExecState* exec, bool& ok) const
- {
- uint32_t i;
- if (getTruncatedUInt32(i)) {
- ok = true;
- return i;
- }
- return toUInt32SlowCase(toNumber(exec), ok);
- }
-
- inline bool JSValuePtr::isCell() const
+ inline bool JSValue::isCell() const
{
return !JSImmediate::isImmediate(asValue());
}
- inline bool JSValuePtr::isInt32Fast() const
+ inline bool JSValue::isInt32() const
{
return JSImmediate::isIntegerNumber(asValue());
}
- inline int32_t JSValuePtr::getInt32Fast() const
+ inline int32_t JSValue::asInt32() const
{
- ASSERT(isInt32Fast());
+ ASSERT(isInt32());
return JSImmediate::getTruncatedInt32(asValue());
}
- inline bool JSValuePtr::isUInt32Fast() const
+ inline bool JSValue::isUInt32() const
{
return JSImmediate::isPositiveIntegerNumber(asValue());
}
- inline uint32_t JSValuePtr::getUInt32Fast() const
+ inline uint32_t JSValue::asUInt32() const
{
- ASSERT(isUInt32Fast());
+ ASSERT(isUInt32());
return JSImmediate::getTruncatedUInt32(asValue());
}
- inline JSValuePtr JSValuePtr::makeInt32Fast(int32_t i)
- {
- return JSImmediate::from(i);
- }
-
- inline bool JSValuePtr::areBothInt32Fast(JSValuePtr v1, JSValuePtr v2)
- {
- return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
- }
-
class JSFastMath {
public:
- static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValue v1, JSValue v2)
{
return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
}
- static ALWAYS_INLINE JSValuePtr equal(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue equal(JSValue v1, JSValue v2)
{
ASSERT(canDoFastBitwiseOperations(v1, v2));
return jsBoolean(v1 == v2);
}
- static ALWAYS_INLINE JSValuePtr notEqual(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue notEqual(JSValue v1, JSValue v2)
{
ASSERT(canDoFastBitwiseOperations(v1, v2));
return jsBoolean(v1 != v2);
}
- static ALWAYS_INLINE JSValuePtr andImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue andImmediateNumbers(JSValue v1, JSValue v2)
{
ASSERT(canDoFastBitwiseOperations(v1, v2));
return JSImmediate::makeValue(JSImmediate::rawValue(v1) & JSImmediate::rawValue(v2));
}
- static ALWAYS_INLINE JSValuePtr xorImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue xorImmediateNumbers(JSValue v1, JSValue v2)
{
ASSERT(canDoFastBitwiseOperations(v1, v2));
return JSImmediate::makeValue((JSImmediate::rawValue(v1) ^ JSImmediate::rawValue(v2)) | JSImmediate::TagTypeNumber);
}
- static ALWAYS_INLINE JSValuePtr orImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue orImmediateNumbers(JSValue v1, JSValue v2)
{
ASSERT(canDoFastBitwiseOperations(v1, v2));
return JSImmediate::makeValue(JSImmediate::rawValue(v1) | JSImmediate::rawValue(v2));
}
- static ALWAYS_INLINE bool canDoFastRshift(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool canDoFastRshift(JSValue v1, JSValue v2)
{
return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
}
- static ALWAYS_INLINE bool canDoFastUrshift(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool canDoFastUrshift(JSValue v1, JSValue v2)
{
return JSImmediate::areBothImmediateIntegerNumbers(v1, v2) && !(JSImmediate::rawValue(v1) & JSImmediate::signBit);
}
- static ALWAYS_INLINE JSValuePtr rightShiftImmediateNumbers(JSValuePtr val, JSValuePtr shift)
+ static ALWAYS_INLINE JSValue rightShiftImmediateNumbers(JSValue val, JSValue shift)
{
ASSERT(canDoFastRshift(val, shift) || canDoFastUrshift(val, shift));
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)
return JSImmediate::makeValue(static_cast<intptr_t>(static_cast<uint32_t>(static_cast<int32_t>(JSImmediate::rawValue(val)) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f))) | JSImmediate::TagTypeNumber);
#else
return JSImmediate::makeValue((JSImmediate::rawValue(val) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f)) | JSImmediate::TagTypeNumber);
#endif
}
- static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr v)
+ static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v)
{
// Number is non-negative and an operation involving two of these can't overflow.
// Checking for allowed negative numbers takes more time than it's worth on SunSpider.
return (JSImmediate::rawValue(v) & (JSImmediate::TagTypeNumber + (JSImmediate::signBit | (JSImmediate::signBit >> 1)))) == JSImmediate::TagTypeNumber;
}
- static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v1, JSValue v2)
{
// Number is non-negative and an operation involving two of these can't overflow.
// Checking for allowed negative numbers takes more time than it's worth on SunSpider.
return canDoFastAdditiveOperations(v1) && canDoFastAdditiveOperations(v2);
}
- static ALWAYS_INLINE JSValuePtr addImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue addImmediateNumbers(JSValue v1, JSValue v2)
{
ASSERT(canDoFastAdditiveOperations(v1, v2));
return JSImmediate::makeValue(JSImmediate::rawValue(v1) + JSImmediate::rawValue(v2) - JSImmediate::TagTypeNumber);
}
- static ALWAYS_INLINE JSValuePtr subImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+ static ALWAYS_INLINE JSValue subImmediateNumbers(JSValue v1, JSValue v2)
{
ASSERT(canDoFastAdditiveOperations(v1, v2));
return JSImmediate::makeValue(JSImmediate::rawValue(v1) - JSImmediate::rawValue(v2) + JSImmediate::TagTypeNumber);
}
- static ALWAYS_INLINE JSValuePtr incImmediateNumber(JSValuePtr v)
+ static ALWAYS_INLINE JSValue incImmediateNumber(JSValue v)
{
ASSERT(canDoFastAdditiveOperations(v));
return JSImmediate::makeValue(JSImmediate::rawValue(v) + (1 << JSImmediate::IntegerPayloadShift));
}
- static ALWAYS_INLINE JSValuePtr decImmediateNumber(JSValuePtr v)
+ static ALWAYS_INLINE JSValue decImmediateNumber(JSValue v)
{
ASSERT(canDoFastAdditiveOperations(v));
return JSImmediate::makeValue(JSImmediate::rawValue(v) - (1 << JSImmediate::IntegerPayloadShift));
} // namespace JSC
+#endif // !USE(JSVALUE32_64)
+
#endif // JSImmediate_h
projects / apple / javascriptcore.git / blobdiff