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 <vector>
 
 #include "src/hydrogen-types.h"
 #include "src/isolate-inl.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
@@ skipping 171 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: le(min(x,y), max(x,y)) holds iff neither x nor y is NaN.
+  static bool le(double x, double y) {

[rossberg, 2014/08/06 13:27:31]

Hint: If you just don't make them static, then you can write T.le() etc below.

+    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;
+  }
+
+
+
   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 = TypesInstance::min(*i, *j);
+        double max = TypesInstance::max(*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 = TypesInstance::min(*i, *j);
+        double max = TypesInstance::max(*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 = TypesInstance::min(*i1, *j1);
+//          double max1 = TypesInstance::max(*i1, *j1);
+//          double min2 = TypesInstance::min(*i2, *j2);
+//          double max2 = TypesInstance::max(*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) == (eq(min1, min2) && eq(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();
 }