contrib/llvm/include/llvm/CodeGen/MachineInstrBuilder.h

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