lib/Target/MBlaze/MBlazeDelaySlotFiller.cpp

   1 //===-- DelaySlotFiller.cpp - MBlaze delay slot filler --------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // A pass that attempts to fill instructions with delay slots. If no
  11 // instructions can be moved into the delay slot then a NOP is placed there.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "delay-slot-filler"
  16
  17 #include "MBlaze.h"
  18 #include "MBlazeTargetMachine.h"
  19 #include "llvm/CodeGen/MachineFunctionPass.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/Target/TargetInstrInfo.h"
  22 #include "llvm/ADT/Statistic.h"
  23 #include "llvm/Support/CommandLine.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/raw_ostream.h"
  27
  28 using namespace llvm;
  29
  30 STATISTIC(FilledSlots, "Number of delay slots filled");
  31
  32 namespace {
  33   struct Filler : public MachineFunctionPass {
  34
  35     TargetMachine &TM;
  36     const TargetInstrInfo *TII;
  37
  38     static char ID;
  39     Filler(TargetMachine &tm)
  40       : MachineFunctionPass(ID), TM(tm), TII(tm.getInstrInfo()) { }
  41
  42     virtual const char *getPassName() const {
  43       return "MBlaze Delay Slot Filler";
  44     }
  45
  46     bool runOnMachineBasicBlock(MachineBasicBlock &MBB);
  47     bool runOnMachineFunction(MachineFunction &F) {
  48       bool Changed = false;
  49       for (MachineFunction::iterator FI = F.begin(), FE = F.end();
  50            FI != FE; ++FI)
  51         Changed |= runOnMachineBasicBlock(*FI);
  52       return Changed;
  53     }
  54
  55   };
  56   char Filler::ID = 0;
  57 } // end of anonymous namespace
  58
  59 static bool hasImmInstruction(MachineBasicBlock::iterator &candidate) {
  60     // Any instruction with an immediate mode operand greater than
  61     // 16-bits requires an implicit IMM instruction.
  62     unsigned numOper = candidate->getNumOperands();
  63     for (unsigned op = 0; op < numOper; ++op) {
  64         if (candidate->getOperand(op).isImm() &&
  65             (candidate->getOperand(op).getImm() & 0xFFFFFFFFFFFF0000LL) != 0)
  66             return true;
  67
  68         // FIXME: we could probably check to see if the FP value happens
  69         //        to not need an IMM instruction. For now we just always
  70         //        assume that FP values always do.
  71         if (candidate->getOperand(op).isFPImm())
  72             return true;
  73     }
  74
  75     return false;
  76 }
  77
  78 static bool delayHasHazard(MachineBasicBlock::iterator &candidate,
  79                            MachineBasicBlock::iterator &slot) {
  80
  81     // Loop over all of the operands in the branch instruction
  82     // and make sure that none of them are defined by the
  83     // candidate instruction.
  84     unsigned numOper = slot->getNumOperands();
  85     for (unsigned op = 0; op < numOper; ++op) {
  86         if (!slot->getOperand(op).isReg() ||
  87             !slot->getOperand(op).isUse() ||
  88             slot->getOperand(op).isImplicit())
  89             continue;
  90
  91         unsigned cnumOper = candidate->getNumOperands();
  92         for (unsigned cop = 0; cop < cnumOper; ++cop) {
  93             if (candidate->getOperand(cop).isReg() &&
  94                 candidate->getOperand(cop).isDef() &&
  95                 candidate->getOperand(cop).getReg() ==
  96                 slot->getOperand(op).getReg())
  97                 return true;
  98         }
  99     }
 100
 101     // There are no hazards between the two instructions
 102     return false;
 103 }
 104
 105 static bool usedBeforeDelaySlot(MachineBasicBlock::iterator &candidate,
 106                                 MachineBasicBlock::iterator &slot) {
 107   MachineBasicBlock::iterator I = candidate;
 108   for (++I; I != slot; ++I) {
 109         unsigned numOper = I->getNumOperands();
 110         for (unsigned op = 0; op < numOper; ++op) {
 111             if (I->getOperand(op).isReg() &&
 112                 I->getOperand(op).isUse()) {
 113                 unsigned reg = I->getOperand(op).getReg();
 114                 unsigned cops = candidate->getNumOperands();
 115                 for (unsigned cop = 0; cop < cops; ++cop) {
 116                     if (candidate->getOperand(cop).isReg() &&
 117                         candidate->getOperand(cop).isDef() &&
 118                         candidate->getOperand(cop).getReg() == reg)
 119                         return true;
 120                 }
 121             }
 122         }
 123   }
 124
 125   return false;
 126 }
 127
 128 static MachineBasicBlock::iterator
 129 findDelayInstr(MachineBasicBlock &MBB,MachineBasicBlock::iterator &slot) {
 130   MachineBasicBlock::iterator found = MBB.end();
 131   for (MachineBasicBlock::iterator I = MBB.begin(); I != slot; ++I) {
 132       TargetInstrDesc desc = I->getDesc();
 133       if (desc.hasDelaySlot() || desc.isBranch() ||
 134           desc.mayLoad() || desc.    mayStore() ||
 135           hasImmInstruction(I) || delayHasHazard(I,slot) ||
 136           usedBeforeDelaySlot(I,slot)) continue;
 137
 138       found = I;
 139   }
 140
 141   return found;
 142 }
 143
 144 /// runOnMachineBasicBlock - Fill in delay slots for the given basic block.
 145 /// Currently, we fill delay slots with NOPs. We assume there is only one
 146 /// delay slot per delayed instruction.
 147 bool Filler::runOnMachineBasicBlock(MachineBasicBlock &MBB) {
 148   bool Changed = false;
 149   for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ++I)
 150     if (I->getDesc().hasDelaySlot()) {
 151       MachineBasicBlock::iterator J = I;
 152       MachineBasicBlock::iterator D = findDelayInstr(MBB,I);
 153
 154       ++J;
 155       ++FilledSlots;
 156       Changed = true;
 157
 158       if (D == MBB.end())
 159         BuildMI(MBB, J, I->getDebugLoc(), TII->get(MBlaze::NOP));
 160       else
 161         MBB.splice(J, &MBB, D);
 162     }
 163   return Changed;
 164 }
 165
 166 /// createMBlazeDelaySlotFillerPass - Returns a pass that fills in delay
 167 /// slots in MBlaze MachineFunctions
 168 FunctionPass *llvm::createMBlazeDelaySlotFillerPass(MBlazeTargetMachine &tm) {
 169   return new Filler(tm);
 170 }
 171