VectorICs: Remove --vector-stores flag.

src/ast.cc

 // 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.
 
 #include "src/ast.h"
 
 #include <cmath>  // For isfinite.
 #include "src/builtins.h"
 #include "src/code-stubs.h"
 #include "src/contexts.h"
@@ skipping 102 matching lines @@
     variable_feedback_slot_ = spec->AddLoadICSlot();
     if (var()->IsUnallocated()) {
       cache->Put(var(), variable_feedback_slot_);
     }
   }
 }
 
 
 static void AssignVectorSlots(Expression* expr, FeedbackVectorSpec* spec,
                               FeedbackVectorSlot* out_slot) {
-  if (FLAG_vector_stores) {
-    Property* property = expr->AsProperty();
-    LhsKind assign_type = Property::GetAssignType(property);
-    if ((assign_type == VARIABLE &&
-         expr->AsVariableProxy()->var()->IsUnallocated()) ||
-        assign_type == NAMED_PROPERTY || assign_type == KEYED_PROPERTY) {
-      // TODO(ishell): consider using ICSlotCache for variables here.
-      FeedbackVectorSlotKind kind = assign_type == KEYED_PROPERTY
-                                        ? FeedbackVectorSlotKind::KEYED_STORE_IC
-                                        : FeedbackVectorSlotKind::STORE_IC;
-      *out_slot = spec->AddSlot(kind);
-    }
+  Property* property = expr->AsProperty();
+  LhsKind assign_type = Property::GetAssignType(property);
+  if ((assign_type == VARIABLE &&
+       expr->AsVariableProxy()->var()->IsUnallocated()) ||
+      assign_type == NAMED_PROPERTY || assign_type == KEYED_PROPERTY) {
+    // TODO(ishell): consider using ICSlotCache for variables here.
+    FeedbackVectorSlotKind kind = assign_type == KEYED_PROPERTY
+                                      ? FeedbackVectorSlotKind::KEYED_STORE_IC
+                                      : FeedbackVectorSlotKind::STORE_IC;
+    *out_slot = spec->AddSlot(kind);
   }
 }
 
 
 void ForEachStatement::AssignFeedbackVectorSlots(
     Isolate* isolate, FeedbackVectorSpec* spec,
     FeedbackVectorSlotCache* cache) {
   AssignVectorSlots(each(), spec, &each_slot_);
 }
 
@@ skipping 104 matching lines @@
     kind_ = CONSTANT;
   } else {
     kind_ = COMPUTED;
   }
 }
 
 
 void ClassLiteral::AssignFeedbackVectorSlots(Isolate* isolate,
                                              FeedbackVectorSpec* spec,
                                              FeedbackVectorSlotCache* cache) {
-  if (!FLAG_vector_stores) return;
-
   // This logic that computes the number of slots needed for vector store
   // ICs must mirror FullCodeGenerator::VisitClassLiteral.
   if (NeedsProxySlot()) {
     slot_ = spec->AddStoreICSlot();
   }
 
   for (int i = 0; i < properties()->length(); i++) {
     ObjectLiteral::Property* property = properties()->at(i);
     Expression* value = property->value();
     if (FunctionLiteral::NeedsHomeObject(value)) {
@@ skipping 16 matching lines @@
 
 
 bool ObjectLiteral::Property::emit_store() {
   return emit_store_;
 }
 
 
 void ObjectLiteral::AssignFeedbackVectorSlots(Isolate* isolate,
                                               FeedbackVectorSpec* spec,
                                               FeedbackVectorSlotCache* cache) {
-  if (!FLAG_vector_stores) return;
-
   // This logic that computes the number of slots needed for vector store
   // ics must mirror FullCodeGenerator::VisitObjectLiteral.
   int property_index = 0;
   for (; property_index < properties()->length(); property_index++) {
     ObjectLiteral::Property* property = properties()->at(property_index);
     if (property->is_computed_name()) break;
     if (property->IsCompileTimeValue()) continue;
 
     Literal* key = property->key()->AsLiteral();
     Expression* value = property->value();
@@ skipping 234 matching lines @@
 
   constant_elements_ = literals;
   set_is_simple(is_simple);
   set_depth(depth_acc);
 }
 
 
 void ArrayLiteral::AssignFeedbackVectorSlots(Isolate* isolate,
                                              FeedbackVectorSpec* spec,
                                              FeedbackVectorSlotCache* cache) {
-  if (!FLAG_vector_stores) return;
-
   // This logic that computes the number of slots needed for vector store
   // ics must mirror FullCodeGenerator::VisitArrayLiteral.
   int array_index = 0;
   for (; array_index < values()->length(); array_index++) {
     Expression* subexpr = values()->at(array_index);
     if (subexpr->IsSpread()) break;
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
 
     // We'll reuse the same literal slot for all of the non-constant
     // subexpressions that use a keyed store IC.
@@ skipping 149 matching lines @@
 void Expression::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
   set_to_boolean_types(oracle->ToBooleanTypes(test_id()));
 }
 
 
 bool Call::IsUsingCallFeedbackICSlot(Isolate* isolate) const {
   CallType call_type = GetCallType(isolate);
   if (call_type == POSSIBLY_EVAL_CALL) {
     return false;
   }
-  if (call_type == SUPER_CALL && !FLAG_vector_stores) {
-    return false;
-  }
   return true;
 }
 
 
 bool Call::IsUsingCallFeedbackSlot(Isolate* isolate) const {
   // SuperConstructorCall uses a CallConstructStub, which wants
   // a Slot, in addition to any IC slots requested elsewhere.
   return GetCallType(isolate) == SUPER_CALL;
 }
 
@@ skipping 415 matching lines @@
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 
 }  // namespace internal
 }  // namespace v8