[TypeFeedbackVector] Root literal arrays in function literals slots

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 2420 matching lines @@
     assembler.Goto(&end);
   }
 
   assembler.Bind(&end);
   assembler.Return(var_result.value());
 }
 
 // static
 compiler::Node* FastNewClosureStub::Generate(CodeStubAssembler* assembler,
                                              compiler::Node* shared_info,
+                                             compiler::Node* feedback_vector,
+                                             compiler::Node* slot,
                                              compiler::Node* context) {
   typedef compiler::Node Node;
   typedef compiler::CodeAssembler::Label Label;
   typedef compiler::CodeAssembler::Variable Variable;
 
   Isolate* isolate = assembler->isolate();
   Factory* factory = assembler->isolate()->factory();
   assembler->IncrementCounter(isolate->counters()->fast_new_closure_total(), 1);
 
   // Create a new closure from the given function info in new space
@@ skipping 93 matching lines @@
   // Get the function map in the current native context and set that
   // as the map of the allocated object.
   Node* native_context = assembler->LoadNativeContext(context);
   Node* map_slot_value =
       assembler->LoadFixedArrayElement(native_context, map_index.value());
   assembler->StoreMapNoWriteBarrier(result, map_slot_value);
 
   // Initialize the rest of the function.
   Node* empty_fixed_array =
       assembler->HeapConstant(factory->empty_fixed_array());
-  Node* empty_literals_array =
-      assembler->HeapConstant(factory->empty_literals_array());
   assembler->StoreObjectFieldNoWriteBarrier(result, JSObject::kPropertiesOffset,
                                             empty_fixed_array);
   assembler->StoreObjectFieldNoWriteBarrier(result, JSObject::kElementsOffset,
                                             empty_fixed_array);
+  Node* literals_array = assembler->LoadFixedArrayElement(
+      feedback_vector, slot, 0, CodeStubAssembler::SMI_PARAMETERS);
   assembler->StoreObjectFieldNoWriteBarrier(result, JSFunction::kLiteralsOffset,
-                                            empty_literals_array);
+                                            literals_array);
   assembler->StoreObjectFieldNoWriteBarrier(
       result, JSFunction::kPrototypeOrInitialMapOffset,
       assembler->TheHoleConstant());
   assembler->StoreObjectFieldNoWriteBarrier(
       result, JSFunction::kSharedFunctionInfoOffset, shared_info);
   assembler->StoreObjectFieldNoWriteBarrier(result, JSFunction::kContextOffset,
                                             context);
   Handle<Code> lazy_builtin_handle(
       assembler->isolate()->builtins()->builtin(Builtins::kCompileLazy));
   Node* lazy_builtin = assembler->HeapConstant(lazy_builtin_handle);
   Node* lazy_builtin_entry = assembler->IntPtrAdd(
       assembler->BitcastTaggedToWord(lazy_builtin),
       assembler->IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
   assembler->StoreObjectFieldNoWriteBarrier(
       result, JSFunction::kCodeEntryOffset, lazy_builtin_entry,
       MachineType::PointerRepresentation());
   assembler->StoreObjectFieldNoWriteBarrier(result,
                                             JSFunction::kNextFunctionLinkOffset,
                                             assembler->UndefinedConstant());
 
   return result;
 }
 
 void FastNewClosureStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
+  CodeStubAssembler assembler(state);
   typedef compiler::Node Node;
-  CodeStubAssembler assembler(state);
   Node* shared = assembler.Parameter(Descriptor::kSharedFunctionInfo);
   Node* context = assembler.Parameter(Descriptor::kContext);
-  assembler.Return(Generate(&assembler, shared, context));
+  Node* vector = assembler.Parameter(Descriptor::kVector);
+  Node* slot = assembler.Parameter(Descriptor::kSlot);
+  assembler.Return(Generate(&assembler, shared, vector, slot, context));
 }
 
 // static
 int FastNewFunctionContextStub::MaximumSlots() {
   return FLAG_test_small_max_function_context_stub_size ? kSmallMaximumSlots
                                                         : kMaximumSlots;
 }
 
 // static
 compiler::Node* FastNewFunctionContextStub::Generate(
@@ skipping 621 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8