[stubs] Port CreateWeakCellStub to turbofan

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/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 4102 matching lines @@
 
 
 void FastCloneShallowArrayStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   FastCloneShallowArrayDescriptor call_descriptor(isolate());
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kCreateArrayLiteralStubBailout)->entry);
 }
 
 
-void CreateWeakCellStub::InitializeDescriptor(CodeStubDescriptor* d) {}
-
-
 void RegExpConstructResultStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kRegExpConstructResult)->entry);
 }
 
 
 void TransitionElementsKindStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
@@ skipping 567 matching lines @@
   entry_hook(function, stack_pointer);
 }
 
 void CreateAllocationSiteStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* size = assembler->IntPtrConstant(AllocationSite::kSize);
   Node* site = assembler->Allocate(size, compiler::CodeAssembler::kPretenured);
 
   // Store the map
-  Node* map =
-      assembler->HeapConstant(isolate()->factory()->allocation_site_map());
-  assembler->StoreMapNoWriteBarrier(site, map);
+  assembler->StoreObjectFieldRoot(site, AllocationSite::kMapOffset,
+                                  Heap::kAllocationSiteMapRootIndex);
 
   Node* kind =
       assembler->SmiConstant(Smi::FromInt(GetInitialFastElementsKind()));
   assembler->StoreObjectFieldNoWriteBarrier(
       site, AllocationSite::kTransitionInfoOffset, kind);
 
   // Unlike literals, constructed arrays don't have nested sites
   Node* zero = assembler->IntPtrConstant(0);
   assembler->StoreObjectFieldNoWriteBarrier(
       site, AllocationSite::kNestedSiteOffset, zero);
 
   // Pretenuring calculation field.
   assembler->StoreObjectFieldNoWriteBarrier(
       site, AllocationSite::kPretenureDataOffset, zero);
 
   // Pretenuring memento creation count field.
   assembler->StoreObjectFieldNoWriteBarrier(
       site, AllocationSite::kPretenureCreateCountOffset, zero);
 
   // Store an empty fixed array for the code dependency.
-  Node* empty_fixed_array =
-      assembler->HeapConstant(isolate()->factory()->empty_fixed_array());
-  assembler->StoreObjectFieldNoWriteBarrier(
-      site, AllocationSite::kDependentCodeOffset, empty_fixed_array);
+  assembler->StoreObjectFieldRoot(site, AllocationSite::kDependentCodeOffset,
+                                  Heap::kEmptyFixedArrayRootIndex);
 
   // Link the object to the allocation site list
   Node* site_list = assembler->ExternalConstant(
       ExternalReference::allocation_sites_list_address(isolate()));
   Node* next_site = assembler->LoadBufferObject(site_list, 0);
 
   // TODO(mvstanton): This is a store to a weak pointer, which we may want to
   // mark as such in order to skip the write barrier, once we have a unified
   // system for weakness. For now we decided to keep it like this because having
   // an initial write barrier backed store makes this pointer strong until the
   // next GC, and allocation sites are designed to survive several GCs anyway.
   assembler->StoreObjectField(site, AllocationSite::kWeakNextOffset, next_site);
   assembler->StoreNoWriteBarrier(MachineRepresentation::kTagged, site_list,
                                  site);
 
   Node* feedback_vector = assembler->Parameter(Descriptor::kVector);
   Node* slot = assembler->Parameter(Descriptor::kSlot);
 
   assembler->StoreFixedArrayElement(feedback_vector, slot, site,
                                     UPDATE_WRITE_BARRIER,
                                     CodeStubAssembler::SMI_PARAMETERS);
 
   assembler->Return(site);
 }
 
+void CreateWeakCellStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+  assembler->Return(assembler->CreateWeakCellInFeedbackVector(
+      assembler->Parameter(Descriptor::kVector),
+      assembler->Parameter(Descriptor::kSlot),
+      assembler->Parameter(Descriptor::kValue)));
+}
+
 void ArrayNoArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* native_context = assembler->LoadObjectField(
       assembler->Parameter(Descriptor::kFunction), JSFunction::kContextOffset);
   bool track_allocation_site =
       AllocationSite::GetMode(elements_kind()) == TRACK_ALLOCATION_SITE &&
       override_mode() != DISABLE_ALLOCATION_SITES;
   Node* allocation_site =
       track_allocation_site ? assembler->Parameter(Descriptor::kAllocationSite)
@@ skipping 148 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8