[Turbofan] Introduce OtherNumberConstant.

test/cctest/types-fuzz.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 36 matching lines @@
     PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
     #undef DECLARE_TYPE
 
     SignedSmall = Type::SignedSmall();
     UnsignedSmall = Type::UnsignedSmall();
 
     object_map = isolate->factory()->NewMap(
         JS_OBJECT_TYPE, JSObject::kHeaderSize);
 
     smi = handle(Smi::FromInt(666), isolate);
+    boxed_smi = isolate->factory()->NewHeapNumber(666);
     signed32 = isolate->factory()->NewHeapNumber(0x40000000);
+    float1 = isolate->factory()->NewHeapNumber(1.53);
+    float2 = isolate->factory()->NewHeapNumber(0.53);
+    // float3 is identical to float1 in order to test that OtherNumberConstant
+    // types are equal by double value and not by handle pointer value.
+    float3 = isolate->factory()->NewHeapNumber(1.53);
     object1 = isolate->factory()->NewJSObjectFromMap(object_map);
     object2 = isolate->factory()->NewJSObjectFromMap(object_map);
     array = isolate->factory()->NewJSArray(20);
     uninitialized = isolate->factory()->uninitialized_value();
-    SmiConstant = Type::Constant(smi, zone);
-    Signed32Constant = Type::Constant(signed32, zone);
+    SmiConstant = Type::NewConstant(smi, zone);
+    Signed32Constant = Type::NewConstant(signed32, zone);
 
-    ObjectConstant1 = Type::Constant(object1, zone);
-    ObjectConstant2 = Type::Constant(object2, zone);
-    ArrayConstant = Type::Constant(array, zone);
-    UninitializedConstant = Type::Constant(uninitialized, zone);
+    ObjectConstant1 = Type::HeapConstant(object1, zone);
+    ObjectConstant2 = Type::HeapConstant(object2, zone);
+    ArrayConstant = Type::HeapConstant(array, zone);
+    UninitializedConstant = Type::HeapConstant(uninitialized, zone);
 
     values.push_back(smi);
+    values.push_back(boxed_smi);
     values.push_back(signed32);
     values.push_back(object1);
     values.push_back(object2);
     values.push_back(array);
     values.push_back(uninitialized);
+    values.push_back(float1);
+    values.push_back(float2);
+    values.push_back(float3);
     for (ValueVector::iterator it = values.begin(); it != values.end(); ++it) {
-      types.push_back(Type::Constant(*it, zone));
+      types.push_back(Type::NewConstant(*it, zone));
     }
 
     integers.push_back(isolate->factory()->NewNumber(-V8_INFINITY));
     integers.push_back(isolate->factory()->NewNumber(+V8_INFINITY));
     integers.push_back(isolate->factory()->NewNumber(-rng_->NextInt(10)));
     integers.push_back(isolate->factory()->NewNumber(+rng_->NextInt(10)));
     for (int i = 0; i < 10; ++i) {
       double x = rng_->NextInt();
       integers.push_back(isolate->factory()->NewNumber(x));
       x *= rng_->NextInt();
       if (!IsMinusZero(x)) integers.push_back(isolate->factory()->NewNumber(x));
     }
 
     Integer = Type::Range(-V8_INFINITY, +V8_INFINITY, zone);
 
     for (int i = 0; i < 30; ++i) {
       types.push_back(Fuzz());
     }
   }
 
   Handle<i::Map> object_map;
 
   Handle<i::Smi> smi;
+  Handle<i::HeapNumber> boxed_smi;
   Handle<i::HeapNumber> signed32;
+  Handle<i::HeapNumber> float1;
+  Handle<i::HeapNumber> float2;
+  Handle<i::HeapNumber> float3;
   Handle<i::JSObject> object1;
   Handle<i::JSObject> object2;
   Handle<i::JSArray> array;
   Handle<i::Oddball> uninitialized;
 
 #define DECLARE_TYPE(name, value) Type* name;
   PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
   #undef DECLARE_TYPE
 
   Type* SignedSmall;
@@ skipping 10 matching lines @@
 
   typedef std::vector<Type*> TypeVector;
   typedef std::vector<Handle<i::Object> > ValueVector;
 
   TypeVector types;
   ValueVector values;
   ValueVector integers;  // "Integer" values used for range limits.
 
   Type* Of(Handle<i::Object> value) { return Type::Of(value, zone_); }
 
-  Type* Constant(Handle<i::Object> value) {
-    return Type::Constant(value, zone_);
+  Type* NewConstant(Handle<i::Object> value) {
+    return Type::NewConstant(value, zone_);
+  }
+
+  Type* HeapConstant(Handle<i::Object> value) {
+    return Type::HeapConstant(value, zone_);
   }
 
   Type* Range(double min, double max) { return Type::Range(min, max, zone_); }
 
   Type* Union(Type* t1, Type* t2) { return Type::Union(t1, t2, zone_); }
 
   Type* Intersect(Type* t1, Type* t2) { return Type::Intersect(t1, t2, zone_); }
 
   Type* Random() {
     return types[rng_->NextInt(static_cast<int>(types.size()))];
@@ skipping 19 matching lines @@
       continue;                                               \
     }                                                         \
   }
           PROPER_BITSET_TYPE_LIST(PICK_BITSET_TYPE)
           #undef PICK_BITSET_TYPE
         }
         return result;
       }
       case 1: {  // constant
         int i = rng_->NextInt(static_cast<int>(values.size()));
-        return Type::Constant(values[i], zone_);
+        return Type::NewConstant(values[i], zone_);
       }
       case 2: {  // range
         int i = rng_->NextInt(static_cast<int>(integers.size()));
         int j = rng_->NextInt(static_cast<int>(integers.size()));
         double min = integers[i]->Number();
         double max = integers[j]->Number();
         if (min > max) std::swap(min, max);
         return Type::Range(min, max, zone_);
       }
       default: {  // union
@@ skipping 14 matching lines @@
  private:
   Zone* zone_;
   v8::base::RandomNumberGenerator* rng_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif