Removing FLAG_vector_ics.

test/cctest/test-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/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/api.h"
 #include "src/debug.h"
 #include "src/execution.h"
@@ skipping 28 matching lines @@
   vector = factory->NewTypeFeedbackVector(&one_slot);
   CHECK_EQ(1, vector->Slots());
   CHECK_EQ(0, vector->ICSlots());
 
   FeedbackVectorSpec one_icslot(0, Code::CALL_IC);
   vector = factory->NewTypeFeedbackVector(&one_icslot);
   CHECK_EQ(0, vector->Slots());
   CHECK_EQ(1, vector->ICSlots());
 
   ZoneFeedbackVectorSpec spec(zone, 3, 5);
-  if (FLAG_vector_ics) {
-    for (int i = 0; i < 5; i++) spec.SetKind(i, Code::CALL_IC);
-  }
+  for (int i = 0; i < 5; i++) spec.SetKind(i, Code::CALL_IC);
   vector = factory->NewTypeFeedbackVector(&spec);
   CHECK_EQ(3, vector->Slots());
   CHECK_EQ(5, vector->ICSlots());
 
   int metadata_length = vector->ic_metadata_length();
-  if (!FLAG_vector_ics) {
-    CHECK_EQ(0, metadata_length);
-  } else {
-    CHECK(metadata_length > 0);
-  }
+  CHECK(metadata_length > 0);
 
   int index = vector->GetIndex(FeedbackVectorSlot(0));
 
   CHECK_EQ(TypeFeedbackVector::kReservedIndexCount + metadata_length, index);
   CHECK(FeedbackVectorSlot(0) == vector->ToSlot(index));
 
   index = vector->GetIndex(FeedbackVectorICSlot(0));
   CHECK_EQ(index,
            TypeFeedbackVector::kReservedIndexCount + metadata_length + 3);
   CHECK(FeedbackVectorICSlot(0) == vector->ToICSlot(index));
   CHECK_EQ(TypeFeedbackVector::kReservedIndexCount + metadata_length + 3 +
                5 * TypeFeedbackVector::elements_per_ic_slot(),
            vector->length());
 }
 
 
 // IC slots need an encoding to recognize what is in there.
 TEST(VectorICMetadata) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  if (!FLAG_vector_ics) {
-    // If FLAG_vector_ics is false, we only store CALL_ICs in the vector, so
-    // there is no need for metadata to describe the slots.
-    return;
-  }
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Zone* zone = isolate->runtime_zone();
 
   ZoneFeedbackVectorSpec spec(zone, 10, 3 * 10);
   // Set metadata.
   for (int i = 0; i < 30; i++) {
     Code::Kind kind;
     if (i % 3 == 0) {
       kind = Code::CALL_IC;
@@ skipping 155 matching lines @@
   CompileRun("f(Array)");
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
   CHECK(nexus.GetFeedback()->IsAllocationSite());
 
   heap->CollectAllGarbage();
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
 }
 
 
 TEST(VectorLoadICStates) {
-  if (i::FLAG_always_opt || !i::FLAG_vector_ics) return;
+  if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "var o = { foo: 3 };"
       "function f(a) { return a.foo; } f(o);");
@@ skipping 33 matching lines @@
   CHECK_EQ(MEGAMORPHIC, nexus.StateFromFeedback());
   CHECK(!nexus.FindFirstMap());
 
   // After a collection, state should not be reset to PREMONOMORPHIC.
   heap->CollectAllGarbage();
   CHECK_EQ(MEGAMORPHIC, nexus.StateFromFeedback());
 }
 
 
 TEST(VectorLoadICSlotSharing) {
-  if (i::FLAG_always_opt || !i::FLAG_vector_ics) return;
+  if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
 
   // Function f has 3 LoadICs, one for each o, but the ICs share the same
   // feedback vector IC slot.
   CompileRun(
       "var o = 10;"
       "function f() {"
       "  var x = o + 10;"
       "  return o + x + o;"
       "}"
       "f();");
   Handle<JSFunction> f = v8::Utils::OpenHandle(
       *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
   // There should be one IC slot.
   Handle<TypeFeedbackVector> feedback_vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
   CHECK_EQ(1, feedback_vector->ICSlots());
   FeedbackVectorICSlot slot(0);
   LoadICNexus nexus(feedback_vector, slot);
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
 }
 
 
 TEST(VectorLoadICOnSmi) {
-  if (i::FLAG_always_opt || !i::FLAG_vector_ics) return;
+  if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "var o = { foo: 3 };"
       "function f(a) { return a.foo; } f(o);");
@@ skipping 35 matching lines @@
   CHECK(number_map_found && o_map_found);
 
   // The degree of polymorphism doesn't change.
   CompileRun("f(100)");
   CHECK_EQ(POLYMORPHIC, nexus.StateFromFeedback());
   MapHandleList maps2;
   nexus.FindAllMaps(&maps2);
   CHECK_EQ(2, maps2.length());
 }
 }