Changeset 27747 in webkit for trunk/JavaScriptCore/kjs/nodes.cpp


Ignore:
Timestamp:
Nov 13, 2007, 12:02:44 AM (18 years ago)
Author:
[email protected]
Message:

2007-11-12 Eric Seidel <​[email protected]>

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):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.