Home | History | Annotate | Download | only in CodeGen 
      1 //===-- lib/CodeGen/MachineInstrBundle.cpp --------------------------------===//
      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 #include "llvm/CodeGen/MachineInstrBundle.h"
     11 #include "llvm/CodeGen/MachineInstrBuilder.h"
     12 #include "llvm/CodeGen/Passes.h"
     13 #include "llvm/CodeGen/MachineFunctionPass.h"
     14 #include "llvm/Target/TargetInstrInfo.h"
     15 #include "llvm/Target/TargetMachine.h"
     16 #include "llvm/Target/TargetRegisterInfo.h"
     17 #include "llvm/ADT/SmallSet.h"
     18 #include "llvm/ADT/SmallVector.h"
     19 using namespace llvm;
     20 
     21 namespace {
     22   class UnpackMachineBundles : public MachineFunctionPass {
     23   public:
     24     static char ID; // Pass identification
     25     UnpackMachineBundles() : MachineFunctionPass(ID) {
     26       initializeUnpackMachineBundlesPass(*PassRegistry::getPassRegistry());
     27     }
     28 
     29     virtual bool runOnMachineFunction(MachineFunction &MF);
     30   };
     31 } // end anonymous namespace
     32 
     33 char UnpackMachineBundles::ID = 0;
     34 char &llvm::UnpackMachineBundlesID = UnpackMachineBundles::ID;
     35 INITIALIZE_PASS(UnpackMachineBundles, "unpack-mi-bundles",
     36                 "Unpack machine instruction bundles", false, false)
     37 
     38 bool UnpackMachineBundles::runOnMachineFunction(MachineFunction &MF) {
     39   bool Changed = false;
     40   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
     41     MachineBasicBlock *MBB = &*I;
     42 
     43     for (MachineBasicBlock::instr_iterator MII = MBB->instr_begin(),
     44            MIE = MBB->instr_end(); MII != MIE; ) {
     45       MachineInstr *MI = &*MII;
     46 
     47       // Remove BUNDLE instruction and the InsideBundle flags from bundled
     48       // instructions.
     49       if (MI->isBundle()) {
     50         while (++MII != MIE && MII->isInsideBundle()) {
     51           MII->setIsInsideBundle(false);
     52           for (unsigned i = 0, e = MII->getNumOperands(); i != e; ++i) {
     53             MachineOperand &MO = MII->getOperand(i);
     54             if (MO.isReg() && MO.isInternalRead())
     55               MO.setIsInternalRead(false);
     56           }
     57         }
     58         MI->eraseFromParent();
     59 
     60         Changed = true;
     61         continue;
     62       }
     63 
     64       ++MII;
     65     }
     66   }
     67 
     68   return Changed;
     69 }
     70 
     71 
     72 namespace {
     73   class FinalizeMachineBundles : public MachineFunctionPass {
     74   public:
     75     static char ID; // Pass identification
     76     FinalizeMachineBundles() : MachineFunctionPass(ID) {
     77       initializeFinalizeMachineBundlesPass(*PassRegistry::getPassRegistry());
     78     }
     79 
     80     virtual bool runOnMachineFunction(MachineFunction &MF);
     81   };
     82 } // end anonymous namespace
     83 
     84 char FinalizeMachineBundles::ID = 0;
     85 char &llvm::FinalizeMachineBundlesID = FinalizeMachineBundles::ID;
     86 INITIALIZE_PASS(FinalizeMachineBundles, "finalize-mi-bundles",
     87                 "Finalize machine instruction bundles", false, false)
     88 
     89 bool FinalizeMachineBundles::runOnMachineFunction(MachineFunction &MF) {
     90   return llvm::finalizeBundles(MF);
     91 }
     92 
     93 
     94 /// finalizeBundle - Finalize a machine instruction bundle which includes
     95 /// a sequence of instructions starting from FirstMI to LastMI (exclusive).
     96 /// This routine adds a BUNDLE instruction to represent the bundle, it adds
     97 /// IsInternalRead markers to MachineOperands which are defined inside the
     98 /// bundle, and it copies externally visible defs and uses to the BUNDLE
     99 /// instruction.
    100 void llvm::finalizeBundle(MachineBasicBlock &MBB,
    101                           MachineBasicBlock::instr_iterator FirstMI,
    102                           MachineBasicBlock::instr_iterator LastMI) {
    103   assert(FirstMI != LastMI && "Empty bundle?");
    104 
    105   const TargetMachine &TM = MBB.getParent()->getTarget();
    106   const TargetInstrInfo *TII = TM.getInstrInfo();
    107   const TargetRegisterInfo *TRI = TM.getRegisterInfo();
    108 
    109   MachineInstrBuilder MIB = BuildMI(MBB, FirstMI, FirstMI->getDebugLoc(),
    110                                     TII->get(TargetOpcode::BUNDLE));
    111 
    112   SmallVector<unsigned, 8> LocalDefs;
    113   SmallSet<unsigned, 8> LocalDefSet;
    114   SmallSet<unsigned, 8> DeadDefSet;
    115   SmallSet<unsigned, 8> KilledDefSet;
    116   SmallVector<unsigned, 8> ExternUses;
    117   SmallSet<unsigned, 8> ExternUseSet;
    118   SmallSet<unsigned, 8> KilledUseSet;
    119   SmallSet<unsigned, 8> UndefUseSet;
    120   SmallVector<MachineOperand*, 4> Defs;
    121   for (; FirstMI != LastMI; ++FirstMI) {
    122     for (unsigned i = 0, e = FirstMI->getNumOperands(); i != e; ++i) {
    123       MachineOperand &MO = FirstMI->getOperand(i);
    124       if (!MO.isReg())
    125         continue;
    126       if (MO.isDef()) {
    127         Defs.push_back(&MO);
    128         continue;
    129       }
    130 
    131       unsigned Reg = MO.getReg();
    132       if (!Reg)
    133         continue;
    134       assert(TargetRegisterInfo::isPhysicalRegister(Reg));
    135       if (LocalDefSet.count(Reg)) {
    136         MO.setIsInternalRead();
    137         if (MO.isKill())
    138           // Internal def is now killed.
    139           KilledDefSet.insert(Reg);
    140       } else {
    141         if (ExternUseSet.insert(Reg)) {
    142           ExternUses.push_back(Reg);
    143           if (MO.isUndef())
    144             UndefUseSet.insert(Reg);
    145         }
    146         if (MO.isKill())
    147           // External def is now killed.
    148           KilledUseSet.insert(Reg);
    149       }
    150     }
    151 
    152     for (unsigned i = 0, e = Defs.size(); i != e; ++i) {
    153       MachineOperand &MO = *Defs[i];
    154       unsigned Reg = MO.getReg();
    155       if (!Reg)
    156         continue;
    157 
    158       if (LocalDefSet.insert(Reg)) {
    159         LocalDefs.push_back(Reg);
    160         if (MO.isDead()) {
    161           DeadDefSet.insert(Reg);
    162         }
    163       } else {
    164         // Re-defined inside the bundle, it's no longer killed.
    165         KilledDefSet.erase(Reg);
    166         if (!MO.isDead())
    167           // Previously defined but dead.
    168           DeadDefSet.erase(Reg);
    169       }
    170 
    171       if (!MO.isDead()) {
    172         for (const uint16_t *SubRegs = TRI->getSubRegisters(Reg);
    173              unsigned SubReg = *SubRegs; ++SubRegs) {
    174           if (LocalDefSet.insert(SubReg))
    175             LocalDefs.push_back(SubReg);
    176         }
    177       }
    178     }
    179 
    180     FirstMI->setIsInsideBundle();
    181     Defs.clear();
    182   }
    183 
    184   SmallSet<unsigned, 8> Added;
    185   for (unsigned i = 0, e = LocalDefs.size(); i != e; ++i) {
    186     unsigned Reg = LocalDefs[i];
    187     if (Added.insert(Reg)) {
    188       // If it's not live beyond end of the bundle, mark it dead.
    189       bool isDead = DeadDefSet.count(Reg) || KilledDefSet.count(Reg);
    190       MIB.addReg(Reg, getDefRegState(true) | getDeadRegState(isDead) |
    191                  getImplRegState(true));
    192     }
    193   }
    194 
    195   for (unsigned i = 0, e = ExternUses.size(); i != e; ++i) {
    196     unsigned Reg = ExternUses[i];
    197     bool isKill = KilledUseSet.count(Reg);
    198     bool isUndef = UndefUseSet.count(Reg);
    199     MIB.addReg(Reg, getKillRegState(isKill) | getUndefRegState(isUndef) |
    200                getImplRegState(true));
    201   }
    202 }
    203 
    204 /// finalizeBundle - Same functionality as the previous finalizeBundle except
    205 /// the last instruction in the bundle is not provided as an input. This is
    206 /// used in cases where bundles are pre-determined by marking instructions
    207 /// with 'InsideBundle' marker. It returns the MBB instruction iterator that
    208 /// points to the end of the bundle.
    209 MachineBasicBlock::instr_iterator
    210 llvm::finalizeBundle(MachineBasicBlock &MBB,
    211                      MachineBasicBlock::instr_iterator FirstMI) {
    212   MachineBasicBlock::instr_iterator E = MBB.instr_end();
    213   MachineBasicBlock::instr_iterator LastMI = llvm::next(FirstMI);
    214   while (LastMI != E && LastMI->isInsideBundle())
    215     ++LastMI;
    216   finalizeBundle(MBB, FirstMI, LastMI);
    217   return LastMI;
    218 }
    219 
    220 /// finalizeBundles - Finalize instruction bundles in the specified
    221 /// MachineFunction. Return true if any bundles are finalized.
    222 bool llvm::finalizeBundles(MachineFunction &MF) {
    223   bool Changed = false;
    224   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
    225     MachineBasicBlock &MBB = *I;
    226 
    227     MachineBasicBlock::instr_iterator MII = MBB.instr_begin();
    228     assert(!MII->isInsideBundle() &&
    229            "First instr cannot be inside bundle before finalization!");
    230 
    231     MachineBasicBlock::instr_iterator MIE = MBB.instr_end();
    232     if (MII == MIE)
    233       continue;
    234     for (++MII; MII != MIE; ) {
    235       if (!MII->isInsideBundle())
    236         ++MII;
    237       else {
    238         MII = finalizeBundle(MBB, llvm::prior(MII));
    239         Changed = true;
    240       }
    241     }
    242   }
    243 
    244   return Changed;
    245 }
    246 
    247 //===----------------------------------------------------------------------===//
    248 // MachineOperand iterator
    249 //===----------------------------------------------------------------------===//
    250 
    251 MachineOperandIteratorBase::RegInfo
    252 MachineOperandIteratorBase::analyzeVirtReg(unsigned Reg,
    253                     SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops) {
    254   RegInfo RI = { false, false, false };
    255   for(; isValid(); ++*this) {
    256     MachineOperand &MO = deref();
    257     if (!MO.isReg() || MO.getReg() != Reg)
    258       continue;
    259 
    260     // Remember each (MI, OpNo) that refers to Reg.
    261     if (Ops)
    262       Ops->push_back(std::make_pair(MO.getParent(), getOperandNo()));
    263 
    264     // Both defs and uses can read virtual registers.
    265     if (MO.readsReg()) {
    266       RI.Reads = true;
    267       if (MO.isDef())
    268         RI.Tied = true;
    269     }
    270 
    271     // Only defs can write.
    272     if (MO.isDef())
    273       RI.Writes = true;
    274     else if (!RI.Tied && MO.getParent()->isRegTiedToDefOperand(getOperandNo()))
    275       RI.Tied = true;
    276   }
    277   return RI;
    278 }
    279