Link type feedback vectors to the shared function info.

src/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/feedback-vector.h"
 #include "src/code-stubs.h"
 #include "src/feedback-vector-inl.h"
 #include "src/ic/ic-inl.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 143 matching lines @@
   return "?";
 }
 
 FeedbackSlotKind FeedbackVector::GetKind(FeedbackSlot slot) const {
   DCHECK(!is_empty());
   return metadata()->GetKind(slot);
 }
 
 // static
 Handle<FeedbackVector> FeedbackVector::New(Isolate* isolate,
-                                           Handle<FeedbackMetadata> metadata) {
+                                           Handle<SharedFunctionInfo> shared) {
   Factory* factory = isolate->factory();
 
-  const int slot_count = metadata->slot_count();
+  const int slot_count = shared->feedback_metadata()->slot_count();
   const int length = slot_count + kReservedIndexCount;
-  if (length == kReservedIndexCount) {
-    return Handle<FeedbackVector>::cast(factory->empty_feedback_vector());
-  }
 
   Handle<FixedArray> array = factory->NewFixedArray(length, TENURED);
   array->set_map_no_write_barrier(isolate->heap()->feedback_vector_map());
-  array->set(kMetadataIndex, *metadata);
+  array->set(kSharedFunctionInfoIndex, *shared);
   array->set(kInvocationCountIndex, Smi::kZero);
 
   // 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();
   for (int i = 0; i < slot_count;) {
     FeedbackSlot slot(i);
-    FeedbackSlotKind kind = metadata->GetKind(slot);
+    FeedbackSlotKind kind = shared->feedback_metadata()->GetKind(slot);
     int index = FeedbackVector::GetIndex(slot);
     int entry_size = FeedbackMetadata::GetSlotSize(kind);
 
     Object* extra_value = *uninitialized_sentinel;
     switch (kind) {
       case FeedbackSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC:
       case FeedbackSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC:
         array->set(index, isolate->heap()->empty_weak_cell(),
                    SKIP_WRITE_BARRIER);
         break;
@@ skipping 51 matching lines @@
 // StaticMarkingVisitor<StaticVisitor>::VisitCodeTarget.
 static bool ClearLogic(Isolate* isolate) {
   return FLAG_cleanup_code_caches_at_gc && isolate->serializer_enabled();
 }
 
 void FeedbackVector::ClearSlotsImpl(SharedFunctionInfo* shared,
                                     bool force_clear) {
   Isolate* isolate = GetIsolate();
   if (!force_clear && !ClearLogic(isolate)) return;
 
-  if (this == isolate->heap()->empty_feedback_vector()) return;
-
   Object* uninitialized_sentinel =
       FeedbackVector::RawUninitializedSentinel(isolate);
   Oddball* undefined_value = isolate->heap()->undefined_value();
 
   FeedbackMetadataIterator iter(metadata());
   while (iter.HasNext()) {
     FeedbackSlot slot = iter.Next();
     FeedbackSlotKind kind = iter.kind();
 
     Object* obj = Get(slot);
@@ skipping 729 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