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 35namespace llvm { 36 37class MCInstrDesc; 38class MDNode; 39 40namespace 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 58class MachineInstrBuilder { 59 MachineFunction *MF = nullptr; 60 MachineInstr *MI = nullptr; 61 62public: 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. 286inline 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. 293inline 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. 302inline 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. 318inline 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 328inline 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 338inline 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. 347inline 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 357inline 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 367inline 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 377inline 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. 385inline 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. 393inline 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 400/// address. The convention is that a DBG_VALUE is indirect iff the 401/// second operand is an immediate. 402MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, 403 const MCInstrDesc &MCID, bool IsIndirect, 404 unsigned Reg, const MDNode *Variable, 405 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 409/// address and inserts it at position I. 410MachineInstrBuilder BuildMI(MachineBasicBlock &BB, 411 MachineBasicBlock::iterator I, const DebugLoc &DL, 412 const MCInstrDesc &MCID, bool IsIndirect, 413 unsigned Reg, const MDNode *Variable, 414 const MDNode *Expr); 415 416/// Clone a DBG_VALUE whose value has been spilled to FrameIndex. 417MachineInstr *buildDbgValueForSpill(MachineBasicBlock &BB, 418 MachineBasicBlock::iterator I, 419 const MachineInstr &Orig, int FrameIndex); 420 421/// Update a DBG_VALUE whose value has been spilled to FrameIndex. Useful when 422/// modifying an instruction in place while iterating over a basic block. 423void updateDbgValueForSpill(MachineInstr &Orig, int FrameIndex); 424 425inline unsigned getDefRegState(bool B) { 426 return B ? RegState::Define : 0; 427} 428inline unsigned getImplRegState(bool B) { 429 return B ? RegState::Implicit : 0; 430} 431inline unsigned getKillRegState(bool B) { 432 return B ? RegState::Kill : 0; 433} 434inline unsigned getDeadRegState(bool B) { 435 return B ? RegState::Dead : 0; 436} 437inline unsigned getUndefRegState(bool B) { 438 return B ? RegState::Undef : 0; 439} 440inline unsigned getInternalReadRegState(bool B) { 441 return B ? RegState::InternalRead : 0; 442} 443inline unsigned getDebugRegState(bool B) { 444 return B ? RegState::Debug : 0; 445} 446 447/// Get all register state flags from machine operand \p RegOp. 448inline unsigned getRegState(const MachineOperand &RegOp) { 449 assert(RegOp.isReg() && "Not a register operand"); 450 return getDefRegState(RegOp.isDef()) | 451 getImplRegState(RegOp.isImplicit()) | 452 getKillRegState(RegOp.isKill()) | 453 getDeadRegState(RegOp.isDead()) | 454 getUndefRegState(RegOp.isUndef()) | 455 getInternalReadRegState(RegOp.isInternalRead()) | 456 getDebugRegState(RegOp.isDebug()); 457} 458 459/// Helper class for constructing bundles of MachineInstrs. 460/// 461/// MIBundleBuilder can create a bundle from scratch by inserting new 462/// MachineInstrs one at a time, or it can create a bundle from a sequence of 463/// existing MachineInstrs in a basic block. 464class MIBundleBuilder { 465 MachineBasicBlock &MBB; 466 MachineBasicBlock::instr_iterator Begin; 467 MachineBasicBlock::instr_iterator End; 468 469public: 470 /// Create an MIBundleBuilder that inserts instructions into a new bundle in 471 /// BB above the bundle or instruction at Pos. 472 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos) 473 : MBB(BB), Begin(Pos.getInstrIterator()), End(Begin) {} 474 475 /// Create a bundle from the sequence of instructions between B and E. 476 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B, 477 MachineBasicBlock::iterator E) 478 : MBB(BB), Begin(B.getInstrIterator()), End(E.getInstrIterator()) { 479 assert(B != E && "No instructions to bundle"); 480 ++B; 481 while (B != E) { 482 MachineInstr &MI = *B; 483 ++B; 484 MI.bundleWithPred(); 485 } 486 } 487 488 /// Create an MIBundleBuilder representing an existing instruction or bundle 489 /// that has MI as its head. 490 explicit MIBundleBuilder(MachineInstr *MI) 491 : MBB(*MI->getParent()), Begin(MI), 492 End(getBundleEnd(MI->getIterator())) {} 493 494 /// Return a reference to the basic block containing this bundle. 495 MachineBasicBlock &getMBB() const { return MBB; } 496 497 /// Return true if no instructions have been inserted in this bundle yet. 498 /// Empty bundles aren't representable in a MachineBasicBlock. 499 bool empty() const { return Begin == End; } 500 501 /// Return an iterator to the first bundled instruction. 502 MachineBasicBlock::instr_iterator begin() const { return Begin; } 503 504 /// Return an iterator beyond the last bundled instruction. 505 MachineBasicBlock::instr_iterator end() const { return End; } 506 507 /// Insert MI into this bundle before I which must point to an instruction in 508 /// the bundle, or end(). 509 MIBundleBuilder &insert(MachineBasicBlock::instr_iterator I, 510 MachineInstr *MI) { 511 MBB.insert(I, MI); 512 if (I == Begin) { 513 if (!empty()) 514 MI->bundleWithSucc(); 515 Begin = MI->getIterator(); 516 return *this; 517 } 518 if (I == End) { 519 MI->bundleWithPred(); 520 return *this; 521 } 522 // MI was inserted in the middle of the bundle, so its neighbors' flags are 523 // already fine. Update MI's bundle flags manually. 524 MI->setFlag(MachineInstr::BundledPred); 525 MI->setFlag(MachineInstr::BundledSucc); 526 return *this; 527 } 528 529 /// Insert MI into MBB by prepending it to the instructions in the bundle. 530 /// MI will become the first instruction in the bundle. 531 MIBundleBuilder &prepend(MachineInstr *MI) { 532 return insert(begin(), MI); 533 } 534 535 /// Insert MI into MBB by appending it to the instructions in the bundle. 536 /// MI will become the last instruction in the bundle. 537 MIBundleBuilder &append(MachineInstr *MI) { 538 return insert(end(), MI); 539 } 540}; 541 542} // end namespace llvm 543 544#endif // LLVM_CODEGEN_MACHINEINSTRBUILDER_H 545