[crankshaft] Use canonical nan_value or minus_zero_value objects instead of constant heap numbers w…

src/crankshaft/hydrogen-instructions.cc

 // Copyright 2012 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 "src/crankshaft/hydrogen-instructions.h"
 
 #include "src/base/bits.h"
 #include "src/base/ieee754.h"
 #include "src/base/safe_math.h"
 #include "src/crankshaft/hydrogen-infer-representation.h"
@@ skipping 2154 matching lines @@
       object_map_(Handle<Map>::null()),
       bit_field_(
           HasStableMapValueField::encode(false) |
           HasSmiValueField::encode(false) | HasInt32ValueField::encode(false) |
           HasDoubleValueField::encode(false) |
           HasExternalReferenceValueField::encode(false) |
           IsNotInNewSpaceField::encode(true) |
           BooleanValueField::encode(object->BooleanValue()) |
           IsUndetectableField::encode(false) | IsCallableField::encode(false) |
           InstanceTypeField::encode(kUnknownInstanceType)) {
+  if (object->IsNumber()) {
+    double n = object->Number();
+    bool has_int32_value = IsInteger32(n);
+    bit_field_ = HasInt32ValueField::update(bit_field_, has_int32_value);
+    int32_value_ = DoubleToInt32(n);
+    bit_field_ = HasSmiValueField::update(
+        bit_field_, has_int32_value && Smi::IsValid(int32_value_));
+    if (std::isnan(n)) {
+      double_value_ = std::numeric_limits<double>::quiet_NaN();
+      // Canonicalize object with NaN value.
+      DCHECK(object->IsHeapObject());  // NaN can't be a Smi.
+      Isolate* isolate = HeapObject::cast(*object)->GetIsolate();
+      object = isolate->factory()->nan_value();
+      object_ = Unique<Object>::CreateUninitialized(object);
+    } else {
+      double_value_ = n;
+      // Canonicalize object with -0.0 value.
+      if (bit_cast<int64_t>(n) == bit_cast<int64_t>(-0.0)) {
+        DCHECK(object->IsHeapObject());  // -0.0 can't be a Smi.
+        Isolate* isolate = HeapObject::cast(*object)->GetIsolate();
+        object = isolate->factory()->minus_zero_value();
+        object_ = Unique<Object>::CreateUninitialized(object);
+      }
+    }
+    bit_field_ = HasDoubleValueField::update(bit_field_, true);
+  }
   if (object->IsHeapObject()) {
     Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
     Isolate* isolate = heap_object->GetIsolate();
     Handle<Map> map(heap_object->map(), isolate);
     bit_field_ = IsNotInNewSpaceField::update(
         bit_field_, !isolate->heap()->InNewSpace(*object));
     bit_field_ = InstanceTypeField::update(bit_field_, map->instance_type());
     bit_field_ =
         IsUndetectableField::update(bit_field_, map->is_undetectable());
     bit_field_ = IsCallableField::update(bit_field_, map->is_callable());
     if (map->is_stable()) object_map_ = Unique<Map>::CreateImmovable(map);
     bit_field_ = HasStableMapValueField::update(
         bit_field_,
         HasMapValue() && Handle<Map>::cast(heap_object)->is_stable());
   }
-  if (object->IsNumber()) {
-    double n = object->Number();
-    bool has_int32_value = IsInteger32(n);
-    bit_field_ = HasInt32ValueField::update(bit_field_, has_int32_value);
-    int32_value_ = DoubleToInt32(n);
-    bit_field_ = HasSmiValueField::update(
-        bit_field_, has_int32_value && Smi::IsValid(int32_value_));
-    if (std::isnan(n)) {
-      double_value_ = std::numeric_limits<double>::quiet_NaN();
-    } else {
-      double_value_ = n;
-    }
-    bit_field_ = HasDoubleValueField::update(bit_field_, true);
-  }
 
   Initialize(r);
 }
 
 
 HConstant::HConstant(Unique<Object> object, Unique<Map> object_map,
                      bool has_stable_map_value, Representation r, HType type,
                      bool is_not_in_new_space, bool boolean_value,
                      bool is_undetectable, InstanceType instance_type)
     : HTemplateInstruction<0>(type),
@@ skipping 1831 matching lines @@
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 }  // namespace internal
 }  // namespace v8