X64: Use roundsd for DoMathFloor.

test/mjsunit/mjsunit.js

 // Copyright 2008 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 function MjsUnitAssertionError(message) {
   this.message = message;
   // This allows fetching the stack trace using TryCatch::StackTrace.
   this.stack = new Error("").stack;
 }
 
-MjsUnitAssertionError.prototype.toString = function () {
-  return this.message;
-}
-
 /*
  * This file is included in all mini jsunit test cases.  The test
  * framework expects lines that signal failed tests to start with
  * the f-word and ignore all other lines.
  */
 
+
+MjsUnitAssertionError.prototype.toString = function () {
+  return this.message;
+};
+
+
+function classOf(object) {
+  var string = Object.prototype.toString.call(object);
+  // String has format [object <ClassName>].
+  return string.substring(8, string.length - 1);
+}
+
+
 function MjsUnitToString(value) {
   switch (typeof value) {
     case "string":
       return JSON.stringify(value);
     case "number":
       if (value === 0 && (1 / value) < 0) return "-0";
+      // FALLTHROUGH.
     case "boolean":
-    case "null":
     case "undefined":
     case "function":
       return String(value);
     case "object":
       if (value === null) return "null";
-      var clazz = Object.prototype.toString.call(value);
-      clazz = clazz.substring(8, clazz.length - 1);
-      switch (clazz) {
+      var objectClass = classOf(value);
+      switch (objectClass) {
         case "Number":
         case "String":
         case "Boolean":
         case "Date":
-          return clazz + "(" + MjsUnitToString(value.valueOf()) + ")";
+          return objectClass + "(" + MjsUnitToString(value.valueOf()) + ")";
         case "RegExp":
           return value.toString();
         case "Array":
           return "[" + value.map(MjsUnitArrayElementToString).join(",") + "]";
         case "Object":
           break;
         default:
-          return clazz + "()";
+          return objectClass + "()";
       }
       // [[Class]] is "Object".
       var constructor = value.constructor.name;
       if (name) return name + "()";
       return "Object()";
     default:
       return "-- unknown value --";
   }
 }
 
@@ skipping 12 matching lines @@
   }
 
   message += ": expected <" + MjsUnitToString(expected) +
       "> found <" + MjsUnitToString(found) + ">";
   throw new MjsUnitAssertionError(message);
 }
 
 
 function deepObjectEquals(a, b) {
   var aProps = [];
-  for (var key in a)
+  for (var key in a) {
     aProps.push(key);
+  }
   var bProps = [];
-  for (var key in b)
+  for (key in b) {
     bProps.push(key);
+  }
   aProps.sort();
   bProps.sort();
   if (!deepEquals(aProps, bProps))
     return false;
   for (var i = 0; i < aProps.length; i++) {
     if (!deepEquals(a[aProps[i]], b[aProps[i]]))
       return false;
   }
   return true;
 }
 
 
 function deepEquals(a, b) {
   if (a == b) {
     // Check for -0.
     if (a === 0 && b === 0) return (1 / a) === (1 / b);
     return true;
   }
   if (typeof a == "number" && typeof b == "number" && isNaN(a) && isNaN(b)) {
     return true;
   }
   if (a == null || b == null) return false;
-  if (a.constructor === RegExp || b.constructor === RegExp) {
-    return (a.constructor === b.constructor) && (a.toString() === b.toString());
+  var aClass = classOf(a);
+  var bClass = classOf(b);
+  if (aClass === "RegExp" || bClass === "RegExp") {
+    return (aClass === bClass) && (a.toString() === b.toString());
   }
   if ((typeof a) !== 'object' || (typeof b) !== 'object' ||
       (a === null) || (b === null))
     return false;
-  if (a.constructor === Array) {
-    if (b.constructor !== Array)
+  if (aClass === "Array") {
+    if (bClass !== "Array")
       return false;
     if (a.length != b.length)
       return false;
     for (var i = 0; i < a.length; i++) {
       if (i in a) {
         if (!(i in b) || !(deepEquals(a[i], b[i])))
           return false;
       } else if (i in b) {
         return false;
       }
     }
     return true;
+  } else if (bClass == "Array") {
+    return false;
   } else {
     return deepObjectEquals(a, b);
   }
 }
 
 
 function assertSame(expected, found, name_opt) {
   if (found !== expected) {
     fail(expected, found, name_opt);
   }
@@ skipping 93 matching lines @@
 
 
 function assertUnreachable(name_opt) {
   // Fix this when we ditch the old test runner.
   var message = "Fail" + "ure: unreachable";
   if (name_opt) {
     message += " - " + name_opt;
   }
   throw new MjsUnitAssertionError(message);
 }