Load elimination fix with a test case.

src/code-stubs-hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 428 matching lines @@
   checker.Then();
 
   HValue* size_in_bytes = Add<HConstant>(size);
 
   HInstruction* object = Add<HAllocate>(size_in_bytes, HType::JSObject(),
       NOT_TENURED, JS_OBJECT_TYPE);
 
   for (int i = 0; i < object_size; i += kPointerSize) {
     HObjectAccess access = HObjectAccess::ForJSObjectOffset(i);
     Add<HStoreNamedField>(object, access,
-                          Add<HLoadNamedField>(boilerplate, access));
+                          Add<HLoadNamedField>(boilerplate, access),
+                          INITIALIZING_STORE);
   }
 
   ASSERT(FLAG_allocation_site_pretenuring || (size == object_size));
   if (FLAG_allocation_site_pretenuring) {
     BuildCreateAllocationMemento(
         object, Add<HConstant>(object_size), allocation_site);
   }
 
   environment()->Push(object);
   checker.ElseDeopt("Uninitialized boilerplate in fast clone");
@@ skipping 16 matching lines @@
 
   // Store the map
   Handle<Map> allocation_site_map = isolate()->factory()->allocation_site_map();
   AddStoreMapConstant(object, allocation_site_map);
 
   // Store the payload (smi elements kind)
   HValue* initial_elements_kind = Add<HConstant>(GetInitialFastElementsKind());
   Add<HStoreNamedField>(object,
                         HObjectAccess::ForAllocationSiteOffset(
                             AllocationSite::kTransitionInfoOffset),
-                        initial_elements_kind);
+                        initial_elements_kind,
+                        INITIALIZING_STORE);
 
   // Unlike literals, constructed arrays don't have nested sites
   Add<HStoreNamedField>(object,
                         HObjectAccess::ForAllocationSiteOffset(
                             AllocationSite::kNestedSiteOffset),
-                        graph()->GetConstant0());
+                        graph()->GetConstant0(),
+                        INITIALIZING_STORE);
 
   // Pretenuring calculation field.
   Add<HStoreNamedField>(object,
                         HObjectAccess::ForAllocationSiteOffset(
                             AllocationSite::kPretenureDataOffset),
-                        graph()->GetConstant0());
+                        graph()->GetConstant0(),
+                        INITIALIZING_STORE);
 
   // Pretenuring memento creation count field.
   Add<HStoreNamedField>(object,
                         HObjectAccess::ForAllocationSiteOffset(
                             AllocationSite::kPretenureCreateCountOffset),
-                        graph()->GetConstant0());
+                        graph()->GetConstant0(),
+                        INITIALIZING_STORE);
 
   // Store an empty fixed array for the code dependency.
   HConstant* empty_fixed_array =
     Add<HConstant>(isolate()->factory()->empty_fixed_array());
   HStoreNamedField* store = Add<HStoreNamedField>(
       object,
       HObjectAccess::ForAllocationSiteOffset(
           AllocationSite::kDependentCodeOffset),
-      empty_fixed_array);
+      empty_fixed_array,
+      INITIALIZING_STORE);
 
   // Link the object to the allocation site list
   HValue* site_list = Add<HConstant>(
       ExternalReference::allocation_sites_list_address(isolate()));
   HValue* site = Add<HLoadNamedField>(site_list,
                                       HObjectAccess::ForAllocationSiteList());
   store = Add<HStoreNamedField>(object,
       HObjectAccess::ForAllocationSiteOffset(AllocationSite::kWeakNextOffset),
-      site);
+      site, INITIALIZING_STORE);
   store->SkipWriteBarrier();
   Add<HStoreNamedField>(site_list, HObjectAccess::ForAllocationSiteList(),
-                        object);
+                        object, INITIALIZING_STORE);
 
   // We use a hammer (SkipWriteBarrier()) to indicate that we know the input
   // cell is really a Cell, and so no write barrier is needed.
   // TODO(mvstanton): Add a debug_code check to verify the input cell is really
   // a cell. (perhaps with a new instruction, HAssert).
   HInstruction* cell = GetParameter(0);
   HObjectAccess access = HObjectAccess::ForCellValue();
-  store = Add<HStoreNamedField>(cell, access, object);
+  store = Add<HStoreNamedField>(cell, access, object, INITIALIZING_STORE);
   store->SkipWriteBarrier();
   return cell;
 }
 
 
 Handle<Code> CreateAllocationSiteStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
 
 
@@ skipping 195 matching lines @@
   // Now populate the elements correctly.
   LoopBuilder builder(this,
                       context(),
                       LoopBuilder::kPostIncrement);
   HValue* start = graph()->GetConstant0();
   HValue* key = builder.BeginBody(start, checked_length, Token::LT);
   HInstruction* argument_elements = Add<HArgumentsElements>(false);
   HInstruction* argument = Add<HAccessArgumentsAt>(
       argument_elements, checked_length, key);
 
-  Add<HStoreKeyed>(elements, key, argument, kind);
+  Add<HStoreKeyed>(elements, key, argument, kind, INITIALIZING_STORE);
   builder.EndBody();
   return new_object;
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ArrayNoArgumentConstructorStub>::BuildCodeStub() {
   ElementsKind kind = casted_stub()->elements_kind();
   AllocationSiteOverrideMode override_mode = casted_stub()->override_mode();
   return BuildArrayConstructor(kind, override_mode, NONE);
@@ skipping 190 matching lines @@
     result = EnforceNumberType(result, result_type);
   }
 
   // Reuse the double box of one of the operands if we are allowed to (i.e.
   // chained binops).
   if (state.CanReuseDoubleBox()) {
     HValue* operand = (state.mode() == OVERWRITE_LEFT) ? left : right;
     IfBuilder if_heap_number(this);
     if_heap_number.IfNot<HIsSmiAndBranch>(operand);
     if_heap_number.Then();
-    Add<HStoreNamedField>(operand, HObjectAccess::ForHeapNumberValue(), result);
+    Add<HStoreNamedField>(operand, HObjectAccess::ForHeapNumberValue(), result,
+                          INITIALIZING_STORE);
     Push(operand);
     if_heap_number.Else();
     Push(result);
     if_heap_number.End();
     result = Pop();
   }
 
   return result;
 }
 
@@ skipping 102 matching lines @@
   } else {
     // Load the payload of the global parameter cell. A hole indicates that the
     // property has been deleted and that the store must be handled by the
     // runtime.
     IfBuilder builder(this);
     HValue* hole_value = Add<HConstant>(hole);
     builder.If<HCompareObjectEqAndBranch>(cell_contents, hole_value);
     builder.Then();
     builder.Deopt("Unexpected cell contents in global store");
     builder.Else();
-    Add<HStoreNamedField>(cell, access, value);
+    Add<HStoreNamedField>(cell, access, value, INITIALIZING_STORE);
     builder.End();
   }
 
   return value;
 }
 
 
 Handle<Code> StoreGlobalStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
@@ skipping 43 matching lines @@
   // TODO(fschneider): Idea: store proper code pointers in the optimized code
   // map and either unmangle them on marking or do nothing as the whole map is
   // discarded on major GC anyway.
   Add<HStoreCodeEntry>(js_function, code_object);
 
   // Now link a function into a list of optimized functions.
   HValue* optimized_functions_list = Add<HLoadNamedField>(native_context,
       HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST));
   Add<HStoreNamedField>(js_function,
                         HObjectAccess::ForNextFunctionLinkPointer(),
-                        optimized_functions_list);
+                        optimized_functions_list, INITIALIZING_STORE);
 
   // This store is the only one that should have a write barrier.
   Add<HStoreNamedField>(native_context,
            HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST),
-           js_function);
+           js_function, INITIALIZING_STORE);
 }
 
 
 void CodeStubGraphBuilderBase::BuildInstallCode(HValue* js_function,
                                                 HValue* shared_info) {
   Add<HStoreNamedField>(js_function,
                         HObjectAccess::ForNextFunctionLinkPointer(),
-                        graph()->GetConstantUndefined());
+                        graph()->GetConstantUndefined(),
+                        INITIALIZING_STORE);
   HValue* code_object = Add<HLoadNamedField>(shared_info,
                                              HObjectAccess::ForCodeOffset());
   Add<HStoreCodeEntry>(js_function, code_object);
 }
 
 
 void CodeStubGraphBuilderBase::BuildInstallFromOptimizedCodeMap(
     HValue* js_function,
     HValue* shared_info,
     HValue* native_context) {
@@ skipping 116 matching lines @@
                                              NOT_TENURED, JS_FUNCTION_TYPE);
 
   int map_index = Context::FunctionMapIndex(casted_stub()->language_mode(),
                                             casted_stub()->is_generator());
 
   // Compute the function map in the current native context and set that
   // as the map of the allocated object.
   HInstruction* native_context = BuildGetNativeContext();
   HInstruction* map_slot_value = Add<HLoadNamedField>(native_context,
       HObjectAccess::ForContextSlot(map_index));
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value);
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value,
+                        INITIALIZING_STORE);
 
   // Initialize the rest of the function.
   Add<HStoreNamedField>(js_function, HObjectAccess::ForPropertiesPointer(),
-                        empty_fixed_array);
+                        empty_fixed_array, INITIALIZING_STORE);
   Add<HStoreNamedField>(js_function, HObjectAccess::ForElementsPointer(),
-                        empty_fixed_array);
+                        empty_fixed_array, INITIALIZING_STORE);
   Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
-                        empty_fixed_array);
+                        empty_fixed_array, INITIALIZING_STORE);
   Add<HStoreNamedField>(js_function, HObjectAccess::ForPrototypeOrInitialMap(),
-                        graph()->GetConstantHole());
+                        graph()->GetConstantHole(), INITIALIZING_STORE);
   Add<HStoreNamedField>(js_function,
                         HObjectAccess::ForSharedFunctionInfoPointer(),
-                        shared_info);
+                        shared_info, INITIALIZING_STORE);
   Add<HStoreNamedField>(js_function, HObjectAccess::ForFunctionContextPointer(),
-                        context());
+                        context(), INITIALIZING_STORE);
 
   // Initialize the code pointer in the function to be the one
   // found in the shared function info object.
   // But first check if there is an optimized version for our context.
   if (FLAG_cache_optimized_code) {
     BuildInstallFromOptimizedCodeMap(js_function, shared_info, native_context);
   } else {
     BuildInstallCode(js_function, shared_info);
   }
 
@@ skipping 16 matching lines @@
   // Allocate the context in new space.
   HAllocate* function_context = Add<HAllocate>(
       Add<HConstant>(length * kPointerSize + FixedArray::kHeaderSize),
       HType::Tagged(), NOT_TENURED, FIXED_ARRAY_TYPE);
 
   // Set up the object header.
   AddStoreMapConstant(function_context,
                       isolate()->factory()->function_context_map());
   Add<HStoreNamedField>(function_context,
                         HObjectAccess::ForFixedArrayLength(),
-                        Add<HConstant>(length));
+                        Add<HConstant>(length), INITIALIZING_STORE);
 
   // Set up the fixed slots.
   Add<HStoreNamedField>(function_context,
                         HObjectAccess::ForContextSlot(Context::CLOSURE_INDEX),
-                        function);
+                        function, INITIALIZING_STORE);
   Add<HStoreNamedField>(function_context,
                         HObjectAccess::ForContextSlot(Context::PREVIOUS_INDEX),
-                        context());
+                        context(), INITIALIZING_STORE);
   Add<HStoreNamedField>(function_context,
                         HObjectAccess::ForContextSlot(Context::EXTENSION_INDEX),
-                        graph()->GetConstant0());
+                        graph()->GetConstant0(), INITIALIZING_STORE);
 
   // Copy the global object from the previous context.
   HValue* global_object = Add<HLoadNamedField>(
       context(), HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
   Add<HStoreNamedField>(function_context,
                         HObjectAccess::ForContextSlot(
                             Context::GLOBAL_OBJECT_INDEX),
-                        global_object);
+                        global_object,
+                        INITIALIZING_STORE);
 
   // Initialize the rest of the slots to undefined.
   for (int i = Context::MIN_CONTEXT_SLOTS; i < length; ++i) {
     Add<HStoreNamedField>(function_context,
                           HObjectAccess::ForContextSlot(i),
-                          graph()->GetConstantUndefined());
+                          graph()->GetConstantUndefined(),
+                          INITIALIZING_STORE);
   }
 
   return function_context;
 }
 
 
 Handle<Code> FastNewContextStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
 
 
 template<>
 HValue* CodeStubGraphBuilder<KeyedLoadDictionaryElementStub>::BuildCodeStub() {
   HValue* receiver = GetParameter(0);
   HValue* key = GetParameter(1);
 
   Add<HCheckSmi>(key);
 
   return BuildUncheckedDictionaryElementLoad(receiver, key);
 }
 
 
 Handle<Code> KeyedLoadDictionaryElementStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
 
 
 } }  // namespace v8::internal