Revert of Remove obsolete V8_INFINITY macro.

src/assembler.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 17 matching lines @@
 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // The original source code covered by the above license above has been
 // modified significantly by Google Inc.
 // Copyright 2012 the V8 project authors. All rights reserved.
 
 #include "src/assembler.h"
 
 #include <cmath>
-#include <limits>
-
 #include "src/api.h"
 #include "src/base/cpu.h"
 #include "src/base/functional.h"
 #include "src/base/lazy-instance.h"
 #include "src/base/platform/platform.h"
 #include "src/builtins.h"
 #include "src/codegen.h"
 #include "src/counters.h"
 #include "src/cpu-profiler.h"
 #include "src/debug.h"
@@ skipping 831 matching lines @@
 
 // -----------------------------------------------------------------------------
 // Implementation of ExternalReference
 
 void ExternalReference::SetUp() {
   double_constants.min_int = kMinInt;
   double_constants.one_half = 0.5;
   double_constants.minus_one_half = -0.5;
   double_constants.canonical_non_hole_nan = base::OS::nan_value();
   double_constants.the_hole_nan = bit_cast<double>(kHoleNanInt64);
-  double_constants.negative_infinity = -std::numeric_limits<double>::infinity();
+  double_constants.negative_infinity = -V8_INFINITY;
   double_constants.uint32_bias =
     static_cast<double>(static_cast<uint32_t>(0xFFFFFFFF)) + 1;
 
   math_exp_data_mutex = new base::Mutex();
 }
 
 
 void ExternalReference::InitializeMathExpData() {
   // Early return?
   if (math_exp_data_initialized) return;
 
   base::LockGuard<base::Mutex> lock_guard(math_exp_data_mutex);
   if (!math_exp_data_initialized) {
     // If this is changed, generated code must be adapted too.
     const int kTableSizeBits = 11;
     const int kTableSize = 1 << kTableSizeBits;
     const double kTableSizeDouble = static_cast<double>(kTableSize);
 
     math_exp_constants_array = new double[9];
     // Input values smaller than this always return 0.
     math_exp_constants_array[0] = -708.39641853226408;
     // Input values larger than this always return +Infinity.
     math_exp_constants_array[1] = 709.78271289338397;
-    math_exp_constants_array[2] = std::numeric_limits<double>::infinity();
+    math_exp_constants_array[2] = V8_INFINITY;
     // The rest is black magic. Do not attempt to understand it. It is
     // loosely based on the "expd" function published at:
     // http://herumi.blogspot.com/2011/08/fast-double-precision-exponential.html
     const double constant3 = (1 << kTableSizeBits) / std::log(2.0);
     math_exp_constants_array[3] = constant3;
     math_exp_constants_array[4] =
         static_cast<double>(static_cast<int64_t>(3) << 51);
     math_exp_constants_array[5] = 1 / constant3;
     math_exp_constants_array[6] = 3.0000000027955394;
     math_exp_constants_array[7] = 0.16666666685227835;
@@ skipping 482 matching lines @@
       isolate->debug()->restarter_frame_function_pointer_address());
 }
 
 
 double power_helper(double x, double y) {
   int y_int = static_cast<int>(y);
   if (y == y_int) {
     return power_double_int(x, y_int);  // Returns 1 if exponent is 0.
   }
   if (y == 0.5) {
-    return (std::isinf(x)) ? std::numeric_limits<double>::infinity()
+    return (std::isinf(x)) ? V8_INFINITY
                            : fast_sqrt(x + 0.0);  // Convert -0 to +0.
   }
   if (y == -0.5) {
     return (std::isinf(x)) ? 0 : 1.0 / fast_sqrt(x + 0.0);  // Convert -0 to +0.
   }
   return power_double_double(x, y);
 }
 
 
 // Helper function to compute x^y, where y is known to be an
@@ skipping 16 matching lines @@
 
 
 double power_double_double(double x, double y) {
 #if defined(__MINGW64_VERSION_MAJOR) && \
     (!defined(__MINGW64_VERSION_RC) || __MINGW64_VERSION_RC < 1)
   // MinGW64 has a custom implementation for pow.  This handles certain
   // special cases that are different.
   if ((x == 0.0 || std::isinf(x)) && std::isfinite(y)) {
     double f;
     if (std::modf(y, &f) != 0.0) {
-      return ((x == 0.0) ^ (y > 0)) ? std::numeric_limits<double>::infinity()
-                                    : 0.0;
+      return ((x == 0.0) ^ (y > 0)) ? V8_INFINITY : 0;
     }
   }
 
   if (x == 2.0) {
     int y_int = static_cast<int>(y);
     if (y == y_int) {
       return std::ldexp(1.0, y_int);
     }
   }
 #endif
@@ skipping 126 matching lines @@
     assembler_->RecordRelocInfo(RelocInfo::POSITION, state_.current_position);
     state_.written_position = state_.current_position;
     written = true;
   }
 
   // Return whether something was written.
   return written;
 }
 
 } }  // namespace v8::internal