[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 13 matching lines @@
 
 namespace {
 
 // Testing auxiliaries (breaking the Type abstraction).
 
 
 static bool IsInteger(double x) {
   return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
 }
 
-
-static bool IsInteger(i::Object* x) {
-  return x->IsNumber() && IsInteger(x->Number());
-}
-
-
 typedef uint32_t bitset;
 
 struct Tests {
   typedef Types::TypeVector::iterator TypeIterator;
   typedef Types::ValueVector::iterator ValueIterator;
 
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
   Types T;
@@ skipping 56 matching lines @@
     CHECK(!type1->Is(type2));
     CHECK(!type2->Is(type1));
     CHECK(!type1->Maybe(type2));
     CHECK(!type2->Maybe(type1));
   }
 
   void IsSomeType() {
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       Type* t = *it;
       CHECK(1 ==
-            this->IsBitset(t) + t->IsConstant() + t->IsRange() +
-                this->IsUnion(t));
+            this->IsBitset(t) + t->IsHeapConstant() + t->IsRange() +
+                t->IsOtherNumberConstant() + this->IsUnion(t));
     }
   }
 
   void Bitset() {
     // None and Any are bitsets.
     CHECK(this->IsBitset(T.None));
     CHECK(this->IsBitset(T.Any));
 
     CHECK(bitset(0) == this->AsBitset(T.None));
     CHECK(bitset(0xfffffffeu) == this->AsBitset(T.Any));
@@ skipping 56 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->IsHeapConstant() || type->IsOtherNumberConstant() ||
+            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->IsHeapConstant()) {
+        CHECK(*value == *type->AsHeapConstant()->Value());
+      } else if (type->IsOtherNumberConstant()) {
+        CHECK(value->IsHeapNumber());
+        CHECK(value->Number() == type->AsOtherNumberConstant()->Value());
+      } else {
+        CHECK(type->IsRange());
+        double v = value->Number();
+        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);
-        CHECK(Equal(type1, type2) == (*value1 == *value2));
+        Type* type1 = T.NewConstant(value1);
+        Type* type2 = T.NewConstant(value2);
+        if (type1->IsOtherNumberConstant() && type2->IsOtherNumberConstant()) {
+          CHECK(Equal(type1, type2) ==
+                (type1->AsOtherNumberConstant()->Value() ==
+                 type2->AsOtherNumberConstant()->Value()));
+        } else if (type1->IsRange() && type2->IsRange()) {
+          CHECK(Equal(type1, type2) ==
+                ((type1->AsRange()->Min() == type2->AsRange()->Min()) &&
+                 (type1->AsRange()->Max() == type2->AsRange()->Max())));
+        } else {
+          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 162 matching lines @@
       }
     }
 
     // (In-)Compatibilities.
     for (TypeIterator i = T.types.begin(); i != T.types.end(); ++i) {
       for (TypeIterator j = T.types.begin(); j != T.types.end(); ++j) {
         Type* type1 = *i;
         Type* type2 = *j;
         CHECK(!type1->Is(type2) || this->IsBitset(type2) ||
               this->IsUnion(type2) || this->IsUnion(type1) ||
-              (type1->IsConstant() && type2->IsConstant()) ||
-              (type1->IsConstant() && type2->IsRange()) ||
+              (type1->IsHeapConstant() && type2->IsHeapConstant()) ||
               (this->IsBitset(type1) && type2->IsRange()) ||
               (type1->IsRange() && type2->IsRange()) ||
+              (type1->IsOtherNumberConstant() &&
+               type2->IsOtherNumberConstant()) ||
               !type1->IsInhabited());
       }
     }
   }
 
   void Is2() {
     // Range(X1, Y1)->Is(Range(X2, Y2)) iff X1 >= X2 /\ Y1 <= Y2
     for (ValueIterator i1 = T.integers.begin();
         i1 != T.integers.end(); ++i1) {
       for (ValueIterator j1 = i1;
@@ skipping 14 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);
-        CHECK(const_type1->Is(const_type2) == (*value1 == *value2));
+        Type* const_type1 = T.NewConstant(value1);
+        Type* const_type2 = T.NewConstant(value2);
+        if (const_type1->IsOtherNumberConstant() &&
+            const_type2->IsOtherNumberConstant()) {
+          CHECK(const_type1->Is(const_type2) ==
+                (const_type1->AsOtherNumberConstant()->Value() ==
+                 const_type2->AsOtherNumberConstant()->Value()));
+        } else if (const_type1->IsRange() && const_type2->IsRange()) {
+          CHECK(Equal(const_type1, const_type2) ==
+                ((const_type1->AsRange()->Min() ==
+                  const_type2->AsRange()->Min()) &&
+                 (const_type1->AsRange()->Max() ==
+                  const_type2->AsRange()->Max())));
+        } else {
+          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())) {
-        CHECK(type->Is(T.Range(type->AsConstant()->Value()->Number(),
-                               type->AsConstant()->Value()->Number())));
-      }
-    }
-
-    // If Constant(x)->Is(Range(min,max)) then IsInteger(v) and min <= x <= max.
-    for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
-      for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
-        Type* type1 = *it1;
-        Type* type2 = *it2;
-        if (type1->IsConstant() && type2->IsRange() && type1->Is(type2)) {
-          double x = type1->AsConstant()->Value()->Number();
-          double min = type2->AsRange()->Min();
-          double max = type2->AsRange()->Max();
-          CHECK(IsInteger(x) && min <= x && x <= max);
-        }
-      }
-    }
-
     // Lub(Range(x,y))->Is(T.Union(T.Integral32, T.OtherNumber))
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       Type* type = *it;
       if (type->IsRange()) {
         Type* lub = BitsetType::NewForTesting(BitsetType::Lub(type));
         CHECK(lub->Is(T.PlainNumber));
       }
     }
 
 
@@ skipping 102 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);
-        CHECK(const_type1->Maybe(const_type2) == (*value1 == *value2));
+        Type* const_type1 = T.NewConstant(value1);
+        Type* const_type2 = T.NewConstant(value2);
+        if (const_type1->IsOtherNumberConstant() &&
+            const_type2->IsOtherNumberConstant()) {
+          CHECK(const_type1->Maybe(const_type2) ==
+                (const_type1->AsOtherNumberConstant()->Value() ==
+                 const_type2->AsOtherNumberConstant()->Value()));
+        } else if (const_type1->IsRange() && const_type2->IsRange()) {
+          CHECK(Equal(const_type1, const_type2) ==
+                ((const_type1->AsRange()->Min() ==
+                  const_type2->AsRange()->Min()) &&
+                 (const_type1->AsRange()->Max() ==
+                  const_type2->AsRange()->Max())));
+        } else {
+          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);
     CheckDisjoint(T.Signed32, T.NaN);
@@ skipping 319 matching lines @@
   void GetRange() {
     // GetRange(Range(a, b)) = Range(a, b).
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       Type* type1 = *it1;
       if (type1->IsRange()) {
         RangeType* range = type1->GetRange()->AsRange();
         CHECK(type1->Min() == range->Min());
         CHECK(type1->Max() == range->Max());
       }
     }
-
-    // GetRange(Union(Constant(x), Range(min,max))) == Range(min, max).
-    for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
-      for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
-        Type* type1 = *it1;
-        Type* type2 = *it2;
-        if (type1->IsConstant() && type2->IsRange()) {
-          Type* u = T.Union(type1, type2);
-
-          CHECK(type2->Min() == u->GetRange()->Min());
-          CHECK(type2->Max() == u->GetRange()->Max());
-        }
-      }
-    }
   }
 };
 
 }  // namespace
 
 TEST(IsSomeType) { Tests().IsSomeType(); }
 
 TEST(BitsetType) { Tests().Bitset(); }
 
 TEST(ConstantType) { Tests().Constant(); }
@@ skipping 20 matching lines @@
 
 TEST(Union3) { Tests().Union3(); }
 
 TEST(Union4) { Tests().Union4(); }
 
 TEST(Intersect) { Tests().Intersect(); }
 
 TEST(Distributivity) { Tests().Distributivity(); }
 
 TEST(GetRange) { Tests().GetRange(); }