[TypeFeedbackVector] Root feedback vectors at function literal site.

src/type-feedback-vector.cc

 // Copyright 2014 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/type-feedback-vector.h"
 
 #include "src/code-stubs.h"
 #include "src/ic/ic-inl.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 103 matching lines @@
     int entry_size = TypeFeedbackMetadata::GetSlotSize(kind);
 
     if (kind != other_spec->GetKind(i)) {
       return true;
     }
     i += entry_size;
   }
   return false;
 }
 
+bool TypeFeedbackMetadata::HasFunctionLiteralSlots() {
+  TypeFeedbackMetadataIterator iter(this);
+  Factory* factory = GetIsolate()->factory();
+  while (iter.HasNext()) {
+    FeedbackVectorSlot slot = iter.Next();
+    FeedbackVectorSlotKind kind = iter.kind();
+    switch (kind) {
+      case FeedbackVectorSlotKind::CREATE_CLOSURE: {
+        return true;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return false;
+}
+
 bool TypeFeedbackMetadata::DiffersFrom(
     const TypeFeedbackMetadata* other_metadata) const {
   if (other_metadata->slot_count() != slot_count()) {
     return true;
   }
 
   int slots = slot_count();
   for (int i = 0; i < slots;) {
     FeedbackVectorSlot slot(i);
     FeedbackVectorSlotKind kind = GetKind(slot);
@@ skipping 57 matching lines @@
   if (length == kReservedIndexCount) {
     return Handle<TypeFeedbackVector>::cast(
         factory->empty_type_feedback_vector());
   }
 
   Handle<FixedArray> array = factory->NewFixedArray(length, TENURED);
   array->set_map_no_write_barrier(isolate->heap()->type_feedback_vector_map());
   array->set(kMetadataIndex, *metadata);
   array->set(kInvocationCountIndex, Smi::kZero);
 
-  DisallowHeapAllocation no_gc;
-
   // Ensure we can skip the write barrier
   Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
+  DCHECK_EQ(isolate->heap()->uninitialized_symbol(), *uninitialized_sentinel);
   Handle<Oddball> undefined_value = factory->undefined_value();
-  DCHECK_EQ(isolate->heap()->uninitialized_symbol(), *uninitialized_sentinel);
   for (int i = 0; i < slot_count;) {
     FeedbackVectorSlot slot(i);
     FeedbackVectorSlotKind kind = metadata->GetKind(slot);
     int index = TypeFeedbackVector::GetIndex(slot);
     int entry_size = TypeFeedbackMetadata::GetSlotSize(kind);
 
-    Object* value;
     Object* extra_value = *uninitialized_sentinel;
     switch (kind) {
       case FeedbackVectorSlotKind::LOAD_GLOBAL_IC:
-        value = isolate->heap()->empty_weak_cell();
+        array->set(index, isolate->heap()->empty_weak_cell(),
+                   SKIP_WRITE_BARRIER);
         break;
       case FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC:
       case FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC:
-        value = Smi::kZero;
+        array->set(index, Smi::kZero, SKIP_WRITE_BARRIER);
         break;
-      case FeedbackVectorSlotKind::CREATE_CLOSURE:
-        // TODO(mvstanton): Root feedback vectors in this location.
-        value = isolate->heap()->empty_type_feedback_vector();
+      case FeedbackVectorSlotKind::CREATE_CLOSURE: {
+        Handle<Cell> cell = factory->NewCell(undefined_value);
+        array->set(index, *cell);
         break;
+      }
       case FeedbackVectorSlotKind::LITERAL:
-        value = *undefined_value;
+        array->set(index, *undefined_value, SKIP_WRITE_BARRIER);
         break;
       case FeedbackVectorSlotKind::CALL_IC:
-        value = *uninitialized_sentinel;
+        array->set(index, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
         extra_value = Smi::kZero;
         break;
       case FeedbackVectorSlotKind::LOAD_IC:
       case FeedbackVectorSlotKind::KEYED_LOAD_IC:
       case FeedbackVectorSlotKind::STORE_IC:
       case FeedbackVectorSlotKind::KEYED_STORE_IC:
       case FeedbackVectorSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC:
       case FeedbackVectorSlotKind::GENERAL:
-        value = *uninitialized_sentinel;
+        array->set(index, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
         break;
 
       case FeedbackVectorSlotKind::INVALID:
       case FeedbackVectorSlotKind::KINDS_NUMBER:
         UNREACHABLE();
-        value = Smi::kZero;
+        array->set(index, Smi::kZero, SKIP_WRITE_BARRIER);
         break;
     }
-    array->set(index, value, SKIP_WRITE_BARRIER);
     for (int j = 1; j < entry_size; j++) {
       array->set(index + j, extra_value, SKIP_WRITE_BARRIER);
     }
     i += entry_size;
   }
   return Handle<TypeFeedbackVector>::cast(array);
 }
 
 // static
 Handle<TypeFeedbackVector> TypeFeedbackVector::Copy(
     Isolate* isolate, Handle<TypeFeedbackVector> vector) {
   Handle<TypeFeedbackVector> result;
   result = Handle<TypeFeedbackVector>::cast(
       isolate->factory()->CopyFixedArray(Handle<FixedArray>::cast(vector)));
   return result;
 }
 
-
 // This logic is copied from
 // StaticMarkingVisitor<StaticVisitor>::VisitCodeTarget.
 static bool ClearLogic(Isolate* isolate) {
   return FLAG_cleanup_code_caches_at_gc && isolate->serializer_enabled();
 }
 
-
 void TypeFeedbackVector::ClearSlotsImpl(SharedFunctionInfo* shared,
                                         bool force_clear) {
   Isolate* isolate = GetIsolate();
   if (!force_clear && !ClearLogic(isolate)) return;
 
   if (this == isolate->heap()->empty_type_feedback_vector()) return;
 
   Object* uninitialized_sentinel =
       TypeFeedbackVector::RawUninitializedSentinel(isolate);
   Oddball* undefined_value = isolate->heap()->undefined_value();
@@ skipping 756 matching lines @@
 void StoreDataPropertyInLiteralICNexus::ConfigureMonomorphic(
     Handle<Name> name, Handle<Map> receiver_map) {
   Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
 
   SetFeedback(*cell);
   SetFeedbackExtra(*name);
 }
 
 }  // namespace internal
 }  // namespace v8