[crankshaft][runtime] Initialize uninitialized double fields with hole NaN value instead of 0.0.

src/crankshaft/hydrogen.cc

 // Copyright 2013 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.h"
 
 #include <memory>
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
@@ skipping 5482 matching lines @@
             FeedbackVectorSlot slot = property->GetSlot();
             if (map.is_null()) {
               // If we don't know the monomorphic type, do a generic store.
               CHECK_ALIVE(store = BuildNamedGeneric(STORE, NULL, slot, literal,
                                                     name, value));
             } else {
               PropertyAccessInfo info(this, STORE, map, name);
               if (info.CanAccessMonomorphic()) {
                 HValue* checked_literal = Add<HCheckMaps>(literal, map);
                 DCHECK(!info.IsAccessorConstant());
+                info.MarkAsInitializingStore();
                 store = BuildMonomorphicAccess(
                     &info, literal, checked_literal, value,
                     BailoutId::None(), BailoutId::None());
               } else {
                 CHECK_ALIVE(store = BuildNamedGeneric(STORE, NULL, slot,
                                                       literal, name, value));
               }
             }
             if (store->IsInstruction()) {
               AddInstruction(HInstruction::cast(store));
@@ skipping 221 matching lines @@
     if (field_access.representation().IsHeapObject()) {
       BuildCheckHeapObject(value);
     }
 
     if (!info->field_maps()->is_empty()) {
       DCHECK(field_access.representation().IsHeapObject());
       value = Add<HCheckMaps>(value, info->field_maps());
     }
 
     // This is a normal store.
-    instr = New<HStoreNamedField>(
-        checked_object->ActualValue(), field_access, value,
-        transition_to_field ? INITIALIZING_STORE : STORE_TO_INITIALIZED_ENTRY);
+    instr = New<HStoreNamedField>(checked_object->ActualValue(), field_access,
+                                  value, info->StoreMode());
   }
 
   if (transition_to_field) {
     Handle<Map> transition(info->transition());
     DCHECK(!transition->is_deprecated());
     instr->SetTransition(Add<HConstant>(transition));
   }
   return instr;
 }
 
+void HOptimizedGraphBuilder::PropertyAccessInfo::MarkAsInitializingStore() {
+  DCHECK_EQ(STORE, access_type_);
+  store_mode_ = INITIALIZING_STORE;
+}
+
+StoreFieldOrKeyedMode HOptimizedGraphBuilder::PropertyAccessInfo::StoreMode() {
+  DCHECK_EQ(STORE, access_type_);
+  if (IsTransition()) return INITIALIZING_STORE;

[Toon Verwaest, 2017/01/16 11:53:31]

if IsTransition() is true, store_mode_ should just be INITIALIZING_STORE as
well...

[Igor Sheludko, 2017/01/16 12:02:59]

Done.

+  return store_mode_;
+}
+
 Handle<FieldType>
 HOptimizedGraphBuilder::PropertyAccessInfo::GetFieldTypeFromMap(
     Handle<Map> map) const {
   DCHECK(IsFound());
   DCHECK(number_ < map->NumberOfOwnDescriptors());
   return handle(map->instance_descriptors()->GetFieldType(number_), isolate());
 }
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::IsCompatible(
     PropertyAccessInfo* info) {
@@ skipping 7170 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8