[turbofan] Use unboxed doubles in range types.

test/cctest/compiler/test-typer.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 <functional>
 
 #include "src/codegen.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/typer.h"
@@ skipping 69 matching lines @@
   }
 
   Type* RandomRange(bool int32 = false) {
     std::vector<double>& numbers = int32 ? int32s : integers;
     double i = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
     double j = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
     return NewRange(i, j);
   }
 
   Type* NewRange(double i, double j) {
-    Factory* f = isolate()->factory();
-    i::Handle<i::Object> min = f->NewNumber(i);
-    i::Handle<i::Object> max = f->NewNumber(j);
-    if (min->Number() > max->Number()) std::swap(min, max);
-    return Type::Range(min, max, main_zone());
+    if (i > j) std::swap(i, j);
+    return Type::Range(i, j, main_zone());
   }
 
   double RandomInt(double min, double max) {
     switch (rng_->NextInt(4)) {
       case 0: return min;
       case 1: return max;
       default: break;
     }
     if (min == +V8_INFINITY) return +V8_INFINITY;
     if (max == -V8_INFINITY) return -V8_INFINITY;
     if (min == -V8_INFINITY && max == +V8_INFINITY) {
       return rng_->NextInt() * static_cast<double>(rng_->NextInt());
     }
     double result = nearbyint(min + (max - min) * rng_->NextDouble());
     if (IsMinusZero(result)) return 0;
     if (std::isnan(result)) return rng_->NextInt(2) ? min : max;
     DCHECK(min <= result && result <= max);
     return result;
   }
 
   double RandomInt(Type::RangeType* range) {
-    return RandomInt(range->Min()->Number(), range->Max()->Number());
+    return RandomInt(range->Min(), range->Max());
   }
 
   // Careful, this function runs O(max_width^5) trials.
   template <class BinaryFunction>
   void TestBinaryArithOpCloseToZero(const Operator* op, BinaryFunction opfun,
                                     int max_width) {
     const int min_min = -2 - max_width / 2;
     const int max_min = 2 + max_width / 2;
     for (int width = 0; width < max_width; width++) {
       for (int lmin = min_min; lmin <= max_min; lmin++) {
@@ skipping 244 matching lines @@
   V(Modulus)
 
 
 #define TEST_FUNC(name)                             \
   TEST(Monotonicity_##name) {                       \
     TyperTester t;                                  \
     t.TestBinaryMonotonicity(t.javascript_.name()); \
   }
 JSBINOP_LIST(TEST_FUNC)
 #undef TEST_FUNC