Adding a type vector to replace type cells.

src/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 159 matching lines @@
 
 
 enum AstPropertiesFlag {
   kDontInline,
   kDontSelfOptimize,
   kDontSoftInline,
   kDontCache
 };
 
 
+class FeedbackSlotInterface {
+ public:
+  virtual ~FeedbackSlotInterface() {}
+  virtual int GetFeedbackSlotCount(Isolate* isolate) = 0;
+  virtual void SetFirstFeedbackSlot(int slot) = 0;
+};
+
+
 class AstProperties V8_FINAL BASE_EMBEDDED {
  public:
   class Flags : public EnumSet<AstPropertiesFlag, int> {};
 
-  AstProperties() : node_count_(0) { }
+  AstProperties() : node_count_(0), slot_nodes_(NULL), slot_count_(-1) {
+  }
+
+  ZoneList<FeedbackSlotInterface*>* slot_nodes() {
+    ASSERT(slot_count_ == -1);
+    return slot_nodes_;
+  }
+  void set_slot_count(int count) {
+    ASSERT(slot_count_ == -1);
+    slot_count_ = count;
+    slot_nodes_ = NULL;  // We are done with this funny list.
+  }
+
+  // Returns -1 if the work hasn't been done yet.
+  int slot_count() {
+    return slot_count_;
+  }
 
   Flags* flags() { return &flags_; }
   int node_count() { return node_count_; }
   void add_node_count(int count) { node_count_ += count; }
+  void add_slot_node(Zone* zone, FeedbackSlotInterface* slot) {
+    if (slot_nodes_ == NULL) {
+      slot_nodes_ = new(zone) ZoneList<FeedbackSlotInterface*>(10, zone);
+    }
+    slot_nodes_->Add(slot, zone);
+  }
 
  private:
   Flags flags_;
   int node_count_;
+  ZoneList<FeedbackSlotInterface*>* slot_nodes_;
+  int slot_count_;
 };
 
 
 class AstNode: public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum NodeType {
     AST_NODE_LIST(DECLARE_TYPE_ENUM)
     kInvalid = -1
   };
 #undef DECLARE_TYPE_ENUM
 
   void* operator new(size_t size, Zone* zone) {
     return zone->New(static_cast<int>(size));
   }
 
   explicit AstNode(int position): position_(position) {}
   virtual ~AstNode() {}
 
   virtual void Accept(AstVisitor* v) = 0;
   virtual NodeType node_type() const = 0;
   int position() const { return position_; }
 
+  static const int kInvalidFeedbackSlot = -1;
+  virtual FeedbackSlotInterface* SupportsFeedbackSlots() { return NULL; }
+
   // Type testing & conversion functions overridden by concrete subclasses.
 #define DECLARE_NODE_FUNCTIONS(type)                  \
   bool Is##type() { return node_type() == AstNode::k##type; }          \
   type* As##type() { return Is##type() ? reinterpret_cast<type*>(this) : NULL; }
   AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
@@ skipping 681 matching lines @@
         each_(NULL),
         subject_(NULL) {
   }
 
  private:
   Expression* each_;
   Expression* subject_;
 };
 
 
-class ForInStatement V8_FINAL : public ForEachStatement {
+class ForInStatement V8_FINAL : public ForEachStatement,
+    public FeedbackSlotInterface {
  public:
   DECLARE_NODE_TYPE(ForInStatement)
 
   Expression* enumerable() const {
     return subject();
   }
 
-  TypeFeedbackId ForInFeedbackId() const { return reuse(PrepareId()); }
+  // Type feedback information.
+  virtual FeedbackSlotInterface* SupportsFeedbackSlots() { return this; }
+  virtual int GetFeedbackSlotCount(Isolate* isolate) { return 1; }
+  virtual void SetFirstFeedbackSlot(int slot) { for_in_feedback_slot_ = slot; }
+
+  int ForInFeedbackSlot() {
+    ASSERT(for_in_feedback_slot_ != kInvalidFeedbackSlot);
+    return for_in_feedback_slot_;
+  }
+
   enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
   ForInType for_in_type() const { return for_in_type_; }
   void set_for_in_type(ForInType type) { for_in_type_ = type; }
 
   BailoutId BodyId() const { return body_id_; }
   BailoutId PrepareId() const { return prepare_id_; }
   virtual BailoutId ContinueId() const V8_OVERRIDE { return EntryId(); }
   virtual BailoutId StackCheckId() const V8_OVERRIDE { return body_id_; }
 
  protected:
   ForInStatement(Zone* zone, ZoneStringList* labels, int pos)
       : ForEachStatement(zone, labels, pos),
         for_in_type_(SLOW_FOR_IN),
+        for_in_feedback_slot_(kInvalidFeedbackSlot),
         body_id_(GetNextId(zone)),
         prepare_id_(GetNextId(zone)) {
   }
 
   ForInType for_in_type_;
+  int for_in_feedback_slot_;
   const BailoutId body_id_;
   const BailoutId prepare_id_;
 };
 
 
 class ForOfStatement V8_FINAL : public ForEachStatement {
  public:
   DECLARE_NODE_TYPE(ForOfStatement)
 
   void Initialize(Expression* each,
@@ skipping 772 matching lines @@
   const BailoutId load_id_;
 
   SmallMapList receiver_types_;
   bool is_pre_monomorphic_ : 1;
   bool is_uninitialized_ : 1;
   bool is_string_access_ : 1;
   bool is_function_prototype_ : 1;
 };
 
 
-class Call V8_FINAL : public Expression {
+class Call V8_FINAL : public Expression, public FeedbackSlotInterface {
  public:
   DECLARE_NODE_TYPE(Call)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   // Type feedback information.
+  virtual FeedbackSlotInterface* SupportsFeedbackSlots() { return this; }
+  virtual int GetFeedbackSlotCount(Isolate* isolate);
+  virtual void SetFirstFeedbackSlot(int slot) {
+    call_feedback_slot_ = slot;
+  }
+
+  bool HasCallFeedbackSlot() const {
+    return call_feedback_slot_ != kInvalidFeedbackSlot;
+  }
+  int CallFeedbackSlot() const { return call_feedback_slot_; }
+
+  // Type feedback information.
   TypeFeedbackId CallFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual SmallMapList* GetReceiverTypes() V8_OVERRIDE {
     return &receiver_types_;
   }
   virtual bool IsMonomorphic() V8_OVERRIDE { return is_monomorphic_; }
   bool KeyedArrayCallIsHoley() { return keyed_array_call_is_holey_; }
   CheckType check_type() const { return check_type_; }
 
   void set_string_check(Handle<JSObject> holder) {
@@ skipping 50 matching lines @@
   Call(Zone* zone,
        Expression* expression,
        ZoneList<Expression*>* arguments,
        int pos)
       : Expression(zone, pos),
         expression_(expression),
         arguments_(arguments),
         is_monomorphic_(false),
         keyed_array_call_is_holey_(true),
         check_type_(RECEIVER_MAP_CHECK),
+        call_feedback_slot_(kInvalidFeedbackSlot),
         return_id_(GetNextId(zone)) { }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
 
   bool is_monomorphic_;
   bool keyed_array_call_is_holey_;
   CheckType check_type_;
   SmallMapList receiver_types_;
   Handle<JSFunction> target_;
   Handle<JSObject> holder_;
   Handle<Cell> cell_;
+  int call_feedback_slot_;
 
   const BailoutId return_id_;
 };
 
 
-class CallNew V8_FINAL : public Expression {
+class CallNew V8_FINAL : public Expression, public FeedbackSlotInterface {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   // Type feedback information.
+  virtual FeedbackSlotInterface* SupportsFeedbackSlots() { return this; }
+  virtual int GetFeedbackSlotCount(Isolate* isolate) { return 1; }
+  virtual void SetFirstFeedbackSlot(int slot) {
+    callnew_feedback_slot_ = slot;
+  }
+
+  int CallNewFeedbackSlot() {
+    ASSERT(callnew_feedback_slot_ != kInvalidFeedbackSlot);
+    return callnew_feedback_slot_;
+  }
+
   TypeFeedbackId CallNewFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() V8_OVERRIDE { return is_monomorphic_; }
   Handle<JSFunction> target() const { return target_; }
   ElementsKind elements_kind() const { return elements_kind_; }
   Handle<AllocationSite> allocation_site() const {
     return allocation_site_;
   }
 
+  static int feedback_slots() { return 1; }
+
   BailoutId ReturnId() const { return return_id_; }
 
  protected:
   CallNew(Zone* zone,
           Expression* expression,
           ZoneList<Expression*>* arguments,
           int pos)
       : Expression(zone, pos),
         expression_(expression),
         arguments_(arguments),
         is_monomorphic_(false),
         elements_kind_(GetInitialFastElementsKind()),
+        callnew_feedback_slot_(kInvalidFeedbackSlot),
         return_id_(GetNextId(zone)) { }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
 
   bool is_monomorphic_;
   Handle<JSFunction> target_;
   ElementsKind elements_kind_;
   Handle<AllocationSite> allocation_site_;
+  Handle<Cell> allocation_info_cell_;
+  int callnew_feedback_slot_;
 
   const BailoutId return_id_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
 class CallRuntime V8_FINAL : public Expression {
@@ skipping 469 matching lines @@
 
   bool is_generator() {
     return IsGenerator::decode(bitfield_) == kIsGenerator;
   }
 
   int ast_node_count() { return ast_properties_.node_count(); }
   AstProperties::Flags* flags() { return ast_properties_.flags(); }
   void set_ast_properties(AstProperties* ast_properties) {
     ast_properties_ = *ast_properties;
   }
-
+  ZoneList<FeedbackSlotInterface*>* slot_nodes() {
+    return ast_properties_.slot_nodes();
+  }
+  int slot_count() {
+    return ast_properties_.slot_count();
+  }
+  void set_slot_count(int count) {
+    ast_properties_.set_slot_count(count);
+  }
   bool dont_optimize() { return dont_optimize_reason_ != kNoReason; }
   BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
   void set_dont_optimize_reason(BailoutReason reason) {
     dont_optimize_reason_ = reason;
   }
 
  protected:
   FunctionLiteral(Zone* zone,
                   Handle<String> name,
                   Scope* scope,
@@ skipping 503 matching lines @@
                                                                     \
   Zone* zone_;                                                      \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // Construction time visitor.
 
 class AstConstructionVisitor BASE_EMBEDDED {
  public:
-  AstConstructionVisitor() : dont_optimize_reason_(kNoReason) { }
+  explicit AstConstructionVisitor(Zone* zone)
+    : dont_optimize_reason_(kNoReason),

[mvstanton, 2014/01/30 15:13:41]

pass the deferred worker here.

[mvstanton, 2014/01/30 17:37:41]

As it turns out, the AstConstructionVisitor can create/hold the deferred worker
just as it does for AstProperties.

+      zone_(zone) { }
 
   AstProperties* ast_properties() { return &properties_; }
   BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
 
  private:
   template<class> friend class AstNodeFactory;
 
   // Node visitors.
 #define DEF_VISIT(type) \
   void Visit##type(type* node);
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   void increase_node_count() { properties_.add_node_count(1); }
   void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); }
   void set_dont_optimize_reason(BailoutReason reason) {
       dont_optimize_reason_ = reason;
   }
 
+  void AddFeedbackSlotInterface(FeedbackSlotInterface* fsi) {
+    if (fsi != NULL) {
+      properties_.add_slot_node(zone_, fsi);
+    }
+  }
+
   AstProperties properties_;
   BailoutReason dont_optimize_reason_;
+  Zone* zone_;
 };
 
 
 class AstNullVisitor BASE_EMBEDDED {
  public:
+  explicit AstNullVisitor(Zone* zone) {}
+
   // Node visitors.
 #define DEF_VISIT(type) \
   void Visit##type(type* node) {}
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
 
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
 template<class Visitor>
 class AstNodeFactory V8_FINAL BASE_EMBEDDED {
  public:
-  explicit AstNodeFactory(Zone* zone) : zone_(zone) { }
+  explicit AstNodeFactory(Zone* zone)
+    : zone_(zone),
+      visitor_(zone) { }
 
   Visitor* visitor() { return &visitor_; }
 
 #define VISIT_AND_RETURN(NodeType, node) \
   visitor_.Visit##NodeType((node)); \
   return node;
 
   VariableDeclaration* NewVariableDeclaration(VariableProxy* proxy,
                                               VariableMode mode,
                                               Scope* scope,
@@ skipping 384 matching lines @@
 
  private:
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_