Extend some operations to range types.

test/cctest/test-types.cc

 // Copyright 2013 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 <math.h>
 #include <vector>
 
 #include "src/hydrogen-types.h"
 #include "src/isolate-inl.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 
 // Testing auxiliaries (breaking the Type abstraction).
@@ skipping 117 matching lines @@
 
     NumberArray = Type::Array(Number, region);
     StringArray = Type::Array(String, region);
     AnyArray = Type::Array(Any, region);
 
     SignedFunction1 = Type::Function(SignedSmall, SignedSmall, region);
     NumberFunction1 = Type::Function(Number, Number, region);
     NumberFunction2 = Type::Function(Number, Number, Number, region);
     MethodFunction = Type::Function(String, Object, 0, region);
 
-    for (int i = 0; i < 40; ++i) {
+    for (int i = 0; i < 30; ++i) {
       types.push_back(Fuzz());
     }
   }
 
   Handle<i::Map> object_map;
   Handle<i::Map> array_map;
   Handle<i::Map> uninitialized_map;
 
   Handle<i::Smi> smi;
   Handle<i::HeapNumber> signed32;
@@ skipping 29 matching lines @@
   typedef std::vector<TypeHandle> TypeVector;
   typedef std::vector<Handle<i::Map> > MapVector;
   typedef std::vector<Handle<i::Object> > ValueVector;
   typedef std::vector<double> DoubleVector;
 
   TypeVector types;
   MapVector maps;
   ValueVector values;
   DoubleVector doubles;  // Some floating-point values, excluding NaN.
 
+  // Range type helper functions, partially copied from types.cc.
+  // Note: dle(dmin(x,y), dmax(x,y)) holds iff neither x nor y is NaN.
+  bool dle(double x, double y) {
+    return x <= y && copysign(1, x) <= copysign(1, y);
+  }
+  bool deq(double x, double y) {
+    return dle(x, y) && dle(y, x);
+  }
+  double dmin(double x, double y) {
+    return dle(x, y) ? x : y;
+  }
+  double dmax(double x, double y) {
+    return dle(x, y) ? y : x;
+  }
+
   TypeHandle Of(Handle<i::Object> value) {
     return Type::Of(value, region_);
   }
 
   TypeHandle NowOf(Handle<i::Object> value) {
     return Type::NowOf(value, region_);
   }
 
   TypeHandle Constant(Handle<i::Object> value) {
     return Type::Constant(value, region_);
@@ skipping 340 matching lines @@
     CHECK(T.Constant(fac->NewNumber(-1.0*0.0))->Is(T.MinusZero));
     CHECK(T.Constant(fac->NewNumber(v8::base::OS::nan_value()))->Is(T.NaN));
     CHECK(T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.OtherNumber));
     CHECK(T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.OtherNumber));
   }
 
   void Range() {
     // Constructor
     for (DoubleIterator i = T.doubles.begin(); i != T.doubles.end(); ++i) {
       for (DoubleIterator j = T.doubles.begin(); j != T.doubles.end(); ++j) {
-        double min = std::min(*i, *j);
-        double max = std::max(*i, *j);
+        double min = T.dmin(*i, *j);
+        double max = T.dmax(*i, *j);
         TypeHandle type = T.Range(min, max);
         CHECK(type->IsRange());
       }
     }
 
     // Range attributes
     for (DoubleIterator i = T.doubles.begin(); i != T.doubles.end(); ++i) {
       for (DoubleIterator j = T.doubles.begin(); j != T.doubles.end(); ++j) {
-        double min = std::min(*i, *j);
-        double max = std::max(*i, *j);
+        double min = T.dmin(*i, *j);
+        double max = T.dmax(*i, *j);
         printf("RangeType: min, max = %f, %f\n", min, max);
         TypeHandle type = T.Range(min, max);
         printf("RangeType: Min, Max = %f, %f\n",
                type->AsRange()->Min(), type->AsRange()->Max());
         CHECK(min == type->AsRange()->Min());
         CHECK(max == type->AsRange()->Max());
       }
     }
 
 // TODO(neis): enable once subtyping is updated.
 //  // Functionality & Injectivity: Range(min1, max1) = Range(min2, max2) <=>
 //  //                              min1 = min2 /\ max1 = max2
 //  for (DoubleIterator i1 = T.doubles.begin(); i1 != T.doubles.end(); ++i1) {
 //    for (DoubleIterator j1 = T.doubles.begin(); j1 != T.doubles.end(); ++j1) {
 //      for (DoubleIterator i2 = T.doubles.begin();
 //           i2 != T.doubles.end(); ++i2) {
 //        for (DoubleIterator j2 = T.doubles.begin();
 //             j2 != T.doubles.end(); ++j2) {
-//          double min1 = std::min(*i1, *j1);
-//          double max1 = std::max(*i1, *j1);
-//          double min2 = std::min(*i2, *j2);
-//          double max2 = std::max(*i2, *j2);
+//          double min1 = T.dmin(*i1, *j1);
+//          double max1 = T.dmax(*i1, *j1);
+//          double min2 = T.dmin(*i2, *j2);
+//          double max2 = T.dmax(*i2, *j2);
 //          TypeHandle type1 = T.Range(min1, max1);
 //          TypeHandle type2 = T.Range(min2, max2);
-//          CHECK(Equal(type1, type2) == (min1 == min2 && max1 == max2));
+//          CHECK(Equal(type1, type2) ==
+//                (T.deq(min1, min2) && T.deq(max1, max2)));
 //        }
 //      }
 //    }
 //  }
   }
 
   void Array() {
     // Constructor
     for (int i = 0; i < 20; ++i) {
       TypeHandle type = T.Random();
@@ skipping 1345 matching lines @@
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }
 
 
 TEST(HTypeFromType) {
   CcTest::InitializeVM();
   ZoneTests().HTypeFromType();
   HeapTests().HTypeFromType();
 }