Revert of Remove obsolete V8_INFINITY macro.

src/types.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 <iomanip>
+
 #include "src/types.h"
 
-#include <iomanip>
-#include <limits>
-
 #include "src/ostreams.h"
 #include "src/types-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 // NOTE: If code is marked as being a "shortcut", this means that removing
 // the code won't affect the semantics of the surrounding function definition.
 
@@ skipping 55 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // Min and Max computation.
 
 template<class Config>
 double TypeImpl<Config>::Min() {
   DCHECK(this->Is(Number()));
   if (this->IsBitset()) return BitsetType::Min(this->AsBitset());
   if (this->IsUnion()) {
-    double min = +std::numeric_limits<double>::infinity();
+    double min = +V8_INFINITY;
     for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
       min = std::min(min, this->AsUnion()->Get(i)->Min());
     }
     return min;
   }
   if (this->IsRange()) return this->AsRange()->Min()->Number();
   if (this->IsConstant()) return this->AsConstant()->Value()->Number();
   UNREACHABLE();
   return 0;
 }
 
 
 template<class Config>
 double TypeImpl<Config>::Max() {
   DCHECK(this->Is(Number()));
   if (this->IsBitset()) return BitsetType::Max(this->AsBitset());
   if (this->IsUnion()) {
-    double max = -std::numeric_limits<double>::infinity();
+    double max = -V8_INFINITY;
     for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
       max = std::max(max, this->AsUnion()->Get(i)->Max());
     }
     return max;
   }
   if (this->IsRange()) return this->AsRange()->Max()->Number();
   if (this->IsConstant()) return this->AsConstant()->Value()->Number();
   UNREACHABLE();
   return 0;
 }
@@ skipping 167 matching lines @@
   if (std::isnan(value)) return kNaN;
   if (IsUint32Double(value) || IsInt32Double(value)) return Lub(value, value);
   return kPlainNumber;
 }
 
 
 // Minimum values of regular numeric bitsets when SmiValuesAre31Bits.
 template <class Config>
 const typename TypeImpl<Config>::BitsetType::BitsetMin
     TypeImpl<Config>::BitsetType::BitsetMins31[] = {
-        {kOtherNumber, -std::numeric_limits<double>::infinity()},
+        {kOtherNumber, -V8_INFINITY},
         {kOtherSigned32, kMinInt},
         {kNegativeSignedSmall, -0x40000000},
         {kUnsignedSmall, 0},
         {kOtherUnsigned31, 0x40000000},
         {kOtherUnsigned32, 0x80000000},
         {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}};
 
 
 // Minimum values of regular numeric bitsets when SmiValuesAre32Bits.
 // OtherSigned32 and OtherUnsigned31 are empty (see the diagrams in types.h).
 template <class Config>
 const typename TypeImpl<Config>::BitsetType::BitsetMin
     TypeImpl<Config>::BitsetType::BitsetMins32[] = {
-        {kOtherNumber, -std::numeric_limits<double>::infinity()},
+        {kOtherNumber, -V8_INFINITY},
         {kNegativeSignedSmall, kMinInt},
         {kUnsignedSmall, 0},
         {kOtherUnsigned32, 0x80000000},
         {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}};
 
 
 template<class Config>
 typename TypeImpl<Config>::bitset
 TypeImpl<Config>::BitsetType::Lub(double min, double max) {
   DisallowHeapAllocation no_allocation;
@@ skipping 31 matching lines @@
 }
 
 
 template<class Config>
 double TypeImpl<Config>::BitsetType::Max(bitset bits) {
   DisallowHeapAllocation no_allocation;
   DCHECK(Is(bits, kNumber));
   const BitsetMin* mins = BitsetMins();
   bool mz = SEMANTIC(bits & kMinusZero);
   if (BitsetType::Is(mins[BitsetMinsSize()-1].bits, bits)) {
-    return +std::numeric_limits<double>::infinity();
+    return +V8_INFINITY;
   }
   for (size_t i = BitsetMinsSize()-1; i-- > 0; ) {
     if (Is(SEMANTIC(mins[i].bits), bits)) {
       return mz ?
           std::max(0.0, mins[i+1].min - 1) : mins[i+1].min - 1;
     }
   }
   if (mz) return 0;
   return base::OS::nan_value();
 }
@@ skipping 730 matching lines @@
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal