lib/Target/SparcV9/SparcV9PeepholeOpts.cpp

   1 //===-- PeepholeOpts.cpp --------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Support for performing several peephole opts in one or a few passes over the
  11 // machine code of a method.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "SparcInternals.h"
  16 #include "llvm/CodeGen/MachineFunction.h"
  17 #include "llvm/CodeGen/MachineInstr.h"
  18 #include "llvm/Target/TargetMachine.h"
  19 #include "llvm/Target/TargetInstrInfo.h"
  20 #include "llvm/BasicBlock.h"
  21 #include "llvm/Pass.h"
  22
  23 //************************* Internal Functions *****************************/
  24
  25 static inline void
  26 DeleteInstruction(MachineBasicBlock& mvec,
  27                   MachineBasicBlock::iterator& BBI,
  28                   const TargetMachine& target) {
  29   // Check if this instruction is in a delay slot of its predecessor.
  30   if (BBI != mvec.begin()) {
  31       const TargetInstrInfo& mii = target.getInstrInfo();
  32       MachineInstr* predMI = *(BBI-1);
  33       if (unsigned ndelay = mii.getNumDelaySlots(predMI->getOpCode())) {
  34         // This instruction is in a delay slot of its predecessor, so
  35         // replace it with a nop. By replacing in place, we save having
  36         // to update the I-I maps.
  37         //
  38         assert(ndelay == 1 && "Not yet handling multiple-delay-slot targets");
  39         (*BBI)->replace(mii.getNOPOpCode(), 0);
  40         return;
  41       }
  42   }
  43
  44   // The instruction is not in a delay slot, so we can simply erase it.
  45   mvec.erase(BBI);
  46   BBI = mvec.end();
  47 }
  48
  49 //******************* Individual Peephole Optimizations ********************/
  50
  51 //----------------------------------------------------------------------------
  52 // Function: IsUselessCopy
  53 // Decide whether a machine instruction is a redundant copy:
  54 // -- ADD    with g0 and result and operand are identical, or
  55 // -- OR     with g0 and result and operand are identical, or
  56 // -- FMOVS or FMOVD and result and operand are identical.
  57 // Other cases are possible but very rare that they would be useless copies,
  58 // so it's not worth analyzing them.
  59 //----------------------------------------------------------------------------
  60
  61 static bool IsUselessCopy(const TargetMachine &target, const MachineInstr* MI) {
  62   if (MI->getOpCode() == V9::FMOVS || MI->getOpCode() == V9::FMOVD) {
  63     return (/* both operands are allocated to the same register */
  64             MI->getOperand(0).getAllocatedRegNum() ==
  65             MI->getOperand(1).getAllocatedRegNum());
  66   } else if (MI->getOpCode() == V9::ADDr || MI->getOpCode() == V9::ORr) {
  67     unsigned srcWithDestReg;
  68
  69     for (srcWithDestReg = 0; srcWithDestReg < 2; ++srcWithDestReg)
  70       if (MI->getOperand(srcWithDestReg).hasAllocatedReg() &&
  71           MI->getOperand(srcWithDestReg).getAllocatedRegNum()
  72           == MI->getOperand(2).getAllocatedRegNum())
  73         break;
  74
  75     if (srcWithDestReg == 2)
  76       return false;
  77     else {
  78       /* else source and dest are allocated to the same register */
  79       unsigned otherOp = 1 - srcWithDestReg;
  80       return (/* either operand otherOp is register %g0 */
  81               (MI->getOperand(otherOp).hasAllocatedReg() &&
  82                MI->getOperand(otherOp).getAllocatedRegNum() ==
  83                target.getRegInfo().getZeroRegNum()) ||
  84
  85               /* or operand otherOp == 0 */
  86               (MI->getOperand(otherOp).getType()
  87                == MachineOperand::MO_SignExtendedImmed &&
  88                MI->getOperand(otherOp).getImmedValue() == 0));
  89     }
  90   }
  91   else
  92     return false;
  93 }
  94
  95 inline bool
  96 RemoveUselessCopies(MachineBasicBlock& mvec,
  97                     MachineBasicBlock::iterator& BBI,
  98                     const TargetMachine& target) {
  99   if (IsUselessCopy(target, *BBI)) {
 100     DeleteInstruction(mvec, BBI, target);
 101     return true;
 102   }
 103   return false;
 104 }
 105
 106
 107 //************************ Class Implementations **************************/
 108
 109 class PeepholeOpts: public BasicBlockPass {
 110   const TargetMachine &target;
 111   bool visit(MachineBasicBlock& mvec,
 112              MachineBasicBlock::iterator BBI) const;
 113 public:
 114   PeepholeOpts(const TargetMachine &T): target(T) { }
 115   bool runOnBasicBlock(BasicBlock &BB); // apply this pass to each BB
 116   virtual const char *getPassName() const { return "Peephole Optimization"; }
 117 };
 118
 119 // Apply a list of peephole optimizations to this machine instruction
 120 // within its local context.  They are allowed to delete MI or any
 121 // instruction before MI, but not
 122 //
 123 bool PeepholeOpts::visit(MachineBasicBlock& mvec,
 124                          MachineBasicBlock::iterator BBI) const {
 125   /* Remove redundant copy instructions */
 126   return RemoveUselessCopies(mvec, BBI, target);
 127 }
 128
 129
 130 bool PeepholeOpts::runOnBasicBlock(BasicBlock &BB) {
 131   // Get the machine instructions for this BB
 132   // FIXME: MachineBasicBlock::get() is deprecated, hence inlining the function
 133   const Function *F = BB.getParent();
 134   MachineFunction &MF = MachineFunction::get(F);
 135   MachineBasicBlock *MBB = NULL;
 136   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
 137     if (I->getBasicBlock() == &BB)
 138       MBB = I;
 139
 140   assert(MBB && "MachineBasicBlock object not found for specified block!");
 141   MachineBasicBlock &mvec = *MBB;
 142
 143   // Iterate over all machine instructions in the BB
 144   // Use a reverse iterator to allow deletion of MI or any instruction after it.
 145   // Insertions or deletions *before* MI are not safe.
 146   //
 147   for (MachineBasicBlock::reverse_iterator RI=mvec.rbegin(),
 148          RE=mvec.rend(); RI != RE; ) {
 149     MachineBasicBlock::iterator BBI = RI.base()-1; // save before incr
 150     ++RI;             // pre-increment to delete MI or after it
 151     visit(mvec, BBI);
 152   }
 153
 154   return true;
 155 }
 156
 157
 158 //===----------------------------------------------------------------------===//
 159 // createPeepholeOptsPass - Public entrypoint for peephole optimization
 160 // and this file as a whole...
 161 //
 162 FunctionPass* createPeepholeOptsPass(TargetMachine &T) {
 163   return new PeepholeOpts(T);
 164 }