Index: src/interpreter/bytecode-register-optimizer.h |
diff --git a/src/interpreter/bytecode-register-optimizer.h b/src/interpreter/bytecode-register-optimizer.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..99c35966d6ebc692d8f4a19c3bf6bb46883342e1 |
--- /dev/null |
+++ b/src/interpreter/bytecode-register-optimizer.h |
@@ -0,0 +1,149 @@ |
+// 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 TemporaryRegisterObserver, |
+ public ZoneObject { |
+ public: |
+ BytecodeRegisterOptimizer(Zone* zone, |
+ TemporaryRegisterAllocator* register_allocator, |
+ int parameter_count, |
+ BytecodePipelineStage* next_stage); |
+ virtual ~BytecodeRegisterOptimizer() {} |
+ |
+ // BytecodePipelineStage interface. |
+ size_t FlushForOffset() override; |
+ void FlushBasicBlock() override; |
+ void Write(BytecodeNode* node) override; |
+ |
+ private: |
+ const uint32_t kInvalidEquivalenceId = kMaxUInt32; |
+ |
+ class RegisterInfo; |
+ |
+ // TemporaryRegisterObserver interface. |
+ void TemporaryRegisterFreeEvent(Register reg) override; |
+ |
+ // Helpers for BytecodePipelineStage interface. |
+ void FlushState(); |
+ void WriteToNextStage(BytecodeNode* node) const; |
+ void WriteToNextStage(BytecodeNode* node, |
+ const BytecodeSourceInfo& output_info) const; |
+ |
+ // 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, |
+ const BytecodeSourceInfo& source_info); |
+ |
+ // Emit a register transfer bytecode from |input| to |output|. |
+ 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(const BytecodeSourceInfo& source_info) const; |
+ |
+ // Handlers for bytecode nodes for register to register transfers. |
+ void DoLdar(const BytecodeNode* const node); |
+ void DoMov(const BytecodeNode* const node); |
+ void DoStar(const BytecodeNode* const 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 CreateMaterializedEquivalent(RegisterInfo* info); |
+ RegisterInfo* GetMaterializedEquivalent(RegisterInfo* info); |
+ RegisterInfo* GetMaterializedEquivalentNotAccumulator(RegisterInfo* info); |
+ void Materialize(RegisterInfo* info); |
+ |
+ // Methods for finding and creating metadata for each register. |
+ RegisterInfo* GetOrCreateRegisterInfo(Register reg); |
+ RegisterInfo* GetRegisterInfo(Register reg); |
+ RegisterInfo* NewRegisterInfo(Register reg); |
+ void GrowRegisterMap(Register reg); |
+ |
+ bool RegisterIsTemporary(Register reg) const { |
+ return reg >= temporary_base_; |
+ } |
+ |
+ bool RegisterIsObservable(Register reg) const { |
+ return reg != accumulator_ && !RegisterIsTemporary(reg); |
+ } |
+ |
+ static Register OperandToRegister(uint32_t operand) { |
+ return Register::FromOperand(static_cast<int32_t>(operand)); |
+ } |
+ |
+ size_t GetRegisterInfoTableIndex(Register reg) const { |
+ return static_cast<size_t>(reg.index() + register_info_table_offset_); |
+ } |
+ |
+ Register RegisterFromRegisterInfoTableIndex(size_t index) const { |
+ return Register(static_cast<int>(index) - register_info_table_offset_); |
+ } |
+ |
+ uint32_t NextEquivalenceId() { |
+ equivalence_id_++; |
+ CHECK_NE(equivalence_id_, kInvalidEquivalenceId); |
+ return equivalence_id_; |
+ } |
+ |
+ Zone* zone() { return zone_; } |
+ |
+ const Register accumulator_; |
+ RegisterInfo* accumulator_info_; |
+ const Register temporary_base_; |
+ |
+ // Direct mapping to register info. |
+ ZoneVector<RegisterInfo*> register_info_table_; |
+ int register_info_table_offset_; |
+ |
+ // Counter for equivalence sets identifiers. |
+ int equivalence_id_; |
+ |
+ BytecodePipelineStage* next_stage_; |
+ bool flushed_; |
+ Zone* zone_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BytecodeRegisterOptimizer); |
+}; |
+ |
+} // namespace interpreter |
+} // namespace internal |
+} // namespace v8 |
+ |
+#endif // V8_INTERPRETER_BYTECODE_REGISTER_OPTIMIZER_H_ |