include/llvm/CodeGen/MachineInstrBuilder.h

   1 //===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- 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 exposes a function named BuildMI, which is useful for dramatically
  11 // simplifying how MachineInstr's are created.  It allows use of code like this:
  12 //
  13 //   M = BuildMI(X86::ADDrr8, 2).addReg(argVal1).addReg(argVal2);
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  18 #define LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  19
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstrBundle.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23
  24 namespace llvm {
  25
  26 class MCInstrDesc;
  27 class MDNode;
  28
  29 namespace RegState {
  30   enum {
  31     Define         = 0x2,
  32     Implicit       = 0x4,
  33     Kill           = 0x8,
  34     Dead           = 0x10,
  35     Undef          = 0x20,
  36     EarlyClobber   = 0x40,
  37     Debug          = 0x80,
  38     InternalRead   = 0x100,
  39     DefineNoRead   = Define | Undef,
  40     ImplicitDefine = Implicit | Define,
  41     ImplicitKill   = Implicit | Kill
  42   };
  43 }
  44
  45 class MachineInstrBuilder {
  46   MachineFunction *MF;
  47   MachineInstr *MI;
  48 public:
  49   MachineInstrBuilder() : MF(nullptr), MI(nullptr) {}
  50
  51   /// Create a MachineInstrBuilder for manipulating an existing instruction.
  52   /// F must be the machine function that was used to allocate I.
  53   MachineInstrBuilder(MachineFunction &F, MachineInstr *I) : MF(&F), MI(I) {}
  54
  55   /// Allow automatic conversion to the machine instruction we are working on.
  56   operator MachineInstr*() const { return MI; }
  57   MachineInstr *operator->() const { return MI; }
  58   operator MachineBasicBlock::iterator() const { return MI; }
  59
  60   /// If conversion operators fail, use this method to get the MachineInstr
  61   /// explicitly.
  62   MachineInstr *getInstr() const { return MI; }
  63
  64   /// Add a new virtual register operand.
  65   const MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0,
  66                                     unsigned SubReg = 0) const {
  67     assert((flags & 0x1) == 0 &&
  68            "Passing in 'true' to addReg is forbidden! Use enums instead.");
  69     MI->addOperand(*MF, MachineOperand::CreateReg(RegNo,
  70                                                flags & RegState::Define,
  71                                                flags & RegState::Implicit,
  72                                                flags & RegState::Kill,
  73                                                flags & RegState::Dead,
  74                                                flags & RegState::Undef,
  75                                                flags & RegState::EarlyClobber,
  76                                                SubReg,
  77                                                flags & RegState::Debug,
  78                                                flags & RegState::InternalRead));
  79     return *this;
  80   }
  81
  82   /// Add a new immediate operand.
  83   const MachineInstrBuilder &addImm(int64_t Val) const {
  84     MI->addOperand(*MF, MachineOperand::CreateImm(Val));
  85     return *this;
  86   }
  87
  88   const MachineInstrBuilder &addCImm(const ConstantInt *Val) const {
  89     MI->addOperand(*MF, MachineOperand::CreateCImm(Val));
  90     return *this;
  91   }
  92
  93   const MachineInstrBuilder &addFPImm(const ConstantFP *Val) const {
  94     MI->addOperand(*MF, MachineOperand::CreateFPImm(Val));
  95     return *this;
  96   }
  97
  98   const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
  99                                     unsigned char TargetFlags = 0) const {
 100     MI->addOperand(*MF, MachineOperand::CreateMBB(MBB, TargetFlags));
 101     return *this;
 102   }
 103
 104   const MachineInstrBuilder &addFrameIndex(int Idx) const {
 105     MI->addOperand(*MF, MachineOperand::CreateFI(Idx));
 106     return *this;
 107   }
 108
 109   const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
 110                                                   int Offset = 0,
 111                                           unsigned char TargetFlags = 0) const {
 112     MI->addOperand(*MF, MachineOperand::CreateCPI(Idx, Offset, TargetFlags));
 113     return *this;
 114   }
 115
 116   const MachineInstrBuilder &addTargetIndex(unsigned Idx, int64_t Offset = 0,
 117                                           unsigned char TargetFlags = 0) const {
 118     MI->addOperand(*MF, MachineOperand::CreateTargetIndex(Idx, Offset,
 119                                                           TargetFlags));
 120     return *this;
 121   }
 122
 123   const MachineInstrBuilder &addJumpTableIndex(unsigned Idx,
 124                                           unsigned char TargetFlags = 0) const {
 125     MI->addOperand(*MF, MachineOperand::CreateJTI(Idx, TargetFlags));
 126     return *this;
 127   }
 128
 129   const MachineInstrBuilder &addGlobalAddress(const GlobalValue *GV,
 130                                               int64_t Offset = 0,
 131                                           unsigned char TargetFlags = 0) const {
 132     MI->addOperand(*MF, MachineOperand::CreateGA(GV, Offset, TargetFlags));
 133     return *this;
 134   }
 135
 136   const MachineInstrBuilder &addExternalSymbol(const char *FnName,
 137                                           unsigned char TargetFlags = 0) const {
 138     MI->addOperand(*MF, MachineOperand::CreateES(FnName, TargetFlags));
 139     return *this;
 140   }
 141
 142   const MachineInstrBuilder &addBlockAddress(const BlockAddress *BA,
 143                                              int64_t Offset = 0,
 144                                           unsigned char TargetFlags = 0) const {
 145     MI->addOperand(*MF, MachineOperand::CreateBA(BA, Offset, TargetFlags));
 146     return *this;
 147   }
 148
 149   const MachineInstrBuilder &addRegMask(const uint32_t *Mask) const {
 150     MI->addOperand(*MF, MachineOperand::CreateRegMask(Mask));
 151     return *this;
 152   }
 153
 154   const MachineInstrBuilder &addMemOperand(MachineMemOperand *MMO) const {
 155     MI->addMemOperand(*MF, MMO);
 156     return *this;
 157   }
 158
 159   const MachineInstrBuilder &setMemRefs(MachineInstr::mmo_iterator b,
 160                                         MachineInstr::mmo_iterator e) const {
 161     MI->setMemRefs(b, e);
 162     return *this;
 163   }
 164
 165
 166   const MachineInstrBuilder &addOperand(const MachineOperand &MO) const {
 167     MI->addOperand(*MF, MO);
 168     return *this;
 169   }
 170
 171   const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
 172     MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
 173     assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
 174                                : true) &&
 175            "first MDNode argument of a DBG_VALUE not a variable");
 176     return *this;
 177   }
 178
 179   const MachineInstrBuilder &addCFIIndex(unsigned CFIIndex) const {
 180     MI->addOperand(*MF, MachineOperand::CreateCFIIndex(CFIIndex));
 181     return *this;
 182   }
 183
 184   const MachineInstrBuilder &addSym(MCSymbol *Sym,
 185                                     unsigned char TargetFlags = 0) const {
 186     MI->addOperand(*MF, MachineOperand::CreateMCSymbol(Sym, TargetFlags));
 187     return *this;
 188   }
 189
 190   const MachineInstrBuilder &setMIFlags(unsigned Flags) const {
 191     MI->setFlags(Flags);
 192     return *this;
 193   }
 194
 195   const MachineInstrBuilder &setMIFlag(MachineInstr::MIFlag Flag) const {
 196     MI->setFlag(Flag);
 197     return *this;
 198   }
 199
 200   // Add a displacement from an existing MachineOperand with an added offset.
 201   const MachineInstrBuilder &addDisp(const MachineOperand &Disp, int64_t off,
 202                                      unsigned char TargetFlags = 0) const {
 203     // If caller specifies new TargetFlags then use it, otherwise the
 204     // default behavior is to copy the target flags from the existing
 205     // MachineOperand. This means if the caller wants to clear the
 206     // target flags it needs to do so explicitly.
 207     if (0 == TargetFlags)
 208       TargetFlags = Disp.getTargetFlags();
 209
 210     switch (Disp.getType()) {
 211       default:
 212         llvm_unreachable("Unhandled operand type in addDisp()");
 213       case MachineOperand::MO_Immediate:
 214         return addImm(Disp.getImm() + off);
 215       case MachineOperand::MO_ConstantPoolIndex:
 216         return addConstantPoolIndex(Disp.getIndex(), Disp.getOffset() + off,
 217                                     TargetFlags);
 218       case MachineOperand::MO_GlobalAddress:
 219         return addGlobalAddress(Disp.getGlobal(), Disp.getOffset() + off,
 220                                 TargetFlags);
 221     }
 222   }
 223
 224   /// Copy all the implicit operands from OtherMI onto this one.
 225   const MachineInstrBuilder &
 226   copyImplicitOps(const MachineInstr *OtherMI) const {
 227     MI->copyImplicitOps(*MF, OtherMI);
 228     return *this;
 229   }
 230 };
 231
 232 /// Builder interface. Specify how to create the initial instruction itself.
 233 inline MachineInstrBuilder BuildMI(MachineFunction &MF,
 234                                    DebugLoc DL,
 235                                    const MCInstrDesc &MCID) {
 236   return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL));
 237 }
 238
 239 /// This version of the builder sets up the first operand as a
 240 /// destination virtual register.
 241 inline MachineInstrBuilder BuildMI(MachineFunction &MF,
 242                                    DebugLoc DL,
 243                                    const MCInstrDesc &MCID,
 244                                    unsigned DestReg) {
 245   return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL))
 246            .addReg(DestReg, RegState::Define);
 247 }
 248
 249 /// This version of the builder inserts the newly-built instruction before
 250 /// the given position in the given MachineBasicBlock, and sets up the first
 251 /// operand as a destination virtual register.
 252 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 253                                    MachineBasicBlock::iterator I,
 254                                    DebugLoc DL,
 255                                    const MCInstrDesc &MCID,
 256                                    unsigned DestReg) {
 257   MachineFunction &MF = *BB.getParent();
 258   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
 259   BB.insert(I, MI);
 260   return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
 261 }
 262
 263 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 264                                    MachineBasicBlock::instr_iterator I,
 265                                    DebugLoc DL,
 266                                    const MCInstrDesc &MCID,
 267                                    unsigned DestReg) {
 268   MachineFunction &MF = *BB.getParent();
 269   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
 270   BB.insert(I, MI);
 271   return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
 272 }
 273
 274 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 275                                    MachineInstr *I,
 276                                    DebugLoc DL,
 277                                    const MCInstrDesc &MCID,
 278                                    unsigned DestReg) {
 279   if (I->isInsideBundle()) {
 280     MachineBasicBlock::instr_iterator MII(I);
 281     return BuildMI(BB, MII, DL, MCID, DestReg);
 282   }
 283
 284   MachineBasicBlock::iterator MII = I;
 285   return BuildMI(BB, MII, DL, MCID, DestReg);
 286 }
 287
 288 /// This version of the builder inserts the newly-built instruction before the
 289 /// given position in the given MachineBasicBlock, and does NOT take a
 290 /// destination register.
 291 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 292                                    MachineBasicBlock::iterator I,
 293                                    DebugLoc DL,
 294                                    const MCInstrDesc &MCID) {
 295   MachineFunction &MF = *BB.getParent();
 296   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
 297   BB.insert(I, MI);
 298   return MachineInstrBuilder(MF, MI);
 299 }
 300
 301 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 302                                    MachineBasicBlock::instr_iterator I,
 303                                    DebugLoc DL,
 304                                    const MCInstrDesc &MCID) {
 305   MachineFunction &MF = *BB.getParent();
 306   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
 307   BB.insert(I, MI);
 308   return MachineInstrBuilder(MF, MI);
 309 }
 310
 311 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 312                                    MachineInstr *I,
 313                                    DebugLoc DL,
 314                                    const MCInstrDesc &MCID) {
 315   if (I->isInsideBundle()) {
 316     MachineBasicBlock::instr_iterator MII(I);
 317     return BuildMI(BB, MII, DL, MCID);
 318   }
 319
 320   MachineBasicBlock::iterator MII = I;
 321   return BuildMI(BB, MII, DL, MCID);
 322 }
 323
 324 /// This version of the builder inserts the newly-built instruction at the end
 325 /// of the given MachineBasicBlock, and does NOT take a destination register.
 326 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB,
 327                                    DebugLoc DL,
 328                                    const MCInstrDesc &MCID) {
 329   return BuildMI(*BB, BB->end(), DL, MCID);
 330 }
 331
 332 /// This version of the builder inserts the newly-built instruction at the
 333 /// end of the given MachineBasicBlock, and sets up the first operand as a
 334 /// destination virtual register.
 335 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB,
 336                                    DebugLoc DL,
 337                                    const MCInstrDesc &MCID,
 338                                    unsigned DestReg) {
 339   return BuildMI(*BB, BB->end(), DL, MCID, DestReg);
 340 }
 341
 342 /// This version of the builder builds a DBG_VALUE intrinsic
 343 /// for either a value in a register or a register-indirect+offset
 344 /// address.  The convention is that a DBG_VALUE is indirect iff the
 345 /// second operand is an immediate.
 346 inline MachineInstrBuilder BuildMI(MachineFunction &MF, DebugLoc DL,
 347                                    const MCInstrDesc &MCID, bool IsIndirect,
 348                                    unsigned Reg, unsigned Offset,
 349                                    const MDNode *Variable, const MDNode *Expr) {
 350   assert(isa<DILocalVariable>(Variable) && "not a variable");
 351   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
 352   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
 353          "Expected inlined-at fields to agree");
 354   if (IsIndirect)
 355     return BuildMI(MF, DL, MCID)
 356         .addReg(Reg, RegState::Debug)
 357         .addImm(Offset)
 358         .addMetadata(Variable)
 359         .addMetadata(Expr);
 360   else {
 361     assert(Offset == 0 && "A direct address cannot have an offset.");
 362     return BuildMI(MF, DL, MCID)
 363         .addReg(Reg, RegState::Debug)
 364         .addReg(0U, RegState::Debug)
 365         .addMetadata(Variable)
 366         .addMetadata(Expr);
 367   }
 368 }
 369
 370 /// This version of the builder builds a DBG_VALUE intrinsic
 371 /// for either a value in a register or a register-indirect+offset
 372 /// address and inserts it at position I.
 373 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 374                                    MachineBasicBlock::iterator I, DebugLoc DL,
 375                                    const MCInstrDesc &MCID, bool IsIndirect,
 376                                    unsigned Reg, unsigned Offset,
 377                                    const MDNode *Variable, const MDNode *Expr) {
 378   assert(isa<DILocalVariable>(Variable) && "not a variable");
 379   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
 380   MachineFunction &MF = *BB.getParent();
 381   MachineInstr *MI =
 382       BuildMI(MF, DL, MCID, IsIndirect, Reg, Offset, Variable, Expr);
 383   BB.insert(I, MI);
 384   return MachineInstrBuilder(MF, MI);
 385 }
 386
 387
 388 inline unsigned getDefRegState(bool B) {
 389   return B ? RegState::Define : 0;
 390 }
 391 inline unsigned getImplRegState(bool B) {
 392   return B ? RegState::Implicit : 0;
 393 }
 394 inline unsigned getKillRegState(bool B) {
 395   return B ? RegState::Kill : 0;
 396 }
 397 inline unsigned getDeadRegState(bool B) {
 398   return B ? RegState::Dead : 0;
 399 }
 400 inline unsigned getUndefRegState(bool B) {
 401   return B ? RegState::Undef : 0;
 402 }
 403 inline unsigned getInternalReadRegState(bool B) {
 404   return B ? RegState::InternalRead : 0;
 405 }
 406 inline unsigned getDebugRegState(bool B) {
 407   return B ? RegState::Debug : 0;
 408 }
 409
 410
 411 /// Helper class for constructing bundles of MachineInstrs.
 412 ///
 413 /// MIBundleBuilder can create a bundle from scratch by inserting new
 414 /// MachineInstrs one at a time, or it can create a bundle from a sequence of
 415 /// existing MachineInstrs in a basic block.
 416 class MIBundleBuilder {
 417   MachineBasicBlock &MBB;
 418   MachineBasicBlock::instr_iterator Begin;
 419   MachineBasicBlock::instr_iterator End;
 420
 421 public:
 422   /// Create an MIBundleBuilder that inserts instructions into a new bundle in
 423   /// BB above the bundle or instruction at Pos.
 424   MIBundleBuilder(MachineBasicBlock &BB,
 425                   MachineBasicBlock::iterator Pos)
 426     : MBB(BB), Begin(Pos.getInstrIterator()), End(Begin) {}
 427
 428   /// Create a bundle from the sequence of instructions between B and E.
 429   MIBundleBuilder(MachineBasicBlock &BB,
 430                   MachineBasicBlock::iterator B,
 431                   MachineBasicBlock::iterator E)
 432     : MBB(BB), Begin(B.getInstrIterator()), End(E.getInstrIterator()) {
 433     assert(B != E && "No instructions to bundle");
 434     ++B;
 435     while (B != E) {
 436       MachineInstr *MI = B;
 437       ++B;
 438       MI->bundleWithPred();
 439     }
 440   }
 441
 442   /// Create an MIBundleBuilder representing an existing instruction or bundle
 443   /// that has MI as its head.
 444   explicit MIBundleBuilder(MachineInstr *MI)
 445     : MBB(*MI->getParent()), Begin(MI), End(getBundleEnd(MI)) {}
 446
 447   /// Return a reference to the basic block containing this bundle.
 448   MachineBasicBlock &getMBB() const { return MBB; }
 449
 450   /// Return true if no instructions have been inserted in this bundle yet.
 451   /// Empty bundles aren't representable in a MachineBasicBlock.
 452   bool empty() const { return Begin == End; }
 453
 454   /// Return an iterator to the first bundled instruction.
 455   MachineBasicBlock::instr_iterator begin() const { return Begin; }
 456
 457   /// Return an iterator beyond the last bundled instruction.
 458   MachineBasicBlock::instr_iterator end() const { return End; }
 459
 460   /// Insert MI into this bundle before I which must point to an instruction in
 461   /// the bundle, or end().
 462   MIBundleBuilder &insert(MachineBasicBlock::instr_iterator I,
 463                           MachineInstr *MI) {
 464     MBB.insert(I, MI);
 465     if (I == Begin) {
 466       if (!empty())
 467         MI->bundleWithSucc();
 468       Begin = MI->getIterator();
 469       return *this;
 470     }
 471     if (I == End) {
 472       MI->bundleWithPred();
 473       return *this;
 474     }
 475     // MI was inserted in the middle of the bundle, so its neighbors' flags are
 476     // already fine. Update MI's bundle flags manually.
 477     MI->setFlag(MachineInstr::BundledPred);
 478     MI->setFlag(MachineInstr::BundledSucc);
 479     return *this;
 480   }
 481
 482   /// Insert MI into MBB by prepending it to the instructions in the bundle.
 483   /// MI will become the first instruction in the bundle.
 484   MIBundleBuilder &prepend(MachineInstr *MI) {
 485     return insert(begin(), MI);
 486   }
 487
 488   /// Insert MI into MBB by appending it to the instructions in the bundle.
 489   /// MI will become the last instruction in the bundle.
 490   MIBundleBuilder &append(MachineInstr *MI) {
 491     return insert(end(), MI);
 492   }
 493 };
 494
 495 } // End llvm namespace
 496
 497 #endif