[Interpreter] Avoid allocating pairs array in VisitDeclarations.

src/interpreter/constant-array-builder.h

 // Copyright 2015 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_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
 #define V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
 
 #include "src/identity-map.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/zone-containers.h"
@@ skipping 30 matching lines @@
   // |index|.
   Handle<Object> At(size_t index) const;
 
   // Returns the number of elements in the array.
   size_t size() const;
 
   // Insert an object into the constants array if it is not already
   // present. Returns the array index associated with the object.
   size_t Insert(Handle<Object> object);
 
+  // Reserves a entry which cannot later be discarded, and returns the array
+  // index associated with the reservation.
+  size_t ReserveEntry();
+
+  // Commits an undiscardable reserved entry and updates the entry with the
+  // given object.
+  void InsertReservedEntry(size_t index, Handle<Object> object);
+
   // Creates a reserved entry in the constant pool and returns
   // the size of the operand that'll be required to hold the entry
   // when committed.
-  OperandSize CreateReservedEntry();
+  OperandSize CreateDiscardableReservedEntry();

[oth, 2016/07/22 10:22:10]

The names here used to align to give a hint that it was a group of related
methods, e.g. CreateReservedEntry, CommitReservedEntry, DiscardReservedEntry.

How about something like:

s/ReserveEntry/AllocateEntry/
s/InsertReservedEntry/BindAllocatedEntry/
s/CreateDiscardableReservedEntry/CreateReservedEntry/

[rmcilroy, 2016/07/25 10:55:29]

SGTM (/s/BindAllocatedEntry/InsertAllocatedEntry). Done.

 
   // Commit reserved entry and returns the constant pool index for the
   // object.
   size_t CommitReservedEntry(OperandSize operand_size, Handle<Object> object);
 
   // Discards constant pool reservation.
   void DiscardReservedEntry(OperandSize operand_size);
 
  private:
   typedef uint32_t index_t;
 
   index_t AllocateEntry(Handle<Object> object);
+  index_t AllocateIndex(Handle<Object> object);
 
   struct ConstantArraySlice final : public ZoneObject {
     ConstantArraySlice(Zone* zone, size_t start_index, size_t capacity,
                        OperandSize operand_size);
     void Reserve();
     void Unreserve();
     size_t Allocate(Handle<Object> object);
     Handle<Object> At(size_t index) const;
+    void Update(size_t index, Handle<Object> object);
 
     inline size_t available() const { return capacity() - reserved() - size(); }
     inline size_t reserved() const { return reserved_; }
     inline size_t capacity() const { return capacity_; }
     inline size_t size() const { return constants_.size(); }
     inline size_t start_index() const { return start_index_; }
     inline size_t max_index() const { return start_index_ + capacity() - 1; }
     inline OperandSize operand_size() const { return operand_size_; }
 
    private:
     const size_t start_index_;
     const size_t capacity_;
     size_t reserved_;
     OperandSize operand_size_;
     ZoneVector<Handle<Object>> constants_;
 
     DISALLOW_COPY_AND_ASSIGN(ConstantArraySlice);
   };
 
-  const ConstantArraySlice* IndexToSlice(size_t index) const;
+  ConstantArraySlice* IndexToSlice(size_t index) const;
   ConstantArraySlice* OperandSizeToSlice(OperandSize operand_size) const;
 
   IdentityMap<index_t>* constants_map() { return &constants_map_; }
 
   Isolate* isolate_;
   ConstantArraySlice* idx_slice_[3];
   IdentityMap<index_t> constants_map_;
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_