include/llvm/CodeGen/MachineInstrBuilder.h

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