LLVM  8.0.0svn
MachineInstrBuilder.h
Go to the documentation of this file.
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"
30 #include "llvm/IR/InstrTypes.h"
31 #include "llvm/IR/Intrinsics.h"
33 #include <cassert>
34 #include <cstdint>
35 #include <utility>
36 
37 namespace llvm {
38 
39 class MCInstrDesc;
40 class MDNode;
41 
42 namespace RegState {
43 
44  enum {
45  Define = 0x2,
46  Implicit = 0x4,
47  Kill = 0x8,
48  Dead = 0x10,
49  Undef = 0x20,
50  EarlyClobber = 0x40,
51  Debug = 0x80,
52  InternalRead = 0x100,
53  Renamable = 0x200,
57  };
58 
59 } // end namespace RegState
60 
62  MachineFunction *MF = nullptr;
63  MachineInstr *MI = nullptr;
64 
65 public:
66  MachineInstrBuilder() = default;
67 
68  /// Create a MachineInstrBuilder for manipulating an existing instruction.
69  /// F must be the machine function that was used to allocate I.
72  : MF(&F), MI(&*I) {}
73 
74  /// Allow automatic conversion to the machine instruction we are working on.
75  operator MachineInstr*() const { return MI; }
76  MachineInstr *operator->() const { return MI; }
77  operator MachineBasicBlock::iterator() const { return MI; }
78 
79  /// If conversion operators fail, use this method to get the MachineInstr
80  /// explicitly.
81  MachineInstr *getInstr() const { return MI; }
82 
83  /// Add a new virtual register operand.
84  const MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0,
85  unsigned SubReg = 0) const {
86  assert((flags & 0x1) == 0 &&
87  "Passing in 'true' to addReg is forbidden! Use enums instead.");
89  flags & RegState::Define,
90  flags & RegState::Implicit,
91  flags & RegState::Kill,
92  flags & RegState::Dead,
93  flags & RegState::Undef,
94  flags & RegState::EarlyClobber,
95  SubReg,
96  flags & RegState::Debug,
97  flags & RegState::InternalRead,
98  flags & RegState::Renamable));
99  return *this;
100  }
101 
102  /// Add a virtual register definition operand.
103  const MachineInstrBuilder &addDef(unsigned RegNo, unsigned Flags = 0,
104  unsigned SubReg = 0) const {
105  return addReg(RegNo, Flags | RegState::Define, SubReg);
106  }
107 
108  /// Add a virtual register use operand. It is an error for Flags to contain
109  /// `RegState::Define` when calling this function.
110  const MachineInstrBuilder &addUse(unsigned RegNo, unsigned Flags = 0,
111  unsigned SubReg = 0) const {
112  assert(!(Flags & RegState::Define) &&
113  "Misleading addUse defines register, use addReg instead.");
114  return addReg(RegNo, Flags, SubReg);
115  }
116 
117  /// Add a new immediate operand.
118  const MachineInstrBuilder &addImm(int64_t Val) const {
119  MI->addOperand(*MF, MachineOperand::CreateImm(Val));
120  return *this;
121  }
122 
123  const MachineInstrBuilder &addCImm(const ConstantInt *Val) const {
124  MI->addOperand(*MF, MachineOperand::CreateCImm(Val));
125  return *this;
126  }
127 
128  const MachineInstrBuilder &addFPImm(const ConstantFP *Val) const {
130  return *this;
131  }
132 
134  unsigned char TargetFlags = 0) const {
136  return *this;
137  }
138 
139  const MachineInstrBuilder &addFrameIndex(int Idx) const {
140  MI->addOperand(*MF, MachineOperand::CreateFI(Idx));
141  return *this;
142  }
143 
145  int Offset = 0,
146  unsigned char TargetFlags = 0) const {
148  return *this;
149  }
150 
151  const MachineInstrBuilder &addTargetIndex(unsigned Idx, int64_t Offset = 0,
152  unsigned char TargetFlags = 0) const {
154  TargetFlags));
155  return *this;
156  }
157 
159  unsigned char TargetFlags = 0) const {
161  return *this;
162  }
163 
165  int64_t Offset = 0,
166  unsigned char TargetFlags = 0) const {
168  return *this;
169  }
170 
171  const MachineInstrBuilder &addExternalSymbol(const char *FnName,
172  unsigned char TargetFlags = 0) const {
174  return *this;
175  }
176 
178  int64_t Offset = 0,
179  unsigned char TargetFlags = 0) const {
181  return *this;
182  }
183 
186  return *this;
187  }
188 
190  MI->addMemOperand(*MF, MMO);
191  return *this;
192  }
193 
194  const MachineInstrBuilder &
196  MI->setMemRefs(*MF, MMOs);
197  return *this;
198  }
199 
200  const MachineInstrBuilder &cloneMemRefs(const MachineInstr &OtherMI) const {
201  MI->cloneMemRefs(*MF, OtherMI);
202  return *this;
203  }
204 
205  const MachineInstrBuilder &
207  MI->cloneMergedMemRefs(*MF, OtherMIs);
208  return *this;
209  }
210 
211  const MachineInstrBuilder &add(const MachineOperand &MO) const {
212  MI->addOperand(*MF, MO);
213  return *this;
214  }
215 
217  for (const MachineOperand &MO : MOs) {
218  MI->addOperand(*MF, MO);
219  }
220  return *this;
221  }
222 
223  const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
225  assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
226  : true) &&
227  "first MDNode argument of a DBG_VALUE not a variable");
228  assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())
229  : true) &&
230  "first MDNode argument of a DBG_LABEL not a label");
231  return *this;
232  }
233 
234  const MachineInstrBuilder &addCFIIndex(unsigned CFIIndex) const {
235  MI->addOperand(*MF, MachineOperand::CreateCFIIndex(CFIIndex));
236  return *this;
237  }
238 
241  return *this;
242  }
243 
246  return *this;
247  }
248 
250  unsigned char TargetFlags = 0) const {
252  return *this;
253  }
254 
255  const MachineInstrBuilder &setMIFlags(unsigned Flags) const {
256  MI->setFlags(Flags);
257  return *this;
258  }
259 
261  MI->setFlag(Flag);
262  return *this;
263  }
264 
265  // Add a displacement from an existing MachineOperand with an added offset.
266  const MachineInstrBuilder &addDisp(const MachineOperand &Disp, int64_t off,
267  unsigned char TargetFlags = 0) const {
268  // If caller specifies new TargetFlags then use it, otherwise the
269  // default behavior is to copy the target flags from the existing
270  // MachineOperand. This means if the caller wants to clear the
271  // target flags it needs to do so explicitly.
272  if (0 == TargetFlags)
273  TargetFlags = Disp.getTargetFlags();
274 
275  switch (Disp.getType()) {
276  default:
277  llvm_unreachable("Unhandled operand type in addDisp()");
279  return addImm(Disp.getImm() + off);
281  return addConstantPoolIndex(Disp.getIndex(), Disp.getOffset() + off,
282  TargetFlags);
284  return addGlobalAddress(Disp.getGlobal(), Disp.getOffset() + off,
285  TargetFlags);
286  }
287  }
288 
289  /// Copy all the implicit operands from OtherMI onto this one.
290  const MachineInstrBuilder &
291  copyImplicitOps(const MachineInstr &OtherMI) const {
292  MI->copyImplicitOps(*MF, OtherMI);
293  return *this;
294  }
295 
297  const TargetRegisterInfo &TRI,
298  const RegisterBankInfo &RBI) const {
299  return constrainSelectedInstRegOperands(*MI, TII, TRI, RBI);
300  }
301 };
302 
303 /// Builder interface. Specify how to create the initial instruction itself.
305  const MCInstrDesc &MCID) {
306  return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL));
307 }
308 
309 /// This version of the builder sets up the first operand as a
310 /// destination virtual register.
312  const MCInstrDesc &MCID, unsigned DestReg) {
313  return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL))
314  .addReg(DestReg, RegState::Define);
315 }
316 
317 /// This version of the builder inserts the newly-built instruction before
318 /// the given position in the given MachineBasicBlock, and sets up the first
319 /// operand as a destination virtual register.
322  const DebugLoc &DL, const MCInstrDesc &MCID,
323  unsigned DestReg) {
324  MachineFunction &MF = *BB.getParent();
325  MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
326  BB.insert(I, MI);
327  return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
328 }
329 
330 /// This version of the builder inserts the newly-built instruction before
331 /// the given position in the given MachineBasicBlock, and sets up the first
332 /// operand as a destination virtual register.
333 ///
334 /// If \c I is inside a bundle, then the newly inserted \a MachineInstr is
335 /// added to the same bundle.
338  const DebugLoc &DL, const MCInstrDesc &MCID,
339  unsigned DestReg) {
340  MachineFunction &MF = *BB.getParent();
341  MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
342  BB.insert(I, MI);
343  return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
344 }
345 
347  const DebugLoc &DL, const MCInstrDesc &MCID,
348  unsigned DestReg) {
349  // Calling the overload for instr_iterator is always correct. However, the
350  // definition is not available in headers, so inline the check.
351  if (I.isInsideBundle())
352  return BuildMI(BB, MachineBasicBlock::instr_iterator(I), DL, MCID, DestReg);
353  return BuildMI(BB, MachineBasicBlock::iterator(I), DL, MCID, DestReg);
354 }
355 
357  const DebugLoc &DL, const MCInstrDesc &MCID,
358  unsigned DestReg) {
359  return BuildMI(BB, *I, DL, MCID, DestReg);
360 }
361 
362 /// This version of the builder inserts the newly-built instruction before the
363 /// given position in the given MachineBasicBlock, and does NOT take a
364 /// destination register.
367  const DebugLoc &DL,
368  const MCInstrDesc &MCID) {
369  MachineFunction &MF = *BB.getParent();
370  MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
371  BB.insert(I, MI);
372  return MachineInstrBuilder(MF, MI);
373 }
374 
377  const DebugLoc &DL,
378  const MCInstrDesc &MCID) {
379  MachineFunction &MF = *BB.getParent();
380  MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
381  BB.insert(I, MI);
382  return MachineInstrBuilder(MF, MI);
383 }
384 
386  const DebugLoc &DL,
387  const MCInstrDesc &MCID) {
388  // Calling the overload for instr_iterator is always correct. However, the
389  // definition is not available in headers, so inline the check.
390  if (I.isInsideBundle())
391  return BuildMI(BB, MachineBasicBlock::instr_iterator(I), DL, MCID);
392  return BuildMI(BB, MachineBasicBlock::iterator(I), DL, MCID);
393 }
394 
396  const DebugLoc &DL,
397  const MCInstrDesc &MCID) {
398  return BuildMI(BB, *I, DL, MCID);
399 }
400 
401 /// This version of the builder inserts the newly-built instruction at the end
402 /// of the given MachineBasicBlock, and does NOT take a destination register.
404  const MCInstrDesc &MCID) {
405  return BuildMI(*BB, BB->end(), DL, MCID);
406 }
407 
408 /// This version of the builder inserts the newly-built instruction at the
409 /// end of the given MachineBasicBlock, and sets up the first operand as a
410 /// destination virtual register.
412  const MCInstrDesc &MCID, unsigned DestReg) {
413  return BuildMI(*BB, BB->end(), DL, MCID, DestReg);
414 }
415 
416 /// This version of the builder builds a DBG_VALUE intrinsic
417 /// for either a value in a register or a register-indirect
418 /// address. The convention is that a DBG_VALUE is indirect iff the
419 /// second operand is an immediate.
421  const MCInstrDesc &MCID, bool IsIndirect,
422  unsigned Reg, const MDNode *Variable,
423  const MDNode *Expr);
424 
425 /// This version of the builder builds a DBG_VALUE intrinsic
426 /// for a MachineOperand.
428  const MCInstrDesc &MCID, bool IsIndirect,
429  MachineOperand &MO, const MDNode *Variable,
430  const MDNode *Expr);
431 
432 /// This version of the builder builds a DBG_VALUE intrinsic
433 /// for either a value in a register or a register-indirect
434 /// address and inserts it at position I.
437  const MCInstrDesc &MCID, bool IsIndirect,
438  unsigned Reg, const MDNode *Variable,
439  const MDNode *Expr);
440 
441 /// This version of the builder builds a DBG_VALUE intrinsic
442 /// for a machine operand and inserts it at position I.
445  const MCInstrDesc &MCID, bool IsIndirect,
446  MachineOperand &MO, const MDNode *Variable,
447  const MDNode *Expr);
448 
449 /// Clone a DBG_VALUE whose value has been spilled to FrameIndex.
452  const MachineInstr &Orig, int FrameIndex);
453 
454 /// Update a DBG_VALUE whose value has been spilled to FrameIndex. Useful when
455 /// modifying an instruction in place while iterating over a basic block.
456 void updateDbgValueForSpill(MachineInstr &Orig, int FrameIndex);
457 
458 inline unsigned getDefRegState(bool B) {
459  return B ? RegState::Define : 0;
460 }
461 inline unsigned getImplRegState(bool B) {
462  return B ? RegState::Implicit : 0;
463 }
464 inline unsigned getKillRegState(bool B) {
465  return B ? RegState::Kill : 0;
466 }
467 inline unsigned getDeadRegState(bool B) {
468  return B ? RegState::Dead : 0;
469 }
470 inline unsigned getUndefRegState(bool B) {
471  return B ? RegState::Undef : 0;
472 }
473 inline unsigned getInternalReadRegState(bool B) {
474  return B ? RegState::InternalRead : 0;
475 }
476 inline unsigned getDebugRegState(bool B) {
477  return B ? RegState::Debug : 0;
478 }
479 inline unsigned getRenamableRegState(bool B) {
480  return B ? RegState::Renamable : 0;
481 }
482 
483 /// Get all register state flags from machine operand \p RegOp.
484 inline unsigned getRegState(const MachineOperand &RegOp) {
485  assert(RegOp.isReg() && "Not a register operand");
486  return getDefRegState(RegOp.isDef()) |
487  getImplRegState(RegOp.isImplicit()) |
488  getKillRegState(RegOp.isKill()) |
489  getDeadRegState(RegOp.isDead()) |
490  getUndefRegState(RegOp.isUndef()) |
492  getDebugRegState(RegOp.isDebug()) |
495  RegOp.isRenamable());
496 }
497 
498 /// Helper class for constructing bundles of MachineInstrs.
499 ///
500 /// MIBundleBuilder can create a bundle from scratch by inserting new
501 /// MachineInstrs one at a time, or it can create a bundle from a sequence of
502 /// existing MachineInstrs in a basic block.
504  MachineBasicBlock &MBB;
507 
508 public:
509  /// Create an MIBundleBuilder that inserts instructions into a new bundle in
510  /// BB above the bundle or instruction at Pos.
512  : MBB(BB), Begin(Pos.getInstrIterator()), End(Begin) {}
513 
514  /// Create a bundle from the sequence of instructions between B and E.
517  : MBB(BB), Begin(B.getInstrIterator()), End(E.getInstrIterator()) {
518  assert(B != E && "No instructions to bundle");
519  ++B;
520  while (B != E) {
521  MachineInstr &MI = *B;
522  ++B;
523  MI.bundleWithPred();
524  }
525  }
526 
527  /// Create an MIBundleBuilder representing an existing instruction or bundle
528  /// that has MI as its head.
530  : MBB(*MI->getParent()), Begin(MI),
531  End(getBundleEnd(MI->getIterator())) {}
532 
533  /// Return a reference to the basic block containing this bundle.
534  MachineBasicBlock &getMBB() const { return MBB; }
535 
536  /// Return true if no instructions have been inserted in this bundle yet.
537  /// Empty bundles aren't representable in a MachineBasicBlock.
538  bool empty() const { return Begin == End; }
539 
540  /// Return an iterator to the first bundled instruction.
541  MachineBasicBlock::instr_iterator begin() const { return Begin; }
542 
543  /// Return an iterator beyond the last bundled instruction.
544  MachineBasicBlock::instr_iterator end() const { return End; }
545 
546  /// Insert MI into this bundle before I which must point to an instruction in
547  /// the bundle, or end().
549  MachineInstr *MI) {
550  MBB.insert(I, MI);
551  if (I == Begin) {
552  if (!empty())
553  MI->bundleWithSucc();
554  Begin = MI->getIterator();
555  return *this;
556  }
557  if (I == End) {
558  MI->bundleWithPred();
559  return *this;
560  }
561  // MI was inserted in the middle of the bundle, so its neighbors' flags are
562  // already fine. Update MI's bundle flags manually.
565  return *this;
566  }
567 
568  /// Insert MI into MBB by prepending it to the instructions in the bundle.
569  /// MI will become the first instruction in the bundle.
571  return insert(begin(), MI);
572  }
573 
574  /// Insert MI into MBB by appending it to the instructions in the bundle.
575  /// MI will become the last instruction in the bundle.
577  return insert(end(), MI);
578  }
579 };
580 
581 } // end namespace llvm
582 
583 #endif // LLVM_CODEGEN_MACHINEINSTRBUILDER_H
unsigned getTargetFlags() const
MachineBasicBlock & getMBB() const
Return a reference to the basic block containing this bundle.
const MachineInstrBuilder & setMemRefs(ArrayRef< MachineMemOperand *> MMOs) const
void bundleWithPred()
Bundle this instruction with its predecessor.
const MachineInstrBuilder & addMetadata(const MDNode *MD) const
const MachineInstrBuilder & add(const MachineOperand &MO) const
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:259
MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos)
Create an MIBundleBuilder that inserts instructions into a new bundle in BB above the bundle or instr...
bool isDebugLabel() const
Definition: MachineInstr.h:998
static MachineOperand CreateCImm(const ConstantInt *CI)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:250
unsigned getRegState(const MachineOperand &RegOp)
Get all register state flags from machine operand RegOp.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static MachineOperand CreateMCSymbol(MCSymbol *Sym, unsigned char TargetFlags=0)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
const MachineInstrBuilder & addIntrinsicID(Intrinsic::ID ID) const
const MachineInstrBuilder & addCFIIndex(unsigned CFIIndex) const
static MachineOperand CreateJTI(unsigned Idx, unsigned char TargetFlags=0)
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:163
unsigned getReg() const
getReg - Returns the register number.
unsigned Reg
const MachineInstrBuilder & addPredicate(CmpInst::Predicate Pred) const
unsigned getInternalReadRegState(bool B)
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:864
F(f)
const MachineInstrBuilder & addGlobalAddress(const GlobalValue *GV, int64_t Offset=0, unsigned char TargetFlags=0) const
MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL, bool NoImp=false)
CreateMachineInstr - Allocate a new MachineInstr.
const MachineInstrBuilder & addTargetIndex(unsigned Idx, int64_t Offset=0, unsigned char TargetFlags=0) const
bool isInternalRead() const
static MachineOperand CreateIntrinsicID(Intrinsic::ID ID)
const MachineInstrBuilder & setMIFlag(MachineInstr::MIFlag Flag) const
static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isEarlyClobber=false, unsigned SubReg=0, bool isDebug=false, bool isInternalRead=false, bool isRenamable=false)
MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B, MachineBasicBlock::iterator E)
Create a bundle from the sequence of instructions between B and E.
The address of a basic block.
Definition: Constants.h:836
Holds all the information related to register banks.
A description of a memory reference used in the backend.
MachineInstr * buildDbgValueForSpill(MachineBasicBlock &BB, MachineBasicBlock::iterator I, const MachineInstr &Orig, int FrameIndex)
Clone a DBG_VALUE whose value has been spilled to FrameIndex.
MachineInstrBuilder(MachineFunction &F, MachineInstr *I)
Create a MachineInstrBuilder for manipulating an existing instruction.
const HexagonInstrInfo * TII
const MachineInstrBuilder & addUse(unsigned RegNo, unsigned Flags=0, unsigned SubReg=0) const
Add a virtual register use operand.
unsigned SubReg
void bundleWithSucc()
Bundle this instruction with its successor.
static MachineOperand CreateRegMask(const uint32_t *Mask)
CreateRegMask - Creates a register mask operand referencing Mask.
void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI)
Copy implicit register operands from specified instruction to this instruction.
MIBundleBuilder & prepend(MachineInstr *MI)
Insert MI into MBB by prepending it to the instructions in the bundle.
const MachineInstrBuilder & addFPImm(const ConstantFP *Val) const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
void addMemOperand(MachineFunction &MF, MachineMemOperand *MO)
Add a MachineMemOperand to the machine instruction.
static MachineOperand CreatePredicate(unsigned Pred)
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
bool isInsideBundle() const
Return true if MI is in a bundle (but not the first MI in a bundle).
Definition: MachineInstr.h:350
unsigned getUndefRegState(bool B)
unsigned getKillRegState(bool B)
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:118
unsigned getDebugRegState(bool B)
TargetInstrInfo - Interface to description of machine instruction set.
unsigned getDeadRegState(bool B)
unsigned getDefRegState(bool B)
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Address of a global value.
MachineInstrBundleIterator< MachineInstr > iterator
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
const MachineInstrBuilder & addBlockAddress(const BlockAddress *BA, int64_t Offset=0, unsigned char TargetFlags=0) const
static MachineOperand CreateCPI(unsigned Idx, int Offset, unsigned char TargetFlags=0)
const MachineInstrBuilder & addCImm(const ConstantInt *Val) const
static MachineOperand CreateFPImm(const ConstantFP *CFP)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
const GlobalValue * getGlobal() const
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
static MachineOperand CreateBA(const BlockAddress *BA, int64_t Offset, unsigned char TargetFlags=0)
void setFlag(MIFlag Flag)
Set a MI flag.
Definition: MachineInstr.h:300
MachineBasicBlock::instr_iterator begin() const
Return an iterator to the first bundled instruction.
const MachineInstrBuilder & addRegMask(const uint32_t *Mask) const
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:685
const DILabel * getDebugLabel() const
Return the debug label referenced by this DBG_LABEL instruction.
static MachineOperand CreateGA(const GlobalValue *GV, int64_t Offset, unsigned char TargetFlags=0)
static MachineOperand CreateTargetIndex(unsigned Idx, int64_t Offset, unsigned char TargetFlags=0)
self_iterator getIterator()
Definition: ilist_node.h:82
const MachineInstrBuilder & addSym(MCSymbol *Sym, unsigned char TargetFlags=0) const
const MachineInstrBuilder & addFrameIndex(int Idx) const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
const MachineInstrBuilder & add(ArrayRef< MachineOperand > MOs) const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void cloneMemRefs(MachineFunction &MF, const MachineInstr &MI)
Clone another MachineInstr&#39;s memory reference descriptor list and replace ours with it...
static MachineOperand CreateMetadata(const MDNode *Meta)
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
void addOperand(MachineFunction &MF, const MachineOperand &Op)
Add the specified operand to the instruction.
unsigned getRenamableRegState(bool B)
MachineBasicBlock::instr_iterator end() const
Return an iterator beyond the last bundled instruction.
void setFlags(unsigned flags)
Definition: MachineInstr.h:304
MachineInstr * operator->() const
bool isDebugValue() const
Definition: MachineInstr.h:997
MachineOperand class - Representation of each machine instruction operand.
bool empty() const
Return true if no instructions have been inserted in this bundle yet.
const MachineInstrBuilder & addMemOperand(MachineMemOperand *MMO) const
const MachineInstrBuilder & addConstantPoolIndex(unsigned Idx, int Offset=0, unsigned char TargetFlags=0) const
const MachineInstrBuilder & addDisp(const MachineOperand &Disp, int64_t off, unsigned char TargetFlags=0) const
void updateDbgValueForSpill(MachineInstr &Orig, int FrameIndex)
Update a DBG_VALUE whose value has been spilled to FrameIndex.
bool constrainSelectedInstRegOperands(MachineInstr &I, const TargetInstrInfo &TII, const TargetRegisterInfo &TRI, const RegisterBankInfo &RBI)
Mutate the newly-selected instruction I to constrain its (possibly generic) virtual register operands...
Definition: Utils.cpp:88
MachineInstr * getInstr() const
If conversion operators fail, use this method to get the MachineInstr explicitly. ...
MIBundleBuilder & insert(MachineBasicBlock::instr_iterator I, MachineInstr *MI)
Insert MI into this bundle before I which must point to an instruction in the bundle, or end().
int64_t getImm() const
static MachineOperand CreateES(const char *SymName, unsigned char TargetFlags=0)
bool isRenamable() const
isRenamable - Returns true if this register may be renamed, i.e.
const MachineInstrBuilder & copyImplicitOps(const MachineInstr &OtherMI) const
Copy all the implicit operands from OtherMI onto this one.
Representation of each machine instruction.
Definition: MachineInstr.h:64
static bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
static MachineOperand CreateMBB(MachineBasicBlock *MBB, unsigned char TargetFlags=0)
const MachineInstrBuilder & setMIFlags(unsigned Flags) const
void cloneMergedMemRefs(MachineFunction &MF, ArrayRef< const MachineInstr *> MIs)
Clone the merge of multiple MachineInstrs&#39; memory reference descriptors list and replace ours with it...
static MachineOperand CreateCFIIndex(unsigned CFIIndex)
int64_t getOffset() const
Return the offset from the symbol in this operand.
const MachineInstrBuilder & addExternalSymbol(const char *FnName, unsigned char TargetFlags=0) const
static MachineOperand CreateImm(int64_t Val)
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned getImplRegState(bool B)
const MachineInstrBuilder & cloneMemRefs(const MachineInstr &OtherMI) const
const MachineInstrBuilder & cloneMergedMemRefs(ArrayRef< const MachineInstr *> OtherMIs) const
const MachineInstrBuilder & addReg(unsigned RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
Instructions::iterator instr_iterator
const MachineInstrBuilder & addJumpTableIndex(unsigned Idx, unsigned char TargetFlags=0) const
MIBundleBuilder & append(MachineInstr *MI)
Insert MI into MBB by appending it to the instructions in the bundle.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void setMemRefs(MachineFunction &MF, ArrayRef< MachineMemOperand *> MemRefs)
Assign this MachineInstr&#39;s memory reference descriptor list.
const DILocalVariable * getDebugVariable() const
Return the debug variable referenced by this DBG_VALUE instruction.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
static const Function * getParent(const Value *V)
IRTranslator LLVM IR MI
Address of indexed Constant in Constant Pool.
const MachineInstrBuilder & addDef(unsigned RegNo, unsigned Flags=0, unsigned SubReg=0) const
Add a virtual register definition operand.
MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)
Returns an iterator pointing beyond the bundle containing I.
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned char TargetFlags=0) const
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
static MachineOperand CreateFI(int Idx)
MachineInstrBuilder(MachineFunction &F, MachineBasicBlock::iterator I)
MIBundleBuilder(MachineInstr *MI)
Create an MIBundleBuilder representing an existing instruction or bundle that has MI as its head...
bool constrainAllUses(const TargetInstrInfo &TII, const TargetRegisterInfo &TRI, const RegisterBankInfo &RBI) const
Helper class for constructing bundles of MachineInstrs.
bool isImplicit() const