[Turbofan] Introduce OtherNumberConstant.

src/compiler/types.h

 // 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.
 
 #ifndef V8_COMPILER_TYPES_H_
 #define V8_COMPILER_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/handles.h"
+#include "src/objects-inl.h"
 #include "src/objects.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // SUMMARY
 //
 // A simple type system for compiler-internal use. It is based entirely on
@@ skipping 236 matching lines @@
   static inline const Boundary* Boundaries();
   static inline size_t BoundariesSize();
 };
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
 class TypeBase {
  protected:
   friend class Type;
 
-  enum Kind { kConstant, kTuple, kUnion, kRange };
+  enum Kind { kConstant, kNumberConstant, kTuple, kUnion, kRange };
 
   Kind kind() const { return kind_; }
   explicit TypeBase(Kind kind) : kind_(kind) {}
 
   static bool IsKind(Type* type, Kind kind) {
     if (BitsetType::IsBitset(type)) return false;
     TypeBase* base = reinterpret_cast<TypeBase*>(type);
     return base->kind() == kind;
   }
 
   // The hacky conversion to/from Type*.
   static Type* AsType(TypeBase* type) { return reinterpret_cast<Type*>(type); }
   static TypeBase* FromType(Type* type) {
     return reinterpret_cast<TypeBase*>(type);
   }
 
  private:
   Kind kind_;
 };
 
 // -----------------------------------------------------------------------------
 // Constant types.
 
+class NumberConstantType : public TypeBase {
+ public:
+  double Value() { return value_; }
+
+  static bool IsNumberConstant(double value) {
+    // Not an integer, not NaN, and not -0.
+    return !std::isnan(value) && nearbyint(value) != value &&

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

make sure you don't allow integers outside of smi range!
try and use the IsInteger() predicate to exclude values.

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

Done.

+           !i::IsMinusZero(value);
+  }
+
+ private:
+  friend class Type;
+  friend class BitsetType;
+
+  static Type* New(double value, Zone* zone) {
+    BitsetType::bitset bitset = BitsetType::Lub(value);
+    return AsType(new (zone->New(sizeof(NumberConstantType)))
+                      NumberConstantType(bitset, value));
+  }
+
+  static NumberConstantType* cast(Type* type) {
+    DCHECK(IsKind(type, kNumberConstant));
+    return static_cast<NumberConstantType*>(FromType(type));
+  }
+
+  NumberConstantType(BitsetType::bitset bitset, double value)
+      : TypeBase(kNumberConstant), bitset_(bitset), value_(value) {
+    CHECK(IsNumberConstant(value));
+  }
+
+  BitsetType::bitset Lub() { return bitset_; }
+

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

No need for bitset member.

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

Done.

+  BitsetType::bitset bitset_;
+  double value_;
+};
+
 class ConstantType : public TypeBase {
  public:
   i::Handle<i::Object> Value() { return object_; }
 
  private:
   friend class Type;
   friend class BitsetType;
 
   static Type* New(i::Handle<i::Object> value, Zone* zone) {
     BitsetType::bitset bitset = BitsetType::Lub(*value);
     return AsType(new (zone->New(sizeof(ConstantType)))
                       ConstantType(bitset, value));
   }
 
   static ConstantType* cast(Type* type) {
     DCHECK(IsKind(type, kConstant));
     return static_cast<ConstantType*>(FromType(type));
   }
 
   ConstantType(BitsetType::bitset bitset, i::Handle<i::Object> object)
-      : TypeBase(kConstant), bitset_(bitset), object_(object) {}
+      : TypeBase(kConstant), bitset_(bitset), object_(object) {
+    CHECK(!object->IsSmi());  // Smis should always be RangeTypes.
+    CHECK(!object->IsHeapNumber() ||
+          !NumberConstantType::IsNumberConstant(
+              HeapNumber::cast(*object)->value()));

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

Confusing!

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

Done.

+  }
 
   BitsetType::bitset Lub() { return bitset_; }
 
   BitsetType::bitset bitset_;
   Handle<i::Object> object_;
 };
-// TODO(neis): Also cache value if numerical.
 
 // -----------------------------------------------------------------------------
 // Range types.
 
 class RangeType : public TypeBase {
  public:
   struct Limits {
     double min;
     double max;
     Limits(double min, double max) : min(min), max(max) {}
@@ skipping 139 matching lines @@
   PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
 #undef DEFINE_TYPE_CONSTRUCTOR
 
   static Type* SignedSmall() {
     return BitsetType::New(BitsetType::SignedSmall());
   }
   static Type* UnsignedSmall() {
     return BitsetType::New(BitsetType::UnsignedSmall());
   }
 
+  static Type* NumberConstant(double value, Zone* zone) {
+    return NumberConstantType::New(value, zone);
+  }
   static Type* Constant(i::Handle<i::Object> value, Zone* zone) {
     return ConstantType::New(value, zone);
   }
   static Type* Range(double min, double max, Zone* zone) {
     return RangeType::New(min, max, zone);
   }
   static Type* Tuple(Type* first, Type* second, Type* third, Zone* zone) {
     Type* tuple = TupleType::New(3, zone);
     tuple->AsTuple()->InitElement(0, first);
     tuple->AsTuple()->InitElement(1, second);
     tuple->AsTuple()->InitElement(2, third);
     return tuple;
   }
 
+  // NewConstant is a factory that returns Constant, Range or Number.
+  static Type* NewConstant(i::Handle<i::Object> value, Zone* zone);
+
   static Type* Union(Type* type1, Type* type2, Zone* zone);
   static Type* Intersect(Type* type1, Type* type2, Zone* zone);
 
   static Type* Of(double value, Zone* zone) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
   }
   static Type* Of(i::Object* value, Zone* zone) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(value)));
   }
   static Type* Of(i::Handle<i::Object> value, Zone* zone) {
     return Of(*value, zone);
   }
 
   static Type* For(i::Map* map) {
     return BitsetType::New(BitsetType::ExpandInternals(BitsetType::Lub(map)));
   }
   static Type* For(i::Handle<i::Map> map) { return For(*map); }
 
   // Predicates.
   bool IsInhabited() { return BitsetType::IsInhabited(this->BitsetLub()); }
 
   bool Is(Type* that) { return this == that || this->SlowIs(that); }
   bool Maybe(Type* that);
   bool Equals(Type* that) { return this->Is(that) && that->Is(this); }
 
   // Inspection.
   bool IsRange() { return IsKind(TypeBase::kRange); }
   bool IsConstant() { return IsKind(TypeBase::kConstant); }
+  bool IsNumberConstant() { return IsKind(TypeBase::kNumberConstant); }
   bool IsTuple() { return IsKind(TypeBase::kTuple); }
 
   ConstantType* AsConstant() { return ConstantType::cast(this); }
+  NumberConstantType* AsNumberConstant() {
+    return NumberConstantType::cast(this);
+  }
   RangeType* AsRange() { return RangeType::cast(this); }
   TupleType* AsTuple() { return TupleType::cast(this); }
 
   // Minimum and maximum of a numeric type.
   // These functions do not distinguish between -0 and +0.  If the type equals
   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
   // functions on subtypes of Number.
   double Min();
   double Max();
 
@@ skipping 44 matching lines @@
   UnionType* AsUnion() { return UnionType::cast(this); }
 
   bitset BitsetGlb() { return BitsetType::Glb(this); }
   bitset BitsetLub() { return BitsetType::Lub(this); }
 
   bool SlowIs(Type* that);
 
   static bool Overlap(RangeType* lhs, RangeType* rhs);
   static bool Contains(RangeType* lhs, RangeType* rhs);
   static bool Contains(RangeType* range, ConstantType* constant);
+  static bool Contains(RangeType* range, NumberConstantType* constant);
   static bool Contains(RangeType* range, i::Object* val);
 
   static int UpdateRange(Type* type, UnionType* result, int size, Zone* zone);
 
   static RangeType::Limits IntersectRangeAndBitset(Type* range, Type* bits,
                                                    Zone* zone);
   static RangeType::Limits ToLimits(bitset bits, Zone* zone);
 
   bool SimplyEquals(Type* that);
 
   static int AddToUnion(Type* type, UnionType* result, int size, Zone* zone);
   static int IntersectAux(Type* type, Type* other, UnionType* result, int size,
                           RangeType::Limits* limits, Zone* zone);
   static Type* NormalizeUnion(Type* unioned, int size, Zone* zone);
   static Type* NormalizeRangeAndBitset(Type* range, bitset* bits, Zone* zone);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_TYPES_H_