Line data    Source code

       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_COMPILER_BACKEND_MOVE_OPTIMIZER_H_
       6             : #define V8_COMPILER_BACKEND_MOVE_OPTIMIZER_H_
       7             : 
       8             : #include "src/compiler/backend/instruction.h"
       9             : #include "src/globals.h"
      10             : #include "src/zone/zone-containers.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : namespace compiler {
      15             : 
      16     2516655 : class V8_EXPORT_PRIVATE MoveOptimizer final {
      17             :  public:
      18             :   MoveOptimizer(Zone* local_zone, InstructionSequence* code);
      19             :   void Run();
      20             : 
      21             :  private:
      22             :   typedef ZoneVector<MoveOperands*> MoveOpVector;
      23             :   typedef ZoneVector<Instruction*> Instructions;
      24             : 
      25             :   InstructionSequence* code() const { return code_; }
      26             :   Zone* local_zone() const { return local_zone_; }
      27             :   Zone* code_zone() const { return code()->zone(); }
      28    17698145 :   MoveOpVector& local_vector() { return local_vector_; }
      29             : 
      30             :   // Consolidate moves into the first gap.
      31             :   void CompressGaps(Instruction* instr);
      32             : 
      33             :   // Attempt to push down to the last instruction those moves that can.
      34             :   void CompressBlock(InstructionBlock* block);
      35             : 
      36             :   // Consolidate moves into the first gap.
      37             :   void CompressMoves(ParallelMove* left, MoveOpVector* right);
      38             : 
      39             :   // Push down those moves in the gap of from that do not change the
      40             :   // semantics of the from instruction, nor the semantics of the moves
      41             :   // that remain behind.
      42             :   void MigrateMoves(Instruction* to, Instruction* from);
      43             : 
      44             :   void RemoveClobberedDestinations(Instruction* instruction);
      45             : 
      46             :   const Instruction* LastInstruction(const InstructionBlock* block) const;
      47             : 
      48             :   // Consolidate common moves appearing across all predecessors of a block.
      49             :   void OptimizeMerge(InstructionBlock* block);
      50             :   void FinalizeMoves(Instruction* instr);
      51             : 
      52             :   Zone* const local_zone_;
      53             :   InstructionSequence* const code_;
      54             :   MoveOpVector local_vector_;
      55             : 
      56             :   // Reusable buffers for storing operand sets. We need at most two sets
      57             :   // at any given time, so we create two buffers.
      58             :   ZoneVector<InstructionOperand> operand_buffer1;
      59             :   ZoneVector<InstructionOperand> operand_buffer2;
      60             : 
      61             :   DISALLOW_COPY_AND_ASSIGN(MoveOptimizer);
      62             : };
      63             : 
      64             : }  // namespace compiler
      65             : }  // namespace internal
      66             : }  // namespace v8
      67             : 
      68             : #endif  // V8_COMPILER_BACKEND_MOVE_OPTIMIZER_H_