Use FeedbackVectorSlotKind instead of Code::Kind for type feedback vector.

src/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_H_
 #define V8_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 179 matching lines @@
   Flags& flags() { return flags_; }
   Flags flags() const { return flags_; }
   int node_count() { return node_count_; }
   void add_node_count(int count) { node_count_ += count; }
 
   int slots() const { return spec_.slots(); }
   void increase_slots(int count) { spec_.increase_slots(count); }
 
   int ic_slots() const { return spec_.ic_slots(); }
   void increase_ic_slots(int count) { spec_.increase_ic_slots(count); }
-  void SetKind(int ic_slot, Code::Kind kind) { spec_.SetKind(ic_slot, kind); }
+  void SetKind(int ic_slot, FeedbackVectorSlotKind kind) {
+    spec_.SetKind(ic_slot, kind);
+  }
   const ZoneFeedbackVectorSpec* get_spec() const { return &spec_; }
 
  private:
   Flags flags_;
   int node_count_;
   ZoneFeedbackVectorSpec spec_;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
 
@@ skipping 39 matching lines @@
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) {
     return FeedbackVectorRequirements(0, 0);
   }
   virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { UNREACHABLE(); }
   virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                                       ICSlotCache* cache) {
     UNREACHABLE();
   }
   // Each ICSlot stores a kind of IC which the participating node should know.
-  virtual Code::Kind FeedbackICSlotKind(int index) {
+  virtual FeedbackVectorSlotKind FeedbackICSlotKind(int index) {
     UNREACHABLE();
-    return Code::NUMBER_OF_KINDS;
+    return FeedbackVectorSlotKind::UNUSED;
   }
 
  private:
   // Hidden to prevent accidental usage. It would have to load the
   // current zone from the TLS.
   void* operator new(size_t size);
 
   friend class CaseClause;  // Generates AST IDs.
 
   int position_;
@@ skipping 532 matching lines @@
 
   Expression* each() const { return each_; }
   Expression* subject() const { return subject_; }
 
   FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     each_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override;
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override;
   FeedbackVectorICSlot EachFeedbackSlot() const { return each_slot_; }
 
  protected:
   ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos),
         each_(NULL),
         subject_(NULL),
         each_slot_(FeedbackVectorICSlot::Invalid()) {}
 
  private:
@@ skipping 721 matching lines @@
   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.
   FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override { return Code::STORE_IC; }
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return FeedbackVectorSlotKind::STORE_IC;
+  }
 
   // After feedback slots were assigned, propagate information to the properties
   // which need it.
   void LayoutFeedbackSlots();
 
  protected:
   ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
                 int boilerplate_properties, bool has_function, bool is_strong,
                 int pos)
       : MaterializedLiteral(zone, literal_index, is_strong, pos),
@@ skipping 157 matching lines @@
 
   bool UsesVariableFeedbackSlot() const {
     return var()->IsUnallocated() || var()->IsLookupSlot();
   }
 
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
 
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override;
-  Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return FeedbackVectorSlotKind::LOAD_IC;
+  }
   FeedbackVectorICSlot VariableFeedbackSlot() {
     return variable_feedback_slot_;
   }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BeforeId() const { return BailoutId(local_id(0)); }
 
  protected:
   VariableProxy(Zone* zone, Variable* var, int start_position,
                 int end_position);
@@ skipping 84 matching lines @@
   bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
 
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, 1);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     property_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override {
-    return key()->IsPropertyName() ? Code::LOAD_IC : Code::KEYED_LOAD_IC;
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return key()->IsPropertyName() ? FeedbackVectorSlotKind::LOAD_IC
+                                   : FeedbackVectorSlotKind::KEYED_LOAD_IC;
   }
 
   FeedbackVectorICSlot PropertyFeedbackSlot() const {
     return property_feedback_slot_;
   }
 
   static LhsKind GetAssignType(Property* property) {
     if (property == NULL) return VARIABLE;
     bool super_access = property->IsSuperAccess();
     return (property->key()->IsPropertyName())
@@ skipping 35 matching lines @@
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   // Type feedback information.
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     ic_slot_ = slot;
   }
   void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override { slot_ = slot; }
-  Code::Kind FeedbackICSlotKind(int index) override { return Code::CALL_IC; }
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return FeedbackVectorSlotKind::CALL_IC;
+  }
 
   FeedbackVectorSlot CallFeedbackSlot() const { return slot_; }
 
   FeedbackVectorICSlot CallFeedbackICSlot() const { return ic_slot_; }
 
   SmallMapList* GetReceiverTypes() override {
     if (expression()->IsProperty()) {
       return expression()->AsProperty()->GetReceiverTypes();
     }
     return NULL;
@@ skipping 329 matching lines @@
   TypeFeedbackId CountStoreFeedbackId() const {
     return TypeFeedbackId(local_id(3));
   }
 
   FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override;
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override;
   FeedbackVectorICSlot CountSlot() const { return slot_; }
 
  protected:
   CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
                  int pos)
       : Expression(zone, pos),
         bit_field_(
             IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
             StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
         type_(NULL),
@@ skipping 157 matching lines @@
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
   }
 
   FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override;
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override;
   FeedbackVectorICSlot AssignmentSlot() const { return slot_; }
 
  protected:
   Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
              int pos);
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
@@ skipping 31 matching lines @@
   // Type feedback information.
   bool HasFeedbackSlots() const { return yield_kind() == kDelegating; }
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, HasFeedbackSlots() ? 3 : 0);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     yield_first_feedback_slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override {
-    return index == 0 ? Code::KEYED_LOAD_IC : Code::LOAD_IC;
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return index == 0 ? FeedbackVectorSlotKind::KEYED_LOAD_IC
+                      : FeedbackVectorSlotKind::LOAD_IC;
   }
 
   FeedbackVectorICSlot KeyedLoadFeedbackSlot() {
     DCHECK(!HasFeedbackSlots() || !yield_first_feedback_slot_.IsInvalid());
     return yield_first_feedback_slot_;
   }
 
   FeedbackVectorICSlot DoneFeedbackSlot() {
     return KeyedLoadFeedbackSlot().next();
   }
@@ skipping 253 matching lines @@
   int num_ids() const { return parent_num_ids() + 4 + properties()->length(); }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override;
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     slot_ = slot;
   }
-  Code::Kind FeedbackICSlotKind(int index) override { return Code::STORE_IC; }
+  FeedbackVectorSlotKind FeedbackICSlotKind(int index) override {
+    return FeedbackVectorSlotKind::STORE_IC;
+  }
 
   bool NeedsProxySlot() const {
     return FLAG_vector_stores && scope() != NULL &&
            class_variable_proxy()->var()->IsUnallocated();
   }
 
   FeedbackVectorICSlot ProxySlot() const { return slot_; }
 
   // After feedback slots were assigned, propagate information to the properties
   // which need it.
@@ skipping 966 matching lines @@
   // ZoneObjects which need to persist until scope analysis must be allocated in
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_