Home | History | Annotate | Download | only in compiler
      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_MOVE_OPTIMIZER_
      6 #define V8_COMPILER_MOVE_OPTIMIZER_
      7 
      8 #include "src/compiler/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 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   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 accross 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_MOVE_OPTIMIZER_
     69