[turbofan] HeapConstant types should compare by handle address

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.h"
@@ skipping 302 matching lines @@
     CHECK(IsOtherNumberConstant(value));
   }
 
   BitsetType::bitset Lub() { return BitsetType::kOtherNumber; }
 
   double value_;
 };
 
 class HeapConstantType : public TypeBase {
  public:
-  i::Handle<i::Object> Value() { return object_; }
+  i::Handle<i::HeapObject> Value() { return object_; }
 
  private:
   friend class Type;
   friend class BitsetType;
 
-  static Type* New(i::Handle<i::Object> value, Zone* zone) {
+  static Type* New(i::Handle<i::HeapObject> value, Zone* zone) {
     BitsetType::bitset bitset = BitsetType::Lub(*value);
     return AsType(new (zone->New(sizeof(HeapConstantType)))
                       HeapConstantType(bitset, value));
   }
 
   static HeapConstantType* cast(Type* type) {
     DCHECK(IsKind(type, kHeapConstant));
     return static_cast<HeapConstantType*>(FromType(type));
   }
 
-  HeapConstantType(BitsetType::bitset bitset, i::Handle<i::Object> object);
+  HeapConstantType(BitsetType::bitset bitset, i::Handle<i::HeapObject> object);
 
   BitsetType::bitset Lub() { return bitset_; }
 
   BitsetType::bitset bitset_;
-  Handle<i::Object> object_;
+  Handle<i::HeapObject> object_;
 };
 
 // -----------------------------------------------------------------------------
 // Range types.
 
 class RangeType : public TypeBase {
  public:
   struct Limits {
     double min;
     double max;
@@ skipping 143 matching lines @@
   static Type* SignedSmall() {
     return BitsetType::New(BitsetType::SignedSmall());
   }
   static Type* UnsignedSmall() {
     return BitsetType::New(BitsetType::UnsignedSmall());
   }
 
   static Type* OtherNumberConstant(double value, Zone* zone) {
     return OtherNumberConstantType::New(value, zone);
   }
-  static Type* HeapConstant(i::Handle<i::Object> value, Zone* zone) {
+  static Type* HeapConstant(i::Handle<i::HeapObject> value, Zone* zone) {
     return HeapConstantType::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);
@@ skipping 119 matching lines @@
                           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_