lib/Target/X86/PeepholeOptimizer.cpp

   1 //===-- PeepholeOptimizer.cpp - X86 Peephole Optimizer --------------------===//
   2 //
   3 // This file contains a peephole optimizer for the X86.
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #include "X86.h"
   8 #include "llvm/CodeGen/MachineFunctionPass.h"
   9 #include "llvm/CodeGen/MachineInstrBuilder.h"
  10
  11 namespace {
  12   struct PH : public MachineFunctionPass {
  13     virtual bool runOnMachineFunction(MachineFunction &MF);
  14
  15     bool PeepholeOptimize(MachineBasicBlock &MBB,
  16                           MachineBasicBlock::iterator &I);
  17
  18     virtual const char *getPassName() const { return "X86 Peephole Optimizer"; }
  19   };
  20 }
  21
  22 Pass *createX86PeepholeOptimizerPass() { return new PH(); }
  23
  24 bool PH::runOnMachineFunction(MachineFunction &MF) {
  25   bool Changed = false;
  26
  27   for (MachineFunction::iterator BI = MF.begin(), E = MF.end(); BI != E; ++BI)
  28     for (MachineBasicBlock::iterator I = BI->begin(), E = BI->end(); I != E; )
  29       if (PeepholeOptimize(*BI, I))
  30         Changed = true;
  31       else
  32         ++I;
  33
  34   return Changed;
  35 }
  36
  37
  38 bool PH::PeepholeOptimize(MachineBasicBlock &MBB,
  39                           MachineBasicBlock::iterator &I) {
  40   MachineInstr *MI = *I;
  41   MachineInstr *Next = (I+1 != MBB.end()) ? *(I+1) : 0;
  42   unsigned Size = 0;
  43   switch (MI->getOpcode()) {
  44   case X86::MOVrr8:
  45   case X86::MOVrr16:
  46   case X86::MOVrr32:   // Destroy X = X copies...
  47     if (MI->getOperand(0).getReg() == MI->getOperand(1).getReg()) {
  48       I = MBB.erase(I);
  49       delete MI;
  50       return true;
  51     }
  52     return false;
  53
  54 #if 0
  55   case X86::MOVir32: Size++;
  56   case X86::MOVir16: Size++;
  57   case X86::MOVir8:
  58     // FIXME: We can only do this transformation if we know that flags are not
  59     // used here, because XOR clobbers the flags!
  60     if (MI->getOperand(1).isImmediate()) {         // avoid mov EAX, <value>
  61       int Val = MI->getOperand(1).getImmedValue();
  62       if (Val == 0) {                              // mov EAX, 0 -> xor EAX, EAX
  63         static const unsigned Opcode[] ={X86::XORrr8,X86::XORrr16,X86::XORrr32};
  64         unsigned Reg = MI->getOperand(0).getReg();
  65         *I = BuildMI(Opcode[Size], 2, Reg).addReg(Reg).addReg(Reg);
  66         delete MI;
  67         return true;
  68       } else if (Val == -1) {                     // mov EAX, -1 -> or EAX, -1
  69         // TODO: 'or Reg, -1' has a smaller encoding than 'mov Reg, -1'
  70       }
  71     }
  72     return false;
  73 #endif
  74   case X86::BSWAPr32:        // Change bswap EAX, bswap EAX into nothing
  75     if (Next->getOpcode() == X86::BSWAPr32 &&
  76         MI->getOperand(0).getReg() == Next->getOperand(0).getReg()) {
  77       I = MBB.erase(MBB.erase(I));
  78       delete MI;
  79       delete Next;
  80       return true;
  81     }
  82     return false;
  83   default:
  84     return false;
  85   }
  86 }