[Interpreter] Optimize the Register Optimizer.

src/interpreter/bytecode-register-optimizer.h

 // Copyright 2016 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_REGISTER_OPTIMIZER_H_
 #define V8_INTERPRETER_BYTECODE_REGISTER_OPTIMIZER_H_
 
 #include "src/interpreter/bytecode-pipeline.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 // An optimization stage for eliminating unnecessary transfers between
 // registers. The bytecode generator uses temporary registers
 // liberally for correctness and convenience and this stage removes
 // transfers that are not required and preserves correctness.
 class BytecodeRegisterOptimizer final
-    : public BytecodePipelineStage,
-      public BytecodeRegisterAllocator::Observer,
+    : public BytecodeRegisterAllocator::Observer,
       public ZoneObject {
  public:
   BytecodeRegisterOptimizer(Zone* zone,
                             BytecodeRegisterAllocator* register_allocator,
                             int fixed_registers_count, int parameter_count,
                             BytecodePipelineStage* next_stage);
   virtual ~BytecodeRegisterOptimizer() {}
 
-  // BytecodePipelineStage interface.
-  void Write(BytecodeNode* node) override;
-  void WriteJump(BytecodeNode* node, BytecodeLabel* label) override;
-  void BindLabel(BytecodeLabel* label) override;
-  void BindLabel(const BytecodeLabel& target, BytecodeLabel* label) override;
-  Handle<BytecodeArray> ToBytecodeArray(
-      Isolate* isolate, int register_count, int parameter_count,
-      Handle<FixedArray> handler_table) override;
+  // Perform explicit register transfer operations.
+  void DoLdar(Register input, const BytecodeSourceInfo& source_info) {
+    RegisterInfo* input_info = GetRegisterInfo(input);
+    RegisterTransfer(input_info, accumulator_info_, source_info);
+  }
+  void DoStar(Register output, const BytecodeSourceInfo& source_info) {
+    RegisterInfo* output_info = GetRegisterInfo(output);
+    RegisterTransfer(accumulator_info_, output_info, source_info);
+  }
+  void DoMov(Register input, Register output,
+             const BytecodeSourceInfo& source_info) {
+    RegisterInfo* input_info = GetRegisterInfo(input);
+    RegisterInfo* output_info = GetRegisterInfo(output);
+    RegisterTransfer(input_info, output_info, source_info);
+  }
+
+  // Materialize all live registers and flush equivalence sets.
+  void Flush();
+
+  // Prepares for |bytecode|.
+  void PrepareForBytecode(Bytecode bytecode);
+
+  // Prepares |reg| for being used as an output operand.
+  void PrepareOutputRegister(Register reg);
+
+  // Prepares registers in |reg_list| for being used as an output operand.
+  void PrepareOutputRegisterList(RegisterList reg_list);
+
+  // Returns an equivalent register to |reg| to be used as an input operand.
+  Register GetInputRegister(Register reg);
+
+  // Returns an equivalent register list to |reg_list| to be used as an input
+  // operand.
+  RegisterList GetInputRegisterList(RegisterList reg_list);
+
+  int maxiumum_register_index() const { return max_register_index_; }
 
  private:
   static const uint32_t kInvalidEquivalenceId = kMaxUInt32;
 
   class RegisterInfo;
 
   // BytecodeRegisterAllocator::Observer interface.
   void RegisterAllocateEvent(Register reg) override;
   void RegisterListAllocateEvent(RegisterList reg_list) override;
   void RegisterListFreeEvent(RegisterList reg) override;
 
-  // Helpers for BytecodePipelineStage interface.
-  void FlushState();
-
   // Update internal state for register transfer from |input| to
   // |output| using |source_info| as source position information if
   // any bytecodes are emitted due to transfer.
   void RegisterTransfer(RegisterInfo* input, RegisterInfo* output,
-                        BytecodeSourceInfo* source_info);
+                        const BytecodeSourceInfo& source_info);
 
   // Emit a register transfer bytecode from |input| to |output|.
-  void OutputRegisterTransfer(RegisterInfo* input, RegisterInfo* output,
-                              BytecodeSourceInfo* source_info = nullptr);
+  void OutputRegisterTransfer(
+      RegisterInfo* input, RegisterInfo* output,
+      const BytecodeSourceInfo& source_info = BytecodeSourceInfo());
 
   // Emits a Nop to preserve source position information in the
   // bytecode pipeline.
-  void EmitNopForSourceInfo(BytecodeSourceInfo* source_info) const;
-
-  // Handlers for bytecode nodes for register to register transfers.
-  void DoLdar(BytecodeNode* node);
-  void DoMov(BytecodeNode* node);
-  void DoStar(BytecodeNode* node);
-
-  // Operand processing methods for bytecodes other than those
-  // performing register to register transfers.
-  void PrepareOperands(BytecodeNode* const node);
-  void PrepareAccumulator(BytecodeNode* const node);
-  void PrepareRegisterOperands(BytecodeNode* const node);
-
-  void PrepareRegisterOutputOperand(RegisterInfo* reg_info);
-  void PrepareRegisterRangeOutputOperand(Register start, int count);
-  void PrepareRegisterInputOperand(BytecodeNode* const node, Register reg,
-                                   int operand_index);
-  void PrepareRegisterRangeInputOperand(Register start, int count);
-
-  Register GetEquivalentRegisterForInputOperand(Register reg);
-
-  static Register GetRegisterInputOperand(int index, Bytecode bytecode,
-                                          const uint32_t* operands,
-                                          int operand_count);
-  static Register GetRegisterOutputOperand(int index, Bytecode bytecode,
-                                           const uint32_t* operands,
-                                           int operand_count);
+  void EmitNopForSourceInfo(const BytecodeSourceInfo& source_info) const;
 
   void CreateMaterializedEquivalent(RegisterInfo* info);
   RegisterInfo* GetMaterializedEquivalent(RegisterInfo* info);
   RegisterInfo* GetMaterializedEquivalentNotAccumulator(RegisterInfo* info);
   void Materialize(RegisterInfo* info);
   void AddToEquivalenceSet(RegisterInfo* set_member,
                            RegisterInfo* non_set_member);
 
   // Methods for finding and creating metadata for each register.
-  RegisterInfo* GetOrCreateRegisterInfo(Register reg);
-  RegisterInfo* GetRegisterInfo(Register reg);
-  RegisterInfo* NewRegisterInfo(Register reg);
+  RegisterInfo* GetRegisterInfo(Register reg) {
+    size_t index = GetRegisterInfoTableIndex(reg);
+    DCHECK_LT(index, register_info_table_.size());
+    return register_info_table_[index];
+  }
+  RegisterInfo* GetOrCreateRegisterInfo(Register reg) {
+    size_t index = GetRegisterInfoTableIndex(reg);
+    return index < register_info_table_.size() ? register_info_table_[index]
+                                               : NewRegisterInfo(reg);
+  }
+  RegisterInfo* NewRegisterInfo(Register reg) {
+    size_t index = GetRegisterInfoTableIndex(reg);
+    DCHECK_GE(index, register_info_table_.size());
+    GrowRegisterMap(reg);
+    return register_info_table_[index];
+  }
+
   void GrowRegisterMap(Register reg);
 
   bool RegisterIsTemporary(Register reg) const {
     return reg >= temporary_base_;
   }
 
   bool RegisterIsObservable(Register reg) const {
     return reg != accumulator_ && !RegisterIsTemporary(reg);
   }
 
@@ skipping 34 matching lines @@
   Zone* zone_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeRegisterOptimizer);
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_REGISTER_OPTIMIZER_H_