[TypeFeedbackVector] Root literal arrays in function literals slots

src/type-feedback-vector.h

 // Copyright 2014 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_TYPE_FEEDBACK_VECTOR_H_
 #define V8_TYPE_FEEDBACK_VECTOR_H_
 
 #include <vector>
 
 #include "src/base/logging.h"
@@ skipping 13 matching lines @@
 
   CALL_IC,
   LOAD_IC,
   LOAD_GLOBAL_IC,
   KEYED_LOAD_IC,
   STORE_IC,
   KEYED_STORE_IC,
   INTERPRETER_BINARYOP_IC,
   INTERPRETER_COMPARE_IC,
 
+  // This kind of slot has an integer parameter associated with it.
+  CREATE_CLOSURE,
   // This is a general purpose slot that occupies one feedback vector element.
   GENERAL,
 
   KINDS_NUMBER  // Last value indicating number of kinds.
 };
 
 std::ostream& operator<<(std::ostream& os, FeedbackVectorSlotKind kind);
 
 
 template <typename Derived>
 class FeedbackVectorSpecBase {
  public:
   inline FeedbackVectorSlot AddSlot(FeedbackVectorSlotKind kind);
 
   FeedbackVectorSlot AddCallICSlot() {
     return AddSlot(FeedbackVectorSlotKind::CALL_IC);
   }
 
   FeedbackVectorSlot AddLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::LOAD_IC);
   }
 
   FeedbackVectorSlot AddLoadGlobalICSlot() {
     return AddSlot(FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
   }
 
+  FeedbackVectorSlot AddCreateClosureSlot(int size) {
+    This()->append_parameter(size);

[Benedikt Meurer, 2016/12/11 17:58:09]

This parameter business looks a bit complicated for this purpose to me.

We talked about moving the literals to the type feedback vector and essentially
turning this indirection into a Cell or Struct. How about doing that first, then
you don't need the parameters at all?

[mvstanton, 2016/12/21 13:09:14]

Good point. However just this change (rooting the array in the vector, adapting
CreateNewClosure in all it's iterations to do the right thing, adapting
CompileLazy stub, etc.) is really large. Merging the literal array and the
feedback vector into a single structure is a big job of it's own. I think we can
do that next.

Right now we are benefiting from an asymmetry here: the literals array can be
created after parse, but the vector can't be created until compile. This fact
allows us to root the literal array and pass it around for lazy compilation,
rather than having to remember the *location* where the literal array is rooted,
and pass that around instead (more administration that way). A lazy compile just
inserts the feedback vector into the literals array, created long before.

+    return AddSlot(FeedbackVectorSlotKind::CREATE_CLOSURE);
+  }
+
   FeedbackVectorSlot AddKeyedLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::KEYED_LOAD_IC);
   }
 
   FeedbackVectorSlot AddStoreICSlot() {
     return AddSlot(FeedbackVectorSlotKind::STORE_IC);
   }
 
   FeedbackVectorSlot AddKeyedStoreICSlot() {
     return AddSlot(FeedbackVectorSlotKind::KEYED_STORE_IC);
@@ skipping 19 matching lines @@
   DECLARE_PRINTER(FeedbackVectorSpec)
 
  private:
   Derived* This() { return static_cast<Derived*>(this); }
 };
 
 
 class StaticFeedbackVectorSpec
     : public FeedbackVectorSpecBase<StaticFeedbackVectorSpec> {
  public:
-  StaticFeedbackVectorSpec() : slot_count_(0) {}
+  StaticFeedbackVectorSpec() : slot_count_(0), parameters_count_(0) {}
 
   int slots() const { return slot_count_; }
 
   FeedbackVectorSlotKind GetKind(int slot) const {
     DCHECK(slot >= 0 && slot < slot_count_);
     return kinds_[slot];
   }
 
+  int parameters_count() const { return parameters_count_; }
+
+  int GetParameter(int index) const {
+    DCHECK(index >= 0 && index < parameters_count_);
+    return parameters_[index];
+  }
+
  private:
   friend class FeedbackVectorSpecBase<StaticFeedbackVectorSpec>;
 
   void append(FeedbackVectorSlotKind kind) {
     DCHECK(slot_count_ < kMaxLength);
     kinds_[slot_count_++] = kind;
   }
 
+  void append_parameter(int parameter) {
+    DCHECK(parameters_count_ < kMaxLength);
+    parameters_[parameters_count_++] = parameter;
+  }
+
   static const int kMaxLength = 12;
 
   int slot_count_;
   FeedbackVectorSlotKind kinds_[kMaxLength];
+  int parameters_count_;
+  int parameters_[kMaxLength];
 };
 
 
 class FeedbackVectorSpec : public FeedbackVectorSpecBase<FeedbackVectorSpec> {
  public:
-  explicit FeedbackVectorSpec(Zone* zone) : slot_kinds_(zone) {
+  explicit FeedbackVectorSpec(Zone* zone)
+      : slot_kinds_(zone), parameters_(zone) {
     slot_kinds_.reserve(16);
+    parameters_.reserve(8);
   }
 
   int slots() const { return static_cast<int>(slot_kinds_.size()); }
 
   FeedbackVectorSlotKind GetKind(int slot) const {
     return static_cast<FeedbackVectorSlotKind>(slot_kinds_.at(slot));
   }
 
+  int parameters_count() const { return static_cast<int>(parameters_.size()); }
+
+  int GetParameter(int index) const { return parameters_.at(index); }
+
  private:
   friend class FeedbackVectorSpecBase<FeedbackVectorSpec>;
 
   void append(FeedbackVectorSlotKind kind) {
     slot_kinds_.push_back(static_cast<unsigned char>(kind));
   }
 
+  void append_parameter(int parameter) { parameters_.push_back(parameter); }
+
   ZoneVector<unsigned char> slot_kinds_;
+  ZoneVector<int> parameters_;
 };
 
 
 // The shape of the TypeFeedbackMetadata is an array with:
 // 0: slot_count
 // 1: names table
-// 2..N: slot kinds packed into a bit vector
+// 2: parameters table
+// 3..N: slot kinds packed into a bit vector
 //
 class TypeFeedbackMetadata : public FixedArray {
  public:
   // Casting.
   static inline TypeFeedbackMetadata* cast(Object* obj);
 
   static const int kSlotsCountIndex = 0;
-  static const int kReservedIndexCount = 1;
+  static const int kParametersTableIndex = 1;
+  static const int kReservedIndexCount = 2;
 
   // Returns number of feedback vector elements used by given slot kind.
   static inline int GetSlotSize(FeedbackVectorSlotKind kind);
 
+  // Defines if slots of given kind require "parameter".
+  static inline bool SlotRequiresParameter(FeedbackVectorSlotKind kind);
+
   bool SpecDiffersFrom(const FeedbackVectorSpec* other_spec) const;
 
   bool DiffersFrom(const TypeFeedbackMetadata* other_metadata) const;
 
   inline bool is_empty() const;
 
   // Returns number of slots in the vector.
   inline int slot_count() const;
 
   // Returns slot kind for given slot.
   FeedbackVectorSlotKind GetKind(FeedbackVectorSlot slot) const;
 
+  // Returns parameter for given index (note: this is not the slot)
+  int GetParameter(int parameter_index) const;
+
   template <typename Spec>
   static Handle<TypeFeedbackMetadata> New(Isolate* isolate, const Spec* spec);
 
 #ifdef OBJECT_PRINT
   // For gdb debugging.
   void Print();
 #endif  // OBJECT_PRINT
 
   DECLARE_PRINTER(TypeFeedbackMetadata)
 
@@ skipping 48 matching lines @@
                               FeedbackVectorSlot slot);
 
   // Conversion from an integer index to the underlying array to a slot.
   static inline FeedbackVectorSlot ToSlot(int index);
   inline Object* Get(FeedbackVectorSlot slot) const;
   inline void Set(FeedbackVectorSlot slot, Object* value,
                   WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Returns slot kind for given slot.
   FeedbackVectorSlotKind GetKind(FeedbackVectorSlot slot) const;
+  // Returns parameter corresponding to given slot or -1.
+  int GetParameter(FeedbackVectorSlot slot) const;
 
   static Handle<TypeFeedbackVector> New(Isolate* isolate,
                                         Handle<TypeFeedbackMetadata> metadata);
 
   static Handle<TypeFeedbackVector> Copy(Isolate* isolate,
                                          Handle<TypeFeedbackVector> vector);
 
 #ifdef OBJECT_PRINT
   // For gdb debugging.
   void Print();
@@ skipping 415 matching lines @@
   }
 };
 
 inline BinaryOperationHint BinaryOperationHintFromFeedback(int type_feedback);
 inline CompareOperationHint CompareOperationHintFromFeedback(int type_feedback);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TRANSITIONS_H_