VectorICs: Remove --vector-stores flag.

src/code-stubs.h

 // Copyright 2012 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_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 26 matching lines @@
   V(JSEntry)                                \
   V(KeyedLoadICTrampoline)                  \
   V(LoadICTrampoline)                       \
   V(CallICTrampoline)                       \
   V(LoadIndexedInterceptor)                 \
   V(LoadIndexedString)                      \
   V(MathPow)                                \
   V(ProfileEntryHook)                       \
   V(RecordWrite)                            \
   V(RegExpExec)                             \
-  V(StoreArrayLiteralElement)               \
   V(StoreBufferOverflow)                    \
   V(StoreElement)                           \
   V(StringCompare)                          \
   V(StubFailureTrampoline)                  \
   V(SubString)                              \
   V(ToNumber)                               \
   V(ToLength)                               \
   V(ToString)                               \
   V(ToObject)                               \
   V(VectorStoreICTrampoline)                \
@@ skipping 1167 matching lines @@
 
   static Register NameRegister() {
     return StoreTransitionDescriptor::NameRegister();
   }
 
   static Register ValueRegister() {
     return StoreTransitionDescriptor::ValueRegister();
   }
 
   static Register SlotRegister() {
-    DCHECK(FLAG_vector_stores);
     return VectorStoreTransitionDescriptor::SlotRegister();
   }
 
   static Register VectorRegister() {
-    DCHECK(FLAG_vector_stores);
     return VectorStoreTransitionDescriptor::VectorRegister();
   }
 
   static Register MapRegister() {
-    if (FLAG_vector_stores) {
-      return VectorStoreTransitionDescriptor::MapRegister();
-    }
-    return StoreTransitionDescriptor::MapRegister();
+    return VectorStoreTransitionDescriptor::MapRegister();
   }
 
   static int ReceiverIndex() {
     return StoreTransitionDescriptor::kReceiverIndex;
   }
 
   static int NameIndex() { return StoreTransitionDescriptor::kReceiverIndex; }
 
   static int ValueIndex() { return StoreTransitionDescriptor::kValueIndex; }
 
   static int MapIndex() {
     DCHECK(static_cast<int>(VectorStoreTransitionDescriptor::kMapIndex) ==
            static_cast<int>(StoreTransitionDescriptor::kMapIndex));
     return StoreTransitionDescriptor::kMapIndex;
   }
 
   static int VectorIndex() {
-    DCHECK(FLAG_vector_stores);
     if (HasVirtualSlotArg()) {
       return VectorStoreTransitionDescriptor::kVirtualSlotVectorIndex;
     }
     return VectorStoreTransitionDescriptor::kVectorIndex;
   }
 
   // Some platforms don't have a slot arg.
   static bool HasVirtualSlotArg() {
-    if (!FLAG_vector_stores) return false;
     return SlotRegister().is(no_reg);
   }
 };
 
 
 class StoreTransitionStub : public HandlerStub {
  public:
   enum StoreMode {
     StoreMapOnly,
     StoreMapAndValue,
@@ skipping 1273 matching lines @@
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
   KeyedAccessStoreMode store_mode() const {
     return CommonStoreModeBits::decode(sub_minor_key());
   }
 
   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
-    if (FLAG_vector_stores) {
-      return VectorStoreICDescriptor(isolate());
-    }
-    return StoreDescriptor(isolate());
+    return VectorStoreICDescriptor(isolate());
   }
 
   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
 
  private:
   class ElementsKindBits : public BitField<ElementsKind, 3, 8> {};
   class IsJSArrayBits : public BitField<bool, 11, 1> {};
 
   DEFINE_HYDROGEN_CODE_STUB(StoreFastElement, HydrogenCodeStub);
 };
@@ skipping 230 matching lines @@
 class StoreElementStub : public PlatformCodeStub {
  public:
   StoreElementStub(Isolate* isolate, ElementsKind elements_kind,
                    KeyedAccessStoreMode mode)
       : PlatformCodeStub(isolate) {
     minor_key_ = ElementsKindBits::encode(elements_kind) |
                  CommonStoreModeBits::encode(mode);
   }
 
   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
-    if (FLAG_vector_stores) {
-      return VectorStoreICDescriptor(isolate());
-    }
-    return StoreDescriptor(isolate());
+    return VectorStoreICDescriptor(isolate());
   }
 
   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
 
  private:
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(minor_key_);
   }
 
   class ElementsKindBits : public BitField<ElementsKind, 3, 8> {};
@@ skipping 117 matching lines @@
 
  private:
   class FromBits : public BitField<ElementsKind, 3, 8> {};
   class ToBits : public BitField<ElementsKind, 11, 8> {};
   class IsJSArrayBits : public BitField<bool, 19, 1> {};
 
   DEFINE_HYDROGEN_CODE_STUB(ElementsTransitionAndStore, HydrogenCodeStub);
 };
 
 
-class StoreArrayLiteralElementStub : public PlatformCodeStub {
- public:
-  explicit StoreArrayLiteralElementStub(Isolate* isolate)
-      : PlatformCodeStub(isolate) { }
-
-  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreArrayLiteralElement);
-  DEFINE_PLATFORM_CODE_STUB(StoreArrayLiteralElement, PlatformCodeStub);
-};
-
-
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   StubFailureTrampolineStub(Isolate* isolate, StubFunctionMode function_mode)
       : PlatformCodeStub(isolate) {
     minor_key_ = FunctionModeField::encode(function_mode);
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
@@ skipping 110 matching lines @@
 #undef DEFINE_HYDROGEN_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE
 
 extern Representation RepresentationFromType(Type* type);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CODE_STUBS_H_