Improve performance of Math.min and Math.max for the case of two arguments.

src/math.js

 // Copyright 2006-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 101 matching lines @@
 
 // ECMA 262 - 15.8.2.10
 function MathLog(x) {
   if (!IS_NUMBER(x)) x = NonNumberToNumber(x);
   return %_MathLog(x);
 }
 
 // ECMA 262 - 15.8.2.11
 function MathMax(arg1, arg2) {  // length == 2
   var length = %_ArgumentsLength();
+  if (length == 2) {
+    if (!IS_NUMBER(arg1)) arg1 = NonNumberToNumber(arg1);
+    if (!IS_NUMBER(arg2)) arg2 = NonNumberToNumber(arg2);
+    if (arg2 > arg1) return arg2;
+    if (arg1 > arg2) return arg1;
+    if (arg1 == arg2) {

[fschneider, 2012/01/03 09:52:06]

It does not make a difference for numbers, but I'd consistently use either ===
or ==.

+      // Make sure -0 is considered less than +0.  -0 is never a Smi, +0 can be
+      // a Smi or a heap number.
+      return (arg1 === 0 && !%_IsSmi(arg1) && 1 / arg1 < 0) ? arg2 : arg1;

[Lasse Reichstein, 2012/01/03 06:17:45]

You can drop the 1/arg1 test, and actually also the '=== 0' test.
How about just:
  return %_IsSmi(arg1) ? arg1 : arg2;
You already know that the values are equal, so just pick the best one (the smi),
which also works out to what you want for 0/-0.

[Lasse Reichstein, 2012/01/03 07:57:48]

Ignore that. If you have +0 as a HeapNumber, that approach isn't enough, and you
do need to do the division.
We could consider creating a %_IsMinusZero predicate to avoid the arithmetic.

+    }
+    // All comparisons failed, one of the arguments must be NaN.
+    return 0/0;  // Compiler constant-folds this to NaN.
+  }
   if (length == 0) {
     return -1/0;  // Compiler constant-folds this to -Infinity.
   }
   var r = arg1;
   if (!IS_NUMBER(r)) r = NonNumberToNumber(r);
   if (NUMBER_IS_NAN(r)) return r;
   for (var i = 1; i < length; i++) {
     var n = %_Arguments(i);
     if (!IS_NUMBER(n)) n = NonNumberToNumber(n);
     if (NUMBER_IS_NAN(n)) return n;
     // Make sure +0 is considered greater than -0.  -0 is never a Smi, +0 can be
     // a Smi or heap number.
     if (n > r || (r === 0 && n === 0 && !%_IsSmi(r) && 1 / r < 0)) r = n;
   }
   return r;
 }
 
 // ECMA 262 - 15.8.2.12
 function MathMin(arg1, arg2) {  // length == 2
   var length = %_ArgumentsLength();
+  if (length == 2) {
+    if (!IS_NUMBER(arg1)) arg1 = NonNumberToNumber(arg1);
+    if (!IS_NUMBER(arg2)) arg2 = NonNumberToNumber(arg2);
+    if (arg2 > arg1) return arg1;
+    if (arg1 > arg2) return arg2;
+    if (arg1 == arg2) {
+      // Make sure -0 is considered less than +0.  -0 is never a Smi, +0 can be
+      // a Smi or a heap number.
+      return (arg1 === 0 && !%_IsSmi(arg1) && 1 / arg1 < 0) ? arg1 : arg2;

[Lasse Reichstein, 2012/01/03 06:17:45]

Here you want to return the non-smi if the values are zero. Otherwise you'd
probably want the smi:
  return ((arg1 === 0) != (%_IsSmi(arg1))) ? arg1 : arg2;

[Lasse Reichstein, 2012/01/03 07:57:48]

Same problem here if +0 and -0 both are non-smi, so ariginal code is correct.

+    }
+    // All comparisons failed, one of the arguments must be NaN.
+    return 0/0;  // Compiler constant-folds this to NaN.
+  }
   if (length == 0) {
     return 1/0;  // Compiler constant-folds this to Infinity.
   }
   var r = arg1;
   if (!IS_NUMBER(r)) r = NonNumberToNumber(r);
   if (NUMBER_IS_NAN(r)) return r;
   for (var i = 1; i < length; i++) {
     var n = %_Arguments(i);
     if (!IS_NUMBER(n)) n = NonNumberToNumber(n);
     if (NUMBER_IS_NAN(n)) return n;
-    // Make sure -0 is considered less than +0.  -0 is never a Smi, +0 can b a
+    // Make sure -0 is considered less than +0.  -0 is never a Smi, +0 can be a
     // Smi or a heap number.
     if (n < r || (r === 0 && n === 0 && !%_IsSmi(n) && 1 / n < 0)) r = n;
   }
   return r;
 }
 
 // ECMA 262 - 15.8.2.13
 function MathPow(x, y) {
   if (!IS_NUMBER(x)) x = NonNumberToNumber(x);
   if (!IS_NUMBER(y)) y = NonNumberToNumber(y);
@@ skipping 92 matching lines @@
     "sqrt", MathSqrt,
     "tan", MathTan,
     "atan2", MathAtan2,
     "pow", MathPow,
     "max", MathMax,
     "min", MathMin
   ));
 }
 
 SetUpMath();