Removing the Class/ObjectLiteral::LayoutFeedbackSlots().

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 1372 matching lines @@
 
   bool IsCompileTimeValue();
 
   void set_emit_store(bool emit_store);
   bool emit_store();
 
   bool is_static() const { return is_static_; }
   bool is_computed_name() const { return is_computed_name_; }
 
   FeedbackVectorICSlot GetSlot(int offset = 0) const {
-    if (ic_slot_or_count_ == FeedbackVectorICSlot::Invalid().ToInt()) {
-      return FeedbackVectorICSlot::Invalid();
-    }
-    return FeedbackVectorICSlot(ic_slot_or_count_ + offset);
+    if (slot_.IsInvalid()) return slot_;
+    int slot = slot_.ToInt();
+    return FeedbackVectorICSlot(slot + offset);
   }
-
-  int ic_slot_count() const {
-    if (ic_slot_or_count_ == FeedbackVectorICSlot::Invalid().ToInt()) {
-      return 0;
-    }
-    return ic_slot_or_count_;
-  }
+  FeedbackVectorICSlot slot() const { return slot_; }
+  void set_slot(FeedbackVectorICSlot slot) { slot_ = slot; }
 
   void set_receiver_type(Handle<Map> map) { receiver_type_ = map; }
-  void set_ic_slot_count(int count) {
-    // Should only be called once.
-    if (count == 0) {
-      ic_slot_or_count_ = FeedbackVectorICSlot::Invalid().ToInt();
-    } else {
-      ic_slot_or_count_ = count;
-    }
-  }
-
-  int set_base_slot(int slot) {
-    if (ic_slot_count() > 0) {
-      int count = ic_slot_count();
-      ic_slot_or_count_ = slot;
-      return count;
-    }
-    return 0;
-  }
 
  protected:
   friend class AstNodeFactory;
 
   ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
                         bool is_static, bool is_computed_name);
   ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
                         Expression* value, bool is_static,
                         bool is_computed_name);
 
  private:
   Expression* key_;
   Expression* value_;
-  int ic_slot_or_count_;
+  FeedbackVectorICSlot slot_;
   Kind kind_;
   bool emit_store_;
   bool is_static_;
   bool is_computed_name_;
   Handle<Map> receiver_type_;
 };
 
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
@@ skipping 62 matching lines @@
 
   // 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(Isolate* isolate, FeedbackVectorSpec* spec,
                                  ICSlotCache* cache) override;
 
-  // 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),
         properties_(properties),
         boilerplate_properties_(boilerplate_properties),
         fast_elements_(false),
         has_elements_(false),
         may_store_doubles_(false),
@@ skipping 1143 matching lines @@
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  ICSlotCache* cache) override;
 
   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.
-  void LayoutFeedbackSlots();
-
  protected:
   ClassLiteral(Zone* zone, const AstRawString* name, Scope* scope,
                VariableProxy* class_variable_proxy, Expression* extends,
                FunctionLiteral* constructor, ZoneList<Property*>* properties,
                int start_position, int end_position)
       : Expression(zone, start_position),
         raw_name_(name),
         scope_(scope),
         class_variable_proxy_(class_variable_proxy),
         extends_(extends),
@@ skipping 954 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_