[stubs] Cleanup storing of maps to objects.

src/code-stubs.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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/bootstrapper.h"
@@ skipping 460 matching lines @@
 }
 
 void StoreMapStub::GenerateAssembly(compiler::CodeAssemblerState* state) const {
   typedef compiler::Node Node;
   CodeStubAssembler assembler(state);
 
   Node* receiver = assembler.Parameter(Descriptor::kReceiver);
   Node* map = assembler.Parameter(Descriptor::kMap);
   Node* value = assembler.Parameter(Descriptor::kValue);
 
-  assembler.StoreObjectField(receiver, JSObject::kMapOffset, map);
+  assembler.StoreMap(receiver, map);
   assembler.Return(value);
 }
 
 void StoreTransitionStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   CodeStubAssembler assembler(state);
 
   Node* receiver = assembler.Parameter(Descriptor::kReceiver);
@@ skipping 22 matching lines @@
     DCHECK(store_mode() == StoreTransitionStub::StoreMapAndValue);
   }
 
   // Store the new value into the "extended" object.
   assembler.Comment("Store value");
   assembler.StoreNamedField(receiver, offset, is_inobject(), representation,
                             prepared_value, true);
 
   // And finally update the map.
   assembler.Comment("Store map");
-  assembler.StoreObjectField(receiver, JSObject::kMapOffset, map);
+  assembler.StoreMap(receiver, map);
   assembler.Return(value);
 
   // Only store to tagged field never bails out.
   if (!representation.IsTagged()) {
     assembler.Bind(&miss);
     {
       assembler.Comment("Miss");
       assembler.TailCallRuntime(Runtime::kStoreIC_Miss, context, value, slot,
                                 vector, receiver, name);
     }
@@ skipping 1691 matching lines @@
   {
     offset.Bind(assembler->IntPtrAdd(offset.value(),
                                      assembler->IntPtrConstant(kPointerSize)));
     assembler->GotoUnless(
         assembler->IntPtrGreaterThanOrEqual(offset.value(), end_offset),
         &loop_body);
   }
 
   if (FLAG_allocation_site_pretenuring) {
     Node* memento = assembler->InnerAllocate(copy, object_size);
-    assembler->StoreObjectFieldNoWriteBarrier(
-        memento, HeapObject::kMapOffset,
-        assembler->LoadRoot(Heap::kAllocationMementoMapRootIndex));
+    assembler->StoreMapNoWriteBarrier(memento,
+                                      Heap::kAllocationMementoMapRootIndex);
     assembler->StoreObjectFieldNoWriteBarrier(
         memento, AllocationMemento::kAllocationSiteOffset, allocation_site);
     Node* memento_create_count = assembler->LoadObjectField(
         allocation_site, AllocationSite::kPretenureCreateCountOffset);
     memento_create_count = assembler->SmiAdd(
         memento_create_count, assembler->SmiConstant(Smi::FromInt(1)));
     assembler->StoreObjectFieldNoWriteBarrier(
         allocation_site, AllocationSite::kPretenureCreateCountOffset,
         memento_create_count);
   }
@@ skipping 346 matching lines @@
   Node* min_context_slots =
       assembler->Int32Constant(Context::MIN_CONTEXT_SLOTS);
   Node* length = assembler->Int32Add(slots, min_context_slots);
   Node* size = assembler->Int32Add(
       assembler->Word32Shl(length, assembler->Int32Constant(kPointerSizeLog2)),
       assembler->Int32Constant(FixedArray::kHeaderSize));
 
   // Create a new closure from the given function info in new space
   Node* function_context = assembler->Allocate(size);
 
-  Isolate* isolate = assembler->isolate();
-  assembler->StoreMapNoWriteBarrier(
-      function_context,
-      assembler->HeapConstant(isolate->factory()->function_context_map()));
+  assembler->StoreMapNoWriteBarrier(function_context,
+                                    Heap::kFunctionContextMapRootIndex);
   assembler->StoreObjectFieldNoWriteBarrier(function_context,
                                             Context::kLengthOffset,
                                             assembler->SmiFromWord32(length));
 
   // Set up the fixed slots.
   assembler->StoreFixedArrayElement(function_context, Context::CLOSURE_INDEX,
                                     function, SKIP_WRITE_BARRIER);
   assembler->StoreFixedArrayElement(function_context, Context::PREVIOUS_INDEX,
                                     context, SKIP_WRITE_BARRIER);
   assembler->StoreFixedArrayElement(function_context, Context::EXTENSION_INDEX,
@@ skipping 108 matching lines @@
     capacity = assembler->SmiUntag(capacity);
     param_mode = CodeStubAssembler::INTEGER_PARAMETERS;
   }
 
   Node *array, *elements;
   std::tie(array, elements) =
       assembler->AllocateUninitializedJSArrayWithElements(
           kind, boilerplate_map, length, allocation_site, capacity, param_mode);
 
   assembler->Comment("copy elements header");
-  for (int offset = 0; offset < FixedArrayBase::kHeaderSize;
-       offset += kPointerSize) {
-    Node* value = assembler->LoadObjectField(boilerplate_elements, offset);
-    assembler->StoreObjectField(elements, offset, value);
+  // Header consists of map and length.
+  STATIC_ASSERT(FixedArrayBase::kHeaderSize == 2 * kPointerSize);
+  assembler->StoreMap(elements, assembler->LoadMap(boilerplate_elements));
+  {
+    int offset = FixedArrayBase::kLengthOffset;
+    assembler->StoreObjectFieldNoWriteBarrier(
+        elements, offset,
+        assembler->LoadObjectField(boilerplate_elements, offset));
   }
 
   if (assembler->Is64()) {
     length = assembler->SmiUntag(length);
   }
 
   assembler->Comment("copy boilerplate elements");
   assembler->CopyFixedArrayElements(kind, boilerplate_elements, elements,
                                     length, SKIP_WRITE_BARRIER, param_mode);
   assembler->IncrementCounter(
@@ skipping 451 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8