[TypeFeedbackVector] Root feedback vectors at function literal site.

src/debug/liveedit.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/debug/liveedit.h"
 
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
@@ skipping 724 matching lines @@
     if (obj->IsJSFunction()) {
       JSFunction* fun = JSFunction::cast(obj);
       if (fun->code() == *original) fun->ReplaceCode(*substitution);
     } else if (obj->IsSharedFunctionInfo()) {
       SharedFunctionInfo* info = SharedFunctionInfo::cast(obj);
       if (info->code() == *original) info->set_code(*substitution);
     }
   }
 }
 
+// Patch function feedback vector.
+// The feedback vector is a cache for complex object boilerplates and for a
+// native context. We must clean cached values, or if the structure of the
+// vector itself changes we need to allocate a new one.
+class FeedbackVectorFixer {
+ public:
+  static void PatchFeedbackVector(FunctionInfoWrapper* compile_info_wrapper,
+                                  Handle<SharedFunctionInfo> shared_info,
+                                  bool feedback_metadata_changed,
+                                  Isolate* isolate) {
+    int new_literal_count = compile_info_wrapper->GetLiteralCount();
 
-// Patch function literals.
-// Name 'literals' is a misnomer. Rather it's a cache for complex object
-// boilerplates and for a native context. We must clean cached values.
-// Additionally we may need to allocate a new array if number of literals
-// changed.
-class LiteralFixer {
- public:
-  static void PatchLiterals(FunctionInfoWrapper* compile_info_wrapper,
-                            Handle<SharedFunctionInfo> shared_info,
-                            bool feedback_metadata_changed, Isolate* isolate) {
-    int new_literal_count = compile_info_wrapper->GetLiteralCount();
-    int old_literal_count = shared_info->num_literals();
-
-    if (old_literal_count == new_literal_count && !feedback_metadata_changed) {
-      // If literal count didn't change, simply go over all functions
-      // and clear literal arrays.
+    if (!feedback_metadata_changed) {
+      // It's enough to clear the feedback vector in this case.
       ClearValuesVisitor visitor;
       IterateJSFunctions(shared_info, &visitor);
     } else {
-      // When literal count changes, we have to create new array instances.
+      // When feedback metadata changes, we have to create new array instances.
       // Since we cannot create instances when iterating heap, we should first
       // collect all functions and fix their literal arrays.
       Handle<FixedArray> function_instances =
           CollectJSFunctions(shared_info, isolate);
       Handle<TypeFeedbackMetadata> feedback_metadata(
           shared_info->feedback_metadata());
 
       for (int i = 0; i < function_instances->length(); i++) {
         Handle<JSFunction> fun(JSFunction::cast(function_instances->get(i)));
         Handle<TypeFeedbackVector> vector =
             TypeFeedbackVector::New(isolate, feedback_metadata);
-        fun->set_feedback_vector(*vector);
+        fun->feedback_vector_cell()->set_value(*vector);
       }
+    }
 
-      shared_info->set_num_literals(new_literal_count);
-    }
+    shared_info->set_num_literals(new_literal_count);
   }
 
  private:
   // Iterates all function instances in the HEAP that refers to the
   // provided shared_info.
   template<typename Visitor>
   static void IterateJSFunctions(Handle<SharedFunctionInfo> shared_info,
                                  Visitor* visitor) {
     HeapIterator iterator(shared_info->GetHeap());
     for (HeapObject* obj = iterator.next(); obj != NULL;
         obj = iterator.next()) {
       if (obj->IsJSFunction()) {
         JSFunction* function = JSFunction::cast(obj);
         if (function->shared() == *shared_info) {
           visitor->visit(function);
         }
       }
     }
   }
 
+  template <typename Visitor>
+  static void IterateAllJSFunctions(Heap* heap, Visitor* visitor) {

[mvstanton, 2017/02/03 12:16:37]

dead code, remove.

+    HeapIterator iterator(heap);
+    for (HeapObject* obj = iterator.next(); obj != NULL;
+         obj = iterator.next()) {
+      if (obj->IsJSFunction()) {
+        JSFunction* function = JSFunction::cast(obj);
+        visitor->visit(function);
+      }
+    }
+  }
+
   // Finds all instances of JSFunction that refers to the provided shared_info
   // and returns array with them.
   static Handle<FixedArray> CollectJSFunctions(
       Handle<SharedFunctionInfo> shared_info, Isolate* isolate) {
     CountVisitor count_visitor;
     count_visitor.count = 0;
     IterateJSFunctions(shared_info, &count_visitor);
     int size = count_visitor.count;
 
     Handle<FixedArray> result = isolate->factory()->NewFixedArray(size);
     if (size > 0) {
       CollectVisitor collect_visitor(result);
       IterateJSFunctions(shared_info, &collect_visitor);
     }
     return result;
   }
 
   class ClearValuesVisitor {
    public:
     void visit(JSFunction* fun) {
-      TypeFeedbackVector* vector = fun->feedback_vector();
-      vector->ClearSlots(fun->shared());
+      if (fun->feedback_vector_cell()->value()->IsTypeFeedbackVector()) {
+        TypeFeedbackVector* vector = fun->feedback_vector();
+        vector->ClearSlots(fun->shared());
+      }
     }
   };
 
   class CountVisitor {
    public:
     void visit(JSFunction* fun) {
       count++;
     }
     int count;
   };
@@ skipping 103 matching lines @@
       isolate->debug()->RemoveDebugInfoAndClearFromShared(
           handle(shared_info->GetDebugInfo()));
     }
     shared_info->set_scope_info(new_shared_info->scope_info());
     shared_info->set_outer_scope_info(new_shared_info->outer_scope_info());
     shared_info->DisableOptimization(kLiveEdit);
     // Update the type feedback vector, if needed.
     Handle<TypeFeedbackMetadata> new_feedback_metadata(
         new_shared_info->feedback_metadata());
     feedback_metadata_changed =
-        new_feedback_metadata->DiffersFrom(shared_info->feedback_metadata());
+        new_feedback_metadata->DiffersFrom(shared_info->feedback_metadata()) ||
+        new_feedback_metadata->HasFunctionLiteralSlots();
     shared_info->set_feedback_metadata(*new_feedback_metadata);
   }
 
   int start_position = compile_info_wrapper.GetStartPosition();
   int end_position = compile_info_wrapper.GetEndPosition();
   shared_info->set_start_position(start_position);
   shared_info->set_end_position(end_position);
 
-  LiteralFixer::PatchLiterals(&compile_info_wrapper, shared_info,
-                              feedback_metadata_changed, isolate);
+  FeedbackVectorFixer::PatchFeedbackVector(&compile_info_wrapper, shared_info,
+                                           feedback_metadata_changed, isolate);
 
   DeoptimizeDependentFunctions(*shared_info);
   isolate->compilation_cache()->Remove(shared_info);
 }
 
 void LiveEdit::FunctionSourceUpdated(Handle<JSArray> shared_info_array,
                                      int new_function_literal_id) {
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
   Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
@@ skipping 698 matching lines @@
     scope_info_length++;
 
     current_scope = current_scope->outer_scope();
   }
 
   return scope_info_list;
 }
 
 }  // namespace internal
 }  // namespace v8