Removing FLAG_vector_ics.

src/type-feedback-vector.h

 // 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.
 
 #ifndef V8_TYPE_FEEDBACK_VECTOR_H_
 #define V8_TYPE_FEEDBACK_VECTOR_H_
 
 #include <vector>
 
 #include "src/checks.h"
@@ skipping 11 matching lines @@
   FeedbackVectorSpec() : slots_(0), has_ic_slot_(false) {}
   explicit FeedbackVectorSpec(int slots) : slots_(slots), has_ic_slot_(false) {}
   FeedbackVectorSpec(int slots, Code::Kind ic_slot_kind)
       : slots_(slots), has_ic_slot_(true), ic_kind_(ic_slot_kind) {}
 
   int slots() const { return slots_; }
 
   int ic_slots() const { return has_ic_slot_ ? 1 : 0; }
 
   Code::Kind GetKind(int ic_slot) const {
-    DCHECK(FLAG_vector_ics && has_ic_slot_ && ic_slot == 0);
+    DCHECK(has_ic_slot_ && ic_slot == 0);
     return ic_kind_;
   }
 
  private:
   int slots_;
   bool has_ic_slot_;
   Code::Kind ic_kind_;
 };
 
 
 class ZoneFeedbackVectorSpec {
  public:
   explicit ZoneFeedbackVectorSpec(Zone* zone)
       : slots_(0), ic_slots_(0), ic_slot_kinds_(zone) {}
 
   ZoneFeedbackVectorSpec(Zone* zone, int slots, int ic_slots)
-      : slots_(slots),
-        ic_slots_(ic_slots),
-        ic_slot_kinds_(FLAG_vector_ics ? ic_slots : 0, zone) {}
+      : slots_(slots), ic_slots_(ic_slots), ic_slot_kinds_(ic_slots, zone) {}
 
   int slots() const { return slots_; }
   void increase_slots(int count) { slots_ += count; }
 
   int ic_slots() const { return ic_slots_; }
   void increase_ic_slots(int count) {
     ic_slots_ += count;
-    if (FLAG_vector_ics) ic_slot_kinds_.resize(ic_slots_);
+    ic_slot_kinds_.resize(ic_slots_);
   }
 
   void SetKind(int ic_slot, Code::Kind kind) {
-    DCHECK(FLAG_vector_ics);
     ic_slot_kinds_[ic_slot] = kind;
   }
 
   Code::Kind GetKind(int ic_slot) const {
-    DCHECK(FLAG_vector_ics);
     return static_cast<Code::Kind>(ic_slot_kinds_.at(ic_slot));
   }
 
  private:
   int slots_;
   int ic_slots_;
   ZoneVector<unsigned char> ic_slot_kinds_;
 };
 
 
@@ skipping 14 matching lines @@
   static TypeFeedbackVector* cast(Object* obj) {
     DCHECK(obj->IsTypeFeedbackVector());
     return reinterpret_cast<TypeFeedbackVector*>(obj);
   }
 
   static const int kReservedIndexCount = 3;
   static const int kFirstICSlotIndex = 0;
   static const int kWithTypesIndex = 1;
   static const int kGenericCountIndex = 2;
 
-  static int elements_per_ic_slot() { return FLAG_vector_ics ? 2 : 1; }
+  static int elements_per_ic_slot() { return 2; }
 
   int first_ic_slot_index() const {
     DCHECK(length() >= kReservedIndexCount);
     return Smi::cast(get(kFirstICSlotIndex))->value();
   }
 
   int ic_with_type_info_count() {
     return length() > 0 ? Smi::cast(get(kWithTypesIndex))->value() : 0;
   }
 
@@ skipping 304 matching lines @@
   void ConfigurePolymorphic(Handle<Name> name, MapHandleList* maps,
                             CodeHandleList* handlers);
 
   InlineCacheState StateFromFeedback() const override;
   Name* FindFirstName() const override;
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_H_