Fixing mozilla test failures regarding Math.pow.

src/ia32/code-stubs-ia32.cc

 // 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 2979 matching lines @@
   if (exponent_type_ != INTEGER) {
     Label fast_power;
     // xmm1: base as double that is not +/- Infinity or NaN
     // xmm2: exponent as double
     // Detect integer exponents stored as double.
     __ cvttsd2si(eax, Operand(xmm2));
     // Skip to runtime if possibly NaN (indicated by the indefinite integer).
     __ cmp(eax, Immediate(0x80000000u));
     __ j(equal, &generic_runtime);
     __ cvtsi2sd(xmm4, eax);
-    __ ucomisd(xmm2, xmm4);
+    __ ucomisd(xmm2, xmm4);  // Already ruled out NaNs for exponent.
     __ j(equal, &int_exponent);
 
     if (exponent_type_ == ON_STACK) {
       // Detect square root case.  Crankshaft detects constant +/-0.5 at
       // compile time and uses DoMathPowHalf instead.  We then skip this check
       // for non-constant cases of +/-0.5 as these hardly occur.
       Label continue_sqrt, continue_rsqrt, not_plus_half;
       // Test for 0.5.
       // Load xmm4 with 0.5.
       __ mov(ecx, Immediate(0x3F000000u));
       __ movd(xmm4, ecx);
       __ cvtss2sd(xmm4, xmm4);
       // xmm4 now has 0.5.
-      __ ucomisd(xmm4, xmm2);
+      __ ucomisd(xmm4, xmm2);  // Already ruled out NaNs for exponent.
       __ j(not_equal, &not_plus_half, Label::kNear);
 
       // Calculates square root of base.  Check for the special case of
       // Math.pow(-Infinity, 0.5) == Infinity (ECMA spec, 15.8.2.13).
       // According to IEEE-754, single-precision -Infinity has the highest
       // 9 bits set and the lowest 23 bits cleared.
       __ mov(ecx, 0xFF800000u);
       __ movd(xmm4, ecx);
       __ cvtss2sd(xmm4, xmm4);
       __ ucomisd(xmm1, xmm4);
+      // Comparing -Infinity with NaN results in "unordered", which sets the
+      // zero flag as if both were equal.  However, it also sets the carry flag.
       __ j(not_equal, &continue_sqrt, Label::kNear);
+      __ j(carry, &continue_sqrt, Label::kNear);
 
       // Set result to Infinity in the special case.
       __ xorps(xmm3, xmm3);
       __ subsd(xmm3, xmm4);
       __ jmp(&done);
 
       __ bind(&continue_sqrt);
       // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.
       __ xorps(xmm4, xmm4);
       __ addsd(xmm4, xmm1);  // Convert -0 to +0.
       __ sqrtsd(xmm3, xmm4);
       __ jmp(&done);
 
       // Test for -0.5.
       __ bind(&not_plus_half);
       // Load xmm2 with -0.5.
       // Since xmm3 is 1 and xmm4 is 0.5 this is simply xmm4 - xmm3.
       __ subsd(xmm4, xmm3);
       // xmm4 now has -0.5.
-      __ ucomisd(xmm4, xmm2);
+      __ ucomisd(xmm4, xmm2);  // Already ruled out NaNs for exponent.
       __ j(not_equal, &fast_power, Label::kNear);
 
       // Calculates reciprocal of square root of base.  Check for the special
       // case of Math.pow(-Infinity, -0.5) == 0 (ECMA spec, 15.8.2.13).
       // According to IEEE-754, single-precision -Infinity has the highest
       // 9 bits set and the lowest 23 bits cleared.
       __ mov(ecx, 0xFF800000u);
       __ movd(xmm4, ecx);
       __ cvtss2sd(xmm4, xmm4);
       __ ucomisd(xmm1, xmm4);
+      // Comparing -Infinity with NaN results in "unordered", which sets the
+      // zero flag as if both were equal.  However, it also sets the carry flag.
       __ j(not_equal, &continue_rsqrt, Label::kNear);
+      __ j(carry, &continue_rsqrt, Label::kNear);
 
       // Set result to 0 in the special case.
       __ xorps(xmm3, xmm3);
       __ jmp(&done);
 
       __ bind(&continue_rsqrt);
       // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.
       __ xorps(xmm2, xmm2);
       __ addsd(xmm2, xmm1);  // Convert -0 to +0.
       __ sqrtsd(xmm2, xmm2);
@@ skipping 69 matching lines @@
 
   // base has the original value of the exponent - if the exponent  is
   // negative return 1/result.
   __ test(ecx, ecx);
   __ j(positive, &done);
   __ divsd(xmm2, xmm3);
   __ movsd(xmm3, xmm2);
   // Test whether result is zero.  Bail out to check for subnormal result.
   // Due to subnormals, x^-y == (1/x)^y does not hold in all cases.
   __ xorps(xmm2, xmm2);
-  __ ucomisd(xmm2, xmm3);
+  __ ucomisd(xmm2, xmm3);  // Result cannot be NaN.
   __ j(equal, &double_int_runtime);
 
   // Returning or bailing out.
   if (exponent_type_ == ON_STACK) {
     // The stub is called from non-optimized code, which expects the result
     // as heap number in eax.
     __ bind(&done);
     // xmm3: result
     __ AllocateHeapNumber(eax, ecx, edx, &generic_runtime);
     __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm3);
@@ skipping 4127 matching lines @@
                                  false);
   __ pop(edx);
   __ ret(0);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32