[Turbofan] Introduce OtherNumberConstant.

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/compiler/types.h"
 #include "src/crankshaft/hydrogen-types.h"
 #include "src/factory.h"
 #include "src/heap/heap.h"
@@ skipping 173 matching lines @@
           CHECK(bits == this->AsBitset(intersect12));
         }
       }
     }
   }
 
   void Constant() {
     // Constructor
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
-      Type* type = T.Constant(value);
-      CHECK(type->IsConstant());
+      Type* type = T.NewConstant(value);
+      CHECK(type->IsConstant() || type->IsNumberConstant() || type->IsRange());
     }
 
     // Value attribute
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
-      Type* type = T.Constant(value);
-      CHECK(*value == *type->AsConstant()->Value());
+      Type* type = T.NewConstant(value);
+      if (type->IsConstant()) {
+        CHECK(*value == *type->AsConstant()->Value());
+      } else if (type->IsNumberConstant()) {
+        double v = value->IsSmi() ? Smi::cast(*value)->value()
+                                  : HeapNumber::cast(*value)->value();
+        CHECK(v == type->AsNumberConstant()->Value());
+      } else {
+        CHECK(type->IsRange());
+        double v = value->IsSmi() ? Smi::cast(*value)->value()
+                                  : HeapNumber::cast(*value)->value();
+        CHECK(v == type->AsRange()->Min() && v == type->AsRange()->Max());
+      }
     }
 
     // Functionality & Injectivity: Constant(V1) = Constant(V2) iff V1 = V2
     for (ValueIterator vt1 = T.values.begin(); vt1 != T.values.end(); ++vt1) {
       for (ValueIterator vt2 = T.values.begin(); vt2 != T.values.end(); ++vt2) {
         Handle<i::Object> value1 = *vt1;
         Handle<i::Object> value2 = *vt2;
-        Type* type1 = T.Constant(value1);
-        Type* type2 = T.Constant(value2);
+        Type* type1 = T.NewConstant(value1);
+        Type* type2 = T.NewConstant(value2);
         CHECK(Equal(type1, type2) == (*value1 == *value2));
       }
     }
 
     // Typing of numbers
     Factory* fac = isolate->factory();
-    CHECK(T.Constant(fac->NewNumber(0))->Is(T.UnsignedSmall));
-    CHECK(T.Constant(fac->NewNumber(1))->Is(T.UnsignedSmall));
-    CHECK(T.Constant(fac->NewNumber(0x3fffffff))->Is(T.UnsignedSmall));
-    CHECK(T.Constant(fac->NewNumber(-1))->Is(T.Negative31));
-    CHECK(T.Constant(fac->NewNumber(-0x3fffffff))->Is(T.Negative31));
-    CHECK(T.Constant(fac->NewNumber(-0x40000000))->Is(T.Negative31));
-    CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.Unsigned31));
-    CHECK(!T.Constant(fac->NewNumber(0x40000000))->Is(T.Unsigned30));
-    CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned31));
-    CHECK(!T.Constant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned30));
-    CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.Negative32));
-    CHECK(!T.Constant(fac->NewNumber(-0x40000001))->Is(T.Negative31));
-    CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.Negative32));
-    CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.Negative31));
+    CHECK(T.NewConstant(fac->NewNumber(0))->Is(T.UnsignedSmall));
+    CHECK(T.NewConstant(fac->NewNumber(1))->Is(T.UnsignedSmall));
+    CHECK(T.NewConstant(fac->NewNumber(0x3fffffff))->Is(T.UnsignedSmall));
+    CHECK(T.NewConstant(fac->NewNumber(-1))->Is(T.Negative31));
+    CHECK(T.NewConstant(fac->NewNumber(-0x3fffffff))->Is(T.Negative31));
+    CHECK(T.NewConstant(fac->NewNumber(-0x40000000))->Is(T.Negative31));
+    CHECK(T.NewConstant(fac->NewNumber(0x40000000))->Is(T.Unsigned31));
+    CHECK(!T.NewConstant(fac->NewNumber(0x40000000))->Is(T.Unsigned30));
+    CHECK(T.NewConstant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned31));
+    CHECK(!T.NewConstant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned30));
+    CHECK(T.NewConstant(fac->NewNumber(-0x40000001))->Is(T.Negative32));
+    CHECK(!T.NewConstant(fac->NewNumber(-0x40000001))->Is(T.Negative31));
+    CHECK(T.NewConstant(fac->NewNumber(-0x7fffffff))->Is(T.Negative32));
+    CHECK(!T.NewConstant(fac->NewNumber(-0x7fffffff - 1))->Is(T.Negative31));
     if (SmiValuesAre31Bits()) {
-      CHECK(!T.Constant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
-      CHECK(!T.Constant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
-      CHECK(!T.Constant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
-      CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
+      CHECK(!T.NewConstant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
+      CHECK(!T.NewConstant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
+      CHECK(!T.NewConstant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
+      CHECK(!T.NewConstant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
     } else {
       CHECK(SmiValuesAre32Bits());
-      CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
-      CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
-      CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
-      CHECK(T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
+      CHECK(T.NewConstant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
+      CHECK(T.NewConstant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
+      CHECK(T.NewConstant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
+      CHECK(T.NewConstant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
     }
-    CHECK(T.Constant(fac->NewNumber(0x80000000u))->Is(T.Unsigned32));
-    CHECK(!T.Constant(fac->NewNumber(0x80000000u))->Is(T.Unsigned31));
-    CHECK(T.Constant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned32));
-    CHECK(!T.Constant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned31));
-    CHECK(T.Constant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(0.1))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(0.1))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(-10.1))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(-10.1))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(10e60))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(10e60))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(-1.0*0.0))->Is(T.MinusZero));
-    CHECK(T.Constant(fac->NewNumber(std::numeric_limits<double>::quiet_NaN()))
-              ->Is(T.NaN));
-    CHECK(T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.Integral32));
-    CHECK(T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.PlainNumber));
-    CHECK(!T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(0x80000000u))->Is(T.Unsigned32));
+    CHECK(!T.NewConstant(fac->NewNumber(0x80000000u))->Is(T.Unsigned31));
+    CHECK(T.NewConstant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned32));
+    CHECK(!T.NewConstant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned31));
+    CHECK(T.NewConstant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(0.1))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(0.1))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(-10.1))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(-10.1))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(10e60))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(10e60))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(-1.0 * 0.0))->Is(T.MinusZero));
+    CHECK(
+        T.NewConstant(fac->NewNumber(std::numeric_limits<double>::quiet_NaN()))
+            ->Is(T.NaN));
+    CHECK(T.NewConstant(fac->NewNumber(V8_INFINITY))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(V8_INFINITY))->Is(T.Integral32));
+    CHECK(T.NewConstant(fac->NewNumber(-V8_INFINITY))->Is(T.PlainNumber));
+    CHECK(!T.NewConstant(fac->NewNumber(-V8_INFINITY))->Is(T.Integral32));
   }
 
   void Range() {
     // Constructor
     for (ValueIterator i = T.integers.begin(); i != T.integers.end(); ++i) {
       for (ValueIterator j = T.integers.begin(); j != T.integers.end(); ++j) {
         double min = (*i)->Number();
         double max = (*j)->Number();
         if (min > max) std::swap(min, max);
         Type* type = T.Range(min, max);
@@ skipping 35 matching lines @@
           }
         }
       }
     }
   }
 
   void Of() {
     // Constant(V)->Is(Of(V))
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
-      Type* const_type = T.Constant(value);
+      Type* const_type = T.NewConstant(value);
       Type* of_type = T.Of(value);
       CHECK(const_type->Is(of_type));
     }
 
     // If Of(V)->Is(T), then Constant(V)->Is(T)
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
         Handle<i::Object> value = *vt;
         Type* type = *it;
-        Type* const_type = T.Constant(value);
+        Type* const_type = T.NewConstant(value);
         Type* of_type = T.Of(value);
         CHECK(!of_type->Is(type) || const_type->Is(type));
       }
     }
 
     // If Constant(V)->Is(T), then Of(V)->Is(T) or T->Maybe(Constant(V))
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
         Handle<i::Object> value = *vt;
         Type* type = *it;
-        Type* const_type = T.Constant(value);
+        Type* const_type = T.NewConstant(value);
         Type* of_type = T.Of(value);
         CHECK(!const_type->Is(type) ||
               of_type->Is(type) || type->Maybe(const_type));
       }
     }
   }
 
   void MinMax() {
     // If b is regular numeric bitset, then Range(b->Min(), b->Max())->Is(b).
     // TODO(neis): Need to ignore representation for this to be true.
@@ skipping 200 matching lines @@
           }
         }
       }
     }
 
     // Constant(V1)->Is(Constant(V2)) iff V1 = V2
     for (ValueIterator vt1 = T.values.begin(); vt1 != T.values.end(); ++vt1) {
       for (ValueIterator vt2 = T.values.begin(); vt2 != T.values.end(); ++vt2) {
         Handle<i::Object> value1 = *vt1;
         Handle<i::Object> value2 = *vt2;
-        Type* const_type1 = T.Constant(value1);
-        Type* const_type2 = T.Constant(value2);
+        Type* const_type1 = T.NewConstant(value1);
+        Type* const_type2 = T.NewConstant(value2);
         CHECK(const_type1->Is(const_type2) == (*value1 == *value2));
       }
     }
 
     // Range-specific subtyping
 
     // If IsInteger(v) then Constant(v)->Is(Range(v, v)).
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       Type* type = *it;
       if (type->IsConstant() && IsInteger(*type->AsConstant()->Value())) {
@@ skipping 131 matching lines @@
         CHECK(!(type1->Is(type2) && type1->IsInhabited()) ||
               type1->Maybe(type2));
       }
     }
 
     // Constant(V1)->Maybe(Constant(V2)) iff V1 = V2
     for (ValueIterator vt1 = T.values.begin(); vt1 != T.values.end(); ++vt1) {
       for (ValueIterator vt2 = T.values.begin(); vt2 != T.values.end(); ++vt2) {
         Handle<i::Object> value1 = *vt1;
         Handle<i::Object> value2 = *vt2;
-        Type* const_type1 = T.Constant(value1);
-        Type* const_type2 = T.Constant(value2);
+        Type* const_type1 = T.NewConstant(value1);
+        Type* const_type2 = T.NewConstant(value2);

[mvstanton, 2016/09/28 14:47:44]

This and other "rule-enforcement" tests need conditionals in case we deal with
OtherNumberConstants().

Also, add to the values array 2 different HeapNumbers with the same double
value.

And add a Smi and a boxed version of the Smi.

[mvstanton, 2016/10/04 11:55:55]

Done.

         CHECK(const_type1->Maybe(const_type2) == (*value1 == *value2));
       }
     }
 
     // Basic types
     CheckDisjoint(T.Boolean, T.Null);
     CheckDisjoint(T.Undefined, T.Null);
     CheckDisjoint(T.Boolean, T.Undefined);
     CheckOverlap(T.SignedSmall, T.Number);
     CheckOverlap(T.NaN, T.Number);
@@ skipping 374 matching lines @@
 
 TEST(Union3) { Tests().Union3(); }
 
 TEST(Union4) { Tests().Union4(); }
 
 TEST(Intersect) { Tests().Intersect(); }
 
 TEST(Distributivity) { Tests().Distributivity(); }
 
 TEST(GetRange) { Tests().GetRange(); }