Extend some operations to range types.

src/types.h

 // 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.
 
 #ifndef V8_TYPES_H_
 #define V8_TYPES_H_
 
 #include "src/factory.h"
 #include "src/handles.h"
 #include "src/ostreams.h"
@@ skipping 267 matching lines @@
     static TypeHandle type(Region* region) {                                  \
       return BitsetType::New(BitsetType::k##type, region);                    \
     }
   BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
   #undef DEFINE_TYPE_CONSTRUCTOR
 
   static TypeHandle Class(i::Handle<i::Map> map, Region* region) {
     return ClassType::New(map, region);
   }
   static TypeHandle Constant(i::Handle<i::Object> value, Region* region) {
-    // TODO(neis): return RangeType for numerical values
+    // TODO(neis): Return RangeType for numerical values.
     return ConstantType::New(value, region);
   }
   static TypeHandle Range(double min, double max, Region* region) {
     return RangeType::New(min, max, region);
   }
   static TypeHandle Context(TypeHandle outer, Region* region) {
     return ContextType::New(outer, region);
   }
   static TypeHandle Array(TypeHandle element, Region* region) {
     return ArrayType::New(element, region);
@@ skipping 208 matching lines @@
     return (bitset1 | bitset2) == bitset2;
   }
 
   static int Glb(TypeImpl* type);  // greatest lower bound that's a bitset
   static int Lub(TypeImpl* type);  // least upper bound that's a bitset
   static int Lub(i::Object* value);
   static int Lub(double value);
   static int Lub(int32_t value);
   static int Lub(uint32_t value);
   static int Lub(i::Map* map);
+  static int RangeLub(double min, double max, TypeHandle bound);

[rossberg, 2014/08/05 14:49:15]

Is this defined anywhere?

[neis, 2014/08/06 13:15:01]

Oops, was a leftover.

   static int InherentLub(TypeImpl* type);
 
   static const char* Name(int bitset);
   static void Print(OStream& os, int bitset);  // NOLINT
   using TypeImpl::PrintTo;
 };
 
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
@@ skipping 150 matching lines @@
 // -----------------------------------------------------------------------------
 // Range types.
 
 template<class Config>
 class TypeImpl<Config>::RangeType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   double Min() { return this->template GetValue<i::HeapNumber>(1)->value(); }
   double Max() { return this->template GetValue<i::HeapNumber>(2)->value(); }
 
+  static bool le(double x, double y) {

[rossberg, 2014/08/05 14:49:15]

These are helpers that shouldn't pollute the public interface. Maybe just make
them static global functions in types.cc?

[neis, 2014/08/06 13:15:01]

Done.

+    return x <= y && copysign(1, x) <= copysign(1, y);
+  }
+  static bool eq(double x, double y) {
+    return le(x, y) && le(y, x);
+  }
+  static double min(double x, double y) {
+    return le(x, y) ? x : y;
+  }
+  static double max(double x, double y) {
+    return le(x, y) ? y : x;
+  }
+
+  static int InherentLub(double min, double max) {

[rossberg, 2014/08/05 14:49:15]

Rename/move this to BitsetType::Lub(double, double), since it's also just an
internal helper.

[neis, 2014/08/06 13:15:01]

Done.

+    DCHECK(le(min, max));
+    DisallowHeapAllocation no_allocation;
+    if (min == max) {

[rossberg, 2014/08/05 14:49:15]

eq(min, max)

[neis, 2014/08/06 13:15:01]

Done.

+      return BitsetType::Lub(min);  // Singleton range.
+    }
+    int bitset = BitsetType::kNumber ^ SEMANTIC(BitsetType::kNaN);
+    if (le(0, min) || max < 0)
+      bitset ^= SEMANTIC(BitsetType::kMinusZero);
+    return bitset;
+    // TODO(neis): Could refine this further by doing more checks on min/max.
+  }
+
   static RangeHandle New(
       double min, double max, TypeHandle bound, Region* region) {
-    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::kNumber));
-    DCHECK(!std::isnan(min) && !std::isnan(max) && min <= max);
+    DCHECK(le(min, max));
+    DCHECK(bound->IsBitset());
+    DCHECK(BitsetType::Is(bound->AsBitset(), InherentLub(min, max)));
     RangeHandle type = Config::template cast<RangeType>(
         StructuralType::New(StructuralType::kRangeTag, 3, region));
     type->Set(0, bound);
     Factory* factory = Config::isolate(region)->factory();
     Handle<HeapNumber> minV = factory->NewHeapNumber(min);
     Handle<HeapNumber> maxV = factory->NewHeapNumber(max);
     type->SetValue(1, minV);
     type->SetValue(2, maxV);
     return type;
   }
 
   static RangeHandle New(double min, double max, Region* region) {
-    TypeHandle bound = BitsetType::New(BitsetType::kNumber, region);
+    TypeHandle bound = BitsetType::New(InherentLub(min, max), region);
     return New(min, max, bound, region);
   }
 
   static RangeType* cast(TypeImpl* type) {
     DCHECK(type->IsRange());
     return static_cast<RangeType*>(type);
   }
 };
 
 
@@ skipping 277 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_