[turbofan] Use unboxed doubles in range types.

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 "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.
 
 
 // -----------------------------------------------------------------------------
 // Range-related helper functions.
 
 // The result may be invalid (max < min).
 template<class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::Intersect(
     Limits lhs, Limits rhs) {
   DisallowHeapAllocation no_allocation;
   Limits result(lhs);
-  if (lhs.min->Number() < rhs.min->Number()) result.min = rhs.min;
-  if (lhs.max->Number() > rhs.max->Number()) result.max = rhs.max;
+  if (lhs.min < rhs.min) result.min = rhs.min;
+  if (lhs.max > rhs.max) result.max = rhs.max;
   result.representation = lhs.representation & rhs.representation;
   return result;
 }
 
 
 template <class Config>
 bool TypeImpl<Config>::IsEmpty(Limits lim) {
-  return lim.min->Number() > lim.max->Number();
+  return lim.min > lim.max;
 }
 
 
 template <class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::Union(Limits lhs,
                                                           Limits rhs) {
   DisallowHeapAllocation no_allocation;
   Limits result(lhs);
-  if (lhs.min->Number() > rhs.min->Number()) result.min = rhs.min;
-  if (lhs.max->Number() < rhs.max->Number()) result.max = rhs.max;
+  if (lhs.min > rhs.min) result.min = rhs.min;
+  if (lhs.max < rhs.max) result.max = rhs.max;
   result.representation = lhs.representation | rhs.representation;
   return result;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Overlap(
     typename TypeImpl<Config>::RangeType* lhs,
     typename TypeImpl<Config>::RangeType* rhs) {
   DisallowHeapAllocation no_allocation;
   typename TypeImpl<Config>::Limits lim = Intersect(Limits(lhs), Limits(rhs));
-  return lim.min->Number() <= lim.max->Number();
+  return lim.min <= lim.max;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Contains(
     typename TypeImpl<Config>::RangeType* lhs,
     typename TypeImpl<Config>::RangeType* rhs) {
   DisallowHeapAllocation no_allocation;
-  return rhs->Bound()->Is(lhs->Bound()) &&
-         lhs->Min()->Number() <= rhs->Min()->Number() &&
-         rhs->Max()->Number() <= lhs->Max()->Number();
+  return BitsetType::Is(rhs->Bound(), lhs->Bound()) &&
+         lhs->Min() <= rhs->Min() && rhs->Max() <= lhs->Max();
 }
 
 
 template <class Config>
 bool TypeImpl<Config>::Contains(typename TypeImpl<Config>::RangeType* lhs,
                                 typename TypeImpl<Config>::ConstantType* rhs) {
   DisallowHeapAllocation no_allocation;
-  return IsInteger(*rhs->Value()) && rhs->Bound()->Is(lhs->Bound()) &&
-         lhs->Min()->Number() <= rhs->Value()->Number() &&
-         rhs->Value()->Number() <= lhs->Max()->Number();
+  return IsInteger(*rhs->Value()) &&
+         BitsetType::Is(rhs->Bound()->AsBitset(), lhs->Bound()) &&
+         lhs->Min() <= rhs->Value()->Number() &&
+         rhs->Value()->Number() <= lhs->Max();
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Contains(
     typename TypeImpl<Config>::RangeType* range, i::Object* val) {
   DisallowHeapAllocation no_allocation;
   return IsInteger(val) &&
-         BitsetType::Is(BitsetType::Lub(val), range->Bound()->AsBitset()) &&
-         range->Min()->Number() <= val->Number() &&
-         val->Number() <= range->Max()->Number();
+         BitsetType::Is(BitsetType::Lub(val), range->Bound()) &&
+         range->Min() <= val->Number() && val->Number() <= range->Max();
 }
 
 
 // -----------------------------------------------------------------------------
 // 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 = +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->IsRange()) return this->AsRange()->Min();
   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 = -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->IsRange()) return this->AsRange()->Max();
   if (this->IsConstant()) return this->AsConstant()->Value()->Number();
   UNREACHABLE();
   return 0;
 }
 
 
 // -----------------------------------------------------------------------------
 // Glb and lub computation.
 
 
 // The largest bitset subsumed by this type.
 template<class Config>
 typename TypeImpl<Config>::bitset
 TypeImpl<Config>::BitsetType::Glb(TypeImpl* type) {
   DisallowHeapAllocation no_allocation;
   if (type->IsBitset()) {
     return type->AsBitset();
   } else if (type->IsUnion()) {
     SLOW_DCHECK(type->AsUnion()->Wellformed());
     return type->AsUnion()->Get(0)->BitsetGlb() |
            type->AsUnion()->Get(1)->BitsetGlb();  // Shortcut.
   } else if (type->IsRange()) {
-    bitset glb = SEMANTIC(BitsetType::Glb(type->AsRange()->Min()->Number(),
-                                          type->AsRange()->Max()->Number()));
+    bitset glb = SEMANTIC(
+        BitsetType::Glb(type->AsRange()->Min(), type->AsRange()->Max()));
     if (glb == 0) {
       return kNone;
     } else {
       return glb | REPRESENTATION(type->BitsetLub());
     }
   } else {
     // (The remaining BitsetGlb's are None anyway).
     return kNone;
   }
 }
@@ skipping 11 matching lines @@
       bitset |= type->AsUnion()->Get(i)->BitsetLub();
     }
     return bitset;
   }
   if (type->IsClass()) {
     // Little hack to avoid the need for a region for handlification here...
     return Config::is_class(type) ? Lub(*Config::as_class(type)) :
         type->AsClass()->Bound(NULL)->AsBitset();
   }
   if (type->IsConstant()) return type->AsConstant()->Bound()->AsBitset();
-  if (type->IsRange()) return type->AsRange()->Bound()->AsBitset();
+  if (type->IsRange()) return type->AsRange()->Bound();
   if (type->IsContext()) return kInternal & kTaggedPointer;
   if (type->IsArray()) return kArray;
   if (type->IsFunction()) return kOtherObject;  // TODO(rossberg): kFunction
   UNREACHABLE();
   return kNone;
 }
 
 
 template<class Config>
 typename TypeImpl<Config>::bitset
@@ skipping 563 matching lines @@
 template <class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::ToLimits(bitset bits,
                                                              Region* region) {
   bitset representation = REPRESENTATION(bits);
   bitset number_bits = BitsetType::NumberBits(bits);
 
   if (representation == BitsetType::kNone && number_bits == BitsetType::kNone) {
     return Limits::Empty(region);
   }
 
-  double bitset_min = BitsetType::Min(number_bits);
-  double bitset_max = BitsetType::Max(number_bits);
-
-  // TODO(jarin) Get rid of the heap numbers.
-  i::Factory* f = i::Isolate::Current()->factory();
-
-  return Limits(f->NewNumber(bitset_min), f->NewNumber(bitset_max),
+  return Limits(BitsetType::Min(number_bits), BitsetType::Max(number_bits),
                 representation);
 }
 
 
 template <class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::IntersectRangeAndBitset(
     TypeHandle range, TypeHandle bitset, Region* region) {
   Limits range_lims(range->AsRange());
   Limits bitset_lims = ToLimits(bitset->AsBitset(), region);
   return Intersect(range_lims, bitset_lims);
@@ skipping 82 matching lines @@
   bitset range_lub = range->BitsetLub();
   if (BitsetType::Is(BitsetType::NumberBits(range_lub), *bits)) {
     *bits |= range_lub;
     return None(region);
   }
 
   // Slow path: reconcile the bitset range and the range.
   double bitset_min = BitsetType::Min(number_bits);
   double bitset_max = BitsetType::Max(number_bits);
 
-  i::Handle<i::Object> range_min_obj = range->Min();
-  i::Handle<i::Object> range_max_obj = range->Max();
-  double range_min = range_min_obj->Number();
-  double range_max = range_max_obj->Number();
+  double range_min = range->Min();
+  double range_max = range->Max();
 
   bitset range_representation = REPRESENTATION(range->BitsetLub());
   bitset bits_representation = REPRESENTATION(*bits);
   bitset representation =
       (bits_representation | range_representation) & BitsetType::kNumber;
 
   // Remove the number bits from the bitset, they would just confuse us now.
   *bits &= ~number_bits;
   if (bits_representation == *bits) {
     *bits = BitsetType::kNone;
   }
 
   if (representation == range_representation && range_min <= bitset_min &&
       range_max >= bitset_max) {
     // Bitset is contained within the range, just return the range.
     return range;
   }
 
   if (bitset_min < range_min) {
-    // TODO(jarin) Get rid of the heap numbers.
-    range_min_obj = i::Isolate::Current()->factory()->NewNumber(bitset_min);
+    range_min = bitset_min;
   }
   if (bitset_max > range_max) {
-    // TODO(jarin) Get rid of the heap numbers.
-    range_max_obj = i::Isolate::Current()->factory()->NewNumber(bitset_max);
+    range_max = bitset_max;
   }
-  return RangeType::New(range_min_obj, range_max_obj,
+  return RangeType::New(range_min, range_max,
                         BitsetType::New(representation, region), region);
 }
 
 
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Union(
     TypeHandle type1, TypeHandle type2, Region* region) {
 
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
@@ skipping 302 matching lines @@
       BitsetType::Print(os, SEMANTIC(this->AsBitset()));
     } else if (this->IsClass()) {
       os << "Class(" << static_cast<void*>(*this->AsClass()->Map()) << " < ";
       BitsetType::New(BitsetType::Lub(this))->PrintTo(os, dim);
       os << ")";
     } else if (this->IsConstant()) {
       os << "Constant(" << Brief(*this->AsConstant()->Value()) << ")";
     } else if (this->IsRange()) {
       std::ostream::fmtflags saved_flags = os.setf(std::ios::fixed);
       std::streamsize saved_precision = os.precision(0);
-      os << "Range(" << this->AsRange()->Min()->Number() << ", "
-         << this->AsRange()->Max()->Number() << ")";
+      os << "Range(" << this->AsRange()->Min() << ", " << this->AsRange()->Max()
+         << ")";
       os.flags(saved_flags);
       os.precision(saved_precision);
     } else if (this->IsContext()) {
       os << "Context(";
       this->AsContext()->Outer()->PrintTo(os, dim);
       os << ")";
     } else if (this->IsUnion()) {
       os << "(";
       for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
         TypeHandle type_i = this->AsUnion()->Get(i);
@@ skipping 56 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