[ic] Encode [Keyed]StoreIC's language mode in slot kind instead of code object's flags.

src/ast/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/ast.h"
 
 #include <cmath>  // For isfinite.
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 204 matching lines @@
 
 void VariableProxy::BindTo(Variable* var) {
   DCHECK((is_this() && var->is_this()) || raw_name() == var->raw_name());
   set_var(var);
   set_is_resolved();
   var->set_is_used();
   if (is_assigned()) var->set_maybe_assigned();
 }
 
 void VariableProxy::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                              LanguageMode language_mode,
                                               FeedbackVectorSlotCache* cache) {
   if (UsesVariableFeedbackSlot()) {
     // VariableProxies that point to the same Variable within a function can
     // make their loads from the same IC slot.
     if (var()->IsUnallocated() || var()->mode() == DYNAMIC_GLOBAL) {
       ZoneHashMap::Entry* entry = cache->Get(var());
       if (entry != NULL) {
         variable_feedback_slot_ = FeedbackVectorSlot(
             static_cast<int>(reinterpret_cast<intptr_t>(entry->value)));
         return;
       }
       variable_feedback_slot_ = spec->AddLoadGlobalICSlot();
       cache->Put(var(), variable_feedback_slot_);
     } else {
       variable_feedback_slot_ = spec->AddLoadICSlot();
     }
   }
 }
 
-
 static void AssignVectorSlots(Expression* expr, FeedbackVectorSpec* spec,
+                              LanguageMode language_mode,
                               FeedbackVectorSlot* out_slot) {
   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);
+    if (assign_type == KEYED_PROPERTY) {
+      *out_slot = spec->AddKeyedStoreICSlot(language_mode);
+
+    } else {
+      *out_slot = spec->AddStoreICSlot(language_mode);
+    }
   }
 }
 
 void ForInStatement::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                               LanguageMode language_mode,
                                                FeedbackVectorSlotCache* cache) {
-  AssignVectorSlots(each(), spec, &each_slot_);
+  AssignVectorSlots(each(), spec, language_mode, &each_slot_);
   for_in_feedback_slot_ = spec->AddGeneralSlot();
 }
 
 Assignment::Assignment(Token::Value op, Expression* target, Expression* value,
                        int pos)
     : Expression(pos, kAssignment),
       target_(target),
       value_(value),
       binary_operation_(NULL) {
   bit_field_ |= IsUninitializedField::encode(false) |
                 KeyTypeField::encode(ELEMENT) |
                 StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op);
 }
 
 void Assignment::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                           LanguageMode language_mode,
                                            FeedbackVectorSlotCache* cache) {
-  AssignVectorSlots(target(), spec, &slot_);
+  AssignVectorSlots(target(), spec, language_mode, &slot_);
 }
 
 void CountOperation::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                               LanguageMode language_mode,
                                                FeedbackVectorSlotCache* cache) {
-  AssignVectorSlots(expression(), spec, &slot_);
+  AssignVectorSlots(expression(), spec, language_mode, &slot_);
   // Assign a slot to collect feedback about binary operations. Used only in
   // ignition. Fullcodegen uses AstId to record type feedback.
   binary_operation_slot_ = spec->AddInterpreterBinaryOpICSlot();
 }
 
 
 Token::Value Assignment::binary_op() const {
   switch (op()) {
     case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
     case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
@@ skipping 87 matching lines @@
 }
 
 ClassLiteralProperty::ClassLiteralProperty(Expression* key, Expression* value,
                                            Kind kind, bool is_static,
                                            bool is_computed_name)
     : LiteralProperty(key, value, is_computed_name),
       kind_(kind),
       is_static_(is_static) {}
 
 void ClassLiteral::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                             LanguageMode language_mode,
                                              FeedbackVectorSlotCache* cache) {
   // This logic that computes the number of slots needed for vector store
   // ICs must mirror BytecodeGenerator::VisitClassLiteral.
   if (FunctionLiteral::NeedsHomeObject(constructor())) {
-    home_object_slot_ = spec->AddStoreICSlot();
+    home_object_slot_ = spec->AddStoreICSlot(language_mode);
   }
 
   if (NeedsProxySlot()) {
-    proxy_slot_ = spec->AddStoreICSlot();
+    proxy_slot_ = spec->AddStoreICSlot(language_mode);
   }
 
   for (int i = 0; i < properties()->length(); i++) {
     ClassLiteral::Property* property = properties()->at(i);
     Expression* value = property->value();
     if (FunctionLiteral::NeedsHomeObject(value)) {
-      property->SetSlot(spec->AddStoreICSlot());
+      property->SetSlot(spec->AddStoreICSlot(language_mode));
     }
     property->SetStoreDataPropertySlot(
         spec->AddStoreDataPropertyInLiteralICSlot());
   }
 }
 
 bool ObjectLiteral::Property::IsCompileTimeValue() const {
   return kind_ == CONSTANT ||
       (kind_ == MATERIALIZED_LITERAL &&
        CompileTimeValue::IsCompileTimeValue(value_));
 }
 
 
 void ObjectLiteral::Property::set_emit_store(bool emit_store) {
   emit_store_ = emit_store;
 }
 
 bool ObjectLiteral::Property::emit_store() const { return emit_store_; }
 
 void ObjectLiteral::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                              LanguageMode language_mode,
                                               FeedbackVectorSlotCache* cache) {
-  MaterializedLiteral::AssignFeedbackVectorSlots(spec, cache);
+  MaterializedLiteral::AssignFeedbackVectorSlots(spec, language_mode, cache);
 
   // 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();
     switch (property->kind()) {
       case ObjectLiteral::Property::SPREAD:
       case ObjectLiteral::Property::CONSTANT:
         UNREACHABLE();
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
       // Fall through.
       case ObjectLiteral::Property::COMPUTED:
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (key->IsStringLiteral()) {
           if (property->emit_store()) {
-            property->SetSlot(spec->AddStoreICSlot());
+            property->SetSlot(spec->AddStoreICSlot(language_mode));
             if (FunctionLiteral::NeedsHomeObject(value)) {
-              property->SetSlot(spec->AddStoreICSlot(), 1);
+              property->SetSlot(spec->AddStoreICSlot(language_mode), 1);
             }
           }
           break;
         }
         if (property->emit_store() && FunctionLiteral::NeedsHomeObject(value)) {
-          property->SetSlot(spec->AddStoreICSlot());
+          property->SetSlot(spec->AddStoreICSlot(language_mode));
         }
         break;
       case ObjectLiteral::Property::PROTOTYPE:
         break;
       case ObjectLiteral::Property::GETTER:
         if (property->emit_store() && FunctionLiteral::NeedsHomeObject(value)) {
-          property->SetSlot(spec->AddStoreICSlot());
+          property->SetSlot(spec->AddStoreICSlot(language_mode));
         }
         break;
       case ObjectLiteral::Property::SETTER:
         if (property->emit_store() && FunctionLiteral::NeedsHomeObject(value)) {
-          property->SetSlot(spec->AddStoreICSlot());
+          property->SetSlot(spec->AddStoreICSlot(language_mode));
         }
         break;
     }
   }
 
   for (; property_index < properties()->length(); property_index++) {
     ObjectLiteral::Property* property = properties()->at(property_index);
 
     Expression* value = property->value();
     if (property->kind() != ObjectLiteral::Property::PROTOTYPE) {
       if (FunctionLiteral::NeedsHomeObject(value)) {
-        property->SetSlot(spec->AddStoreICSlot());
+        property->SetSlot(spec->AddStoreICSlot(language_mode));
       }
     }
     property->SetStoreDataPropertySlot(
         spec->AddStoreDataPropertyInLiteralICSlot());
   }
 }
 
 
 void ObjectLiteral::CalculateEmitStore(Zone* zone) {
   const auto GETTER = ObjectLiteral::Property::GETTER;
@@ skipping 278 matching lines @@
   constant_elements_ = literals;
 }
 
 bool ArrayLiteral::IsFastCloningSupported() const {
   return depth() <= 1 &&
          values()->length() <=
              ConstructorBuiltinsAssembler::kMaximumClonedShallowArrayElements;
 }
 
 void ArrayLiteral::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                             LanguageMode language_mode,
                                              FeedbackVectorSlotCache* cache) {
-  MaterializedLiteral::AssignFeedbackVectorSlots(spec, cache);
+  MaterializedLiteral::AssignFeedbackVectorSlots(spec, language_mode, cache);
 
   // This logic that computes the number of slots needed for vector store
   // ics must mirror FullCodeGenerator::VisitArrayLiteral.
   for (int array_index = 0; array_index < values()->length(); array_index++) {
     Expression* subexpr = values()->at(array_index);
     DCHECK(!subexpr->IsSpread());
     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.
-    literal_slot_ = spec->AddKeyedStoreICSlot();
+    literal_slot_ = spec->AddKeyedStoreICSlot(language_mode);
     return;
   }
 }
 
 
 Handle<Object> MaterializedLiteral::GetBoilerplateValue(Expression* expression,
                                                         Isolate* isolate) {
   if (expression->IsLiteral()) {
     return expression->AsLiteral()->value();
   }
@@ skipping 38 matching lines @@
 void BinaryOperation::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
   // TODO(olivf) If this Operation is used in a test context, then the right
   // hand side has a ToBoolean stub and we want to collect the type information.
   // However the GraphBuilder expects it to be on the instruction corresponding
   // to the TestContext, therefore we have to store it here and not on the
   // right hand operand.
   set_to_boolean_types(oracle->ToBooleanTypes(right()->test_id()));
 }
 
 void BinaryOperation::AssignFeedbackVectorSlots(
-    FeedbackVectorSpec* spec, FeedbackVectorSlotCache* cache) {
+    FeedbackVectorSpec* spec, LanguageMode language_mode,
+    FeedbackVectorSlotCache* cache) {
   // Feedback vector slot is only used by interpreter for binary operations.
   // Full-codegen uses AstId to record type feedback.
   switch (op()) {
     // Comma, logical_or and logical_and do not collect type feedback.
     case Token::COMMA:
     case Token::AND:
     case Token::OR:
       return;
     default:
       type_feedback_slot_ = spec->AddInterpreterBinaryOpICSlot();
       return;
   }
 }
 
 static bool IsTypeof(Expression* expr) {
   UnaryOperation* maybe_unary = expr->AsUnaryOperation();
   return maybe_unary != NULL && maybe_unary->op() == Token::TYPEOF;
 }
 
 void CompareOperation::AssignFeedbackVectorSlots(
-    FeedbackVectorSpec* spec, FeedbackVectorSlotCache* cache_) {
+    FeedbackVectorSpec* spec, LanguageMode language_mode,
+    FeedbackVectorSlotCache* cache_) {
   // Feedback vector slot is only used by interpreter for binary operations.
   // Full-codegen uses AstId to record type feedback.
   switch (op()) {
     // instanceof and in do not collect type feedback.
     case Token::INSTANCEOF:
     case Token::IN:
       return;
     default:
       type_feedback_slot_ = spec->AddInterpreterCompareICSlot();
   }
@@ skipping 138 matching lines @@
     PROPERTY_NODE_LIST(GENERATE_CASE)
     CALL_NODE_LIST(GENERATE_CASE)
 #undef GENERATE_CASE
     default:
       UNREACHABLE();
       return false;
   }
 }
 
 void Call::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                     LanguageMode language_mode,
                                      FeedbackVectorSlotCache* cache) {
   ic_slot_ = spec->AddCallICSlot();
 }
 
 Call::CallType Call::GetCallType() const {
   VariableProxy* proxy = expression()->AsVariableProxy();
   if (proxy != NULL) {
     if (proxy->var()->IsUnallocated()) {
       return GLOBAL_CALL;
     } else if (proxy->var()->IsLookupSlot()) {
@@ skipping 19 matching lines @@
 }
 
 CaseClause::CaseClause(Expression* label, ZoneList<Statement*>* statements,
                        int pos)
     : Expression(pos, kCaseClause),
       label_(label),
       statements_(statements),
       compare_type_(AstType::None()) {}
 
 void CaseClause::AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                           LanguageMode language_mode,
                                            FeedbackVectorSlotCache* cache) {
   type_feedback_slot_ = spec->AddInterpreterCompareICSlot();
 }
 
 uint32_t Literal::Hash() {
   return raw_value()->IsString()
              ? raw_value()->AsString()->hash()
              : ComputeLongHash(double_to_uint64(raw_value()->AsNumber()));
 }
 
 
 // static
 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());
 }
 
 const char* CallRuntime::debug_name() {
 #ifdef DEBUG
   return NameForNativeContextIntrinsicIndex(context_index_);
 #else
   return is_jsruntime() ? "(context function)" : function_->name;
 #endif  // DEBUG
 }
 
 }  // namespace internal
 }  // namespace v8