Remove obsolete V8_INFINITY macro.

src/compiler/typer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/compiler/typer.h"
+
+#include <limits>
+
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
-#include "src/compiler/typer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 #define NATIVE_TYPES(V) \
   V(Int8)               \
   V(Uint8)              \
   V(Int16)              \
   V(Uint16)             \
@@ skipping 129 matching lines @@
       context_(context),
       decorator_(NULL),
       cache_(new (graph->zone()) LazyTypeCache(graph->zone())),
       weaken_min_limits_(graph->zone()),
       weaken_max_limits_(graph->zone()) {
   Zone* zone = this->zone();
   Factory* f = zone->isolate()->factory();
 
   Handle<Object> zero = f->NewNumber(0);
   Handle<Object> one = f->NewNumber(1);
-  Handle<Object> infinity = f->NewNumber(+V8_INFINITY);
-  Handle<Object> minusinfinity = f->NewNumber(-V8_INFINITY);
+  Handle<Object> infinity =
+      f->NewNumber(+std::numeric_limits<double>::infinity());
+  Handle<Object> minusinfinity =
+      f->NewNumber(-std::numeric_limits<double>::infinity());
 
   Type* number = Type::Number();
   Type* signed32 = Type::Signed32();
   Type* unsigned32 = Type::Unsigned32();
   Type* nan_or_minuszero = Type::Union(Type::NaN(), Type::MinusZero(), zone);
   Type* truncating_to_zero =
       Type::Union(Type::Union(Type::Constant(infinity, zone),
                               Type::Constant(minusinfinity, zone), zone),
                   nan_or_minuszero, zone);
 
@@ skipping 754 matching lines @@
 
 
 // JS arithmetic operators.
 
 
 // Returns the array's least element, ignoring NaN.
 // There must be at least one non-NaN element.
 // Any -0 is converted to 0.
 static double array_min(double a[], size_t n) {
   DCHECK(n != 0);
-  double x = +V8_INFINITY;
+  double x = +std::numeric_limits<double>::infinity();
   for (size_t i = 0; i < n; ++i) {
     if (!std::isnan(a[i])) {
       x = std::min(a[i], x);
     }
   }
   DCHECK(!std::isnan(x));
   return x == 0 ? 0 : x;  // -0 -> 0
 }
 
 
 // Returns the array's greatest element, ignoring NaN.
 // There must be at least one non-NaN element.
 // Any -0 is converted to 0.
 static double array_max(double a[], size_t n) {
   DCHECK(n != 0);
-  double x = -V8_INFINITY;
+  double x = -std::numeric_limits<double>::infinity();
   for (size_t i = 0; i < n; ++i) {
     if (!std::isnan(a[i])) {
       x = std::max(a[i], x);
     }
   }
   DCHECK(!std::isnan(x));
   return x == 0 ? 0 : x;  // -0 -> 0
 }
 
 
@@ skipping 94 matching lines @@
   double rmax = rhs->Max()->Number();
   results[0] = lmin * rmin;
   results[1] = lmin * rmax;
   results[2] = lmax * rmin;
   results[3] = lmax * rmax;
   // If the result may be nan, we give up on calculating a precise type, because
   // the discontinuity makes it too complicated.  Note that even if none of the
   // "results" above is nan, the actual result may still be, so we have to do a
   // different check:
   bool maybe_nan = (lhs->Maybe(t->singleton_zero) &&
-                    (rmin == -V8_INFINITY || rmax == +V8_INFINITY)) ||
+                    (rmin == -std::numeric_limits<double>::infinity() ||
+                     rmax == +std::numeric_limits<double>::infinity())) ||
                    (rhs->Maybe(t->singleton_zero) &&
-                    (lmin == -V8_INFINITY || lmax == +V8_INFINITY));
+                    (lmin == -std::numeric_limits<double>::infinity() ||
+                     lmax == +std::numeric_limits<double>::infinity()));
   if (maybe_nan) return t->weakint;  // Giving up.
   bool maybe_minuszero = (lhs->Maybe(t->singleton_zero) && rmin < 0) ||
                          (rhs->Maybe(t->singleton_zero) && lmin < 0);
   Factory* f = t->isolate()->factory();
   Type* range = Type::Range(f->NewNumber(array_min(results, 4)),
                             f->NewNumber(array_max(results, 4)), t->zone());
   return maybe_minuszero ? Type::Union(range, Type::MinusZero(), t->zone())
                          : range;
 }
 
 
 Type* Typer::Visitor::JSMultiplyTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = Rangify(ToNumber(lhs, t), t);
   rhs = Rangify(ToNumber(rhs, t), t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSMultiplyRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
   return Type::Number();
 }
 
 
 Type* Typer::Visitor::JSDivideTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = ToNumber(lhs, t);
   rhs = ToNumber(rhs, t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
   // Division is tricky, so all we do is try ruling out nan.
   // TODO(neis): try ruling out -0 as well?
-  bool maybe_nan =
-      lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish) ||
-      ((lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) &&
-       (rhs->Min() == -V8_INFINITY || rhs->Max() == +V8_INFINITY));
+  bool maybe_nan = lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish) ||
+                   ((lhs->Min() == -std::numeric_limits<double>::infinity() ||
+                     lhs->Max() == +std::numeric_limits<double>::infinity()) &&
+                    (rhs->Min() == -std::numeric_limits<double>::infinity() ||
+                     rhs->Max() == +std::numeric_limits<double>::infinity()));
   return maybe_nan ? Type::Number() : Type::OrderedNumber();
 }
 
 
 Type* Typer::Visitor::JSModulusRanger(Type::RangeType* lhs,
                                       Type::RangeType* rhs, Typer* t) {
   double lmin = lhs->Min()->Number();
   double lmax = lhs->Max()->Number();
   double rmin = rhs->Min()->Number();
   double rmax = rhs->Max()->Number();
@@ skipping 24 matching lines @@
   return result;
 }
 
 
 Type* Typer::Visitor::JSModulusTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = ToNumber(lhs, t);
   rhs = ToNumber(rhs, t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
 
   if (lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish) ||
-      lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) {
+      lhs->Min() == -std::numeric_limits<double>::infinity() ||
+      lhs->Max() == +std::numeric_limits<double>::infinity()) {
     // Result maybe NaN.
     return Type::Number();
   }
 
   lhs = Rangify(lhs, t);
   rhs = Rangify(rhs, t);
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSModulusRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
   return Type::OrderedNumber();
@@ skipping 932 matching lines @@
         // TODO(rossberg): Do we want some ClampedArray type to express this?
         break;
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8