Ignore:
Timestamp:
Jan 12, 2009, 8:51:16 PM (16 years ago)
Author:
[email protected]
Message:

JavaScriptCore:

2009-01-12 Gavin Barraclough <​[email protected]>

Reviewed by Oliver Hunt.

Make the JSImmediate interface private.

All manipulation of JS values should be through the JSValuePtr class, not by using JSImmediate
directly. The key missing methods on JSValuePtr are:

  • isCell() - check for values that are JSCell*s, and as such where asCell() may be used.
  • isInt32Fast() getInt32Fast() - fast check/access for integer immediates.
  • isUInt32Fast() getUInt32Fast() - ditto for unsigned integer immediates.

The JIT is allowed full access to JSImmediate, since it needs to be able to directly
manipulate JSValuePtrs. The Interpreter is provided access to perform operations directly
on JSValuePtrs through the new JSFastMath interface.

No performance impact.

  • API/JSCallbackObjectFunctions.h: (JSC::::toNumber):
  • API/JSValueRef.cpp: (JSValueIsEqual): (JSValueIsStrictEqual):
  • JavaScriptCore.exp:
  • bytecode/CodeBlock.h: (JSC::CodeBlock::isKnownNotImmediate):
  • bytecompiler/BytecodeGenerator.cpp: (JSC::keyForImmediateSwitch):
  • bytecompiler/BytecodeGenerator.h: (JSC::BytecodeGenerator::JSValueHashTraits::constructDeletedValue): (JSC::BytecodeGenerator::JSValueHashTraits::isDeletedValue):
  • interpreter/Interpreter.cpp: (JSC::jsLess): (JSC::jsLessEq): (JSC::jsAdd): (JSC::jsIsObjectType): (JSC::cachePrototypeChain): (JSC::Interpreter::tryCachePutByID): (JSC::Interpreter::tryCacheGetByID): (JSC::Interpreter::privateExecute): (JSC::Interpreter::tryCTICachePutByID): (JSC::Interpreter::tryCTICacheGetByID): (JSC::Interpreter::cti_op_add): (JSC::Interpreter::cti_op_get_by_id_self_fail): (JSC::Interpreter::cti_op_get_by_id_proto_list): (JSC::Interpreter::cti_op_instanceof): (JSC::Interpreter::cti_op_mul): (JSC::Interpreter::cti_op_get_by_val): (JSC::Interpreter::cti_op_get_by_val_byte_array): (JSC::Interpreter::cti_op_sub): (JSC::Interpreter::cti_op_put_by_val): (JSC::Interpreter::cti_op_put_by_val_array): (JSC::Interpreter::cti_op_put_by_val_byte_array): (JSC::Interpreter::cti_op_negate): (JSC::Interpreter::cti_op_div): (JSC::Interpreter::cti_op_eq): (JSC::Interpreter::cti_op_lshift): (JSC::Interpreter::cti_op_bitand): (JSC::Interpreter::cti_op_rshift): (JSC::Interpreter::cti_op_bitnot): (JSC::Interpreter::cti_op_neq): (JSC::Interpreter::cti_op_urshift): (JSC::Interpreter::cti_op_call_eval): (JSC::Interpreter::cti_op_throw): (JSC::Interpreter::cti_op_is_undefined): (JSC::Interpreter::cti_op_stricteq): (JSC::Interpreter::cti_op_nstricteq): (JSC::Interpreter::cti_op_switch_imm): (JSC::Interpreter::cti_vm_throw):
  • interpreter/Interpreter.h: (JSC::Interpreter::isJSArray): (JSC::Interpreter::isJSString): (JSC::Interpreter::isJSByteArray):
  • jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::privateCompileMainPass):
  • jit/JIT.h: (JSC::JIT::isStrictEqCaseHandledInJITCode):
  • jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_rshift): (JSC::JIT::compileFastArith_op_bitand): (JSC::JIT::compileFastArith_op_mod):
  • jit/JITCall.cpp: (JSC::JIT::unlinkCall): (JSC::JIT::compileOpCall):
  • jit/JITInlineMethods.h: (JSC::JIT::getConstantOperandImmediateInt): (JSC::JIT::isOperandConstantImmediateInt):
  • parser/Nodes.cpp: (JSC::processClauseList):
  • runtime/ArrayPrototype.cpp: (JSC::arrayProtoFuncIndexOf): (JSC::arrayProtoFuncLastIndexOf):
  • runtime/BooleanPrototype.cpp: (JSC::booleanProtoFuncValueOf):
  • runtime/Collector.cpp: (JSC::Heap::protect): (JSC::Heap::unprotect): (JSC::Heap::heap):
  • runtime/JSByteArray.cpp: (JSC::JSByteArray::getOwnPropertySlot):
  • runtime/JSByteArray.h: (JSC::JSByteArray::getIndex):
  • runtime/JSCell.cpp:
  • runtime/JSCell.h: (JSC::JSValuePtr::isNumberCell): (JSC::JSValuePtr::asCell): (JSC::JSValuePtr::isNumber):
  • runtime/JSGlobalObjectFunctions.cpp: (JSC::globalFuncParseInt):
  • runtime/JSImmediate.h: (JSC::js0): (JSC::jsImpossibleValue): (JSC::JSValuePtr::toInt32): (JSC::JSValuePtr::toUInt32): (JSC::JSValuePtr::isCell): (JSC::JSValuePtr::isInt32Fast): (JSC::JSValuePtr::getInt32Fast): (JSC::JSValuePtr::isUInt32Fast): (JSC::JSValuePtr::getUInt32Fast): (JSC::JSValuePtr::makeInt32Fast): (JSC::JSValuePtr::areBothInt32Fast): (JSC::JSFastMath::canDoFastBitwiseOperations): (JSC::JSFastMath::equal): (JSC::JSFastMath::notEqual): (JSC::JSFastMath::andImmediateNumbers): (JSC::JSFastMath::xorImmediateNumbers): (JSC::JSFastMath::orImmediateNumbers): (JSC::JSFastMath::canDoFastRshift): (JSC::JSFastMath::canDoFastUrshift): (JSC::JSFastMath::rightShiftImmediateNumbers): (JSC::JSFastMath::canDoFastAdditiveOperations): (JSC::JSFastMath::addImmediateNumbers): (JSC::JSFastMath::subImmediateNumbers): (JSC::JSFastMath::incImmediateNumber): (JSC::JSFastMath::decImmediateNumber):
  • runtime/JSNumberCell.h: (JSC::JSValuePtr::asNumberCell): (JSC::jsNumber): (JSC::JSValuePtr::uncheckedGetNumber): (JSC::JSNumberCell::toInt32): (JSC::JSNumberCell::toUInt32): (JSC::JSValuePtr::toJSNumber): (JSC::JSValuePtr::getNumber): (JSC::JSValuePtr::numberToInt32): (JSC::JSValuePtr::numberToUInt32):
  • runtime/JSObject.h: (JSC::JSValuePtr::isObject): (JSC::JSValuePtr::get): (JSC::JSValuePtr::put):
  • runtime/JSValue.cpp: (JSC::JSValuePtr::toInteger): (JSC::JSValuePtr::toIntegerPreserveNaN):
  • runtime/JSValue.h:
  • runtime/Operations.cpp: (JSC::JSValuePtr::equalSlowCase): (JSC::JSValuePtr::strictEqualSlowCase):
  • runtime/Operations.h: (JSC::JSValuePtr::equal): (JSC::JSValuePtr::equalSlowCaseInline): (JSC::JSValuePtr::strictEqual): (JSC::JSValuePtr::strictEqualSlowCaseInline):
  • runtime/Protect.h: (JSC::gcProtect): (JSC::gcUnprotect):
  • runtime/StringPrototype.cpp: (JSC::stringProtoFuncCharAt): (JSC::stringProtoFuncCharCodeAt):
  • runtime/Structure.cpp: (JSC::Structure::createCachedPrototypeChain):

WebCore:

2009-01-12 Gavin Barraclough <​[email protected]>

Reviewed by Oliver Hunt.

Deprecate JSValuePtr::getNumber() - two ways to get a number should be enough.

  • bindings/js/JSSQLTransactionCustom.cpp: (WebCore::JSSQLTransaction::executeSql):
  • bindings/objc/WebScriptObject.mm: (+[WebScriptObject _convertValueToObjcValue:originRootObject:rootObject:]):

WebKit/mac:

2009-01-12 Gavin Barraclough <​[email protected]>

Reviewed by Oliver Hunt.

Deprecate JSValuePtr::getNumber() - two ways to get a number should be enough.

  • WebView/WebView.mm: (aeDescFromJSValue):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/interpreter/Interpreter.cpp

    r39800 r39851  
    108108}
    109109
    110 // FIXME: This operation should be called "getNumber", not "isNumber" (as it is in JSValue.h).
    111 // FIXME: There's no need to have a "slow" version of this. All versions should be fast.
    112 static ALWAYS_INLINE bool fastIsNumber(JSValuePtr value, double& arg)
    113 {
    114     if (JSImmediate::isNumber(value))
    115         arg = JSImmediate::getTruncatedInt32(value);
    116     else if (LIKELY(!JSImmediate::isImmediate(value)) && LIKELY(Heap::isNumber(asCell(value))))
    117         arg = asNumberCell(value)->value();
    118     else
    119         return false;
    120     return true;
    121 }
    122 
    123 // FIXME: Why doesn't JSValuePtr::toInt32 have the Heap::isNumber optimization?
    124 static bool fastToInt32(JSValuePtr value, int32_t& arg)
    125 {
    126     if (JSImmediate::isNumber(value))
    127         arg = JSImmediate::getTruncatedInt32(value);
    128     else if (LIKELY(!JSImmediate::isImmediate(value)) && LIKELY(Heap::isNumber(asCell(value))))
    129         arg = asNumberCell(value)->toInt32();
    130     else
    131         return false;
    132     return true;
    133 }
    134 
    135 static ALWAYS_INLINE bool fastToUInt32(JSValuePtr value, uint32_t& arg)
    136 {
    137     if (JSImmediate::isNumber(value)) {
    138         if (JSImmediate::getTruncatedUInt32(value, arg))
    139             return true;
    140         bool scratch;
    141         arg = toUInt32SlowCase(JSImmediate::getTruncatedInt32(value), scratch);
    142         return true;
    143     } else if (!JSImmediate::isImmediate(value) && Heap::isNumber(asCell(value)))
    144         arg = asNumberCell(value)->toUInt32();
    145     else
    146         return false;
    147     return true;
    148 }
    149 
    150110static inline bool jsLess(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
    151111{
    152     if (JSImmediate::areBothImmediateNumbers(v1, v2))
    153         return JSImmediate::getTruncatedInt32(v1) < JSImmediate::getTruncatedInt32(v2);
     112    if (JSValuePtr::areBothInt32Fast(v1, v2))
     113        return v1->getInt32Fast() < v2->getInt32Fast();
    154114
    155115    double n1;
    156116    double n2;
    157     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
     117    if (v1->getNumber(n1) && v2->getNumber(n2))
    158118        return n1 < n2;
    159119
    … …  
    175135static inline bool jsLessEq(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
    176136{
    177     if (JSImmediate::areBothImmediateNumbers(v1, v2))
    178         return JSImmediate::getTruncatedInt32(v1) <= JSImmediate::getTruncatedInt32(v2);
     137    if (JSValuePtr::areBothInt32Fast(v1, v2))
     138        return v1->getInt32Fast() <= v2->getInt32Fast();
    179139
    180140    double n1;
    181141    double n2;
    182     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
     142    if (v1->getNumber(n1) && v2->getNumber(n2))
    183143        return n1 <= n2;
    184144
    … …  
    228188    double right = 0.0;
    229189
    230     bool rightIsNumber = fastIsNumber(v2, right);
    231     if (rightIsNumber && fastIsNumber(v1, left))
     190    bool rightIsNumber = v2->getNumber(right);
     191    if (rightIsNumber && v1->getNumber(left))
    232192        return jsNumber(callFrame, left + right);
    233193   
    … …  
    241201
    242202    if (rightIsNumber & leftIsString) {
    243         RefPtr<UString::Rep> value = JSImmediate::isImmediate(v2) ?
    244             concatenate(asString(v1)->value().rep(), JSImmediate::getTruncatedInt32(v2)) :
     203        RefPtr<UString::Rep> value = v2->isInt32Fast() ?
     204            concatenate(asString(v1)->value().rep(), v2->getInt32Fast()) :
    245205            concatenate(asString(v1)->value().rep(), right);
    246206
    … …  
    278238static bool jsIsObjectType(JSValuePtr v)
    279239{
    280     if (JSImmediate::isImmediate(v))
     240    if (!v->isCell())
    281241        return v->isNull();
    282242
    … …  
    12081168{
    12091169    JSValuePtr prototype = structure->prototypeForLookup(callFrame);
    1210     if (JSImmediate::isImmediate(prototype))
     1170    if (!prototype->isCell())
    12111171        return 0;
    12121172    RefPtr<StructureChain> chain = StructureChain::create(asObject(prototype)->structure());
    … …  
    12211181        return;
    12221182
    1223     if (JSImmediate::isImmediate(baseValue))
     1183    if (!baseValue->isCell())
    12241184        return;
    12251185
    … …  
    13301290
    13311291    // FIXME: Cache property access for immediates.
    1332     if (JSImmediate::isImmediate(baseValue)) {
     1292    if (!baseValue->isCell()) {
    13331293        vPC[0] = getOpcode(op_get_by_id_generic);
    13341294        return;
    … …  
    15741534        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    15751535        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    1576         if (JSImmediate::areBothImmediateNumbers(src1, src2))
    1577             callFrame[dst] = jsBoolean(src1 == src2);
     1536        if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
     1537            callFrame[dst] = JSFastMath::equal(src1, src2);
    15781538        else {
    1579             JSValuePtr result = jsBoolean(equalSlowCase(callFrame, src1, src2));
     1539            JSValuePtr result = jsBoolean(JSValuePtr::equalSlowCase(callFrame, src1, src2));
    15801540            CHECK_FOR_EXCEPTION();
    15811541            callFrame[dst] = result;
    … …  
    16001560        }
    16011561       
    1602         callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structure()->typeInfo().masqueradesAsUndefined());
     1562        callFrame[dst] = jsBoolean(src->isCell() && src->asCell()->structure()->typeInfo().masqueradesAsUndefined());
    16031563        ++vPC;
    16041564        NEXT_INSTRUCTION();
    … …  
    16141574        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    16151575        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    1616         if (JSImmediate::areBothImmediateNumbers(src1, src2))
    1617             callFrame[dst] = jsBoolean(src1 != src2);
     1576        if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
     1577            callFrame[dst] = JSFastMath::notEqual(src1, src2);
    16181578        else {
    1619             JSValuePtr result = jsBoolean(!equalSlowCase(callFrame, src1, src2));
     1579            JSValuePtr result = jsBoolean(!JSValuePtr::equalSlowCase(callFrame, src1, src2));
    16201580            CHECK_FOR_EXCEPTION();
    16211581            callFrame[dst] = result;
    … …  
    16401600        }
    16411601       
    1642         callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined());
     1602        callFrame[dst] = jsBoolean(src->isCell() || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined());
    16431603        ++vPC;
    16441604        NEXT_INSTRUCTION();
    … …  
    16541614        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    16551615        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    1656         if (JSImmediate::areBothImmediate(src1, src2))
    1657             callFrame[dst] = jsBoolean(src1 == src2);
    1658         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
    1659             callFrame[dst] = jsBoolean(false);
    1660         else
    1661             callFrame[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
     1616        callFrame[dst] = jsBoolean(JSValuePtr::strictEqual(src1, src2));
    16621617
    16631618        ++vPC;
    … …  
    16741629        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    16751630        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    1676 
    1677         if (JSImmediate::areBothImmediate(src1, src2))
    1678             callFrame[dst] = jsBoolean(src1 != src2);
    1679         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
    1680             callFrame[dst] = jsBoolean(true);
    1681         else
    1682             callFrame[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
     1631        callFrame[dst] = jsBoolean(!JSValuePtr::strictEqual(src1, src2));
    16831632
    16841633        ++vPC;
    … …  
    17271676        int srcDst = (++vPC)->u.operand;
    17281677        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
    1729         if (JSImmediate::canDoFastAdditiveOperations(v))
    1730             callFrame[srcDst] = JSValuePtr(JSImmediate::incImmediateNumber(v));
     1678        if (JSFastMath::canDoFastAdditiveOperations(v))
     1679            callFrame[srcDst] = JSValuePtr(JSFastMath::incImmediateNumber(v));
    17311680        else {
    17321681            JSValuePtr result = jsNumber(callFrame, v->toNumber(callFrame) + 1);
    … …  
    17461695        int srcDst = (++vPC)->u.operand;
    17471696        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
    1748         if (JSImmediate::canDoFastAdditiveOperations(v))
    1749             callFrame[srcDst] = JSValuePtr(JSImmediate::decImmediateNumber(v));
     1697        if (JSFastMath::canDoFastAdditiveOperations(v))
     1698            callFrame[srcDst] = JSValuePtr(JSFastMath::decImmediateNumber(v));
    17501699        else {
    17511700            JSValuePtr result = jsNumber(callFrame, v->toNumber(callFrame) - 1);
    … …  
    17671716        int srcDst = (++vPC)->u.operand;
    17681717        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
    1769         if (JSImmediate::canDoFastAdditiveOperations(v)) {
     1718        if (JSFastMath::canDoFastAdditiveOperations(v)) {
    17701719            callFrame[dst] = v;
    1771             callFrame[srcDst] = JSValuePtr(JSImmediate::incImmediateNumber(v));
     1720            callFrame[srcDst] = JSValuePtr(JSFastMath::incImmediateNumber(v));
    17721721        } else {
    17731722            JSValuePtr number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
    … …  
    17901739        int srcDst = (++vPC)->u.operand;
    17911740        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
    1792         if (JSImmediate::canDoFastAdditiveOperations(v)) {
     1741        if (JSFastMath::canDoFastAdditiveOperations(v)) {
    17931742            callFrame[dst] = v;
    1794             callFrame[srcDst] = JSValuePtr(JSImmediate::decImmediateNumber(v));
     1743            callFrame[srcDst] = JSValuePtr(JSFastMath::decImmediateNumber(v));
    17951744        } else {
    17961745            JSValuePtr number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
    … …  
    18351784        ++vPC;
    18361785        double v;
    1837         if (fastIsNumber(src, v))
     1786        if (src->getNumber(v))
    18381787            callFrame[dst] = JSValuePtr(jsNumber(callFrame, -v));
    18391788        else {
    … …  
    18551804        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    18561805        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    1857         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
    1858             callFrame[dst] = JSValuePtr(JSImmediate::addImmediateNumbers(src1, src2));
     1806        if (JSFastMath::canDoFastAdditiveOperations(src1, src2))
     1807            callFrame[dst] = JSValuePtr(JSFastMath::addImmediateNumbers(src1, src2));
    18591808        else {
    18601809            JSValuePtr result = jsAdd(callFrame, src1, src2);
    … …  
    18761825        double left;
    18771826        double right;
    1878         if (JSImmediate::areBothImmediateNumbers(src1, src2)) {
    1879             int32_t left = JSImmediate::getTruncatedInt32(src1);
    1880             int32_t right = JSImmediate::getTruncatedInt32(src2);
     1827        if (JSValuePtr::areBothInt32Fast(src1, src2)) {
     1828            int32_t left = src1->getInt32Fast();
     1829            int32_t right = src2->getInt32Fast();
    18811830            if ((left | right) >> 15 == 0)
    18821831                callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right));
    18831832            else
    18841833                callFrame[dst] = JSValuePtr(jsNumber(callFrame, static_cast<double>(left) * static_cast<double>(right)));
    1885         } else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
     1834        } else if (src1->getNumber(left) && src2->getNumber(right))
    18861835            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right));
    18871836        else {
    … …  
    19061855        double left;
    19071856        double right;
    1908         if (fastIsNumber(dividend, left) && fastIsNumber(divisor, right))
     1857        if (dividend->getNumber(left) && divisor->getNumber(right))
    19091858            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left / right));
    19101859        else {
    … …  
    19301879        JSValuePtr divisorValue = callFrame[divisor].jsValue(callFrame);
    19311880
    1932         if (JSImmediate::areBothImmediateNumbers(dividendValue, divisorValue) && divisorValue != JSImmediate::from(0)) {
    1933             callFrame[dst] = JSValuePtr(JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue)));
     1881        if (JSValuePtr::areBothInt32Fast(dividendValue, divisorValue) && divisorValue != js0()) {
     1882            // We expect the result of the modulus of a number that was representable as an int32 to also be representable
     1883            // as an int32.
     1884            JSValuePtr result = JSValuePtr::makeInt32Fast(dividendValue->getInt32Fast() % divisorValue->getInt32Fast());
     1885            ASSERT(result);
     1886            callFrame[dst] = result;
    19341887            ++vPC;
    19351888            NEXT_INSTRUCTION();
    … …  
    19551908        double left;
    19561909        double right;
    1957         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
    1958             callFrame[dst] = JSValuePtr(JSImmediate::subImmediateNumbers(src1, src2));
    1959         else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
     1910        if (JSFastMath::canDoFastAdditiveOperations(src1, src2))
     1911            callFrame[dst] = JSValuePtr(JSFastMath::subImmediateNumbers(src1, src2));
     1912        else if (src1->getNumber(left) && src2->getNumber(right))
    19601913            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left - right));
    19611914        else {
    … …  
    19791932        int32_t left;
    19801933        uint32_t right;
    1981         if (JSImmediate::areBothImmediateNumbers(val, shift))
    1982             callFrame[dst] = JSValuePtr(jsNumber(callFrame, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f)));
    1983         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
     1934        if (JSValuePtr::areBothInt32Fast(val, shift))
     1935            callFrame[dst] = JSValuePtr(jsNumber(callFrame, val->getInt32Fast() << (shift->getInt32Fast() & 0x1f)));
     1936        else if (val->numberToInt32(left) && shift->numberToUInt32(right))
    19841937            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left << (right & 0x1f)));
    19851938        else {
    … …  
    20041957        int32_t left;
    20051958        uint32_t right;
    2006         if (JSImmediate::areBothImmediateNumbers(val, shift))
    2007             callFrame[dst] = JSValuePtr(JSImmediate::rightShiftImmediateNumbers(val, shift));
    2008         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
     1959        if (JSFastMath::canDoFastRshift(val, shift))
     1960            callFrame[dst] = JSValuePtr(JSFastMath::rightShiftImmediateNumbers(val, shift));
     1961        else if (val->numberToInt32(left) && shift->numberToUInt32(right))
    20091962            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left >> (right & 0x1f)));
    20101963        else {
    … …  
    20271980        JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    20281981        JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    2029         if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
    2030             callFrame[dst] = JSValuePtr(JSImmediate::rightShiftImmediateNumbers(val, shift));
     1982        if (JSFastMath::canDoFastUrshift(val, shift))
     1983            callFrame[dst] = JSValuePtr(JSFastMath::rightShiftImmediateNumbers(val, shift));
    20311984        else {
    20321985            JSValuePtr result = jsNumber(callFrame, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
    … …  
    20502003        int32_t left;
    20512004        int32_t right;
    2052         if (JSImmediate::areBothImmediateNumbers(src1, src2))
    2053             callFrame[dst] = JSValuePtr(JSImmediate::andImmediateNumbers(src1, src2));
    2054         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
     2005        if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
     2006            callFrame[dst] = JSValuePtr(JSFastMath::andImmediateNumbers(src1, src2));
     2007        else if (src1->numberToInt32(left) && src2->numberToInt32(right))
    20552008            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left & right));
    20562009        else {
    … …  
    20752028        int32_t left;
    20762029        int32_t right;
    2077         if (JSImmediate::areBothImmediateNumbers(src1, src2))
    2078             callFrame[dst] = JSValuePtr(JSImmediate::xorImmediateNumbers(src1, src2));
    2079         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
     2030        if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
     2031            callFrame[dst] = JSValuePtr(JSFastMath::xorImmediateNumbers(src1, src2));
     2032        else if (src1->numberToInt32(left) && src2->numberToInt32(right))
    20802033            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left ^ right));
    20812034        else {
    … …  
    21002053        int32_t left;
    21012054        int32_t right;
    2102         if (JSImmediate::areBothImmediateNumbers(src1, src2))
    2103             callFrame[dst] = JSValuePtr(JSImmediate::orImmediateNumbers(src1, src2));
    2104         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
     2055        if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
     2056            callFrame[dst] = JSValuePtr(JSFastMath::orImmediateNumbers(src1, src2));
     2057        else if (src1->numberToInt32(left) && src2->numberToInt32(right))
    21052058            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left | right));
    21062059        else {
    … …  
    21222075        JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    21232076        int32_t value;
    2124         if (fastToInt32(src, value))
     2077        if (src->numberToInt32(value))
    21252078            callFrame[dst] = JSValuePtr(jsNumber(callFrame, ~value));
    21262079        else {
    … …  
    21992152        int src = (++vPC)->u.operand;
    22002153        JSValuePtr v = callFrame[src].jsValue(callFrame);
    2201         callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
     2154        callFrame[dst] = jsBoolean(v->isCell() ? v->asCell()->structure()->typeInfo().masqueradesAsUndefined() : v->isUndefined());
    22022155
    22032156        ++vPC;
    … …  
    25102463        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
    25112464
    2512         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
     2465        if (LIKELY(baseValue->isCell())) {
    25132466            JSCell* baseCell = asCell(baseValue);
    25142467            Structure* structure = vPC[4].u.structure;
    … …  
    25412494        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
    25422495
    2543         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
     2496        if (LIKELY(baseValue->isCell())) {
    25442497            JSCell* baseCell = asCell(baseValue);
    25452498            Structure* structure = vPC[4].u.structure;
    … …  
    25902543        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
    25912544
    2592         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
     2545        if (LIKELY(baseValue->isCell())) {
    25932546            JSCell* baseCell = asCell(baseValue);
    25942547            Structure* structure = vPC[4].u.structure;
    … …  
    27222675        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
    27232676       
    2724         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
     2677        if (LIKELY(baseValue->isCell())) {
    27252678            JSCell* baseCell = asCell(baseValue);
    27262679            Structure* oldStructure = vPC[4].u.structure;
    … …  
    27722725        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
    27732726
    2774         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
     2727        if (LIKELY(baseValue->isCell())) {
    27752728            JSCell* baseCell = asCell(baseValue);
    27762729            Structure* structure = vPC[4].u.structure;
    … …  
    28512804
    28522805        JSValuePtr result;
    2853         unsigned i;
    2854 
    2855         bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    2856         if (LIKELY(isUInt32)) {
     2806
     2807        if (LIKELY(subscript->isUInt32Fast())) {
     2808            uint32_t i = subscript->getUInt32Fast();
    28572809            if (isJSArray(baseValue)) {
    28582810                JSArray* jsArray = asArray(baseValue);
    … …  
    28642816                result = asString(baseValue)->getIndex(&callFrame->globalData(), i);
    28652817            else if (isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i))
    2866                 result = asByteArray(baseValue)->getIndex(i);
     2818                result = asByteArray(baseValue)->getIndex(callFrame, i);
    28672819            else
    28682820                result = baseValue->get(callFrame, i);
    … …  
    28952847        JSValuePtr subscript = callFrame[property].jsValue(callFrame);
    28962848
    2897         unsigned i;
    2898 
    2899         bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    2900         if (LIKELY(isUInt32)) {
     2849        if (LIKELY(subscript->isUInt32Fast())) {
     2850            uint32_t i = subscript->getUInt32Fast();
    29012851            if (isJSArray(baseValue)) {
    29022852                JSArray* jsArray = asArray(baseValue);
    … …  
    29092859                double dValue = 0;
    29102860                JSValuePtr jsValue = callFrame[value].jsValue(callFrame);
    2911                 if (JSImmediate::isNumber(jsValue))
    2912                     jsByteArray->setIndex(i, JSImmediate::getTruncatedInt32(jsValue));
    2913                 else if (fastIsNumber(jsValue, dValue))
     2861                if (jsValue->isInt32Fast())
     2862                    jsByteArray->setIndex(i, jsValue->getInt32Fast());
     2863                else if (jsValue->getNumber(dValue))
    29142864                    jsByteArray->setIndex(i, dValue);
    29152865                else
    … …  
    30743024        JSValuePtr srcValue = callFrame[src].jsValue(callFrame);
    30753025
    3076         if (srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
     3026        if (srcValue->isUndefinedOrNull() || (srcValue->isCell() && srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
    30773027            vPC += target;
    30783028            NEXT_INSTRUCTION();
    … …  
    30923042        JSValuePtr srcValue = callFrame[src].jsValue(callFrame);
    30933043
    3094         if (!srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && !srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
     3044        if (!srcValue->isUndefinedOrNull() || (srcValue->isCell() && !srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
    30953045            vPC += target;
    30963046            NEXT_INSTRUCTION();
    … …  
    31893139        int defaultOffset = (++vPC)->u.operand;
    31903140        JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
    3191         if (!JSImmediate::isNumber(scrutinee))
     3141        if (scrutinee->isInt32Fast())
     3142            vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(scrutinee->getInt32Fast(), defaultOffset);
     3143        else
    31923144            vPC += defaultOffset;
    3193         else {
    3194             int32_t value = JSImmediate::getTruncatedInt32(scrutinee);
    3195             vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(value, defaultOffset);
    3196         }
    31973145        NEXT_INSTRUCTION();
    31983146    }
    … …  
    40574005    // The interpreter checks for recursion here; I do not believe this can occur in CTI.
    40584006
    4059     if (JSImmediate::isImmediate(baseValue))
     4007    if (!baseValue->isCell())
    40604008        return;
    40614009
    … …  
    41164064
    41174065    // FIXME: Cache property access for immediates.
    4118     if (JSImmediate::isImmediate(baseValue)) {
     4066    if (!baseValue->isCell()) {
    41194067        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_get_by_id_generic));
    41204068        return;
    … …  
    43324280    double right = 0.0;
    43334281
    4334     bool rightIsNumber = fastIsNumber(v2, right);
    4335     if (rightIsNumber && fastIsNumber(v1, left))
     4282    bool rightIsNumber = v2->getNumber(right);
     4283    if (rightIsNumber && v1->getNumber(left))
    43364284        return JSValuePtr::encode(jsNumber(ARG_globalData, left + right));
    43374285   
    … …  
    43504298
    43514299    if (rightIsNumber & leftIsString) {
    4352         RefPtr<UString::Rep> value = JSImmediate::isImmediate(v2) ?
    4353             concatenate(asString(v1)->value().rep(), JSImmediate::getTruncatedInt32(v2)) :
     4300        RefPtr<UString::Rep> value = v2->isInt32Fast() ?
     4301            concatenate(asString(v1)->value().rep(), v2->getInt32Fast()) :
    43544302            concatenate(asString(v1)->value().rep(), right);
    43554303
    … …  
    45504498    CHECK_FOR_EXCEPTION();
    45514499
    4552     if (!JSImmediate::isImmediate(baseValue)
     4500    if (baseValue->isCell()
    45534501        && slot.isCacheable()
    45544502        && !asCell(baseValue)->structure()->isDictionary()
    … …  
    46244572    CHECK_FOR_EXCEPTION();
    46254573
    4626     if (JSImmediate::isImmediate(baseValue) || !slot.isCacheable() || asCell(baseValue)->structure()->isDictionary()) {
     4574    if (!baseValue->isCell() || !slot.isCacheable() || asCell(baseValue)->structure()->isDictionary()) {
    46274575        ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_proto_fail));
    46284576        return JSValuePtr::encode(result);
    … …  
    47334681
    47344682    // at least one of these checks must have failed to get to the slow case
    4735     ASSERT(JSImmediate::isAnyImmediate(value, baseVal, proto)
     4683    ASSERT(!value->isCell() || !baseVal->isCell() || !proto->isCell()
    47364684           || !value->isObject() || !baseVal->isObject() || !proto->isObject()
    47374685           || (asObject(baseVal)->structure()->typeInfo().flags() & (ImplementsHasInstance | OverridesHasInstance)) != ImplementsHasInstance);
    … …  
    47844732    double left;
    47854733    double right;
    4786     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
     4734    if (src1->getNumber(left) && src2->getNumber(right))
    47874735        return JSValuePtr::encode(jsNumber(ARG_globalData, left * right));
    47884736
    … …  
    51065054
    51075055    JSValuePtr result;
    5108     unsigned i;
    5109 
    5110     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    5111     if (LIKELY(isUInt32)) {
     5056
     5057    if (LIKELY(subscript->isUInt32Fast())) {
     5058        uint32_t i = subscript->getUInt32Fast();
    51125059        if (interpreter->isJSArray(baseValue)) {
    51135060            JSArray* jsArray = asArray(baseValue);
    … …  
    51215068            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    51225069            ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val_byte_array));
    5123             return JSValuePtr::encode(asByteArray(baseValue)->getIndex(i));
     5070            return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i));
    51245071        } else
    51255072            result = baseValue->get(callFrame, i);
    … …  
    51445091   
    51455092    JSValuePtr result;
    5146     unsigned i;
    5147    
    5148     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    5149     if (LIKELY(isUInt32)) {
     5093
     5094    if (LIKELY(subscript->isUInt32Fast())) {
     5095        uint32_t i = subscript->getUInt32Fast();
    51505096        if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
    51515097            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    5152             return JSValuePtr::encode(asByteArray(baseValue)->getIndex(i));
     5098            return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i));
    51535099        }
    51545100
    … …  
    52165162    double left;
    52175163    double right;
    5218     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
     5164    if (src1->getNumber(left) && src2->getNumber(right))
    52195165        return JSValuePtr::encode(jsNumber(ARG_globalData, left - right));
    52205166
    … …  
    52365182    JSValuePtr value = ARG_src3;
    52375183
    5238     unsigned i;
    5239 
    5240     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    5241     if (LIKELY(isUInt32)) {
     5184    if (LIKELY(subscript->isUInt32Fast())) {
     5185        uint32_t i = subscript->getUInt32Fast();
    52425186        if (interpreter->isJSArray(baseValue)) {
    52435187            JSArray* jsArray = asArray(baseValue);
    … …  
    52505194            ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_put_by_val_byte_array));
    52515195            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    5252             if (JSImmediate::isNumber(value)) {
    5253                 jsByteArray->setIndex(i, JSImmediate::getTruncatedInt32(value));
     5196            if (value->isInt32Fast()) {
     5197                jsByteArray->setIndex(i, value->getInt32Fast());
    52545198                return;
    52555199            } else {
    52565200                double dValue = 0;
    5257                 if (fastIsNumber(value, dValue)) {
     5201                if (value->getNumber(dValue)) {
    52585202                    jsByteArray->setIndex(i, dValue);
    52595203                    return;
    … …  
    52905234        asArray(baseValue)->JSArray::put(callFrame, i, value);
    52915235    else {
    5292         Identifier property(callFrame, JSImmediate::from(i)->toString(callFrame));
     5236        // This should work since we're re-boxing an immediate unboxed in JIT code.
     5237        ASSERT(JSValuePtr::makeInt32Fast(i));
     5238        Identifier property(callFrame, JSValuePtr::makeInt32Fast(i)->toString(callFrame));
    52935239        // FIXME: can toString throw an exception here?
    52945240        if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
    … …  
    53125258    JSValuePtr value = ARG_src3;
    53135259   
    5314     unsigned i;
    5315    
    5316     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
    5317     if (LIKELY(isUInt32)) {
     5260    if (LIKELY(subscript->isUInt32Fast())) {
     5261        uint32_t i = subscript->getUInt32Fast();
    53185262        if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
    53195263            JSByteArray* jsByteArray = asByteArray(baseValue);
    53205264           
    53215265            // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
    5322             if (JSImmediate::isNumber(value)) {
    5323                 jsByteArray->setIndex(i, JSImmediate::getTruncatedInt32(value));
     5266            if (value->isInt32Fast()) {
     5267                jsByteArray->setIndex(i, value->getInt32Fast());
    53245268                return;
    53255269            } else {
    53265270                double dValue = 0;               
    5327                 if (fastIsNumber(value, dValue)) {
     5271                if (value->getNumber(dValue)) {
    53285272                    jsByteArray->setIndex(i, dValue);
    53295273                    return;
    … …  
    53765320
    53775321    double v;
    5378     if (fastIsNumber(src, v))
     5322    if (src->getNumber(v))
    53795323        return JSValuePtr::encode(jsNumber(ARG_globalData, -v));
    53805324
    … …  
    54665410    double left;
    54675411    double right;
    5468     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
     5412    if (src1->getNumber(left) && src2->getNumber(right))
    54695413        return JSValuePtr::encode(jsNumber(ARG_globalData, left / right));
    54705414
    … …  
    55495493    CallFrame* callFrame = ARG_callFrame;
    55505494
    5551     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
    5552     JSValuePtr result = jsBoolean(equalSlowCaseInline(callFrame, src1, src2));
     5495    ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2));
     5496    JSValuePtr result = jsBoolean(JSValuePtr::equalSlowCaseInline(callFrame, src1, src2));
    55535497    CHECK_FOR_EXCEPTION_AT_END();
    55545498    return JSValuePtr::encode(result);
    … …  
    55645508    int32_t left;
    55655509    uint32_t right;
    5566     if (JSImmediate::areBothImmediateNumbers(val, shift))
    5567         return JSValuePtr::encode(jsNumber(ARG_globalData, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f)));
    5568     if (fastToInt32(val, left) && fastToUInt32(shift, right))
     5510    if (JSValuePtr::areBothInt32Fast(val, shift))
     5511        return JSValuePtr::encode(jsNumber(ARG_globalData, val->getInt32Fast() << (shift->getInt32Fast() & 0x1f)));
     5512    if (val->numberToInt32(left) && shift->numberToUInt32(right))
    55695513        return JSValuePtr::encode(jsNumber(ARG_globalData, left << (right & 0x1f)));
    55705514
    … …  
    55845528    int32_t left;
    55855529    int32_t right;
    5586     if (fastToInt32(src1, left) && fastToInt32(src2, right))
     5530    if (src1->numberToInt32(left) && src2->numberToInt32(right))
    55875531        return JSValuePtr::encode(jsNumber(ARG_globalData, left & right));
    55885532
    … …  
    56025546    int32_t left;
    56035547    uint32_t right;
    5604     if (JSImmediate::areBothImmediateNumbers(val, shift))
    5605         return JSValuePtr::encode(JSImmediate::rightShiftImmediateNumbers(val, shift));
    5606     if (fastToInt32(val, left) && fastToUInt32(shift, right))
     5548    if (JSFastMath::canDoFastRshift(val, shift))
     5549        return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
     5550    if (val->numberToInt32(left) && shift->numberToUInt32(right))
    56075551        return JSValuePtr::encode(jsNumber(ARG_globalData, left >> (right & 0x1f)));
    56085552
    … …  
    56205564
    56215565    int value;
    5622     if (fastToInt32(src, value))
     5566    if (src->numberToInt32(value))
    56235567        return JSValuePtr::encode(jsNumber(ARG_globalData, ~value));
    56245568
    … …  
    57015645    JSValuePtr src2 = ARG_src2;
    57025646
    5703     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
    5704 
    5705     CallFrame* callFrame = ARG_callFrame;
    5706     JSValuePtr result = jsBoolean(!equalSlowCaseInline(callFrame, src1, src2));
     5647    ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2));
     5648
     5649    CallFrame* callFrame = ARG_callFrame;
     5650    JSValuePtr result = jsBoolean(!JSValuePtr::equalSlowCaseInline(callFrame, src1, src2));
    57075651    CHECK_FOR_EXCEPTION_AT_END();
    57085652    return JSValuePtr::encode(result);
    … …  
    57325676    CallFrame* callFrame = ARG_callFrame;
    57335677
    5734     if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
    5735         return JSValuePtr::encode(JSImmediate::rightShiftImmediateNumbers(val, shift));
     5678    if (JSFastMath::canDoFastUrshift(val, shift))
     5679        return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
    57365680    else {
    57375681        JSValuePtr result = jsNumber(ARG_globalData, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
    … …  
    58045748    }
    58055749
    5806     return JSValuePtr::encode(JSImmediate::impossibleValue());
     5750    return JSValuePtr::encode(jsImpossibleValue());
    58075751}
    58085752
    … …  
    58235767    if (!handler) {
    58245768        *ARG_exception = exceptionValue;
    5825         return JSValuePtr::encode(JSImmediate::nullImmediate());
     5769        return JSValuePtr::encode(jsNull());
    58265770    }
    58275771
    … …  
    58805824
    58815825    JSValuePtr v = ARG_src1;
    5882     return JSValuePtr::encode(jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined()));
     5826    return JSValuePtr::encode(jsBoolean(v->isCell() ? v->asCell()->structure()->typeInfo().masqueradesAsUndefined() : v->isUndefined()));
    58835827}
    58845828
    … …  
    59265870
    59275871    // handled inline as fast cases
    5928     ASSERT(!JSImmediate::areBothImmediate(src1, src2));
    5929     ASSERT(!(JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate())));
    5930 
    5931     return JSValuePtr::encode(jsBoolean(strictEqualSlowCaseInline(src1, src2)));
     5872    ASSERT(!JIT::isStrictEqCaseHandledInJITCode(src1, src2));
     5873
     5874    return JSValuePtr::encode(jsBoolean(JSValuePtr::strictEqualSlowCaseInline(src1, src2)));
    59325875}
    59335876
    … …  
    59405883
    59415884    // handled inline as fast cases
    5942     ASSERT(!JSImmediate::areBothImmediate(src1, src2));
    5943     ASSERT(!(JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate())));
     5885    ASSERT(!JIT::isStrictEqCaseHandledInJITCode(src1, src2));
    59445886   
    5945     return JSValuePtr::encode(jsBoolean(!strictEqualSlowCaseInline(src1, src2)));
     5887    return JSValuePtr::encode(jsBoolean(!JSValuePtr::strictEqualSlowCaseInline(src1, src2)));
    59465888}
    59475889
    … …  
    60285970    CodeBlock* codeBlock = callFrame->codeBlock();
    60295971
    6030     if (JSImmediate::isNumber(scrutinee)) {
    6031         int32_t value = JSImmediate::getTruncatedInt32(scrutinee);
    6032         return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(value);
    6033     }
     5972    if (scrutinee->isInt32Fast())
     5973        return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(scrutinee->getInt32Fast());
    60345974
    60355975    return codeBlock->immediateSwitchJumpTable(tableIndex).ctiDefault;
    … …  
    61696109    if (!handler) {
    61706110        *ARG_exception = exceptionValue;
    6171         return JSValuePtr::encode(JSImmediate::nullImmediate());
     6111        return JSValuePtr::encode(jsNull());
    61726112    }
    61736113
Note: See TracChangeset for help on using the changeset viewer.