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

Timestamp:

Apr 20, 2005, 3:14:35 AM (20 years ago)

Author:

darin

Message:

Reviewed by Maciej.

• speedups, total 12% on JavaScript iBench

I ran the benchmark under Shark and followed its advice a lot, mainly.

• kjs/collector.cpp: (KJS::Collector::allocate): Take out special case for 0; costing speed but unexercised. Use numLiveObjectsAtLastCollect instead of numAllocationsSinceLastCollect so we don't have to bump it each time we call allocate. Put numLiveObjects into a local variable to cut down on global variable accesses. Make "next" cell pointer be a byte offset rather than a pointer so we don't need a special case for NULL. Allow freeList to point to some bogus item when the entire block is full rather than going out of our way to make it point to NULL. (KJS::Collector::markProtectedObjects): Get table size and pointer into locals outside the loop to avoid re-loading them over and over again. (KJS::Collector::collect): Put numLiveObjects into a local variable to cut down on global variable accesses. Make "next" cell pointer be a byte offset as above. Put numLiveObjects into a local variable to cut down on global variable accesses. Set numLiveObjectsAtLastCollect rather than numAllocationsSinceLastCollect. (KJS::Collector::numReferencedObjects): Get table size and pointer into locals outside the loop to avoid re-loading them over and over again. (KJS::Collector::rootObjectClasses): Ditto.

• kjs/internal.h: Make Value be a friend of NumberImp so it can construct number objects directly, avoiding the conversion from Number to Value.

• kjs/internal.cpp: (StringImp::toObject): Don't use Object::dynamicCast, because we know the thing is an object and we don't want to do all the extra work; just cast directly.

• kjs/list.cpp: (KJS::List::List): Construct valueRefCount in a way that avoids the need for a branch -- in the hot case this just meant avoiding checking a variable we just set to false.

• kjs/lookup.cpp: (keysMatch): Marked this inline.

• kjs/nodes.cpp: Disabled KJS_BREAKPOINT, to avoid calling hitStatement all the time. (BooleanNode::evaluate): Make a Value directly, rather than making a Boolean which is converted into a Value. (NumberNode::evaluate): Ditto. (StringNode::evaluate): Ditto. (ArrayNode::evaluate): Ditto. (FunctionCallNode::evaluate): Use new inline baseIfMutable to avoid unnecessary getBase function. Also just use a pointer for func, rather than an Object. (PostfixNode::evaluate): Change code so that it doesn't make an excess Number, and so that it passes a "known to be integer" boolean in, often avoiding a conversion from floating point to integer and back. (DeleteNode::evaluate): Make a Value directly. (TypeOfNode::evaluate): Use new inline baseIfMutable and make Value directly. (PrefixNode::evaluate): Change code so that it doesn't make an excess Number, and so that it passes a "known to be integer" boolean in, often avoiding a conversion from floating point to integer and back. (UnaryPlusNode::evaluate): Make a Value directly. (NegateNode::evaluate): Change code so that it doesn't make an excess Number, and so that it passes a "known to be integer" boolean in, often avoiding a conversion from floating point to integer and back. (BitwiseNotNode::evaluate): Make a Value directly. (LogicalNotNode::evaluate): Ditto. (ShiftNode::evaluate): Don't convert to a double before making a Value. (RelationalNode::evaluate): Make a Value directly. (EqualNode::evaluate): Ditto. (BitOperNode::evaluate): Ditto. (AssignNode::evaluate): Make a Value directly. Change code so that it passes a "known to be integer" boolean in, often avoiding a conversion from floating point to integer and back. (VarDeclNode::evaluate): Make a Value directly. (ForNode::execute): Remove unused local variable.

• kjs/operations.h: (KJS::isNaN): Inlined. (KJS::isInf): Ditto. (KJS::isPosInf): Ditto. (KJS::isNegInf): Ditto.

• kjs/operations.cpp: Change isNaN, isInf, isPosInf, and isNegInf to be inlines. (KJS::equal): Rewrite to avoid creating values and recursing back into the function. (KJS::relation): Rearranged code so that we don't need explicit isNaN checks. (KJS::add): Changed code to make Value directly, and so that it passes a "known to be integer" boolean in, often avoiding a conversion from floating point to integer and back. (KJS::mult): Ditto.

• kjs/property_map.cpp: (KJS::PropertyMap::~PropertyMap): Get size and entries pointer outside loop to avoid re-getting them inside the loop. (KJS::PropertyMap::clear): Ditto. Clear value pointer in addition to key, so we can just look at the value pointer in the mark function. (KJS::PropertyMap::get): Get sizeMask and entries pointer outside loop to avoid re-getting them inside the loop. (KJS::PropertyMap::put): Ditto. (KJS::PropertyMap::insert): Ditto. (KJS::PropertyMap::remove): Ditto. (KJS::PropertyMap::mark): Get size and entries pointer outside loop to avoid re-getting them inside the loop. Don't bother checking key for 0, since we already have to check value for 0. (Also had to change clear() to set value to 0.) (KJS::PropertyMap::addEnumerablesToReferenceList): Get size and entries pointer outside loop to avoid re-getting them inside the loop. (KJS::PropertyMap::addSparseArrayPropertiesToReferenceList): Ditto. (KJS::PropertyMap::save): Ditto.

• other changes

• kjs/protected_values.h: Remove unneeded class name qualifiers.

• kjs/reference.h: (KJS::Reference::baseIfMutable): New inline function: replaces isMutable(). (KJS::Reference::Reference): Inlined.
• kjs/reference.cpp: (KJS::Reference::getValue): Rewrite to not use getBase. (KJS::Reference::putValue): Ditto. (KJS::Reference::deleteValue): Dittol

• kjs/simple_number.h: (KJS::SimpleNumber::integerFits): Added. For use when the parameter is known to be integral.

• kjs/string_object.cpp: (StringProtoFuncImp::call): Create the number without first converting to double in various cases that involve integers.

• kjs/ustring.h: (KJS::UString::attach): Inlined. (KJS::UString::release): Inlined.
• kjs/ustring.cpp: (KJS::UString::find): Get first character outside the loop instead of re-fetching it each time.

• kjs/value.cpp: (Value::Value): Added overloads for all the various specific types of values, so you don't have to convert from, say, Number to Value, just to create one. (Number::Number): Added an overload that takes a boolean to indicate the number is already known to be an integer.

• kjs/value.h: Added more Value constructors, added a version of toNumber that returns a boolean to indicate if the number is known to be an integer (because it was a "simple number"). (KJS::ValueImp::marked): Inlined. (KJS::ValueImp::dispatchType): Inlined. (KJS::ValueImp::dispatchToPrimitive): Inlined. (KJS::ValueImp::dispatchToBoolean): Inlined. (KJS::ValueImp::dispatchToNumber): Inlined. (KJS::ValueImp::dispatchToString): Inlined. (KJS::ValueImp::dispatchToUInt32): Inlined.

File:

• trunk/JavaScriptCore/kjs/nodes.cpp (modified) (29 diffs)

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -48 +48 @@
 using namespace KJS;
 
+// Disabled for now because it shows up on benchmark (0.5%).
+#if DEBUGGER_SUPPORT
+
 #define KJS_BREAKPOINT \
   if (!hitStatement(exec)) \
@@ -56 +59 @@
       exec->dynamicInterpreter()->imp()->debugger()->imp()->aborted()) \
     return Completion(Normal);
+
+#else
+
+#define KJS_BREAKPOINT
+#define KJS_ABORTPOINT
+
+#endif
 
 #define KJS_CHECKEXCEPTION \
@@ -210 +220 @@
 Value BooleanNode::evaluate(ExecState */*exec*/)
 {
-  return Boolean(value);
+  return Value(value);
 }
 
@@ -217 +227 @@
 Value NumberNode::evaluate(ExecState */*exec*/)
 {
-  return Number(value);
+  return Value(value);
 }
 
@@ -224 +234 @@
 Value StringNode::evaluate(ExecState */*exec*/)
 {
-  return String(value);
+  return value;
 }
 
@@ -379 +389 @@
 
   if (opt)
-    array.put(exec,lengthPropertyName, Number(elision + length), DontEnum | DontDelete);
+    array.put(exec,lengthPropertyName, Value(elision + length), DontEnum | DontDelete);
 
   return array;
@@ -699 +709 @@
   }
 
-  Object func = Object(static_cast<ObjectImp*>(v.imp()));
-
-  if (!func.implementsCall()) {
+  ObjectImp *func = static_cast<ObjectImp*>(v.imp());
+
+  if (!func->implementsCall()) {
     return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, expr);
   }
 
-  Value thisVal;
-  if (ref.isMutable())
-    thisVal = ref.getBase(exec);
-  else
-    thisVal = Null();
-
-  if (thisVal.type() == ObjectType &&
-      Object::dynamicCast(thisVal).inherits(&ActivationImp::info))
-    thisVal = Null();
-
-  if (thisVal.type() != ObjectType) {
+  ObjectImp *thisObjImp = 0;
+  ValueImp *thisValImp = ref.baseIfMutable();
+  if (thisValImp && thisValImp->type() == ObjectType && !static_cast<ObjectImp *>(thisValImp)->inherits(&ActivationImp::info))
+    thisObjImp = static_cast<ObjectImp *>(thisValImp);
+
+  if (!thisObjImp) {
     // ECMA 11.2.3 says that in this situation the this value should be null.
     // However, section 10.2.3 says that in the case where the value provided
@@ -722 +727 @@
     // of implementation we use the global object anyway here. This guarantees
     // that in host objects you always get a valid object for this.
-    // thisVal = Null();
-    thisVal = exec->dynamicInterpreter()->globalObject();
-  }
-
-  Object thisObj = Object::dynamicCast(thisVal);
-  Value result = func.call(exec,thisObj, argList);
-
-  return result;
+    thisObjImp = exec->dynamicInterpreter()->globalObject().imp();
+  }
+
+  Object thisObj(thisObjImp);
+  return func->call(exec, thisObj, argList);
 }
 
@@ -754 +756 @@
   KJS_CHECKEXCEPTIONVALUE
   Value v = ref.getValue(exec);
-  Number n = v.toNumber(exec);
-
-  double newValue = (oper == OpPlusPlus) ? n.value() + 1 : n.value() - 1;
-  Value n2 = Number(newValue);
-
-  ref.putValue(exec,n2);
-
-  return n;
+
+  bool knownToBeInteger;
+  double n = v.toNumber(exec, knownToBeInteger);
+
+  double newValue = (oper == OpPlusPlus) ? n + 1 : n - 1;
+  ref.putValue(exec, Value(newValue, knownToBeInteger));
+
+  return Value(n, knownToBeInteger);
 }
 
@@ -785 +787 @@
   Reference ref = expr->evaluateReference(exec);
   KJS_CHECKEXCEPTIONVALUE
-  return Boolean(ref.deleteValue(exec));
+  return Value(ref.deleteValue(exec));
 }
 
@@ -835 +837 @@
   Reference ref = expr->evaluateReference(exec);
   KJS_CHECKEXCEPTIONVALUE
-  if (ref.isMutable()) {
-    Value b = ref.getBase(exec);
-    if (b.type() == NullType)
-      return String("undefined");
-  }
+  ValueImp *b = ref.baseIfMutable();
+  if (b && b->dispatchType() == NullType)
+    return Value("undefined");
   Value v = ref.getValue(exec);
   switch (v.type())
@@ -866 +866 @@
     }
 
-  return String(s);
+  return Value(s);
 }
 
@@ -891 +891 @@
   KJS_CHECKEXCEPTIONVALUE
   Value v = ref.getValue(exec);
-  Number n = v.toNumber(exec);
-
-  double newValue = (oper == OpPlusPlus) ? n.value() + 1 : n.value() - 1;
-  Value n2 = Number(newValue);
-
-  ref.putValue(exec,n2);
+
+  bool knownToBeInteger;
+  double n = v.toNumber(exec, knownToBeInteger);
+
+  double newValue = (oper == OpPlusPlus) ? n + 1 : n - 1;
+  Value n2(newValue, knownToBeInteger);
+
+  ref.putValue(exec, n2);
 
   return n2;
@@ -923 +925 @@
   KJS_CHECKEXCEPTIONVALUE
 
-  return Number(v.toNumber(exec)); /* TODO: optimize */
+  return Value(v.toNumber(exec)); /* TODO: optimize */
 }
 
@@ -947 +949 @@
   Value v = expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-  Number n = v.toNumber(exec);
-
-  double d = -n.value();
-
-  return Number(d);
+
+  bool knownToBeInteger;
+  double n = v.toNumber(exec, knownToBeInteger);
+  return Value(-n, knownToBeInteger && n != 0);
 }
 
@@ -975 +976 @@
   Value v = expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-  int i32 = v.toInt32(exec);
-
-  return Number(~i32);
+  return Value(~v.toInt32(exec));
 }
 
@@ -1001 +1000 @@
   Value v = expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-  bool b = v.toBoolean(exec);
-
-  return Boolean(!b);
+  return Value(!v.toBoolean(exec));
 }
 
@@ -1035 +1032 @@
   KJS_CHECKEXCEPTIONVALUE
 
-  return mult(exec,v1, v2, oper);
+  return mult(exec, v1, v2, oper);
 }
 
@@ -1067 +1064 @@
   KJS_CHECKEXCEPTIONVALUE
 
-  return add(exec,v1, v2, oper);
+  return add(exec, v1, v2, oper);
 }
 
@@ -1100 +1097 @@
   i2 &= 0x1f;
 
-  double result;
   switch (oper) {
   case OpLShift:
-    result = v1.toInt32(exec) << i2;
-    break;
+    return Value(v1.toInt32(exec) << i2);
   case OpRShift:
-    result = v1.toInt32(exec) >> i2;
-    break;
+    return Value(v1.toInt32(exec) >> i2);
   case OpURShift:
-    result = v1.toUInt32(exec) >> i2;
-    break;
+    return Value(v1.toUInt32(exec) >> i2);
   default:
     assert(!"ShiftNode: unhandled switch case");
-    result = 0;
-  }
-
-  return Number(result);
+    return Undefined();
+  }
 }
 
@@ -1178 +1169 @@
       // property. It seems that all object have the property, but not all implement it, so in this
       // case we return false (consistent with mozilla)
-      return Boolean(false);
+      return Value(false);
       //      return throwError(exec, TypeError,
       //                        "Object does not implement the [[HasInstance]] method." );
@@ -1185 +1176 @@
   }
 
-  return Boolean(b);
+  return Value(b);
 }
 
@@ -1226 +1217 @@
     result = oper == OpStrEq ? eq : !eq;
   }
-  return Boolean(result);
+  return Value(result);
 }
 
@@ -1266 +1257 @@
     result = i1 | i2;
 
-  return Number(result);
+  return Value(result);
 }
 
@@ -1396 +1387 @@
       i1 = v1.toInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(i1 <<= i2);
+      v = Value(i1 << i2);
       break;
     case OpRShift:
       i1 = v1.toInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(i1 >>= i2);
+      v = Value(i1 >> i2);
       break;
     case OpURShift:
       ui = v1.toUInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(ui >>= i2);
+      v = Value(ui >> i2);
       break;
     case OpAndEq:
       i1 = v1.toInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(i1 &= i2);
+      v = Value(i1 & i2);
       break;
     case OpXOrEq:
       i1 = v1.toInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(i1 ^= i2);
+      v = Value(i1 ^ i2);
       break;
     case OpOrEq:
       i1 = v1.toInt32(exec);
       i2 = v2.toInt32(exec);
-      v = Number(i1 |= i2);
+      v = Value(i1 | i2);
       break;
     case OpModEq: {
-      double d1 = v1.toNumber(exec);
-      double d2 = v2.toNumber(exec);
-      v = Number(fmod(d1,d2));
+      bool d1KnownToBeInteger;
+      double d1 = v1.toNumber(exec, d1KnownToBeInteger);
+      bool d2KnownToBeInteger;
+      double d2 = v2.toNumber(exec, d2KnownToBeInteger);
+      v = Value(fmod(d1, d2), d1KnownToBeInteger && d2KnownToBeInteger && d2 != 0);
     }
       break;
@@ -1596 +1589 @@
 Value VarDeclNode::evaluate(ExecState *exec)
 {
-  Object variable = Object::dynamicCast(exec->context().imp()->variableObject());
+  Object variable = exec->context().imp()->variableObject();
 
   Value val;
@@ -1617 +1610 @@
   variable.put(exec, ident, val, DontDelete | Internal);
 
-  return String(ident.ustring());
+  return ident.ustring();
 }
 
@@ -1978 +1971 @@
 Completion ForNode::execute(ExecState *exec)
 {
-  Value e, v, cval;
-  bool b;
+  Value v, cval;
 
   if (expr1) {
@@ -1989 +1981 @@
       v = expr2->evaluate(exec);
       KJS_CHECKEXCEPTION
-      b = v.toBoolean(exec);
-      if (b == false)
+      if (!v.toBoolean(exec))
         return Completion(Normal, cval);
     }