[Interpreter] Reduce temporary register usage in generated bytecode.

src/interpreter/bytecode-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_BYTECODE_ARRAY_BUILDER_H_
 #define V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_
 
 #include <vector>
 
 #include "src/ast.h"
@@ skipping 10 matching lines @@
 namespace interpreter {
 
 class BytecodeLabel;
 class Register;
 
 class BytecodeArrayBuilder {
  public:
   BytecodeArrayBuilder(Isolate* isolate, Zone* zone);
   Handle<BytecodeArray> ToBytecodeArray();
 
-  // Set number of parameters expected by function.
+  // Set the number of parameters expected by function.
   void set_parameter_count(int number_of_params);
   int parameter_count() const {
     DCHECK_GE(parameter_count_, 0);
     return parameter_count_;
   }
 
-  // Set number of locals required for bytecode array.
+  // Set the number of locals required for bytecode array.
   void set_locals_count(int number_of_locals);
   int locals_count() const {
     DCHECK_GE(local_register_count_, 0);
     return local_register_count_;
   }
 
   // Set number of contexts required for bytecode array.
   void set_context_count(int number_of_contexts);
   int context_count() const {
     DCHECK_GE(context_register_count_, 0);
     return context_register_count_;
   }
 
   Register first_context_register() const;
   Register last_context_register() const;
 
   // Returns the number of fixed (non-temporary) registers.
   int fixed_register_count() const { return context_count() + locals_count(); }
 
   Register Parameter(int parameter_index) const;
 
-  // Constant loads to the accumulator.
+  // Return true if the register |reg| represents a parameter or a
+  // local.
+  bool RegisterIsParameterOrLocal(Register reg) const;
+
+  // Constant loads to accumulator.
   BytecodeArrayBuilder& LoadLiteral(v8::internal::Smi* value);
   BytecodeArrayBuilder& LoadLiteral(Handle<Object> object);
   BytecodeArrayBuilder& LoadUndefined();
   BytecodeArrayBuilder& LoadNull();
   BytecodeArrayBuilder& LoadTheHole();
   BytecodeArrayBuilder& LoadTrue();
   BytecodeArrayBuilder& LoadFalse();
 
-  // Global loads to accumulator and stores from the accumulator.
+  // Global loads to the accumulator and stores from the accumulator.
   BytecodeArrayBuilder& LoadGlobal(int slot_index);
   BytecodeArrayBuilder& StoreGlobal(int slot_index, LanguageMode language_mode);
 
   // Load the object at |slot_index| in |context| into the accumulator.
   BytecodeArrayBuilder& LoadContextSlot(Register context, int slot_index);
 
   // Stores the object in the accumulator into |slot_index| of |context|.
   BytecodeArrayBuilder& StoreContextSlot(Register context, int slot_index);
 
   // Register-accumulator transfers.
@@ skipping 53 matching lines @@
                                         Strength strength);
 
   // Unary Operators.
   BytecodeArrayBuilder& LogicalNot();
   BytecodeArrayBuilder& TypeOf();
 
   // Tests.
   BytecodeArrayBuilder& CompareOperation(Token::Value op, Register reg,
                                          Strength strength);
 
-  // Casts
+  // Casts.
   BytecodeArrayBuilder& CastAccumulatorToBoolean();
   BytecodeArrayBuilder& CastAccumulatorToName();
 
   // Flow Control.
   BytecodeArrayBuilder& Bind(BytecodeLabel* label);
   BytecodeArrayBuilder& Bind(const BytecodeLabel& target, BytecodeLabel* label);
 
   BytecodeArrayBuilder& Jump(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfTrue(BytecodeLabel* label);
   BytecodeArrayBuilder& JumpIfFalse(BytecodeLabel* label);
@@ skipping 45 matching lines @@
 
   void EnsureReturn();
 
   bool OperandIsValid(Bytecode bytecode, int operand_index,
                       uint32_t operand_value) const;
   bool LastBytecodeInSameBlock() const;
 
   size_t GetConstantPoolEntry(Handle<Object> object);
 
   // Scope helpers used by TemporaryRegisterScope
+  Register first_temporary_register() const;
+  Register last_temporary_register() const;

[rmcilroy, 2015/10/19 12:56:22]

nit - move getters below TemporaryRegisterIsLive() (with a newline whitespace)

[oth, 2015/10/20 15:28:52]

Done.

   int BorrowTemporaryRegister();
   void ReturnTemporaryRegister(int reg_index);
+  void PrepareForConsecutiveTemporaryRegisters(size_t count);
+  bool TemporaryRegisterIsLive(Register reg) const;
 
   Isolate* isolate_;
   Zone* zone_;
   ZoneVector<uint8_t> bytecodes_;
   bool bytecode_generated_;
   size_t last_block_end_;
   size_t last_bytecode_start_;
   bool return_seen_in_block_;
 
   IdentityMap<size_t> constants_map_;
   ZoneVector<Handle<Object>> constants_;
 
   int parameter_count_;
   int local_register_count_;
   int context_register_count_;
+  ZoneVector<int> free_temporaries_;
   int temporary_register_count_;
-  int temporary_register_next_;
 
   friend class TemporaryRegisterScope;
-  DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArrayBuilder);
+  DISALLOW_COPY_AND_ASSIGN(BytecodeArrayBuilder);
 };
 
 
 // A label representing a branch target in a bytecode array. When a
 // label is bound, it represents a known position in the bytecode
 // array. For labels that are forward references there can be at most
 // one reference whilst it is unbound.
 class BytecodeLabel final {
  public:
   BytecodeLabel() : bound_(false), offset_(kInvalidOffset) {}
@@ skipping 28 matching lines @@
 };
 
 
 // A stack-allocated class than allows the instantiator to allocate
 // temporary registers that are cleaned up when scope is closed.
 class TemporaryRegisterScope {
  public:
   explicit TemporaryRegisterScope(BytecodeArrayBuilder* builder);
   ~TemporaryRegisterScope();
   Register NewRegister();
+  void PrepareForConsecutiveAllocations(size_t count);
 
  private:
   void* operator new(size_t size);
   void operator delete(void* p);
 
   BytecodeArrayBuilder* builder_;
-  int count_;
-  int last_register_index_;
+  const TemporaryRegisterScope* outer_;
+  ZoneVector<int> allocated_;
 
   DISALLOW_COPY_AND_ASSIGN(TemporaryRegisterScope);
 };
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_ARRAY_BUILDER_H_