[TypeFeedbackVector] Combine the literals array and the feedback vector.

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 146 matching lines @@
     case FeedbackVectorSlotKind::KEYED_STORE_IC:
       return "KEYED_STORE_IC";
     case FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC:
       return "INTERPRETER_BINARYOP_IC";
     case FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC:
       return "INTERPRETER_COMPARE_IC";
     case FeedbackVectorSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC:
       return "STORE_DATA_PROPERTY_IN_LITERAL_IC";
     case FeedbackVectorSlotKind::CREATE_CLOSURE:
       return "CREATE_CLOSURE";
+    case FeedbackVectorSlotKind::LITERAL:
+      return "LITERAL";
     case FeedbackVectorSlotKind::GENERAL:
       return "STUB";
     case FeedbackVectorSlotKind::KINDS_NUMBER:
       break;
   }
   UNREACHABLE();
   return "?";
 }
 
 FeedbackVectorSlotKind TypeFeedbackVector::GetKind(
@@ skipping 18 matching lines @@
   array->set_map_no_write_barrier(isolate->heap()->type_feedback_vector_map());
   array->set(kMetadataIndex, *metadata);
   array->set(kInvocationCountIndex, Smi::kZero);
   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);
 
     if (kind == FeedbackVectorSlotKind::CREATE_CLOSURE) {
-      // TODO(mvstanton): Root literal arrays in this location.
-      array->set(index, *factory->empty_literals_array(), SKIP_WRITE_BARRIER);
+      // TODO(mvstanton): Root feedback vectors in this location.
+      array->set(index, *factory->empty_type_feedback_vector(),
+                 SKIP_WRITE_BARRIER);
     }
     i += entry_size;
   }
 
   DisallowHeapAllocation no_gc;
 
   // Ensure we can skip the write barrier
   Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
+  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;
     if (kind == FeedbackVectorSlotKind::LOAD_GLOBAL_IC) {
       value = isolate->heap()->empty_weak_cell();
     } else if (kind == FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC ||
                kind == FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC) {
       value = Smi::kZero;
+    } else if (kind == FeedbackVectorSlotKind::LITERAL) {
+      value = *undefined_value;
     } else {
       value = *uninitialized_sentinel;
     }
 
     if (kind != FeedbackVectorSlotKind::CREATE_CLOSURE) {
       array->set(index, value, SKIP_WRITE_BARRIER);
       value = kind == FeedbackVectorSlotKind::CALL_IC ? Smi::kZero
                                                       : *uninitialized_sentinel;
       for (int j = 1; j < entry_size; j++) {
         array->set(index + j, value, SKIP_WRITE_BARRIER);
       }
     }
     i += entry_size;
   }
   return Handle<TypeFeedbackVector>::cast(array);
 }
 
-
-// static
-int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec* spec,
-                                         FeedbackVectorSlot slot) {
-  return kReservedIndexCount + slot.ToInt();
-}
-
-
 // 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();
 
   TypeFeedbackMetadataIterator iter(metadata());
   while (iter.HasNext()) {
     FeedbackVectorSlot slot = iter.Next();
     FeedbackVectorSlotKind kind = iter.kind();
 
     Object* obj = Get(slot);
     if (obj != uninitialized_sentinel) {
       switch (kind) {
         case FeedbackVectorSlotKind::CALL_IC: {
@@ skipping 27 matching lines @@
           break;
         }
         case FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC:
         case FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC: {
           DCHECK(Get(slot)->IsSmi());
           // don't clear these smi slots.
           // Set(slot, Smi::kZero);
           break;
         }
         case FeedbackVectorSlotKind::CREATE_CLOSURE: {
-          // Fill the array with undefined.
-          FixedArray* array = FixedArray::cast(Get(slot));
-          for (int i = 1; i < array->length(); i++) {
-            array->set_undefined(i);
-          }
           break;
         }
         case FeedbackVectorSlotKind::GENERAL: {
           if (obj->IsHeapObject()) {
             InstanceType instance_type =
                 HeapObject::cast(obj)->map()->instance_type();
             // AllocationSites are exempt from clearing. They don't store Maps
             // or Code pointers which can cause memory leaks if not cleared
             // regularly.
             if (instance_type != ALLOCATION_SITE_TYPE) {
               Set(slot, uninitialized_sentinel, SKIP_WRITE_BARRIER);
             }
           }
           break;
         }
+        case FeedbackVectorSlotKind::LITERAL: {
+          Set(slot, undefined_value, SKIP_WRITE_BARRIER);
+          break;
+        }
         case FeedbackVectorSlotKind::STORE_DATA_PROPERTY_IN_LITERAL_IC: {
           StoreDataPropertyInLiteralICNexus nexus(this, slot);
           nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::INVALID:
         case FeedbackVectorSlotKind::KINDS_NUMBER:
           UNREACHABLE();
           break;
       }
@@ skipping 680 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