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

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 714 matching lines @@
   }
 
   Expression* each() const { return each_; }
   Expression* subject() const { return subject_; }
 
   void set_each(Expression* e) { each_ = e; }
   void set_subject(Expression* e) { subject_ = e; }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot EachFeedbackSlot() const { return each_slot_; }
   FeedbackVectorSlot ForInFeedbackSlot() {
     DCHECK(!for_in_feedback_slot_.IsInvalid());
     return for_in_feedback_slot_;
   }
 
   enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
   ForInType for_in_type() const { return ForInTypeField::decode(bit_field_); }
   void set_for_in_type(ForInType type) {
@@ skipping 202 matching lines @@
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
   TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
 
   AstType* compare_type() { return compare_type_; }
   void set_compare_type(AstType* type) { compare_type_ = type; }
 
   // CaseClause will have both a slot in the feedback vector and the
   // TypeFeedbackId to record the type information. TypeFeedbackId is used by
   // full codegen and the feedback vector slot is used by interpreter.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot CompareOperationFeedbackSlot() {
     return type_feedback_slot_;
   }
 
  private:
   friend class AstNodeFactory;
 
   static int parent_num_ids() { return Expression::num_ids(); }
@@ skipping 260 matching lines @@
 // Base class for literals that need space in the type feedback vector.
 class MaterializedLiteral : public Expression {
  public:
   int depth() const {
     // only callable after initialization.
     DCHECK(depth_ >= 1);
     return depth_;
   }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
     literal_slot_ = spec->AddLiteralSlot();
   }
 
   FeedbackVectorSlot literal_slot() const { return literal_slot_; }
 
  private:
   int depth_ : 31;
   FeedbackVectorSlot literal_slot_;
 
@@ skipping 197 matching lines @@
   // Return an AST id for a property that is used in simulate instructions.
   BailoutId GetIdForPropertySet(int i) { return BailoutId(local_id(i + 1)); }
 
   // Unlike other AST nodes, this number of bailout IDs allocated for an
   // ObjectLiteral can vary, so num_ids() is not a static method.
   int num_ids() const { return parent_num_ids() + 1 + properties()->length(); }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
  private:
   friend class AstNodeFactory;
 
   ObjectLiteral(ZoneList<Property*>* properties,
                 uint32_t boilerplate_properties, int pos,
                 bool has_rest_property)
       : MaterializedLiteral(pos, kObjectLiteral),
         boilerplate_properties_(boilerplate_properties),
@@ skipping 125 matching lines @@
     first_spread_index_ = -1;
   }
 
   enum Flags {
     kNoFlags = 0,
     kShallowElements = 1,
     kDisableMementos = 1 << 1
   };
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot LiteralFeedbackSlot() const { return literal_slot_; }
 
  private:
   friend class AstNodeFactory;
 
   ArrayLiteral(ZoneList<Expression*>* values, int first_spread_index, int pos)
       : MaterializedLiteral(pos, kArrayLiteral),
         first_spread_index_(first_spread_index),
         values_(values) {}
@@ skipping 58 matching lines @@
   }
 
   // Bind this proxy to the variable var.
   void BindTo(Variable* var);
 
   bool UsesVariableFeedbackSlot() const {
     return var()->IsUnallocated() || var()->IsLookupSlot();
   }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot VariableFeedbackSlot() { return variable_feedback_slot_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BeforeId() const { return BailoutId(local_id(0)); }
   void set_next_unresolved(VariableProxy* next) { next_unresolved_ = next; }
   VariableProxy* next_unresolved() { return next_unresolved_; }
 
  private:
@@ skipping 76 matching lines @@
     bit_field_ = InlineCacheStateField::update(bit_field_, state);
   }
   void mark_for_call() {
     bit_field_ = IsForCallField::update(bit_field_, true);
   }
   bool is_for_call() const { return IsForCallField::decode(bit_field_); }
 
   bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
-    FeedbackVectorSlotKind kind = key()->IsPropertyName()
-                                      ? FeedbackVectorSlotKind::LOAD_IC
-                                      : FeedbackVectorSlotKind::KEYED_LOAD_IC;
-    property_feedback_slot_ = spec->AddSlot(kind);
+    if (key()->IsPropertyName()) {
+      property_feedback_slot_ = spec->AddLoadICSlot();
+    } else {
+      property_feedback_slot_ = spec->AddKeyedLoadICSlot();
+    }
   }
 
   FeedbackVectorSlot PropertyFeedbackSlot() const {
     return property_feedback_slot_;
   }
 
   // Returns the properties assign type.
   static LhsKind GetAssignType(Property* property) {
     if (property == NULL) return VARIABLE;
     bool super_access = property->IsSuperAccess();
@@ skipping 33 matching lines @@
 
 class Call final : public Expression {
  public:
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot CallFeedbackICSlot() const { return ic_slot_; }
 
   SmallMapList* GetReceiverTypes() {
     if (expression()->IsProperty()) {
       return expression()->AsProperty()->GetReceiverTypes();
     }
     return nullptr;
   }
@@ skipping 102 matching lines @@
 
 class CallNew final : public Expression {
  public:
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
     // CallNew stores feedback in the exact same way as Call. We can
     // piggyback on the type feedback infrastructure for calls.
     callnew_feedback_slot_ = spec->AddCallICSlot();
   }
 
   FeedbackVectorSlot CallNewFeedbackSlot() {
     DCHECK(!callnew_feedback_slot_.IsInvalid());
     return callnew_feedback_slot_;
   }
@@ skipping 155 matching lines @@
 
   // The short-circuit logical operations need an AST ID for their
   // right-hand subexpression.
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId RightId() const { return BailoutId(local_id(0)); }
 
   // BinaryOperation will have both a slot in the feedback vector and the
   // TypeFeedbackId to record the type information. TypeFeedbackId is used
   // by full codegen and the feedback vector slot is used by interpreter.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot BinaryOperationFeedbackSlot() const {
     return type_feedback_slot_;
   }
 
   TypeFeedbackId BinaryOperationFeedbackId() const {
     return TypeFeedbackId(local_id(1));
   }
   Maybe<int> fixed_right_arg() const {
@@ skipping 73 matching lines @@
   TypeFeedbackId CountStoreFeedbackId() const {
     return TypeFeedbackId(local_id(3));
   }
 
   // Feedback slot for binary operation is only used by ignition.
   FeedbackVectorSlot CountBinaryOpFeedbackSlot() const {
     return binary_operation_slot_;
   }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot CountSlot() const { return slot_; }
 
  private:
   friend class AstNodeFactory;
 
   CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
       : Expression(pos, kCountOperation), type_(NULL), expression_(expr) {
     bit_field_ |=
         IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
@@ skipping 32 matching lines @@
   TypeFeedbackId CompareOperationFeedbackId() const {
     return TypeFeedbackId(local_id(0));
   }
   AstType* combined_type() const { return combined_type_; }
   void set_combined_type(AstType* type) { combined_type_ = type; }
 
   // CompareOperation will have both a slot in the feedback vector and the
   // TypeFeedbackId to record the type information. TypeFeedbackId is used
   // by full codegen and the feedback vector slot is used by interpreter.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot CompareOperationFeedbackSlot() const {
     return type_feedback_slot_;
   }
 
   // Match special cases.
   bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
   bool IsLiteralCompareUndefined(Expression** expr);
   bool IsLiteralCompareNull(Expression** expr);
@@ skipping 126 matching lines @@
     bit_field_ = IsUninitializedField::update(bit_field_, b);
   }
   void set_key_type(IcCheckType key_type) {
     bit_field_ = KeyTypeField::update(bit_field_, key_type);
   }
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
   }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot AssignmentSlot() const { return slot_; }
 
  private:
   friend class AstNodeFactory;
 
   Assignment(Token::Value op, Expression* target, Expression* value, int pos);
 
   static int parent_num_ids() { return Expression::num_ids(); }
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
@@ skipping 147 matching lines @@
   bool is_declaration() const { return function_type() == kDeclaration; }
   bool is_named_expression() const {
     return function_type() == kNamedExpression;
   }
   bool is_anonymous_expression() const {
     return function_type() == kAnonymousExpression;
   }
   LanguageMode language_mode() const;
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
     literal_feedback_slot_ = spec->AddCreateClosureSlot();
   }
 
   FeedbackVectorSlot LiteralFeedbackSlot() const {
     return literal_feedback_slot_;
   }
 
   static bool NeedsHomeObject(Expression* expr);
 
@@ skipping 196 matching lines @@
   bool has_name_static_property() const {
     return HasNameStaticProperty::decode(bit_field_);
   }
   bool has_static_computed_names() const {
     return HasStaticComputedNames::decode(bit_field_);
   }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache);
 
   bool NeedsProxySlot() const {
     return class_variable_proxy() != nullptr &&
            class_variable_proxy()->var()->IsUnallocated();
   }
 
   FeedbackVectorSlot HomeObjectSlot() const { return home_object_slot_; }
   FeedbackVectorSlot ProxySlot() const { return proxy_slot_; }
 
@@ skipping 31 matching lines @@
 
 class NativeFunctionLiteral final : public Expression {
  public:
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
   FeedbackVectorSlot LiteralFeedbackSlot() const {
     return literal_feedback_slot_;
   }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
     // TODO(mvstanton): The FeedbackVectorSlotCache can be adapted
     // to always return the same slot for this case.
     literal_feedback_slot_ = spec->AddCreateClosureSlot();
   }
 
  private:
   friend class AstNodeFactory;
 
   NativeFunctionLiteral(const AstRawString* name, v8::Extension* extension,
@@ skipping 82 matching lines @@
 // desugars this into a LoadIC / JSLoadNamed, CallIC, and a type-check to
 // validate return value of the Symbol.iterator() call.
 class GetIterator final : public Expression {
  public:
   Expression* iterable() const { return iterable_; }
   void set_iterable(Expression* iterable) { iterable_ = iterable; }
 
   static int num_ids() { return parent_num_ids(); }
 
   void AssignFeedbackVectorSlots(FeedbackVectorSpec* spec,
+                                 LanguageMode language_mode,
                                  FeedbackVectorSlotCache* cache) {
-    iterator_property_feedback_slot_ =
-        spec->AddSlot(FeedbackVectorSlotKind::LOAD_IC);
-    iterator_call_feedback_slot_ =
-        spec->AddSlot(FeedbackVectorSlotKind::CALL_IC);
+    iterator_property_feedback_slot_ = spec->AddLoadICSlot();
+    iterator_call_feedback_slot_ = spec->AddCallICSlot();
   }
 
   FeedbackVectorSlot IteratorPropertyFeedbackSlot() const {
     return iterator_property_feedback_slot_;
   }
 
   FeedbackVectorSlot IteratorCallFeedbackSlot() const {
     return iterator_call_feedback_slot_;
   }
 
@@ skipping 653 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_