[TypeFeedbackVector] Root literal arrays in function literals slots

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 2551 matching lines @@
   int SourceSize() const { return end_position() - start_position(); }
   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(Isolate* isolate, FeedbackVectorSpec* spec,
+                                 FeedbackVectorSlotCache* cache) {
+    if (FLAG_strong_rooted_literals) {
+      literal_feedback_slot_ =
+          spec->AddCreateClosureSlot(materialized_literal_count_ + 1);
+    } else {
+      literal_feedback_slot_ = FeedbackVectorSlot::Invalid();
+    }
+  }
+
+  FeedbackVectorSlot LiteralFeedbackSlot() const {
+    return literal_feedback_slot_;
+  }
+
   static bool NeedsHomeObject(Expression* expr);
 
   int materialized_literal_count() { return materialized_literal_count_; }
   int expected_property_count() { return expected_property_count_; }
   int parameter_count() { return parameter_count_; }
   int function_length() { return function_length_; }
 
   bool AllowsLazyCompilation();
 
   Handle<String> debug_name() const {
@@ skipping 167 matching lines @@
   int yield_count_;
   bool has_braces_;
 
   const AstString* raw_name_;
   DeclarationScope* scope_;
   ZoneList<Statement*>* body_;
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
   int function_literal_id_;
+  FeedbackVectorSlot literal_feedback_slot_;
 };
 
 // Property is used for passing information
 // about a class literal's properties from the parser to the code generator.
 class ClassLiteralProperty final : public LiteralProperty {
  public:
   enum Kind : uint8_t { METHOD, GETTER, SETTER, FIELD };
 
   Kind kind() const { return kind_; }
 
@@ skipping 79 matching lines @@
       : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
   class HasStaticComputedNames
       : public BitField<bool, HasNameStaticProperty::kNext, 1> {};
 };
 
 
 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(Isolate* isolate, FeedbackVectorSpec* spec,
+                                 FeedbackVectorSlotCache* cache) {
+    // TODO(mvstanton): It's actually silly to create these slots.
+    // At the very least, can we use the FeedbackVectorSlotCache to make
+    // sure we only allocate 1 for a given function and constantly reuse it?
+    if (FLAG_strong_rooted_literals) {
+      // 0 is a magic number here. It means we are holding the literals
+      // array for a native function literal, which needs to be
+      // the empty literals array.
+      // TODO(mvstanton): better way to deal with this?
+      literal_feedback_slot_ = spec->AddCreateClosureSlot(0);
+    } else {
+      literal_feedback_slot_ = FeedbackVectorSlot::Invalid();
+    }
+  }
 
  private:
   friend class AstNodeFactory;
 
   NativeFunctionLiteral(const AstRawString* name, v8::Extension* extension,
                         int pos)
       : Expression(pos, kNativeFunctionLiteral),
         name_(name),
         extension_(extension) {}
 
   const AstRawString* name_;
   v8::Extension* extension_;
+  FeedbackVectorSlot literal_feedback_slot_;
 };
 
 
 class ThisFunction final : public Expression {
  private:
   friend class AstNodeFactory;
   explicit ThisFunction(int pos) : Expression(pos, kThisFunction) {}
 };
 
 
@@ skipping 754 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_