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