[turbofan] HeapConstant types should compare by handle address

src/compiler/types.cc

 // 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.
 
 #include <iomanip>
 
 #include "src/compiler/types.h"
 
 #include "src/handles-inl.h"
 #include "src/ostreams.h"
@@ skipping 384 matching lines @@
          !i::IsMinusZero(value);
 }
 
 // static
 bool OtherNumberConstantType::IsOtherNumberConstant(Object* value) {
   return value->IsHeapNumber() &&
          IsOtherNumberConstant(HeapNumber::cast(value)->value());
 }
 
 HeapConstantType::HeapConstantType(BitsetType::bitset bitset,
-                                   i::Handle<i::Object> object)
+                                   i::Handle<i::HeapObject> object)
     : TypeBase(kHeapConstant), bitset_(bitset), object_(object) {
-  // All number types should be expressed as Ranges, OtherNumberConstants,
-  // or bitsets (nan, negative-zero).
-  DCHECK(!object->IsSmi() && !object->IsHeapNumber());
+  DCHECK(!object->IsHeapNumber());
 }
 
 // -----------------------------------------------------------------------------
 // Predicates.
 
 bool Type::SimplyEquals(Type* that) {
   DisallowHeapAllocation no_allocation;
   if (this->IsHeapConstant()) {
     return that->IsHeapConstant() &&
-           *this->AsHeapConstant()->Value() == *that->AsHeapConstant()->Value();
+           this->AsHeapConstant()->Value().address() ==
+               that->AsHeapConstant()->Value().address();
   }
   if (this->IsOtherNumberConstant()) {
     return that->IsOtherNumberConstant() &&
            this->AsOtherNumberConstant()->Value() ==
                that->AsOtherNumberConstant()->Value();
   }
   if (this->IsRange()) {
     if (that->IsHeapConstant() || that->IsOtherNumberConstant()) return false;
   }
   if (this->IsTuple()) {
@@ skipping 345 matching lines @@
   return OtherNumberConstant(value, zone);
 }
 
 Type* Type::NewConstant(i::Handle<i::Object> value, Zone* zone) {
   if (IsInteger(*value)) {
     double v = value->Number();
     return Range(v, v, zone);
   } else if (value->IsHeapNumber()) {
     return NewConstant(value->Number(), zone);
   }
-  return HeapConstant(value, zone);
+  return HeapConstant(i::Handle<i::HeapObject>::cast(value), zone);
 }
 
 Type* Type::Union(Type* type1, Type* type2, Zone* zone) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset());
   }
 
   // Fast case: top or bottom types.
   if (type1->IsAny() || type2->IsNone()) return type1;
@@ skipping 198 matching lines @@
   return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
 }
 
 BitsetType::bitset BitsetType::UnsignedSmall() {
   return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8