Optimize isFinite and isNaN.

src/v8natives.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 // const $Function = global.Function;
 // const $Array = global.Array;
 // const $NaN = 0/0;
 //
 // in math.js:
 // const $floor = MathFloor
 
 const $isNaN = GlobalIsNaN;
 const $isFinite = GlobalIsFinite;
 
-
 // ----------------------------------------------------------------------------
 
 
 // Helper function used to install functions on objects.
 function InstallFunctions(object, attributes, functions) {
   if (functions.length >= 8) {
     %OptimizeObjectForAddingMultipleProperties(object, functions.length >> 1);
   }
   for (var i = 0; i < functions.length; i += 2) {
     var key = functions[i];
@@ skipping 13 matching lines @@
     %SetNativeFlag(f);
   }
   %ToFastProperties(object);
 }
 
 // Emulates JSC by installing functions on a hidden prototype that
 // lies above the current object/prototype.  This lets you override
 // functions on String.prototype etc. and then restore the old function
 // with delete.  See http://code.google.com/p/chromium/issues/detail?id=1717
 function InstallFunctionsOnHiddenPrototype(object, attributes, functions) {
-  %CheckIsBootstrapping();
   var hidden_prototype = new $Object();
   %SetHiddenPrototype(object, hidden_prototype);
   InstallFunctions(hidden_prototype, attributes, functions);
 }
 
 
-// Prevents changes to the prototype of a built-infunction.
-// The "prototype" property of the function object is made non-configurable,
-// and the prototype object is made non-extensible. The latter prevents
-// changing the __proto__ property.
-function SetUpLockedPrototype(constructor, fields, methods) {
-  %CheckIsBootstrapping();
-  var prototype = constructor.prototype;
-  // Install functions first, because this function is used to initialize
-  // PropertyDescriptor itself.
-  var property_count = (methods.length >> 1) + (fields ? fields.length : 0);
-  if (property_count >= 4) {
-    %OptimizeObjectForAddingMultipleProperties(prototype, property_count);
-  }
-  if (fields) {
-    for (var i = 0; i < fields.length; i++) {
-      %SetProperty(prototype, fields[i], void 0, DONT_ENUM | DONT_DELETE);
-    }
-  }
-  for (var i = 0; i < methods.length; i += 2) {
-    var key = methods[i];
-    var f = methods[i + 1];
-    %SetProperty(prototype, key, f, DONT_ENUM | DONT_DELETE | READ_ONLY);
-    %SetNativeFlag(f);
-  }
-  prototype.__proto__ = null;
-  %PreventExtensions(prototype);
-  %ToFastProperties(prototype);
-
-  var desc = GetOwnProperty(constructor, "prototype");
-  desc.setWritable(false);
-  desc.setConfigurable(false);
-  DefineOwnProperty(constructor, "prototype", desc, false);
-}
-
-
 // ----------------------------------------------------------------------------
 
 
 // ECMA 262 - 15.1.4
 function GlobalIsNaN(number) {
-  var n = ToNumber(number);
-  return NUMBER_IS_NAN(n);
+  if (!IS_NUMBER(number)) number = NonNumberToNumber(number);
+  return NUMBER_IS_NAN(number);
 }
 
 
 // ECMA 262 - 15.1.5
 function GlobalIsFinite(number) {
   if (!IS_NUMBER(number)) number = NonNumberToNumber(number);
-
-  // NaN - NaN == NaN, Infinity - Infinity == NaN, -Infinity - -Infinity == NaN.
-  return %_IsSmi(number) || number - number == 0;
+  return NUMBER_IS_FINITE(number);
 }
 
 
 // ECMA-262 - 15.1.2.2
 function GlobalParseInt(string, radix) {
   if (IS_UNDEFINED(radix) || radix === 10 || radix === 0) {
     // Some people use parseInt instead of Math.floor.  This
     // optimization makes parseInt on a Smi 12 times faster (60ns
     // vs 800ns).  The following optimization makes parseInt on a
     // non-Smi number 9 times faster (230ns vs 2070ns).  Together
     // they make parseInt on a string 1.4% slower (274ns vs 270ns).
     if (%_IsSmi(string)) return string;
     if (IS_NUMBER(string) &&
         ((0.01 < string && string < 1e9) ||
             (-1e9 < string && string < -0.01))) {
       // Truncate number.
       return string | 0;
     }
-    string = TO_STRING_INLINE(string);
     radix = radix | 0;
   } else {
-    // The spec says ToString should be evaluated before ToInt32.
-    string = TO_STRING_INLINE(string);
     radix = TO_INT32(radix);
     if (!(radix == 0 || (2 <= radix && radix <= 36)))
       return $NaN;
   }
-
+  string = TO_STRING_INLINE(string);
   if (%_HasCachedArrayIndex(string) &&
       (radix == 0 || radix == 10)) {
     return %_GetCachedArrayIndex(string);
   }
   return %StringParseInt(string, radix);
 }
 
 
 // ECMA-262 - 15.1.2.3
 function GlobalParseFloat(string) {
@@ skipping 26 matching lines @@
 
   var f = %CompileString(x);
   if (!IS_FUNCTION(f)) return f;
 
   return %_CallFunction(receiver, f);
 }
 
 
 // ----------------------------------------------------------------------------
 
-// Set up global object.
-function SetUpGlobal() {
-  %CheckIsBootstrapping();
+
+function SetupGlobal() {
   // ECMA 262 - 15.1.1.1.
   %SetProperty(global, "NaN", $NaN, DONT_ENUM | DONT_DELETE);
 
   // ECMA-262 - 15.1.1.2.
   %SetProperty(global, "Infinity", 1/0, DONT_ENUM | DONT_DELETE);
 
   // ECMA-262 - 15.1.1.3.
   %SetProperty(global, "undefined", void 0, DONT_ENUM | DONT_DELETE);
 
-  // Set up non-enumerable function on the global object.
+  // Setup non-enumerable function on the global object.
   InstallFunctions(global, DONT_ENUM, $Array(
     "isNaN", GlobalIsNaN,
     "isFinite", GlobalIsFinite,
     "parseInt", GlobalParseInt,
     "parseFloat", GlobalParseFloat,
     "eval", GlobalEval
   ));
 }
 
-SetUpGlobal();
+SetupGlobal();
+
 
 // ----------------------------------------------------------------------------
 // Boolean (first part of definition)
 
 
 %SetCode($Boolean, function(x) {
   if (%_IsConstructCall()) {
     %_SetValueOf(this, ToBoolean(x));
   } else {
     return ToBoolean(x);
@@ skipping 276 matching lines @@
   this.enumerable_ = false;
   this.hasEnumerable_ = false;
   this.configurable_ = false;
   this.hasConfigurable_ = false;
   this.get_ = void 0;
   this.hasGetter_ = false;
   this.set_ = void 0;
   this.hasSetter_ = false;
 }
 
-SetUpLockedPrototype(PropertyDescriptor, $Array(
-    "value_",
-    "hasValue_",
-    "writable_",
-    "hasWritable_",
-    "enumerable_",
-    "hasEnumerable_",
-    "configurable_",
-    "hasConfigurable_",
-    "get_",
-    "hasGetter_",
-    "set_",
-    "hasSetter_"
-  ), $Array(
-    "toString", function() {
-      return "[object PropertyDescriptor]";
-    },
-    "setValue", function(value) {
-      this.value_ = value;
-      this.hasValue_ = true;
-    },
-    "getValue", function() {
-      return this.value_;
-    },
-    "hasValue", function() {
-      return this.hasValue_;
-    },
-    "setEnumerable", function(enumerable) {
-      this.enumerable_ = enumerable;
-        this.hasEnumerable_ = true;
-    },
-    "isEnumerable", function () {
-      return this.enumerable_;
-    },
-    "hasEnumerable", function() {
-      return this.hasEnumerable_;
-    },
-    "setWritable", function(writable) {
-      this.writable_ = writable;
-      this.hasWritable_ = true;
-    },
-    "isWritable", function() {
-      return this.writable_;
-    },
-    "hasWritable", function() {
-      return this.hasWritable_;
-    },
-    "setConfigurable", function(configurable) {
-      this.configurable_ = configurable;
-      this.hasConfigurable_ = true;
-    },
-    "hasConfigurable", function() {
-      return this.hasConfigurable_;
-    },
-    "isConfigurable", function() {
-      return this.configurable_;
-    },
-    "setGet", function(get) {
-      this.get_ = get;
-        this.hasGetter_ = true;
-    },
-    "getGet", function() {
-      return this.get_;
-    },
-    "hasGetter", function() {
-      return this.hasGetter_;
-    },
-    "setSet", function(set) {
-      this.set_ = set;
-      this.hasSetter_ = true;
-    },
-    "getSet", function() {
-      return this.set_;
-    },
-    "hasSetter", function() {
-      return this.hasSetter_;
-  }));
+PropertyDescriptor.prototype.__proto__ = null;
+
+PropertyDescriptor.prototype.toString = function() {
+  return "[object PropertyDescriptor]";
+};
+
+PropertyDescriptor.prototype.setValue = function(value) {
+  this.value_ = value;
+  this.hasValue_ = true;
+}
+
+
+PropertyDescriptor.prototype.getValue = function() {
+  return this.value_;
+}
+
+
+PropertyDescriptor.prototype.hasValue = function() {
+  return this.hasValue_;
+}
+
+
+PropertyDescriptor.prototype.setEnumerable = function(enumerable) {
+  this.enumerable_ = enumerable;
+  this.hasEnumerable_ = true;
+}
+
+
+PropertyDescriptor.prototype.isEnumerable = function () {
+  return this.enumerable_;
+}
+
+
+PropertyDescriptor.prototype.hasEnumerable = function() {
+  return this.hasEnumerable_;
+}
+
+
+PropertyDescriptor.prototype.setWritable = function(writable) {
+  this.writable_ = writable;
+  this.hasWritable_ = true;
+}
+
+
+PropertyDescriptor.prototype.isWritable = function() {
+  return this.writable_;
+}
+
+
+PropertyDescriptor.prototype.hasWritable = function() {
+  return this.hasWritable_;
+}
+
+
+PropertyDescriptor.prototype.setConfigurable = function(configurable) {
+  this.configurable_ = configurable;
+  this.hasConfigurable_ = true;
+}
+
+
+PropertyDescriptor.prototype.hasConfigurable = function() {
+  return this.hasConfigurable_;
+}
+
+
+PropertyDescriptor.prototype.isConfigurable = function() {
+  return this.configurable_;
+}
+
+
+PropertyDescriptor.prototype.setGet = function(get) {
+  this.get_ = get;
+  this.hasGetter_ = true;
+}
+
+
+PropertyDescriptor.prototype.getGet = function() {
+  return this.get_;
+}
+
+
+PropertyDescriptor.prototype.hasGetter = function() {
+  return this.hasGetter_;
+}
+
+
+PropertyDescriptor.prototype.setSet = function(set) {
+  this.set_ = set;
+  this.hasSetter_ = true;
+}
+
+
+PropertyDescriptor.prototype.getSet = function() {
+  return this.set_;
+}
+
+
+PropertyDescriptor.prototype.hasSetter = function() {
+  return this.hasSetter_;
+}
 
 
 // Converts an array returned from Runtime_GetOwnProperty to an actual
 // property descriptor. For a description of the array layout please
 // see the runtime.cc file.
 function ConvertDescriptorArrayToDescriptor(desc_array) {
   if (desc_array === false) {
     throw 'Internal error: invalid desc_array';
   }
 
@@ skipping 567 matching lines @@
     return ToObject(x);
   } else {
     if (x == null) return { };
     return ToObject(x);
   }
 });
 
 %SetExpectedNumberOfProperties($Object, 4);
 
 // ----------------------------------------------------------------------------
-// Object
 
-function SetUpObject() {
-  %CheckIsBootstrapping();
-  // Set Up non-enumerable functions on the Object.prototype object.
+
+function SetupObject() {
+  // Setup non-enumerable functions on the Object.prototype object.
   InstallFunctions($Object.prototype, DONT_ENUM, $Array(
     "toString", ObjectToString,
     "toLocaleString", ObjectToLocaleString,
     "valueOf", ObjectValueOf,
     "hasOwnProperty", ObjectHasOwnProperty,
     "isPrototypeOf", ObjectIsPrototypeOf,
     "propertyIsEnumerable", ObjectPropertyIsEnumerable,
     "__defineGetter__", ObjectDefineGetter,
     "__lookupGetter__", ObjectLookupGetter,
     "__defineSetter__", ObjectDefineSetter,
     "__lookupSetter__", ObjectLookupSetter
   ));
   InstallFunctions($Object, DONT_ENUM, $Array(
     "keys", ObjectKeys,
     "create", ObjectCreate,
     "defineProperty", ObjectDefineProperty,
     "defineProperties", ObjectDefineProperties,
     "freeze", ObjectFreeze,
     "getPrototypeOf", ObjectGetPrototypeOf,
     "getOwnPropertyDescriptor", ObjectGetOwnPropertyDescriptor,
     "getOwnPropertyNames", ObjectGetOwnPropertyNames,
     "isExtensible", ObjectIsExtensible,
     "isFrozen", ObjectIsFrozen,
     "isSealed", ObjectIsSealed,
     "preventExtensions", ObjectPreventExtension,
     "seal", ObjectSeal
   ));
 }
 
-SetUpObject();
+SetupObject();
+
 
 // ----------------------------------------------------------------------------
 // Boolean
 
 function BooleanToString() {
   // NOTE: Both Boolean objects and values can enter here as
   // 'this'. This is not as dictated by ECMA-262.
   var b = this;
   if (!IS_BOOLEAN(b)) {
     if (!IS_BOOLEAN_WRAPPER(b)) {
@@ skipping 10 matching lines @@
   // 'this'. This is not as dictated by ECMA-262.
   if (!IS_BOOLEAN(this) && !IS_BOOLEAN_WRAPPER(this))
     throw new $TypeError('Boolean.prototype.valueOf is not generic');
   return %_ValueOf(this);
 }
 
 
 // ----------------------------------------------------------------------------
 
 
-function SetUpBoolean () {
-  %CheckIsBootstrapping();
+function SetupBoolean() {
   InstallFunctions($Boolean.prototype, DONT_ENUM, $Array(
     "toString", BooleanToString,
     "valueOf", BooleanValueOf
   ));
 }
 
-SetUpBoolean();
-
+SetupBoolean();
 
 // ----------------------------------------------------------------------------
 // Number
 
 // Set the Number function and constructor.
 %SetCode($Number, function(x) {
   var value = %_ArgumentsLength() == 0 ? 0 : ToNumber(x);
   if (%_IsConstructCall()) {
     %_SetValueOf(this, value);
   } else {
@@ skipping 93 matching lines @@
   if (p < 1 || p > 21) {
     throw new $RangeError("toPrecision() argument must be between 1 and 21");
   }
   var x = ToNumber(this);
   return %NumberToPrecision(x, p);
 }
 
 
 // ----------------------------------------------------------------------------
 
-function SetUpNumber() {
-  %CheckIsBootstrapping();
+function SetupNumber() {
   %OptimizeObjectForAddingMultipleProperties($Number.prototype, 8);
-  // Set up the constructor property on the Number prototype object.
+  // Setup the constructor property on the Number prototype object.
   %SetProperty($Number.prototype, "constructor", $Number, DONT_ENUM);
 
   %OptimizeObjectForAddingMultipleProperties($Number, 5);
   // ECMA-262 section 15.7.3.1.
   %SetProperty($Number,
                "MAX_VALUE",
                1.7976931348623157e+308,
                DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   // ECMA-262 section 15.7.3.2.
   %SetProperty($Number, "MIN_VALUE", 5e-324, DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   // ECMA-262 section 15.7.3.3.
   %SetProperty($Number, "NaN", $NaN, DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   // ECMA-262 section 15.7.3.4.
   %SetProperty($Number,
                "NEGATIVE_INFINITY",
                -1/0,
                DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   // ECMA-262 section 15.7.3.5.
   %SetProperty($Number,
                "POSITIVE_INFINITY",
                1/0,
                DONT_ENUM | DONT_DELETE | READ_ONLY);
   %ToFastProperties($Number);
 
-  // Set up non-enumerable functions on the Number prototype object.
+  // Setup non-enumerable functions on the Number prototype object.
   InstallFunctions($Number.prototype, DONT_ENUM, $Array(
     "toString", NumberToString,
     "toLocaleString", NumberToLocaleString,
     "valueOf", NumberValueOf,
     "toFixed", NumberToFixed,
     "toExponential", NumberToExponential,
     "toPrecision", NumberToPrecision
   ));
 }
 
-SetUpNumber();
+SetupNumber();
 
 
 // ----------------------------------------------------------------------------
 // Function
 
 $Function.prototype.constructor = $Function;
 
 function FunctionSourceString(func) {
   if (!IS_FUNCTION(func)) {
     throw new $TypeError('Function.prototype.toString is not generic');
@@ skipping 108 matching lines @@
   // property of the resulting function is enumerable (ECMA262, 15.3.5.2).
   var f = %CompileString(source)();
   %FunctionMarkNameShouldPrintAsAnonymous(f);
   return %SetNewFunctionAttributes(f);
 }
 
 %SetCode($Function, NewFunction);
 
 // ----------------------------------------------------------------------------
 
-function SetUpFunction() {
-  %CheckIsBootstrapping();
+function SetupFunction() {
   InstallFunctions($Function.prototype, DONT_ENUM, $Array(
     "bind", FunctionBind,
     "toString", FunctionToString
   ));
 }
 
-SetUpFunction();
+SetupFunction();