contrib/llvm/include/llvm/CodeGen/MachineInstrBundle.h

   1 //===-- CodeGen/MachineInstBundle.h - MI bundle utilities -------*- C++ -*-===//
   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 // This file provide utility functions to manipulate machine instruction
  11 // bundles.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
  16 #define LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
  17
  18 #include "llvm/CodeGen/MachineBasicBlock.h"
  19
  20 namespace llvm {
  21
  22 /// finalizeBundle - Finalize a machine instruction bundle which includes
  23 /// a sequence of instructions starting from FirstMI to LastMI (exclusive).
  24 /// This routine adds a BUNDLE instruction to represent the bundle, it adds
  25 /// IsInternalRead markers to MachineOperands which are defined inside the
  26 /// bundle, and it copies externally visible defs and uses to the BUNDLE
  27 /// instruction.
  28 void finalizeBundle(MachineBasicBlock &MBB,
  29                     MachineBasicBlock::instr_iterator FirstMI,
  30                     MachineBasicBlock::instr_iterator LastMI);
  31
  32 /// finalizeBundle - Same functionality as the previous finalizeBundle except
  33 /// the last instruction in the bundle is not provided as an input. This is
  34 /// used in cases where bundles are pre-determined by marking instructions
  35 /// with 'InsideBundle' marker. It returns the MBB instruction iterator that
  36 /// points to the end of the bundle.
  37 MachineBasicBlock::instr_iterator finalizeBundle(MachineBasicBlock &MBB,
  38                     MachineBasicBlock::instr_iterator FirstMI);
  39
  40 /// finalizeBundles - Finalize instruction bundles in the specified
  41 /// MachineFunction. Return true if any bundles are finalized.
  42 bool finalizeBundles(MachineFunction &MF);
  43
  44 /// Returns an iterator to the first instruction in the bundle containing \p I.
  45 inline MachineBasicBlock::instr_iterator getBundleStart(
  46     MachineBasicBlock::instr_iterator I) {
  47   while (I->isBundledWithPred())
  48     --I;
  49   return I;
  50 }
  51
  52 /// Returns an iterator to the first instruction in the bundle containing \p I.
  53 inline MachineBasicBlock::const_instr_iterator getBundleStart(
  54     MachineBasicBlock::const_instr_iterator I) {
  55   while (I->isBundledWithPred())
  56     --I;
  57   return I;
  58 }
  59
  60 /// Returns an iterator pointing beyond the bundle containing \p I.
  61 inline MachineBasicBlock::instr_iterator getBundleEnd(
  62     MachineBasicBlock::instr_iterator I) {
  63   while (I->isBundledWithSucc())
  64     ++I;
  65   return ++I;
  66 }
  67
  68 /// Returns an iterator pointing beyond the bundle containing \p I.
  69 inline MachineBasicBlock::const_instr_iterator getBundleEnd(
  70     MachineBasicBlock::const_instr_iterator I) {
  71   while (I->isBundledWithSucc())
  72     ++I;
  73   return ++I;
  74 }
  75
  76 //===----------------------------------------------------------------------===//
  77 // MachineOperand iterator
  78 //
  79
  80 /// MachineOperandIteratorBase - Iterator that can visit all operands on a
  81 /// MachineInstr, or all operands on a bundle of MachineInstrs.  This class is
  82 /// not intended to be used directly, use one of the sub-classes instead.
  83 ///
  84 /// Intended use:
  85 ///
  86 ///   for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) {
  87 ///     if (!MIO->isReg())
  88 ///       continue;
  89 ///     ...
  90 ///   }
  91 ///
  92 class MachineOperandIteratorBase {
  93   MachineBasicBlock::instr_iterator InstrI, InstrE;
  94   MachineInstr::mop_iterator OpI, OpE;
  95
  96   // If the operands on InstrI are exhausted, advance InstrI to the next
  97   // bundled instruction with operands.
  98   void advance() {
  99     while (OpI == OpE) {
 100       // Don't advance off the basic block, or into a new bundle.
 101       if (++InstrI == InstrE || !InstrI->isInsideBundle())
 102         break;
 103       OpI = InstrI->operands_begin();
 104       OpE = InstrI->operands_end();
 105     }
 106   }
 107
 108 protected:
 109   /// MachineOperandIteratorBase - Create an iterator that visits all operands
 110   /// on MI, or all operands on every instruction in the bundle containing MI.
 111   ///
 112   /// @param MI The instruction to examine.
 113   /// @param WholeBundle When true, visit all operands on the entire bundle.
 114   ///
 115   explicit MachineOperandIteratorBase(MachineInstr &MI, bool WholeBundle) {
 116     if (WholeBundle) {
 117       InstrI = getBundleStart(MI.getIterator());
 118       InstrE = MI.getParent()->instr_end();
 119     } else {
 120       InstrI = InstrE = MI.getIterator();
 121       ++InstrE;
 122     }
 123     OpI = InstrI->operands_begin();
 124     OpE = InstrI->operands_end();
 125     if (WholeBundle)
 126       advance();
 127   }
 128
 129   MachineOperand &deref() const { return *OpI; }
 130
 131 public:
 132   /// isValid - Returns true until all the operands have been visited.
 133   bool isValid() const { return OpI != OpE; }
 134
 135   /// Preincrement.  Move to the next operand.
 136   void operator++() {
 137     assert(isValid() && "Cannot advance MIOperands beyond the last operand");
 138     ++OpI;
 139     advance();
 140   }
 141
 142   /// getOperandNo - Returns the number of the current operand relative to its
 143   /// instruction.
 144   ///
 145   unsigned getOperandNo() const {
 146     return OpI - InstrI->operands_begin();
 147   }
 148
 149   /// VirtRegInfo - Information about a virtual register used by a set of operands.
 150   ///
 151   struct VirtRegInfo {
 152     /// Reads - One of the operands read the virtual register.  This does not
 153     /// include <undef> or <internal> use operands, see MO::readsReg().
 154     bool Reads;
 155
 156     /// Writes - One of the operands writes the virtual register.
 157     bool Writes;
 158
 159     /// Tied - Uses and defs must use the same register. This can be because of
 160     /// a two-address constraint, or there may be a partial redefinition of a
 161     /// sub-register.
 162     bool Tied;
 163   };
 164
 165   /// Information about how a physical register Reg is used by a set of
 166   /// operands.
 167   struct PhysRegInfo {
 168     /// There is a regmask operand indicating Reg is clobbered.
 169     /// \see MachineOperand::CreateRegMask().
 170     bool Clobbered;
 171
 172     /// Reg or one of its aliases is defined. The definition may only cover
 173     /// parts of the register.
 174     bool Defined;
 175     /// Reg or a super-register is defined. The definition covers the full
 176     /// register.
 177     bool FullyDefined;
 178
 179     /// Reg or one of its aliases is read. The register may only be read
 180     /// partially.
 181     bool Read;
 182     /// Reg or a super-register is read. The full register is read.
 183     bool FullyRead;
 184
 185     /// Either:
 186     /// - Reg is FullyDefined and all defs of reg or an overlapping
 187     ///   register are dead, or
 188     /// - Reg is completely dead because "defined" by a clobber.
 189     bool DeadDef;
 190
 191     /// Reg is Defined and all defs of reg or an overlapping register are
 192     /// dead.
 193     bool PartialDeadDef;
 194
 195     /// There is a use operand of reg or a super-register with kill flag set.
 196     bool Killed;
 197   };
 198
 199   /// analyzeVirtReg - Analyze how the current instruction or bundle uses a
 200   /// virtual register.  This function should not be called after operator++(),
 201   /// it expects a fresh iterator.
 202   ///
 203   /// @param Reg The virtual register to analyze.
 204   /// @param Ops When set, this vector will receive an (MI, OpNum) entry for
 205   ///            each operand referring to Reg.
 206   /// @returns A filled-in RegInfo struct.
 207   VirtRegInfo analyzeVirtReg(unsigned Reg,
 208            SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = nullptr);
 209
 210   /// analyzePhysReg - Analyze how the current instruction or bundle uses a
 211   /// physical register.  This function should not be called after operator++(),
 212   /// it expects a fresh iterator.
 213   ///
 214   /// @param Reg The physical register to analyze.
 215   /// @returns A filled-in PhysRegInfo struct.
 216   PhysRegInfo analyzePhysReg(unsigned Reg, const TargetRegisterInfo *TRI);
 217 };
 218
 219 /// MIOperands - Iterate over operands of a single instruction.
 220 ///
 221 class MIOperands : public MachineOperandIteratorBase {
 222 public:
 223   MIOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, false) {}
 224   MachineOperand &operator* () const { return deref(); }
 225   MachineOperand *operator->() const { return &deref(); }
 226 };
 227
 228 /// ConstMIOperands - Iterate over operands of a single const instruction.
 229 ///
 230 class ConstMIOperands : public MachineOperandIteratorBase {
 231 public:
 232   ConstMIOperands(const MachineInstr &MI)
 233       : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), false) {}
 234   const MachineOperand &operator* () const { return deref(); }
 235   const MachineOperand *operator->() const { return &deref(); }
 236 };
 237
 238 /// MIBundleOperands - Iterate over all operands in a bundle of machine
 239 /// instructions.
 240 ///
 241 class MIBundleOperands : public MachineOperandIteratorBase {
 242 public:
 243   MIBundleOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, true) {}
 244   MachineOperand &operator* () const { return deref(); }
 245   MachineOperand *operator->() const { return &deref(); }
 246 };
 247
 248 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of
 249 /// machine instructions.
 250 ///
 251 class ConstMIBundleOperands : public MachineOperandIteratorBase {
 252 public:
 253   ConstMIBundleOperands(const MachineInstr &MI)
 254       : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), true) {}
 255   const MachineOperand &operator* () const { return deref(); }
 256   const MachineOperand *operator->() const { return &deref(); }
 257 };
 258
 259 } // End llvm namespace
 260
 261 #endif