Fix double canonicalization

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 2177 matching lines @@
         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_));
-    double_value_ = n;
+    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,
@@ skipping 32 matching lines @@
       int32_value_(integer_value),
       double_value_(FastI2D(integer_value)) {
   // It's possible to create a constant with a value in Smi-range but stored
   // in a (pre-existing) HeapNumber. See crbug.com/349878.
   bool could_be_heapobject = r.IsTagged() && !object.handle().is_null();
   bool is_smi = HasSmiValue() && !could_be_heapobject;
   set_type(is_smi ? HType::Smi() : HType::TaggedNumber());
   Initialize(r);
 }
 
-
 HConstant::HConstant(double double_value, Representation r,
                      bool is_not_in_new_space, Unique<Object> object)
     : object_(object),
       object_map_(Handle<Map>::null()),
       bit_field_(HasStableMapValueField::encode(false) |
                  HasInt32ValueField::encode(IsInteger32(double_value)) |
                  HasDoubleValueField::encode(true) |
                  HasExternalReferenceValueField::encode(false) |
                  IsNotInNewSpaceField::encode(is_not_in_new_space) |
                  BooleanValueField::encode(double_value != 0 &&
                                            !std::isnan(double_value)) |
                  IsUndetectableField::encode(false) |
                  InstanceTypeField::encode(kUnknownInstanceType)),
-      int32_value_(DoubleToInt32(double_value)),
-      double_value_(double_value) {
+      int32_value_(DoubleToInt32(double_value)) {
   bit_field_ = HasSmiValueField::update(
       bit_field_, HasInteger32Value() && Smi::IsValid(int32_value_));
   // It's possible to create a constant with a value in Smi-range but stored
   // in a (pre-existing) HeapNumber. See crbug.com/349878.
   bool could_be_heapobject = r.IsTagged() && !object.handle().is_null();
   bool is_smi = HasSmiValue() && !could_be_heapobject;
   set_type(is_smi ? HType::Smi() : HType::TaggedNumber());
+  if (std::isnan(double_value)) {
+    double_value_ = std::numeric_limits<double>::quiet_NaN();
+  } else {
+    double_value_ = double_value;
+  }
   Initialize(r);
 }
 
 
 HConstant::HConstant(ExternalReference reference)
     : HTemplateInstruction<0>(HType::Any()),
       object_(Unique<Object>(Handle<Object>::null())),
       object_map_(Handle<Map>::null()),
       bit_field_(
           HasStableMapValueField::encode(false) |
@@ skipping 998 matching lines @@
 bool HStoreKeyed::NeedsCanonicalization() {
   switch (value()->opcode()) {
     case kLoadKeyed: {
       ElementsKind load_kind = HLoadKeyed::cast(value())->elements_kind();
       return IsFixedFloatElementsKind(load_kind);
     }
     case kChange: {
       Representation from = HChange::cast(value())->from();
       return from.IsTagged() || from.IsHeapObject();
     }
-    case kLoadNamedField:
-    case kPhi: {
-      // Better safe than sorry...
-      return true;
-    }
+    case kConstant:
+      // Double constants are canonicalized upon construction.
+      return false;
     default:
-      return false;
+      return !value()->IsBinaryOperation();
   }
 }
 
 
 #define H_CONSTANT_INT(val) \
   HConstant::New(isolate, zone, context, static_cast<int32_t>(val))
 #define H_CONSTANT_DOUBLE(val) \
   HConstant::New(isolate, zone, context, static_cast<double>(val))
 
 #define DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HInstr, op)                     \
@@ skipping 732 matching lines @@
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 }  // namespace internal
 }  // namespace v8