Use signaling NaN for holes in fixed double arrays.

src/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/v8.h"
 
 #include "src/base/bits.h"
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
@@ skipping 2665 matching lines @@
 static bool IsInteger32(double value) {
   if (value >= std::numeric_limits<int32_t>::min() &&
       value <= std::numeric_limits<int32_t>::max()) {
     double roundtrip_value = static_cast<double>(static_cast<int32_t>(value));
     return bit_cast<int64_t>(roundtrip_value) == bit_cast<int64_t>(value);
   }
   return false;
 }
 
 
+HConstant::HConstant(Special special)
+    : HTemplateInstruction<0>(HType::TaggedNumber()),
+      object_(Handle<Object>::null()),
+      object_map_(Handle<Map>::null()),
+      bit_field_(HasDoubleValueField::encode(true) |
+                 InstanceTypeField::encode(kUnknownInstanceType)),
+      int32_value_(0) {
+  DCHECK_EQ(kHoleNaN, special);
+  std::memcpy(&double_value_, &kHoleNanInt64, sizeof(double_value_));
+  Initialize(Representation::Double());
+}
+
+
 HConstant::HConstant(Handle<Object> object, Representation r)
     : HTemplateInstruction<0>(HType::FromValue(object)),
       object_(Unique<Object>::CreateUninitialized(object)),
       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) |
@@ skipping 1337 matching lines @@
   // constant-offset-from-key * kPointerSize)
   v8::base::internal::CheckedNumeric<uint32_t> addition_result = base_offset_;
   addition_result += increase_by_value;
   if (!addition_result.IsValid()) return false;
   base_offset_ = addition_result.ValueOrDie();
   return true;
 }
 
 
 bool HStoreKeyed::NeedsCanonicalization() {
-  // If value is an integer or smi or comes from the result of a keyed load or
-  // constant then it is either be a non-hole value or in the case of a constant
-  // the hole is only being stored explicitly: no need for canonicalization.
-  //
-  // The exception to that is keyed loads from external float or double arrays:
-  // these can load arbitrary representation of NaN.
-
-  if (value()->IsConstant()) {
-    return false;
+  switch (value()->opcode()) {

[Vyacheslav Egorov (Google), 2015/01/22 02:52:20]

This check should account for heap number fields (mutable boxes, unboxed fields,
etc).

There we just load payload directly bypassing the HChange.

Repro:

function A(src) { this.x = src[0]; }

new A(fixed_double_elements);
new A(fixed_double_elements);

%OptimizeFunctionOnNextCall(A);

var obj = new A(fixed_double_elements);

function move_x(dst, obj) { dst[0] = obj.x; }

var doubles = [0.5];
move_x(doubles, obj);
move_x(doubles, obj);
%OptimizeFunctionOnNextCall(move_x);
move_x(doubles, obj);
assertTrue(doubles[0] !== undefined);

[Benedikt Meurer, 2015/01/22 06:11:15]

Fixed, thanks.

+    case kLoadKeyed: {
+      ElementsKind load_kind = HLoadKeyed::cast(value())->elements_kind();
+      return IsExternalFloatOrDoubleElementsKind(load_kind) ||
+             IsFixedFloatElementsKind(load_kind);
+    }
+    case kChange: {
+      Representation from = HChange::cast(value())->from();
+      return from.IsTagged() || from.IsHeapObject();
+    }
+    case kPhi:
+      // Better safe than sorry...
+      return true;
+    default:
+      return false;
   }
-
-  if (value()->IsLoadKeyed()) {
-    return IsExternalFloatOrDoubleElementsKind(
-        HLoadKeyed::cast(value())->elements_kind());
-  }
-
-  if (value()->IsChange()) {
-    if (HChange::cast(value())->from().IsSmiOrInteger32()) {
-      return false;
-    }
-    if (HChange::cast(value())->value()->type().IsSmi()) {
-      return false;
-    }
-  }
-  return true;
 }
 
 
 #define H_CONSTANT_INT(val)                                                    \
 HConstant::New(zone, context, static_cast<int32_t>(val))
 #define H_CONSTANT_DOUBLE(val)                                                 \
 HConstant::New(zone, context, static_cast<double>(val))
 
 #define DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HInstr, op)                       \
 HInstruction* HInstr::New(                                                     \
@@ skipping 739 matching lines @@
       break;
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 } }  // namespace v8::internal