Distinction between FeedbackVectorICSlot and FeedbackVectorSlot eliminated.

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 22 matching lines @@
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/heap/gc-tracer.h"
 #include "src/ic/ic.h"
 #include "src/macro-assembler.h"
 #include "src/snapshot/snapshot.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap-tester.h"
+#include "test/cctest/test-feedback-vector.h"
 
 using v8::Just;
 
 namespace v8 {
 namespace internal {
 
 static void CheckMap(Map* map, int type, int instance_size) {
   CHECK(map->IsHeapObject());
 #ifdef DEBUG
   CHECK(CcTest::heap()->Contains(map));
@@ skipping 3601 matching lines @@
   CcTest::global()->Set(v8_str("fun1"), fun1);
   CcTest::global()->Set(v8_str("fun2"), fun2);
   CompileRun("function f(a, b) { a(); b(); } f(fun1, fun2);");
 
   Handle<JSFunction> f =
       v8::Utils::OpenHandle(
           *v8::Handle<v8::Function>::Cast(
               CcTest::global()->Get(v8_str("f"))));
 
   Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+  FeedbackVectorHelper feedback_helper(feedback_vector);
 
   int expected_slots = 2;
-  CHECK_EQ(expected_slots, feedback_vector->ICSlots());
+  CHECK_EQ(expected_slots, feedback_helper.slot_count());
   int slot1 = 0;
   int slot2 = 1;
-  CHECK(feedback_vector->Get(FeedbackVectorICSlot(slot1))->IsWeakCell());
-  CHECK(feedback_vector->Get(FeedbackVectorICSlot(slot2))->IsWeakCell());
+  CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakCell());
+  CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakCell());
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
-  CHECK(!WeakCell::cast(feedback_vector->Get(FeedbackVectorICSlot(slot1)))
+  CHECK(!WeakCell::cast(feedback_vector->Get(feedback_helper.slot(slot1)))
              ->cleared());
-  CHECK(!WeakCell::cast(feedback_vector->Get(FeedbackVectorICSlot(slot2)))
+  CHECK(!WeakCell::cast(feedback_vector->Get(feedback_helper.slot(slot2)))
              ->cleared());
 }
 
 
 static Code* FindFirstIC(Code* code, Code::Kind kind) {
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
              RelocInfo::ModeMask(RelocInfo::CONSTRUCT_CALL) |
              RelocInfo::ModeMask(RelocInfo::CODE_TARGET_WITH_ID);
   for (RelocIterator it(code, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     Code* target = Code::GetCodeFromTargetAddress(info->target_address());
     if (target->is_inline_cache_stub() && target->kind() == kind) {
       return target;
     }
   }
   return NULL;
 }
 
 
-static void CheckVectorIC(Handle<JSFunction> f, int ic_slot_index,
+static void CheckVectorIC(Handle<JSFunction> f, int slot_index,
                           InlineCacheState desired_state) {
   Handle<TypeFeedbackVector> vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector());
-  FeedbackVectorICSlot slot(ic_slot_index);
+  FeedbackVectorHelper helper(vector);
+  FeedbackVectorSlot slot = helper.slot(slot_index);
   if (vector->GetKind(slot) == FeedbackVectorSlotKind::LOAD_IC) {
     LoadICNexus nexus(vector, slot);
     CHECK(nexus.StateFromFeedback() == desired_state);
   } else {
     CHECK_EQ(FeedbackVectorSlotKind::KEYED_LOAD_IC, vector->GetKind(slot));
     KeyedLoadICNexus nexus(vector, slot);
     CHECK(nexus.StateFromFeedback() == desired_state);
   }
 }
 
 
-static void CheckVectorICCleared(Handle<JSFunction> f, int ic_slot_index) {
+static void CheckVectorICCleared(Handle<JSFunction> f, int slot_index) {
   Handle<TypeFeedbackVector> vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector());
-  FeedbackVectorICSlot slot(ic_slot_index);
+  FeedbackVectorSlot slot(slot_index);
   LoadICNexus nexus(vector, slot);
   CHECK(IC::IsCleared(&nexus));
 }
 
 
 TEST(ICInBuiltInIsClearedAppropriately) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<JSFunction> apply;
   {
     LocalContext env;
     v8::Local<v8::Value> res = CompileRun("Function.apply");
     Handle<JSObject> maybe_apply =
         v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
     apply = Handle<JSFunction>::cast(maybe_apply);
-    TypeFeedbackVector* vector = apply->shared()->feedback_vector();
-    CHECK(vector->ICSlots() == 1);
+    Handle<TypeFeedbackVector> vector(apply->shared()->feedback_vector());
+    FeedbackVectorHelper feedback_helper(vector);
+    CHECK_EQ(1, feedback_helper.slot_count());
     CheckVectorIC(apply, 0, UNINITIALIZED);
     CompileRun(
         "function b(a1, a2, a3) { return a1 + a2 + a3; }"
         "function fun(bar) { bar.apply({}, [1, 2, 3]); };"
         "fun(b); fun(b)");
     CheckVectorIC(apply, 0, MONOMORPHIC);
   }
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
@@ skipping 1487 matching lines @@
 
 Handle<JSFunction> GetFunctionByName(Isolate* isolate, const char* name) {
   Handle<String> str = isolate->factory()->InternalizeUtf8String(name);
   Handle<Object> obj =
       Object::GetProperty(isolate->global_object(), str).ToHandleChecked();
   return Handle<JSFunction>::cast(obj);
 }
 
 
 void CheckIC(Code* code, Code::Kind kind, SharedFunctionInfo* shared,
-             int ic_slot, InlineCacheState state) {
+             int slot_index, InlineCacheState state) {
   if (kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC ||
       kind == Code::CALL_IC) {
     TypeFeedbackVector* vector = shared->feedback_vector();
-    FeedbackVectorICSlot slot(ic_slot);
+    FeedbackVectorSlot slot(slot_index);
     if (kind == Code::LOAD_IC) {
       LoadICNexus nexus(vector, slot);
       CHECK_EQ(nexus.StateFromFeedback(), state);
     } else if (kind == Code::KEYED_LOAD_IC) {
       KeyedLoadICNexus nexus(vector, slot);
       CHECK_EQ(nexus.StateFromFeedback(), state);
     } else if (kind == Code::CALL_IC) {
       CallICNexus nexus(vector, slot);
       CHECK_EQ(nexus.StateFromFeedback(), state);
     }
@@ skipping 1102 matching lines @@
     for (HeapObject* obj = it.next(); obj != NULL; obj = it.next()) {
       if (!obj->IsSharedFunctionInfo()) continue;
       // Shared function infos without a script (API functions or C++ builtins)
       // are not returned by the iterator because they are not created from a
       // script. They are not interesting for type feedback vector anyways.
 
       // TODO(mvstanton): There are builtins that use type feedback vectors,
       // consider adding these to the iterator.
       SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
       if (shared->script()->IsUndefined()) {
-        CHECK(shared->native() || 0 == shared->feedback_vector()->ICSlots());
+        CHECK(shared->native() || shared->feedback_vector()->is_empty());
       } else {
         sfi_count++;
       }
     }
   }
 
   {
     SharedFunctionInfo::Iterator iterator(isolate);
     while (iterator.Next()) sfi_count--;
   }
@@ skipping 31 matching lines @@
   // The CollectGarbage call above starts sweeper threads.
   // The crash will happen if the following two functions
   // are called before sweeping finishes.
   heap->StartIncrementalMarking();
   heap->FinalizeIncrementalMarkingIfComplete("test");
 }
 
 
 }  // namespace internal
 }  // namespace v8