[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 2431 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 94 matching lines @@
   // as the map of the allocated object.
   Node* native_context = assembler->LoadNativeContext(context);
   Node* map_slot_value =
       assembler->LoadFixedArrayElement(native_context, map_index.value(), 0,
                                        CodeStubAssembler::INTPTR_PARAMETERS);
   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);
+  // TODO(mvstanton): Do I need a write barrier here?

[Benedikt Meurer, 2016/12/10 17:20:36]

A write barrier for a load?

[mvstanton, 2016/12/21 13:09:13]

Ach, sorry the todo is for the store of the literals array in the new object
just below. I believe I don't need it.

+  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(
       lazy_builtin,
       assembler->IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
   assembler->StoreObjectFieldNoWriteBarrier(
       result, JSFunction::kCodeEntryOffset, lazy_builtin_entry);
   assembler->StoreObjectFieldNoWriteBarrier(result,
                                             JSFunction::kNextFunctionLinkOffset,
                                             assembler->UndefinedConstant());
 
   return result;
 }
 
 void FastNewClosureStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   CodeStubAssembler assembler(state);
-  assembler.Return(
-      Generate(&assembler, assembler.Parameter(0), assembler.Parameter(1)));
+  if (FLAG_strong_rooted_literals) {
+    assembler.Return(Generate(&assembler, assembler.Parameter(0),
+                              assembler.Parameter(1), assembler.Parameter(2),
+                              assembler.Parameter(3)));
+  } else {
+    assembler.Return(Generate(&assembler, assembler.Parameter(0), NULL, NULL,
+                              assembler.Parameter(1)));
+  }
 }
 
 // static
 compiler::Node* FastNewFunctionContextStub::Generate(
     CodeStubAssembler* assembler, compiler::Node* function,
     compiler::Node* slots, compiler::Node* context) {
   typedef compiler::Node Node;
 
   Node* min_context_slots =
       assembler->Int32Constant(Context::MIN_CONTEXT_SLOTS);
@@ skipping 607 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8