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

src/crankshaft/hydrogen.h

 // 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.
 
 #ifndef V8_CRANKSHAFT_HYDROGEN_H_
 #define V8_CRANKSHAFT_HYDROGEN_H_
 
 #include "src/accessors.h"
 #include "src/allocation.h"
 #include "src/ast/ast-type-bounds.h"
@@ skipping 2438 matching lines @@
     PropertyAccessInfo(HOptimizedGraphBuilder* builder,
                        PropertyAccessType access_type, Handle<Map> map,
                        Handle<Name> name)
         : builder_(builder),
           access_type_(access_type),
           map_(map),
           name_(isolate()->factory()->InternalizeName(name)),
           field_type_(HType::Tagged()),
           access_(HObjectAccess::ForMap()),
           lookup_type_(NOT_FOUND),
-          details_(PropertyDetails::Empty()) {}
+          details_(PropertyDetails::Empty()),
+          store_mode_(STORE_TO_INITIALIZED_ENTRY) {}
+
+    // Ensure the full store is performed.
+    void MarkAsInitializingStore() {
+      DCHECK_EQ(STORE, access_type_);
+      store_mode_ = INITIALIZING_STORE;
+    }
+
+    StoreFieldOrKeyedMode StoreMode() {
+      DCHECK_EQ(STORE, access_type_);
+      return store_mode_;
+    }
 
     // Checkes whether this PropertyAccessInfo can be handled as a monomorphic
     // load named. It additionally fills in the fields necessary to generate the
     // lookup code.
     bool CanAccessMonomorphic();
 
     // Checks whether all types behave uniform when loading name. If all maps
     // behave the same, a single monomorphic load instruction can be emitted,
     // guarded by a single map-checks instruction that whether the receiver is
     // an instance of any of the types.
@@ skipping 95 matching lines @@
       number_ = number;
     }
     void LookupTransition(Map* map, Name* name, PropertyAttributes attributes) {
       Map* target =
           TransitionArray::SearchTransition(map, kData, name, attributes);
       if (target == NULL) return NotFound();
       lookup_type_ = TRANSITION_TYPE;
       transition_ = handle(target);
       number_ = transition_->LastAdded();
       details_ = transition_->instance_descriptors()->GetDetails(number_);
+      MarkAsInitializingStore();
     }
     void NotFound() {
       lookup_type_ = NOT_FOUND;
       details_ = PropertyDetails::Empty();
     }
     Representation representation() const {
       DCHECK(IsFound());
       return details_.representation();
     }
     bool IsTransitionToData() const {
@@ skipping 26 matching lines @@
     Handle<JSObject> api_holder_;
     Handle<Object> constant_;
     SmallMapList field_maps_;
     HType field_type_;
     HObjectAccess access_;
 
     enum { NOT_FOUND, DESCRIPTOR_TYPE, TRANSITION_TYPE } lookup_type_;
     Handle<Map> transition_;
     int number_;
     PropertyDetails details_;
+    StoreFieldOrKeyedMode store_mode_;
   };
 
   HValue* BuildMonomorphicAccess(PropertyAccessInfo* info, HValue* object,
                                  HValue* checked_object, HValue* value,
                                  BailoutId ast_id, BailoutId return_id,
                                  bool can_inline_accessor = true);
 
   HValue* BuildNamedAccess(PropertyAccessType access, BailoutId ast_id,
                            BailoutId reutrn_id, Expression* expr,
                            FeedbackVectorSlot slot, HValue* object,
@@ skipping 351 matching lines @@
   }
 
  private:
   HOptimizedGraphBuilder* builder_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CRANKSHAFT_HYDROGEN_H_