Changeset 27747 in webkit


Ignore:
Timestamp:
Nov 13, 2007 12:02:44 AM (16 years ago)
Author:
eric@webkit.org
Message:

2007-11-12 Eric Seidel <​eric@webkit.org>

Reviewed by Oliver.

Add evaluateToInt32 and evaluateUInt32 methods and deploy them.
Fix a few missing evaluateToBoolean methods
Deploy all evaluateTo* functions to more nodes to avoid slowdowns
​http://bugs.webkit.org/show_bug.cgi?id=15950

SunSpider claims this is at least a 1.4% speedup.

  • kjs/JSImmediate.h: (KJS::JSImmediate::getTruncatedInt32): (KJS::JSImmediate::toDouble): (KJS::JSImmediate::getUInt32):
  • kjs/nodes.cpp: (KJS::ExpressionNode::evaluateToNumber): (KJS::ExpressionNode::evaluateToInt32): (KJS::ExpressionNode::evaluateToUInt32): (KJS::NumberNode::evaluateToInt32): (KJS::NumberNode::evaluateToUInt32): (KJS::ImmediateNumberNode::evaluateToInt32): (KJS::ImmediateNumberNode::evaluateToUInt32): (KJS::ResolveNode::evaluate): (KJS::ResolveNode::evaluateToNumber): (KJS::ResolveNode::evaluateToBoolean): (KJS::ResolveNode::evaluateToInt32): (KJS::ResolveNode::evaluateToUInt32): (KJS::LocalVarAccessNode::evaluateToInt32): (KJS::LocalVarAccessNode::evaluateToUInt32): (KJS::BracketAccessorNode::evaluateToNumber): (KJS::BracketAccessorNode::evaluateToBoolean): (KJS::BracketAccessorNode::evaluateToInt32): (KJS::BracketAccessorNode::evaluateToUInt32): (KJS::DotAccessorNode::inlineEvaluate): (KJS::DotAccessorNode::evaluate): (KJS::DotAccessorNode::evaluateToNumber): (KJS::DotAccessorNode::evaluateToBoolean): (KJS::DotAccessorNode::evaluateToInt32): (KJS::DotAccessorNode::evaluateToUInt32): (KJS::NewExprNode::inlineEvaluate): (KJS::NewExprNode::evaluate): (KJS::NewExprNode::evaluateToNumber): (KJS::NewExprNode::evaluateToBoolean): (KJS::NewExprNode::evaluateToInt32): (KJS::NewExprNode::evaluateToUInt32): (KJS::FunctionCallResolveNode::inlineEvaluate): (KJS::FunctionCallResolveNode::evaluate): (KJS::FunctionCallResolveNode::evaluateToNumber): (KJS::FunctionCallResolveNode::evaluateToBoolean): (KJS::FunctionCallResolveNode::evaluateToInt32): (KJS::FunctionCallResolveNode::evaluateToUInt32): (KJS::LocalVarFunctionCallNode::evaluate): (KJS::LocalVarFunctionCallNode::evaluateToNumber): (KJS::LocalVarFunctionCallNode::evaluateToBoolean): (KJS::LocalVarFunctionCallNode::evaluateToInt32): (KJS::LocalVarFunctionCallNode::evaluateToUInt32): (KJS::FunctionCallDotNode::evaluate): (KJS::FunctionCallDotNode::evaluateToNumber): (KJS::FunctionCallDotNode::evaluateToBoolean): (KJS::FunctionCallDotNode::evaluateToInt32): (KJS::FunctionCallDotNode::evaluateToUInt32): (KJS::PostDecLocalVarNode::inlineEvaluateToNumber): (KJS::PostDecLocalVarNode::evaluateToNumber): (KJS::PostDecLocalVarNode::evaluateToBoolean): (KJS::PostDecLocalVarNode::evaluateToInt32): (KJS::PostDecLocalVarNode::evaluateToUInt32): (KJS::typeStringForValue): (KJS::UnaryPlusNode::evaluate): (KJS::UnaryPlusNode::evaluateToBoolean): (KJS::UnaryPlusNode::evaluateToNumber): (KJS::UnaryPlusNode::evaluateToInt32): (KJS::BitwiseNotNode::inlineEvaluateToInt32): (KJS::BitwiseNotNode::evaluate): (KJS::BitwiseNotNode::evaluateToNumber): (KJS::BitwiseNotNode::evaluateToBoolean): (KJS::BitwiseNotNode::evaluateToInt32): (KJS::MultNode::evaluateToBoolean): (KJS::MultNode::evaluateToInt32): (KJS::MultNode::evaluateToUInt32): (KJS::DivNode::evaluateToInt32): (KJS::DivNode::evaluateToUInt32): (KJS::ModNode::evaluateToBoolean): (KJS::ModNode::evaluateToInt32): (KJS::ModNode::evaluateToUInt32): (KJS::AddNode::evaluateToNumber): (KJS::AddNode::evaluateToInt32): (KJS::AddNode::evaluateToUInt32): (KJS::AddNumbersNode::evaluateToInt32): (KJS::AddNumbersNode::evaluateToUInt32): (KJS::SubNode::evaluateToInt32): (KJS::SubNode::evaluateToUInt32): (KJS::LeftShiftNode::inlineEvaluateToInt32): (KJS::LeftShiftNode::evaluate): (KJS::LeftShiftNode::evaluateToNumber): (KJS::LeftShiftNode::evaluateToInt32): (KJS::RightShiftNode::inlineEvaluateToInt32): (KJS::RightShiftNode::evaluate): (KJS::RightShiftNode::evaluateToNumber): (KJS::RightShiftNode::evaluateToInt32): (KJS::UnsignedRightShiftNode::inlineEvaluateToUInt32): (KJS::UnsignedRightShiftNode::evaluate): (KJS::UnsignedRightShiftNode::evaluateToNumber): (KJS::UnsignedRightShiftNode::evaluateToInt32): (KJS::LessNode::inlineEvaluateToBoolean): (KJS::LessNode::evaluate): (KJS::LessNode::evaluateToBoolean): (KJS::LessNumbersNode::inlineEvaluateToBoolean): (KJS::LessNumbersNode::evaluate): (KJS::LessNumbersNode::evaluateToBoolean): (KJS::LessStringsNode::inlineEvaluateToBoolean): (KJS::LessStringsNode::evaluate): (KJS::BitAndNode::evaluate): (KJS::BitAndNode::inlineEvaluateToInt32): (KJS::BitAndNode::evaluateToNumber): (KJS::BitAndNode::evaluateToBoolean): (KJS::BitAndNode::evaluateToInt32): (KJS::BitXOrNode::inlineEvaluateToInt32): (KJS::BitXOrNode::evaluate): (KJS::BitXOrNode::evaluateToNumber): (KJS::BitXOrNode::evaluateToBoolean): (KJS::BitXOrNode::evaluateToInt32): (KJS::BitOrNode::inlineEvaluateToInt32): (KJS::BitOrNode::evaluate): (KJS::BitOrNode::evaluateToNumber): (KJS::BitOrNode::evaluateToBoolean): (KJS::BitOrNode::evaluateToInt32): (KJS::ConditionalNode::evaluateToNumber): (KJS::ConditionalNode::evaluateToInt32): (KJS::ConditionalNode::evaluateToUInt32): (KJS::valueForReadModifyAssignment): (KJS::AssignExprNode::evaluate): (KJS::AssignExprNode::evaluateToBoolean): (KJS::AssignExprNode::evaluateToNumber): (KJS::AssignExprNode::evaluateToInt32): (KJS::VarDeclNode::handleSlowCase):
  • kjs/nodes.h: (KJS::FunctionCallResolveNode::precedence): (KJS::AddNode::precedence): (KJS::AddNode::): (KJS::LessNumbersNode::): (KJS::LessStringsNode::):
  • kjs/value.cpp: (KJS::JSValue::toInt32SlowCase): (KJS::JSValue::toUInt32SlowCase):
  • kjs/value.h: (KJS::JSValue::asCell): (KJS::JSValue::toInt32): (KJS::JSValue::toUInt32):
Location:
trunk/JavaScriptCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r27746 r27747  
     12007-11-12  Eric Seidel  <eric@webkit.org>
     2
     3        Reviewed by Oliver.
     4
     5        Add evaluateToInt32 and evaluateUInt32 methods and deploy them.
     6        Fix a few missing evaluateToBoolean methods
     7        Deploy all evaluateTo* functions to more nodes to avoid slowdowns
     8        http://bugs.webkit.org/show_bug.cgi?id=15950
     9       
     10        SunSpider claims this is at least a 1.4% speedup.
     11
     12        * kjs/JSImmediate.h:
     13        (KJS::JSImmediate::getTruncatedInt32):
     14        (KJS::JSImmediate::toDouble):
     15        (KJS::JSImmediate::getUInt32):
     16        * kjs/nodes.cpp:
     17        (KJS::ExpressionNode::evaluateToNumber):
     18        (KJS::ExpressionNode::evaluateToInt32):
     19        (KJS::ExpressionNode::evaluateToUInt32):
     20        (KJS::NumberNode::evaluateToInt32):
     21        (KJS::NumberNode::evaluateToUInt32):
     22        (KJS::ImmediateNumberNode::evaluateToInt32):
     23        (KJS::ImmediateNumberNode::evaluateToUInt32):
     24        (KJS::ResolveNode::evaluate):
     25        (KJS::ResolveNode::evaluateToNumber):
     26        (KJS::ResolveNode::evaluateToBoolean):
     27        (KJS::ResolveNode::evaluateToInt32):
     28        (KJS::ResolveNode::evaluateToUInt32):
     29        (KJS::LocalVarAccessNode::evaluateToInt32):
     30        (KJS::LocalVarAccessNode::evaluateToUInt32):
     31        (KJS::BracketAccessorNode::evaluateToNumber):
     32        (KJS::BracketAccessorNode::evaluateToBoolean):
     33        (KJS::BracketAccessorNode::evaluateToInt32):
     34        (KJS::BracketAccessorNode::evaluateToUInt32):
     35        (KJS::DotAccessorNode::inlineEvaluate):
     36        (KJS::DotAccessorNode::evaluate):
     37        (KJS::DotAccessorNode::evaluateToNumber):
     38        (KJS::DotAccessorNode::evaluateToBoolean):
     39        (KJS::DotAccessorNode::evaluateToInt32):
     40        (KJS::DotAccessorNode::evaluateToUInt32):
     41        (KJS::NewExprNode::inlineEvaluate):
     42        (KJS::NewExprNode::evaluate):
     43        (KJS::NewExprNode::evaluateToNumber):
     44        (KJS::NewExprNode::evaluateToBoolean):
     45        (KJS::NewExprNode::evaluateToInt32):
     46        (KJS::NewExprNode::evaluateToUInt32):
     47        (KJS::FunctionCallResolveNode::inlineEvaluate):
     48        (KJS::FunctionCallResolveNode::evaluate):
     49        (KJS::FunctionCallResolveNode::evaluateToNumber):
     50        (KJS::FunctionCallResolveNode::evaluateToBoolean):
     51        (KJS::FunctionCallResolveNode::evaluateToInt32):
     52        (KJS::FunctionCallResolveNode::evaluateToUInt32):
     53        (KJS::LocalVarFunctionCallNode::evaluate):
     54        (KJS::LocalVarFunctionCallNode::evaluateToNumber):
     55        (KJS::LocalVarFunctionCallNode::evaluateToBoolean):
     56        (KJS::LocalVarFunctionCallNode::evaluateToInt32):
     57        (KJS::LocalVarFunctionCallNode::evaluateToUInt32):
     58        (KJS::FunctionCallDotNode::evaluate):
     59        (KJS::FunctionCallDotNode::evaluateToNumber):
     60        (KJS::FunctionCallDotNode::evaluateToBoolean):
     61        (KJS::FunctionCallDotNode::evaluateToInt32):
     62        (KJS::FunctionCallDotNode::evaluateToUInt32):
     63        (KJS::PostDecLocalVarNode::inlineEvaluateToNumber):
     64        (KJS::PostDecLocalVarNode::evaluateToNumber):
     65        (KJS::PostDecLocalVarNode::evaluateToBoolean):
     66        (KJS::PostDecLocalVarNode::evaluateToInt32):
     67        (KJS::PostDecLocalVarNode::evaluateToUInt32):
     68        (KJS::typeStringForValue):
     69        (KJS::UnaryPlusNode::evaluate):
     70        (KJS::UnaryPlusNode::evaluateToBoolean):
     71        (KJS::UnaryPlusNode::evaluateToNumber):
     72        (KJS::UnaryPlusNode::evaluateToInt32):
     73        (KJS::BitwiseNotNode::inlineEvaluateToInt32):
     74        (KJS::BitwiseNotNode::evaluate):
     75        (KJS::BitwiseNotNode::evaluateToNumber):
     76        (KJS::BitwiseNotNode::evaluateToBoolean):
     77        (KJS::BitwiseNotNode::evaluateToInt32):
     78        (KJS::MultNode::evaluateToBoolean):
     79        (KJS::MultNode::evaluateToInt32):
     80        (KJS::MultNode::evaluateToUInt32):
     81        (KJS::DivNode::evaluateToInt32):
     82        (KJS::DivNode::evaluateToUInt32):
     83        (KJS::ModNode::evaluateToBoolean):
     84        (KJS::ModNode::evaluateToInt32):
     85        (KJS::ModNode::evaluateToUInt32):
     86        (KJS::AddNode::evaluateToNumber):
     87        (KJS::AddNode::evaluateToInt32):
     88        (KJS::AddNode::evaluateToUInt32):
     89        (KJS::AddNumbersNode::evaluateToInt32):
     90        (KJS::AddNumbersNode::evaluateToUInt32):
     91        (KJS::SubNode::evaluateToInt32):
     92        (KJS::SubNode::evaluateToUInt32):
     93        (KJS::LeftShiftNode::inlineEvaluateToInt32):
     94        (KJS::LeftShiftNode::evaluate):
     95        (KJS::LeftShiftNode::evaluateToNumber):
     96        (KJS::LeftShiftNode::evaluateToInt32):
     97        (KJS::RightShiftNode::inlineEvaluateToInt32):
     98        (KJS::RightShiftNode::evaluate):
     99        (KJS::RightShiftNode::evaluateToNumber):
     100        (KJS::RightShiftNode::evaluateToInt32):
     101        (KJS::UnsignedRightShiftNode::inlineEvaluateToUInt32):
     102        (KJS::UnsignedRightShiftNode::evaluate):
     103        (KJS::UnsignedRightShiftNode::evaluateToNumber):
     104        (KJS::UnsignedRightShiftNode::evaluateToInt32):
     105        (KJS::LessNode::inlineEvaluateToBoolean):
     106        (KJS::LessNode::evaluate):
     107        (KJS::LessNode::evaluateToBoolean):
     108        (KJS::LessNumbersNode::inlineEvaluateToBoolean):
     109        (KJS::LessNumbersNode::evaluate):
     110        (KJS::LessNumbersNode::evaluateToBoolean):
     111        (KJS::LessStringsNode::inlineEvaluateToBoolean):
     112        (KJS::LessStringsNode::evaluate):
     113        (KJS::BitAndNode::evaluate):
     114        (KJS::BitAndNode::inlineEvaluateToInt32):
     115        (KJS::BitAndNode::evaluateToNumber):
     116        (KJS::BitAndNode::evaluateToBoolean):
     117        (KJS::BitAndNode::evaluateToInt32):
     118        (KJS::BitXOrNode::inlineEvaluateToInt32):
     119        (KJS::BitXOrNode::evaluate):
     120        (KJS::BitXOrNode::evaluateToNumber):
     121        (KJS::BitXOrNode::evaluateToBoolean):
     122        (KJS::BitXOrNode::evaluateToInt32):
     123        (KJS::BitOrNode::inlineEvaluateToInt32):
     124        (KJS::BitOrNode::evaluate):
     125        (KJS::BitOrNode::evaluateToNumber):
     126        (KJS::BitOrNode::evaluateToBoolean):
     127        (KJS::BitOrNode::evaluateToInt32):
     128        (KJS::ConditionalNode::evaluateToNumber):
     129        (KJS::ConditionalNode::evaluateToInt32):
     130        (KJS::ConditionalNode::evaluateToUInt32):
     131        (KJS::valueForReadModifyAssignment):
     132        (KJS::AssignExprNode::evaluate):
     133        (KJS::AssignExprNode::evaluateToBoolean):
     134        (KJS::AssignExprNode::evaluateToNumber):
     135        (KJS::AssignExprNode::evaluateToInt32):
     136        (KJS::VarDeclNode::handleSlowCase):
     137        * kjs/nodes.h:
     138        (KJS::FunctionCallResolveNode::precedence):
     139        (KJS::AddNode::precedence):
     140        (KJS::AddNode::):
     141        (KJS::LessNumbersNode::):
     142        (KJS::LessStringsNode::):
     143        * kjs/value.cpp:
     144        (KJS::JSValue::toInt32SlowCase):
     145        (KJS::JSValue::toUInt32SlowCase):
     146        * kjs/value.h:
     147        (KJS::JSValue::asCell):
     148        (KJS::JSValue::toInt32):
     149        (KJS::JSValue::toUInt32):
     150
    11512007-11-12  Alexey Proskuryakov  <ap@webkit.org>
    2152

  • trunk/JavaScriptCore/kjs/JSImmediate.h

    r27632 r27747  
    117117    static bool getTruncatedUInt32(const JSValue*, uint32_t&);
    118118
     119    static int32_t getTruncatedInt32(const JSValue*);
     120
    119121    static JSValue* trueImmediate();
    120122    static JSValue* falseImmediate();
    … …  
    239241}
    240242
     243ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(const JSValue* v)
     244{
     245    return static_cast<int32_t>(unTag(v)) >> 2;
     246}
     247
    241248ALWAYS_INLINE double JSImmediate::toDouble(const JSValue* v)
    242249{
    243250    ASSERT(isImmediate(v));
    244     const int32_t i = static_cast<int32_t>(unTag(v)) >> 2;
     251    const int32_t i = getTruncatedInt32(v);
    245252    if (JSImmediate::getTag(v) == UndefinedType && i)
    246253        return std::numeric_limits<double>::quiet_NaN();
    … …  
    250257ALWAYS_INLINE bool JSImmediate::getUInt32(const JSValue* v, uint32_t& i)
    251258{
    252     const int32_t si = static_cast<int32_t>(unTag(v)) >> 2;
     259    const int32_t si = getTruncatedInt32(v);
    253260    i = si;
    254261    return isNumber(v) & (si >= 0);
    … …  
    257264ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(const JSValue* v, int32_t& i)
    258265{
    259     i = static_cast<int32_t>(unTag(v)) >> 2;
     266    i = getTruncatedInt32(v);
    260267    return isNumber(v);
    261268}

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r27702 r27747  
    6060  if (exec->hadException()) { \
    6161    handleException(exec); \
    62     return 0.0; \
     62    return 0; \
    6363  }
    6464
    … …  
    228228    JSValue* value = evaluate(exec);
    229229    KJS_CHECKEXCEPTIONNUMBER
    230     // No need to check exception after toNumber, caller will do so right after evaluateToNumber() call
    231230    return value->toNumber(exec);
    232231}
    … …  
    237236    KJS_CHECKEXCEPTIONBOOLEAN
    238237    return value->toBoolean(exec);
     238}
     239
     240int32_t ExpressionNode::evaluateToInt32(ExecState* exec)
     241{
     242    JSValue* value = evaluate(exec);
     243    KJS_CHECKEXCEPTIONNUMBER
     244    return value->toInt32(exec);
     245}
     246
     247uint32_t ExpressionNode::evaluateToUInt32(ExecState* exec)
     248{
     249    JSValue* value = evaluate(exec);
     250    KJS_CHECKEXCEPTIONNUMBER
     251    return value->toUInt32(exec);
    239252}
    240253
    … …  
    426439}
    427440
     441int32_t NumberNode::evaluateToInt32(ExecState*)
     442{
     443    return JSValue::toInt32(m_double);
     444}
     445
     446uint32_t NumberNode::evaluateToUInt32(ExecState*)
     447{
     448    return JSValue::toUInt32(m_double);
     449}
     450
    428451// ------------------------------ ImmediateNumberNode -----------------------------------
    429452
    … …  
    431454{
    432455    return m_value;
     456}
     457
     458int32_t ImmediateNumberNode::evaluateToInt32(ExecState*)
     459{
     460    return JSImmediate::getTruncatedInt32(m_value);
     461}
     462
     463uint32_t ImmediateNumberNode::evaluateToUInt32(ExecState*)
     464{
     465    uint32_t i;
     466    if (JSImmediate::getTruncatedUInt32(m_value, i))
     467        return i;
     468    bool ok;
     469    return JSValue::toUInt32SlowCase(m_double, ok);
    433470}
    434471
    … …  
    468505
    469506// ECMA 11.1.2 & 10.1.4
    470 JSValue *ResolveNode::evaluate(ExecState *exec)
     507JSValue* ResolveNode::inlineEvaluate(ExecState* exec)
    471508{
    472509  // Check for missed optimization opportunity.
    … …  
    493530}
    494531
     532JSValue* ResolveNode::evaluate(ExecState* exec)
     533{
     534    return inlineEvaluate(exec);
     535}
     536
     537double ResolveNode::evaluateToNumber(ExecState* exec)
     538{
     539    JSValue* v = inlineEvaluate(exec);
     540    KJS_CHECKEXCEPTIONNUMBER
     541    return v->toNumber(exec);
     542}
     543
     544bool ResolveNode::evaluateToBoolean(ExecState* exec)
     545{
     546    JSValue* v = inlineEvaluate(exec);
     547    KJS_CHECKEXCEPTIONBOOLEAN
     548    return v->toBoolean(exec);
     549}
     550
     551int32_t ResolveNode::evaluateToInt32(ExecState* exec)
     552{
     553    JSValue* v = inlineEvaluate(exec);
     554    KJS_CHECKEXCEPTIONNUMBER
     555    return v->toInt32(exec);
     556}
     557
     558uint32_t ResolveNode::evaluateToUInt32(ExecState* exec)
     559{
     560    JSValue* v = inlineEvaluate(exec);
     561    KJS_CHECKEXCEPTIONNUMBER
     562    return v->toUInt32(exec);
     563}
     564
    495565void ResolveNode::optimizeVariableAccess(FunctionBodyNode* functionBody, DeclarationStacks::NodeStack&)
    496566{
    … …  
    520590{
    521591    return inlineEvaluate(exec)->toBoolean(exec);
     592}
     593
     594int32_t LocalVarAccessNode::evaluateToInt32(ExecState* exec)
     595{
     596    return inlineEvaluate(exec)->toInt32(exec);
     597}
     598
     599uint32_t LocalVarAccessNode::evaluateToUInt32(ExecState* exec)
     600{
     601    return inlineEvaluate(exec)->toUInt32(exec);
    522602}
    523603
    … …  
    673753double BracketAccessorNode::evaluateToNumber(ExecState* exec)
    674754{
    675     return inlineEvaluate(exec)->toNumber(exec);
     755    JSValue* v = inlineEvaluate(exec);
     756    KJS_CHECKEXCEPTIONNUMBER
     757    return v->toNumber(exec);
    676758}
    677759
    678760bool BracketAccessorNode::evaluateToBoolean(ExecState* exec)
    679761{
    680     return inlineEvaluate(exec)->toBoolean(exec);
    681 }
     762    JSValue* v = inlineEvaluate(exec);
     763    KJS_CHECKEXCEPTIONBOOLEAN
     764    return v->toBoolean(exec);
     765}
     766
     767int32_t BracketAccessorNode::evaluateToInt32(ExecState* exec)
     768{
     769    JSValue* v = inlineEvaluate(exec);
     770    KJS_CHECKEXCEPTIONNUMBER
     771    return v->toInt32(exec);
     772}
     773
     774uint32_t BracketAccessorNode::evaluateToUInt32(ExecState* exec)
     775{
     776    JSValue* v = inlineEvaluate(exec);
     777    KJS_CHECKEXCEPTIONNUMBER
     778    return v->toUInt32(exec);
     779}   
    682780
    683781// ------------------------------ DotAccessorNode --------------------------------
    … …  
    689787
    690788// ECMA 11.2.1b
    691 JSValue *DotAccessorNode::evaluate(ExecState *exec)
    692 {
    693   JSValue *v = expr->evaluate(exec);
    694   KJS_CHECKEXCEPTIONVALUE
    695   return v->toObject(exec)->get(exec, ident);
    696 
    697 }
     789JSValue* DotAccessorNode::inlineEvaluate(ExecState* exec)
     790{
     791    JSValue* v = expr->evaluate(exec);
     792    KJS_CHECKEXCEPTIONVALUE
     793    return v->toObject(exec)->get(exec, ident);
     794}
     795
     796JSValue* DotAccessorNode::evaluate(ExecState* exec)
     797{
     798    return inlineEvaluate(exec);
     799}
     800
     801double DotAccessorNode::evaluateToNumber(ExecState* exec)
     802{
     803    JSValue* v = inlineEvaluate(exec);
     804    KJS_CHECKEXCEPTIONNUMBER
     805    return v->toNumber(exec);
     806}
     807
     808bool DotAccessorNode::evaluateToBoolean(ExecState* exec)
     809{
     810    JSValue* v = inlineEvaluate(exec);
     811    KJS_CHECKEXCEPTIONBOOLEAN
     812    return v->toBoolean(exec);
     813}
     814
     815int32_t DotAccessorNode::evaluateToInt32(ExecState* exec)
     816{
     817    JSValue* v = inlineEvaluate(exec);
     818    KJS_CHECKEXCEPTIONNUMBER
     819    return v->toInt32(exec);
     820}
     821
     822uint32_t DotAccessorNode::evaluateToUInt32(ExecState* exec)
     823{
     824    JSValue* v = inlineEvaluate(exec);
     825    KJS_CHECKEXCEPTIONNUMBER
     826    return v->toUInt32(exec);
     827}   
    698828
    699829// ------------------------------ ArgumentListNode -----------------------------
    … …  
    736866// ECMA 11.2.2
    737867
    738 JSValue *NewExprNode::evaluate(ExecState *exec)
    739 {
    740   JSValue *v = expr->evaluate(exec);
     868JSValue* NewExprNode::inlineEvaluate(ExecState* exec)
     869{
     870  JSValue* v = expr->evaluate(exec);
    741871  KJS_CHECKEXCEPTIONVALUE
    742872
    … …  
    747877  }
    748878
    749   if (!v->isObject()) {
     879  if (!v->isObject())
    750880    return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with new.", v, expr.get());
    751   }
    752881
    753882  JSObject *constr = static_cast<JSObject*>(v);
    754   if (!constr->implementsConstruct()) {
     883  if (!constr->implementsConstruct())
    755884    return throwError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", v, expr.get());
    756   }
    757885
    758886  return constr->construct(exec, argList);
    759887}
     888
     889JSValue* NewExprNode::evaluate(ExecState* exec)
     890{
     891    return inlineEvaluate(exec);
     892}
     893
     894double NewExprNode::evaluateToNumber(ExecState* exec)
     895{
     896    JSValue* v = inlineEvaluate(exec);
     897    KJS_CHECKEXCEPTIONNUMBER
     898    return v->toNumber(exec);
     899}
     900
     901bool NewExprNode::evaluateToBoolean(ExecState* exec)
     902{
     903    JSValue* v = inlineEvaluate(exec);
     904    KJS_CHECKEXCEPTIONBOOLEAN
     905    return v->toBoolean(exec);
     906}
     907
     908int32_t NewExprNode::evaluateToInt32(ExecState* exec)
     909{
     910    JSValue* v = inlineEvaluate(exec);
     911    KJS_CHECKEXCEPTIONNUMBER
     912    return v->toInt32(exec);
     913}
     914
     915uint32_t NewExprNode::evaluateToUInt32(ExecState* exec)
     916{
     917    JSValue* v = inlineEvaluate(exec);
     918    KJS_CHECKEXCEPTIONNUMBER
     919    return v->toUInt32(exec);
     920}   
    760921
    761922void FunctionCallValueNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
    … …  
    800961
    801962// ECMA 11.2.3
    802 JSValue *FunctionCallResolveNode::evaluate(ExecState *exec)
     963JSValue* FunctionCallResolveNode::inlineEvaluate(ExecState* exec)
    803964{
    804965  // Check for missed optimization opportunity.
    … …  
    820981      KJS_CHECKEXCEPTIONVALUE
    821982       
    822       if (!v->isObject()) {
     983      if (!v->isObject())
    823984        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, ident);
    824       }
    825985     
    826986      JSObject *func = static_cast<JSObject*>(v);
    827987     
    828       if (!func->implementsCall()) {
     988      if (!func->implementsCall())
    829989        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, ident);
    830       }
    831990     
    832991      List argList;
    … …  
    8521011}
    8531012
    854 JSValue* LocalVarFunctionCallNode::evaluate(ExecState* exec)
     1013JSValue* FunctionCallResolveNode::evaluate(ExecState* exec)
     1014{
     1015    return inlineEvaluate(exec);
     1016}
     1017
     1018double FunctionCallResolveNode::evaluateToNumber(ExecState* exec)
     1019{
     1020    JSValue* v = inlineEvaluate(exec);
     1021    KJS_CHECKEXCEPTIONNUMBER
     1022    return v->toNumber(exec);
     1023}
     1024
     1025bool FunctionCallResolveNode::evaluateToBoolean(ExecState* exec)
     1026{
     1027    JSValue* v = inlineEvaluate(exec);
     1028    KJS_CHECKEXCEPTIONBOOLEAN
     1029    return v->toBoolean(exec);
     1030}
     1031
     1032int32_t FunctionCallResolveNode::evaluateToInt32(ExecState* exec)
     1033{
     1034    JSValue* v = inlineEvaluate(exec);
     1035    KJS_CHECKEXCEPTIONNUMBER
     1036    return v->toInt32(exec);
     1037}
     1038
     1039uint32_t FunctionCallResolveNode::evaluateToUInt32(ExecState* exec)
     1040{
     1041    JSValue* v = inlineEvaluate(exec);
     1042    KJS_CHECKEXCEPTIONNUMBER
     1043    return v->toUInt32(exec);
     1044}
     1045
     1046JSValue* LocalVarFunctionCallNode::inlineEvaluate(ExecState* exec)
    8551047{
    8561048    ASSERT(static_cast<ActivationImp*>(exec->variableObject())->isActivation());
    … …  
    8711063
    8721064    return func->call(exec, exec->dynamicInterpreter()->globalObject(), argList);
     1065}
     1066
     1067JSValue* LocalVarFunctionCallNode::evaluate(ExecState* exec)
     1068{
     1069    return inlineEvaluate(exec);
     1070}
     1071
     1072double LocalVarFunctionCallNode::evaluateToNumber(ExecState* exec)
     1073{
     1074    JSValue* v = inlineEvaluate(exec);
     1075    KJS_CHECKEXCEPTIONNUMBER
     1076    return v->toNumber(exec);
     1077}
     1078
     1079bool LocalVarFunctionCallNode::evaluateToBoolean(ExecState* exec)
     1080{
     1081    JSValue* v = inlineEvaluate(exec);
     1082    KJS_CHECKEXCEPTIONBOOLEAN
     1083    return v->toBoolean(exec);
     1084}
     1085
     1086int32_t LocalVarFunctionCallNode::evaluateToInt32(ExecState* exec)
     1087{
     1088    JSValue* v = inlineEvaluate(exec);
     1089    KJS_CHECKEXCEPTIONNUMBER
     1090    return v->toInt32(exec);
     1091}
     1092
     1093uint32_t LocalVarFunctionCallNode::evaluateToUInt32(ExecState* exec)
     1094{
     1095    JSValue* v = inlineEvaluate(exec);
     1096    KJS_CHECKEXCEPTIONNUMBER
     1097    return v->toUInt32(exec);
    8731098}
    8741099
    … …  
    9491174
    9501175// ECMA 11.2.3
    951 JSValue *FunctionCallDotNode::evaluate(ExecState *exec)
     1176JSValue* FunctionCallDotNode::inlineEvaluate(ExecState* exec)
    9521177{
    9531178  JSValue *baseVal = base->evaluate(exec);
    … …  
    9771202
    9781203  return func->call(exec, thisObj, argList);
     1204}
     1205
     1206JSValue* FunctionCallDotNode::evaluate(ExecState* exec)
     1207{
     1208    return inlineEvaluate(exec);
     1209}
     1210
     1211double FunctionCallDotNode::evaluateToNumber(ExecState* exec)
     1212{
     1213    JSValue* v = inlineEvaluate(exec);
     1214    KJS_CHECKEXCEPTIONNUMBER
     1215    return v->toNumber(exec);
     1216}
     1217
     1218bool FunctionCallDotNode::evaluateToBoolean(ExecState* exec)
     1219{
     1220    JSValue* v = inlineEvaluate(exec);
     1221    KJS_CHECKEXCEPTIONBOOLEAN
     1222    return v->toBoolean(exec);
     1223}
     1224
     1225int32_t FunctionCallDotNode::evaluateToInt32(ExecState* exec)
     1226{
     1227    JSValue* v = inlineEvaluate(exec);
     1228    KJS_CHECKEXCEPTIONNUMBER
     1229    return v->toInt32(exec);
     1230}
     1231
     1232uint32_t FunctionCallDotNode::evaluateToUInt32(ExecState* exec)
     1233{
     1234    JSValue* v = inlineEvaluate(exec);
     1235    KJS_CHECKEXCEPTIONNUMBER
     1236    return v->toUInt32(exec);
    9791237}
    9801238
    … …  
    10911349    *slot = jsNumber(v->toNumber(exec) - 1);
    10921350    return v;
     1351}
     1352
     1353double PostDecLocalVarNode::inlineEvaluateToNumber(ExecState* exec)
     1354{
     1355    ASSERT(static_cast<ActivationImp*>(exec->variableObject())->isActivation());
     1356    ASSERT(static_cast<ActivationImp*>(exec->variableObject()) == exec->scopeChain().top());
     1357   
     1358    JSValue** slot = &exec->localStorage()[m_index].value;
     1359    double n = (*slot)->toNumber(exec);
     1360    *slot = jsNumber(n - 1);
     1361    return n;
     1362}
     1363
     1364double PostDecLocalVarNode::evaluateToNumber(ExecState* exec)
     1365{
     1366    return inlineEvaluateToNumber(exec);
     1367}
     1368
     1369bool PostDecLocalVarNode::evaluateToBoolean(ExecState* exec)
     1370{
     1371    return inlineEvaluateToNumber(exec);
     1372}
     1373
     1374int32_t PostDecLocalVarNode::evaluateToInt32(ExecState* exec)
     1375{
     1376    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     1377}
     1378
     1379uint32_t PostDecLocalVarNode::evaluateToUInt32(ExecState* exec)
     1380{
     1381    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
    10931382}
    10941383
    … …  
    13571646            // as null when doing comparisons.
    13581647            if (static_cast<JSObject*>(v)->masqueradeAsUndefined())
    1359                 return jsString("undefined");           
     1648                return jsString("undefined");
    13601649            else if (static_cast<JSObject*>(v)->implementsCall())
    13611650                return jsString("function");
    … …  
    16481937JSValue* UnaryPlusNode::evaluate(ExecState* exec)
    16491938{
    1650   JSValue *v = m_expr->evaluate(exec);
    1651   KJS_CHECKEXCEPTIONVALUE
    1652 
    1653   return v->toJSNumber(exec);
     1939    JSValue *v = m_expr->evaluate(exec);
     1940    KJS_CHECKEXCEPTIONVALUE
     1941    return v->toJSNumber(exec);
     1942}
     1943
     1944bool UnaryPlusNode::evaluateToBoolean(ExecState* exec)
     1945{
     1946    return m_expr->evaluateToBoolean(exec);
     1947}
     1948
     1949double UnaryPlusNode::evaluateToNumber(ExecState* exec)
     1950{
     1951    return m_expr->evaluateToNumber(exec);
     1952}
     1953
     1954int32_t UnaryPlusNode::evaluateToInt32(ExecState* exec)
     1955{
     1956    return m_expr->evaluateToInt32(exec);
     1957}
     1958
     1959uint32_t UnaryPlusNode::evaluateToUInt32(ExecState* exec)
     1960{
     1961    return m_expr->evaluateToInt32(exec);
    16541962}
    16551963
    … …  
    16821990
    16831991// ECMA 11.4.8
    1684 JSValue *BitwiseNotNode::evaluate(ExecState *exec)
    1685 {
    1686   JSValue *v = expr->evaluate(exec);
    1687   KJS_CHECKEXCEPTIONVALUE
    1688   return jsNumber(~v->toInt32(exec));
     1992int32_t BitwiseNotNode::inlineEvaluateToInt32(ExecState* exec)
     1993{
     1994    return ~expr->evaluateToInt32(exec);
     1995}
     1996
     1997JSValue* BitwiseNotNode::evaluate(ExecState* exec)
     1998{
     1999    return jsNumber(inlineEvaluateToInt32(exec));
     2000}
     2001
     2002double BitwiseNotNode::evaluateToNumber(ExecState* exec)
     2003{
     2004    return inlineEvaluateToInt32(exec);
     2005}
     2006
     2007bool BitwiseNotNode::evaluateToBoolean(ExecState* exec)
     2008{
     2009    return inlineEvaluateToInt32(exec);
     2010}
     2011
     2012int32_t BitwiseNotNode::evaluateToInt32(ExecState* exec)
     2013{
     2014    return inlineEvaluateToInt32(exec);
     2015}
     2016
     2017uint32_t BitwiseNotNode::evaluateToUInt32(ExecState* exec)
     2018{
     2019    return inlineEvaluateToInt32(exec);
    16892020}
    16902021
    … …  
    17342065}
    17352066
     2067bool MultNode::evaluateToBoolean(ExecState* exec)
     2068{
     2069    return inlineEvaluateToNumber(exec);
     2070}
     2071
     2072int32_t MultNode::evaluateToInt32(ExecState* exec)
     2073{
     2074    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2075}
     2076
     2077uint32_t MultNode::evaluateToUInt32(ExecState* exec)
     2078{
     2079    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
     2080}
     2081
    17362082void DivNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
    17372083{
    … …  
    17592105}
    17602106
     2107int32_t DivNode::evaluateToInt32(ExecState* exec)
     2108{
     2109    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2110}
     2111
     2112uint32_t DivNode::evaluateToUInt32(ExecState* exec)
     2113{
     2114    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
     2115}
     2116
    17612117void ModNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
    17622118{
    … …  
    17822138{
    17832139    return inlineEvaluateToNumber(exec);
     2140}
     2141
     2142bool ModNode::evaluateToBoolean(ExecState* exec)
     2143{
     2144    return inlineEvaluateToNumber(exec);
     2145}
     2146
     2147int32_t ModNode::evaluateToInt32(ExecState* exec)
     2148{
     2149    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2150}
     2151
     2152uint32_t ModNode::evaluateToUInt32(ExecState* exec)
     2153{
     2154    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
    17842155}
    17852156
    … …  
    18992270}
    19002271
    1901 double AddNode::evaluateToNumber(ExecState* exec)
     2272double AddNode::inlineEvaluateToNumber(ExecState* exec)
    19022273{
    19032274    JSValue* v1 = term1->evaluate(exec);
    … …  
    19102281}
    19112282
     2283double AddNode::evaluateToNumber(ExecState* exec)
     2284{
     2285    return inlineEvaluateToNumber(exec);
     2286}
     2287
     2288int32_t AddNode::evaluateToInt32(ExecState* exec)
     2289{
     2290    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2291}
     2292
     2293uint32_t AddNode::evaluateToUInt32(ExecState* exec)
     2294{
     2295    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
     2296}   
     2297
    19122298double AddNumbersNode::inlineEvaluateToNumber(ExecState* exec)
    19132299{
    … …  
    19282314}
    19292315
     2316int32_t AddNumbersNode::evaluateToInt32(ExecState* exec)
     2317{
     2318    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2319}
     2320
     2321uint32_t AddNumbersNode::evaluateToUInt32(ExecState* exec)
     2322{
     2323    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
     2324}
     2325
    19302326JSValue* AddStringsNode::evaluate(ExecState* exec)
    19312327{
    … …  
    19882384}
    19892385
     2386int32_t SubNode::evaluateToInt32(ExecState* exec)
     2387{
     2388    return JSValue::toInt32(inlineEvaluateToNumber(exec));
     2389}
     2390
     2391uint32_t SubNode::evaluateToUInt32(ExecState* exec)
     2392{
     2393    return JSValue::toUInt32(inlineEvaluateToNumber(exec));
     2394}   
     2395
    19902396// ------------------------------ Shift Nodes ------------------------------------
    19912397
    … …  
    19972403
    19982404// ECMA 11.7.1
    1999 JSValue *LeftShiftNode::evaluate(ExecState *exec)
    2000 {
    2001   JSValue *v1 = term1->evaluate(exec);
    2002   KJS_CHECKEXCEPTIONVALUE
    2003   JSValue *v2 = term2->evaluate(exec);
    2004   KJS_CHECKEXCEPTIONVALUE
    2005   unsigned int i2 = v2->toUInt32(exec);
    2006   i2 &= 0x1f;
    2007 
    2008   return jsNumber(v1->toInt32(exec) << i2);
     2405int32_t LeftShiftNode::inlineEvaluateToInt32(ExecState* exec)
     2406{
     2407    int i1 = term1->evaluateToInt32(exec);
     2408    KJS_CHECKEXCEPTIONNUMBER
     2409    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
     2410    return (i1 << i2);
     2411}
     2412
     2413JSValue* LeftShiftNode::evaluate(ExecState* exec)
     2414{
     2415    return jsNumber(inlineEvaluateToInt32(exec));
     2416}
     2417
     2418double LeftShiftNode::evaluateToNumber(ExecState* exec)
     2419{
     2420    return inlineEvaluateToInt32(exec);
     2421}
     2422
     2423int32_t LeftShiftNode::evaluateToInt32(ExecState* exec)
     2424{
     2425    return inlineEvaluateToInt32(exec);
     2426}
     2427
     2428uint32_t LeftShiftNode::evaluateToUInt32(ExecState* exec)
     2429{
     2430    return inlineEvaluateToInt32(exec);
    20092431}
    20102432
    … …  
    20162438
    20172439// ECMA 11.7.2
    2018 JSValue *RightShiftNode::evaluate(ExecState *exec)
    2019 {
    2020   JSValue *v1 = term1->evaluate(exec);
    2021   KJS_CHECKEXCEPTIONVALUE
    2022   JSValue *v2 = term2->evaluate(exec);
    2023   KJS_CHECKEXCEPTIONVALUE
    2024   unsigned int i2 = v2->toUInt32(exec);
    2025   i2 &= 0x1f;
    2026 
    2027   return jsNumber(v1->toInt32(exec) >> i2);
     2440int32_t RightShiftNode::inlineEvaluateToInt32(ExecState* exec)
     2441{
     2442    int i1 = term1->evaluateToInt32(exec);
     2443    KJS_CHECKEXCEPTIONNUMBER
     2444    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
     2445    return (i1 >> i2);
     2446}
     2447
     2448JSValue* RightShiftNode::evaluate(ExecState* exec)
     2449{
     2450    return jsNumber(inlineEvaluateToInt32(exec));
     2451}
     2452
     2453double RightShiftNode::evaluateToNumber(ExecState* exec)
     2454{
     2455    return inlineEvaluateToInt32(exec);
     2456}
     2457
     2458int32_t RightShiftNode::evaluateToInt32(ExecState* exec)
     2459{
     2460    return inlineEvaluateToInt32(exec);
     2461}
     2462
     2463uint32_t RightShiftNode::evaluateToUInt32(ExecState* exec)
     2464{
     2465    return inlineEvaluateToInt32(exec);
    20282466}
    20292467
    … …  
    20352473
    20362474// ECMA 11.7.3
    2037 JSValue *UnsignedRightShiftNode::evaluate(ExecState *exec)
    2038 {
    2039   JSValue *v1 = term1->evaluate(exec);
    2040   KJS_CHECKEXCEPTIONVALUE
    2041   JSValue *v2 = term2->evaluate(exec);
    2042   KJS_CHECKEXCEPTIONVALUE
    2043   unsigned int i2 = v2->toUInt32(exec);
    2044   i2 &= 0x1f;
    2045 
    2046   return jsNumber(v1->toUInt32(exec) >> i2);
     2475uint32_t UnsignedRightShiftNode::inlineEvaluateToUInt32(ExecState* exec)
     2476{
     2477    unsigned int i1 = term1->evaluateToUInt32(exec);
     2478    KJS_CHECKEXCEPTIONNUMBER
     2479    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
     2480    return (i1 >> i2);
     2481}
     2482
     2483JSValue* UnsignedRightShiftNode::evaluate(ExecState* exec)
     2484{
     2485    return jsNumber(inlineEvaluateToUInt32(exec));
     2486}
     2487
     2488double UnsignedRightShiftNode::evaluateToNumber(ExecState* exec)
     2489{
     2490    return inlineEvaluateToUInt32(exec);
     2491}
     2492
     2493int32_t UnsignedRightShiftNode::evaluateToInt32(ExecState* exec)
     2494{
     2495    return inlineEvaluateToUInt32(exec);
     2496}
     2497
     2498uint32_t UnsignedRightShiftNode::evaluateToUInt32(ExecState* exec)
     2499{
     2500    return inlineEvaluateToUInt32(exec);
    20472501}
    20482502
    … …  
    20862540
    20872541// ECMA 11.8.1
    2088 JSValue* LessNode::evaluate(ExecState* exec)
    2089 {
    2090     JSValue* v1 = expr1->evaluate(exec);
    2091     KJS_CHECKEXCEPTIONVALUE
    2092     JSValue* v2 = expr2->evaluate(exec);
    2093     KJS_CHECKEXCEPTIONVALUE
    2094     return jsBoolean(lessThan(exec, v1, v2));
    2095 }
    2096 
    2097 bool LessNode::evaluateToBoolean(ExecState* exec)
     2542bool LessNode::inlineEvaluateToBoolean(ExecState* exec)
    20982543{
    20992544    JSValue* v1 = expr1->evaluate(exec);
    … …  
    21042549}
    21052550
     2551JSValue* LessNode::evaluate(ExecState* exec)
     2552{
     2553    return jsBoolean(inlineEvaluateToBoolean(exec));
     2554}
     2555
     2556bool LessNode::evaluateToBoolean(ExecState* exec)
     2557{
     2558    return inlineEvaluateToBoolean(exec);
     2559}
     2560
     2561bool LessNumbersNode::inlineEvaluateToBoolean(ExecState* exec)
     2562{
     2563    double n1 = expr1->evaluateToNumber(exec);
     2564    KJS_CHECKEXCEPTIONVALUE
     2565    double n2 = expr2->evaluateToNumber(exec);
     2566    return n1 < n2;
     2567}
     2568
    21062569JSValue* LessNumbersNode::evaluate(ExecState* exec)
    21072570{
    2108     double n1 = expr1->evaluateToNumber(exec);
    2109     KJS_CHECKEXCEPTIONVALUE
    2110     double n2 = expr2->evaluateToNumber(exec);
    2111     return jsBoolean(n1 < n2);
     2571    return jsBoolean(inlineEvaluateToBoolean(exec));
     2572}
     2573
     2574bool LessNumbersNode::evaluateToBoolean(ExecState* exec)
     2575{
     2576    return inlineEvaluateToBoolean(exec);
     2577}
     2578
     2579bool LessStringsNode::inlineEvaluateToBoolean(ExecState* exec)
     2580{
     2581    JSValue* v1 = expr1->evaluate(exec);
     2582    KJS_CHECKEXCEPTIONVALUE
     2583    JSValue* v2 = expr2->evaluate(exec);
     2584    return static_cast<StringImp*>(v1)->value() < static_cast<StringImp*>(v2)->value();
    21122585}
    21132586
    21142587JSValue* LessStringsNode::evaluate(ExecState* exec)
    21152588{
    2116     JSValue* v1 = expr1->evaluate(exec);
    2117     KJS_CHECKEXCEPTIONVALUE
    2118     JSValue* v2 = expr2->evaluate(exec);
    2119     return jsBoolean(static_cast<StringImp*>(v1)->value() < static_cast<StringImp*>(v2)->value());
     2589    return jsBoolean(inlineEvaluateToBoolean(exec));
     2590}
     2591
     2592bool LessStringsNode::evaluateToBoolean(ExecState* exec)
     2593{
     2594    return inlineEvaluateToBoolean(exec);
    21202595}
    21212596
    … …  
    24002875
    24012876// ECMA 11.10
    2402 JSValue *BitAndNode::evaluate(ExecState *exec)
     2877JSValue* BitAndNode::evaluate(ExecState* exec)
    24032878{   
    2404   JSValue *v1 = expr1->evaluate(exec);
    2405   KJS_CHECKEXCEPTIONVALUE
    2406   JSValue *v2 = expr2->evaluate(exec);
    2407   KJS_CHECKEXCEPTIONVALUE
    2408  
    2409   return jsNumberFromAnd(exec, v1, v2);
     2879    JSValue *v1 = expr1->evaluate(exec);
     2880    KJS_CHECKEXCEPTIONVALUE
     2881    JSValue *v2 = expr2->evaluate(exec);
     2882    KJS_CHECKEXCEPTIONVALUE
     2883
     2884    return jsNumberFromAnd(exec, v1, v2);
     2885}
     2886
     2887int32_t BitAndNode::inlineEvaluateToInt32(ExecState* exec)
     2888{
     2889    int32_t i1 = expr1->evaluateToInt32(exec);
     2890    KJS_CHECKEXCEPTIONNUMBER
     2891    int32_t i2 = expr2->evaluateToInt32(exec);
     2892    return (i1 & i2);
     2893}
     2894
     2895double BitAndNode::evaluateToNumber(ExecState* exec)
     2896{
     2897    return inlineEvaluateToInt32(exec);
     2898}
     2899
     2900bool BitAndNode::evaluateToBoolean(ExecState* exec)
     2901{
     2902    return inlineEvaluateToInt32(exec);
     2903}
     2904
     2905int32_t BitAndNode::evaluateToInt32(ExecState* exec)
     2906{
     2907    return inlineEvaluateToInt32(exec);
     2908}
     2909
     2910uint32_t BitAndNode::evaluateToUInt32(ExecState* exec)
     2911{
     2912    return inlineEvaluateToInt32(exec);
    24102913}
    24112914
    … …  
    24162919}
    24172920
    2418 JSValue *BitXOrNode::evaluate(ExecState *exec)
    2419 {
    2420   JSValue *v1 = expr1->evaluate(exec);
    2421   KJS_CHECKEXCEPTIONVALUE
    2422   JSValue *v2 = expr2->evaluate(exec);
    2423   KJS_CHECKEXCEPTIONVALUE
    2424  
    2425   return jsNumber(v1->toInt32(exec) ^ v2->toInt32(exec));
     2921int32_t BitXOrNode::inlineEvaluateToInt32(ExecState* exec)
     2922{
     2923    int i1 = expr1->evaluateToInt32(exec);
     2924    KJS_CHECKEXCEPTIONNUMBER
     2925    int i2 = expr2->evaluateToInt32(exec);
     2926    return (i1 ^ i2);
     2927}
     2928
     2929JSValue* BitXOrNode::evaluate(ExecState* exec)
     2930{
     2931    return jsNumber(inlineEvaluateToInt32(exec));
     2932}
     2933
     2934double BitXOrNode::evaluateToNumber(ExecState* exec)
     2935{
     2936    return inlineEvaluateToInt32(exec);
     2937}
     2938
     2939bool BitXOrNode::evaluateToBoolean(ExecState* exec)
     2940{
     2941    return inlineEvaluateToInt32(exec);
     2942}
     2943
     2944int32_t BitXOrNode::evaluateToInt32(ExecState* exec)
     2945{
     2946    return inlineEvaluateToInt32(exec);
     2947}
     2948
     2949uint32_t BitXOrNode::evaluateToUInt32(ExecState* exec)
     2950{
     2951    return inlineEvaluateToInt32(exec);
    24262952}
    24272953
    … …  
    24322958}
    24332959
    2434 JSValue *BitOrNode::evaluate(ExecState *exec)
    2435 {
    2436   JSValue *v1 = expr1->evaluate(exec);
    2437   KJS_CHECKEXCEPTIONVALUE
    2438   JSValue *v2 = expr2->evaluate(exec);
    2439   KJS_CHECKEXCEPTIONVALUE
    2440  
    2441   return jsNumber(v1->toInt32(exec) | v2->toInt32(exec));
     2960int32_t BitOrNode::inlineEvaluateToInt32(ExecState* exec)
     2961{
     2962    int i1 = expr1->evaluateToInt32(exec);
     2963    KJS_CHECKEXCEPTIONNUMBER
     2964    int i2 = expr2->evaluateToInt32(exec);
     2965    return (i1 | i2);
     2966}
     2967
     2968JSValue* BitOrNode::evaluate(ExecState* exec)
     2969{
     2970    return jsNumber(inlineEvaluateToInt32(exec));
     2971}
     2972
     2973double BitOrNode::evaluateToNumber(ExecState* exec)
     2974{
     2975    return inlineEvaluateToInt32(exec);
     2976}
     2977
     2978bool BitOrNode::evaluateToBoolean(ExecState* exec)
     2979{
     2980    return inlineEvaluateToInt32(exec);
     2981}
     2982
     2983int32_t BitOrNode::evaluateToInt32(ExecState* exec)
     2984{
     2985    return inlineEvaluateToInt32(exec);
     2986}
     2987
     2988uint32_t BitOrNode::evaluateToUInt32(ExecState* exec)
     2989{
     2990    return inlineEvaluateToInt32(exec);
    24422991}
    24432992
    … …  
    25153064    KJS_CHECKEXCEPTIONBOOLEAN
    25163065    return b ? expr1->evaluateToBoolean(exec) : expr2->evaluateToBoolean(exec);
     3066}
     3067
     3068double ConditionalNode::evaluateToNumber(ExecState* exec)
     3069{
     3070    bool b = logical->evaluateToBoolean(exec);
     3071    KJS_CHECKEXCEPTIONNUMBER
     3072    return b ? expr1->evaluateToNumber(exec) : expr2->evaluateToNumber(exec);
     3073}
     3074
     3075int32_t ConditionalNode::evaluateToInt32(ExecState* exec)
     3076{
     3077    bool b = logical->evaluateToBoolean(exec);
     3078    KJS_CHECKEXCEPTIONNUMBER
     3079    return b ? expr1->evaluateToInt32(exec) : expr2->evaluateToInt32(exec);
     3080}
     3081
     3082uint32_t ConditionalNode::evaluateToUInt32(ExecState* exec)
     3083{
     3084    bool b = logical->evaluateToBoolean(exec);
     3085    KJS_CHECKEXCEPTIONNUMBER
     3086    return b ? expr1->evaluateToUInt32(exec) : expr2->evaluateToUInt32(exec);
    25173087}
    25183088
    … …  
    25413111  case OpLShift:
    25423112    i1 = current->toInt32(exec);
    2543     i2 = right->evaluate(exec)->toInt32(exec);
     3113    i2 = right->evaluateToInt32(exec);
    25443114    v = jsNumber(i1 << i2);
    25453115    break;
    25463116  case OpRShift:
    25473117    i1 = current->toInt32(exec);
    2548     i2 = right->evaluate(exec)->toInt32(exec);
     3118    i2 = right->evaluateToInt32(exec);
    25493119    v = jsNumber(i1 >> i2);
    25503120    break;
    25513121  case OpURShift:
    25523122    ui = current->toUInt32(exec);
    2553     i2 = right->evaluate(exec)->toInt32(exec);
     3123    i2 = right->evaluateToInt32(exec);
    25543124    v = jsNumber(ui >> i2);
    25553125    break;
    25563126  case OpAndEq:
    25573127    i1 = current->toInt32(exec);
    2558     i2 = right->evaluate(exec)->toInt32(exec);
     3128    i2 = right->evaluateToInt32(exec);
    25593129    v = jsNumber(i1 & i2);
    25603130    break;
    25613131  case OpXOrEq:
    25623132    i1 = current->toInt32(exec);
    2563     i2 = right->evaluate(exec)->toInt32(exec);
     3133    i2 = right->evaluateToInt32(exec);
    25643134    v = jsNumber(i1 ^ i2);
    25653135    break;
    25663136  case OpOrEq:
    25673137    i1 = current->toInt32(exec);
    2568     i2 = right->evaluate(exec)->toInt32(exec);
     3138    i2 = right->evaluateToInt32(exec);
    25693139    v = jsNumber(i1 | i2);
    25703140    break;
    … …  
    28553425
    28563426// ECMA 12.2
    2857 JSValue *AssignExprNode::evaluate(ExecState *exec)
    2858 {
    2859   return expr->evaluate(exec);
     3427JSValue* AssignExprNode::evaluate(ExecState* exec)
     3428{
     3429    return expr->evaluate(exec);
     3430}
     3431
     3432bool AssignExprNode::evaluateToBoolean(ExecState* exec)
     3433{
     3434    return expr->evaluateToBoolean(exec);
     3435}
     3436
     3437double AssignExprNode::evaluateToNumber(ExecState* exec)
     3438{
     3439    return expr->evaluateToNumber(exec);
     3440}
     3441
     3442int32_t AssignExprNode::evaluateToInt32(ExecState* exec)
     3443{
     3444    return expr->evaluateToInt32(exec);
     3445}
     3446
     3447uint32_t AssignExprNode::evaluateToUInt32(ExecState* exec)
     3448{
     3449    return expr->evaluateToInt32(exec);
    28603450}
    28613451
    … …  
    28973487{
    28983488    ScopeChainIterator iter = chain.begin();
    2899     ScopeChainIterator end = chain.end();       
     3489    ScopeChainIterator end = chain.end();
    29003490   
    29013491    // we must always have something in the scope chain

  • trunk/JavaScriptCore/kjs/nodes.h

    r27703 r27747  
    181181        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL = 0;
    182182        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     183        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     184        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    183185        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
    184186
    … …  
    235237    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
    236238    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     239    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     240    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    237241    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    238242    virtual Precedence precedence() const { return PrecPrimary; }
    … …  
    250254      ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL : NumberNode(d), m_value(v) { ASSERT(v == JSImmediate::from(d)); }
    251255      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     256      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     257      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    252258     
    253259      virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); }
    … …  
    307313
    308314    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     315    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     316    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     317    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     318    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    309319    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    310320    virtual Precedence precedence() const { return PrecPrimary; }
    … …  
    315325
    316326  protected:
     327    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    317328    Identifier ident;
    318329    size_t index; // Used by LocalVarAccessNode.
    … …  
    331342    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
    332343    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     344    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     345    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    333346  private:
    334347    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    … …  
    429442    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
    430443    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     444    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     445    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    431446    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    432447    virtual Precedence precedence() const { return PrecMember; }
    … …  
    448463    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    449464    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     465    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     466    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     467    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     468    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    450469    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    451470    virtual Precedence precedence() const { return PrecMember; }
    … …  
    457476
    458477  private:
     478    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    459479    RefPtr<ExpressionNode> expr;
    460480    Identifier ident;
    … …  
    500520    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    501521    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     522    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     523    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     524    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
     525    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
    502526    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    503527    virtual Precedence precedence() const { return PrecLeftHandSide; }
    504528  private:
     529    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    505530    RefPtr<ExpressionNode> expr;
    506531    RefPtr<ArgumentsNode> args;
    … …  
    536561    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    537562    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     563    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     564    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     565    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     566    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    538567    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    539568    virtual Precedence precedence() const { return PrecCall; }
    540569
    541570  protected:
     571    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    542572    Identifier ident;
    543573    RefPtr<ArgumentsNode> args;
    … …  
    555585
    556586    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     587    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     588    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     589    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     590    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
     591  private:
     592    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    557593  };
    558594
    … …  
    575611    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    576612    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     613    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     614    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     615    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     616    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    577617    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    578618    virtual Precedence precedence() const { return PrecCall; }
    579   protected:
     619  private:
     620    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    580621    RefPtr<ExpressionNode> base;
    581622    Identifier ident;
    … …  
    654695
    655696    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     697    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     698    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     699    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     700    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    656701    virtual void optimizeForUnnecessaryResult();
     702  private:
     703    ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    657704  };
    658705
    … …  
    9811028    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    9821029    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1030    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1031    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1032    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1033    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    9831034    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    9841035    virtual Precedence precedence() const { return PrecUnary; }
    … …  
    10041055    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    10051056    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1057    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1058    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1059    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1060    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10061061    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    10071062    virtual Precedence precedence() const { return PrecUnary; }
    10081063  private:
     1064    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    10091065    RefPtr<ExpressionNode> expr;
    10101066  };
    … …  
    10281084      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10291085      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1086      virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1087      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1088      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10301089      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    10311090      virtual Precedence precedence() const { return PrecMultiplicitave; }
    … …  
    10421101      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10431102      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1103      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1104      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10441105      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    10451106      virtual Precedence precedence() const { return PrecMultiplicitave; }
    … …  
    10561117      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10571118      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1119      virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1120      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1121      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10581122      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    10591123      virtual Precedence precedence() const { return PrecMultiplicitave; }
    … …  
    10701134    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10711135    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1136    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1137    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10721138    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    10731139    virtual Precedence precedence() const { return PrecAdditive; }
    … …  
    10761142    RefPtr<ExpressionNode> term1;
    10771143    RefPtr<ExpressionNode> term2;
     1144  private:
     1145    ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    10781146  };
    10791147
    … …  
    10831151        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10841152        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1153        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1154        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    10851155    private:
    10861156        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*) KJS_FAST_CALL;
    … …  
    11111181      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    11121182      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1183      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1184      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    11131185      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    11141186      virtual Precedence precedence() const { return PrecAdditive; }
    … …  
    11251197    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    11261198    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1199    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1200    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1201    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    11271202    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    11281203    virtual Precedence precedence() const { return PrecShift; }
    11291204  private:
     1205    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    11301206    RefPtr<ExpressionNode> term1;
    11311207    RefPtr<ExpressionNode> term2;
    … …  
    11381214    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    11391215    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1216    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1217    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1218    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    11401219    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    11411220    virtual Precedence precedence() const { return PrecShift; }
    11421221  private:
     1222    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    11431223    RefPtr<ExpressionNode> term1;
    11441224    RefPtr<ExpressionNode> term2;
    … …  
    11511231    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    11521232    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1233    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1234    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1235    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    11531236    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    11541237    virtual Precedence precedence() const { return PrecShift; }
    11551238  private:
     1239    ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
    11561240    RefPtr<ExpressionNode> term1;
    11571241    RefPtr<ExpressionNode> term2;
    … …  
    11671251    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    11681252    virtual Precedence precedence() const { return PrecRelational; }
     1253  private:
     1254    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    11691255  protected:
    11701256    RefPtr<ExpressionNode> expr1;
    … …  
    11751261    public:
    11761262        LessNumbersNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1177         : LessNode(e1, e2) {}
     1263            : LessNode(e1, e2) {}
    11781264        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1265        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1266    private:
     1267        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    11791268    };
    11801269
    … …  
    11821271    public:
    11831272        LessStringsNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1184         : LessNode(e1, e2) {}
     1273            : LessNode(e1, e2) {}
    11851274        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1275        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1276    private:
     1277        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    11861278    };
    11871279
    … …  
    13181410    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    13191411    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1412    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1413    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1414    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1415    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    13201416    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13211417    virtual Precedence precedence() const { return PrecBitwiseAnd; }
    13221418  private:
     1419    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    13231420    RefPtr<ExpressionNode> expr1;
    13241421    RefPtr<ExpressionNode> expr2;
    … …  
    13311428    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    13321429    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1430    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1431    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1432    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1433    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    13331434    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13341435    virtual Precedence precedence() const { return PrecBitwiseOr; }
    13351436  private:
     1437    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    13361438    RefPtr<ExpressionNode> expr1;
    13371439    RefPtr<ExpressionNode> expr2;
    … …  
    13441446    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    13451447    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1448    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1449    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1450    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1451    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    13461452    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13471453    virtual Precedence precedence() const { return PrecBitwiseXor; }
    13481454  private:
     1455    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    13491456    RefPtr<ExpressionNode> expr1;
    13501457    RefPtr<ExpressionNode> expr2;
    … …  
    13641471    virtual Precedence precedence() const { return PrecLogicalAnd; }
    13651472  private:
     1473        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    13661474    RefPtr<ExpressionNode> expr1;
    13671475    RefPtr<ExpressionNode> expr2;
    … …  
    13781486    virtual Precedence precedence() const { return PrecLogicalOr; }
    13791487  private:
     1488        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    13801489    RefPtr<ExpressionNode> expr1;
    13811490    RefPtr<ExpressionNode> expr2;
    … …  
    13921501    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    13931502    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1503    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1504    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1505    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    13941506    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13951507    virtual Precedence precedence() const { return PrecConditional; }
    … …  
    15671679    virtual void optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    15681680    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     1681    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
     1682    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
     1683    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
     1684    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
    15691685    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15701686    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }

  • trunk/JavaScriptCore/kjs/value.cpp

    r27201 r27747  
    7373}
    7474
    75 int32_t JSValue::toInt32SlowCase(ExecState* exec, bool& ok) const
     75int32_t JSValue::toInt32SlowCase(double d, bool& ok)
    7676{
    7777    ok = true;
    7878
    79     double d = toNumber(exec);
    8079    if (d >= -D32 / 2 && d < D32 / 2)
    8180        return static_cast<int32_t>(d);
    … …  
    9493}
    9594
    96 uint32_t JSValue::toUInt32SlowCase(ExecState* exec, bool& ok) const
     95int32_t JSValue::toInt32SlowCase(ExecState* exec, bool& ok) const
     96{
     97    return JSValue::toInt32SlowCase(toNumber(exec), ok);
     98}
     99
     100uint32_t JSValue::toUInt32SlowCase(double d, bool& ok)
    97101{
    98102    ok = true;
    99103
    100     double d = toNumber(exec);
    101104    if (d >= 0.0 && d < D32)
    102105        return static_cast<uint32_t>(d);
    … …  
    111114        d32 += D32;
    112115    return static_cast<uint32_t>(d32);
     116}
     117
     118uint32_t JSValue::toUInt32SlowCase(ExecState* exec, bool& ok) const
     119{
     120    return JSValue::toUInt32SlowCase(toNumber(exec), ok);
    113121}
    114122

  • trunk/JavaScriptCore/kjs/value.h

    r27695 r27747  
    9898    uint32_t toUInt32(ExecState*, bool& ok) const;
    9999
     100    // These are identical logic to above, and faster than jsNumber(number)->toInt32(exec)
     101    static int32_t toInt32(double);
     102    static int32_t toUInt32(double);
     103
    100104    // Floating point conversions.
    101105    float toFloat(ExecState*) const;
    … …  
    104108    void mark();
    105109    bool marked() const;
     110
     111    static int32_t toInt32SlowCase(double, bool& ok);
     112    static uint32_t toUInt32SlowCase(double, bool& ok);
    106113
    107114private:
    … …  
    289296}
    290297
    291 inline JSCell *JSValue::asCell()
     298ALWAYS_INLINE JSCell* JSValue::asCell()
    292299{
    293300    ASSERT(!JSImmediate::isImmediate(this));
    294     return static_cast<JSCell *>(this);
    295 }
    296 
    297 inline const JSCell *JSValue::asCell() const
     301    return static_cast<JSCell*>(this);
     302}
     303
     304ALWAYS_INLINE const JSCell* JSValue::asCell() const
    298305{
    299306    ASSERT(!JSImmediate::isImmediate(this));
    300     return static_cast<const JSCell *>(this);
     307    return static_cast<const JSCell*>(this);
    301308}
    302309
    … …  
    474481}
    475482
     483inline int32_t JSValue::toInt32(double val)
     484{
     485    if (!(val >= -2147483648.0 && val < 2147483648.0)) {
     486        bool ignored;
     487        return toInt32SlowCase(val, ignored);
     488    }
     489    return static_cast<int32_t>(val);
     490}
     491
     492inline int32_t JSValue::toUInt32(double val)
     493{
     494    if (!(val >= 0.0 && val < 4294967296.0)) {
     495        bool ignored;
     496        return toUInt32SlowCase(val, ignored);
     497    }
     498    return static_cast<uint32_t>(val);
     499}
     500
    476501inline int32_t JSValue::toInt32(ExecState* exec, bool& ok) const
    477502{
Note: See TracChangeset for help on using the changeset viewer.