LLVM 24.0.0git
MachineInstr.cpp
Go to the documentation of this file.
1//===- lib/CodeGen/MachineInstr.cpp ---------------------------------------===//
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// Methods common to all machine instructions.
10//
11//===----------------------------------------------------------------------===//
12
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/Hashing.h"
16#include "llvm/ADT/STLExtras.h"
38#include "llvm/IR/Constants.h"
40#include "llvm/IR/DebugLoc.h"
41#include "llvm/IR/Function.h"
42#include "llvm/IR/InlineAsm.h"
44#include "llvm/IR/LLVMContext.h"
45#include "llvm/IR/Metadata.h"
46#include "llvm/IR/Module.h"
48#include "llvm/IR/Operator.h"
49#include "llvm/MC/MCInstrDesc.h"
53#include "llvm/Support/Debug.h"
58#include <algorithm>
59#include <cassert>
60#include <cstdint>
61#include <cstring>
62#include <utility>
63
64using namespace llvm;
65
66static cl::opt<bool>
67 PrintMIAddrs("print-mi-addrs", cl::Hidden,
68 cl::desc("Print addresses of MachineInstrs when dumping"));
69
71 if (const MachineBasicBlock *MBB = MI.getParent())
72 if (const MachineFunction *MF = MBB->getParent())
73 return MF;
74 return nullptr;
75}
76
77// Try to crawl up to the machine function and get TRI/MRI/TII from it.
79 const TargetRegisterInfo *&TRI,
81 const TargetInstrInfo *&TII) {
82
83 if (const MachineFunction *MF = getMFIfAvailable(MI)) {
84 TRI = MF->getSubtarget().getRegisterInfo();
85 MRI = &MF->getRegInfo();
86 TII = MF->getSubtarget().getInstrInfo();
87 }
88}
89
91 for (MCPhysReg ImpDef : MCID->implicit_defs())
92 addOperand(MF, MachineOperand::CreateReg(ImpDef, true, true));
93 for (MCPhysReg ImpUse : MCID->implicit_uses())
94 addOperand(MF, MachineOperand::CreateReg(ImpUse, false, true));
95}
96
97/// MachineInstr ctor - This constructor creates a MachineInstr and adds the
98/// implicit operands. It reserves space for the number of operands specified by
99/// the MCInstrDesc.
100MachineInstr::MachineInstr(MachineFunction &MF, const MCInstrDesc &TID,
101 DebugLoc DL, bool NoImp)
102 : MCID(&TID), NumOperands(0), Flags(0), AsmPrinterFlags(0),
103 Opcode(TID.Opcode), DebugInstrNum(0), DbgLoc(std::move(DL)) {
104 // Reserve space for the expected number of operands.
105 if (unsigned NumOps = MCID->getNumOperands() + MCID->implicit_defs().size() +
106 MCID->implicit_uses().size()) {
107 CapOperands = OperandCapacity::get(NumOps);
108 Operands = MF.allocateOperandArray(CapOperands);
109 }
110
111 if (!NoImp)
113}
114
115/// MachineInstr ctor - Copies MachineInstr arg exactly.
116/// Does not copy the number from debug instruction numbering, to preserve
117/// uniqueness.
118MachineInstr::MachineInstr(MachineFunction &MF, const MachineInstr &MI)
119 : MCID(&MI.getDesc()), NumOperands(0), Flags(0), AsmPrinterFlags(0),
120 Opcode(MI.getOpcode()), DebugInstrNum(0), Info(MI.Info),
121 DbgLoc(MI.getDebugLoc()) {
122 CapOperands = OperandCapacity::get(MI.getNumOperands());
123 Operands = MF.allocateOperandArray(CapOperands);
124
125 // Copy operands.
126 for (const MachineOperand &MO : MI.operands())
127 addOperand(MF, MO);
128
129 // Replicate ties between the operands, which addOperand was not
130 // able to do reliably.
131 for (unsigned i = 0, e = getNumOperands(); i < e; ++i) {
132 MachineOperand &NewMO = getOperand(i);
133 const MachineOperand &OrigMO = MI.getOperand(i);
134 NewMO.TiedTo = OrigMO.TiedTo;
135 }
136
137 // Copy all the sensible flags.
138 setFlags(MI.Flags);
139}
140
142 if (getParent())
143 getMF()->handleChangeDesc(*this, TID);
144 MCID = &TID;
145 Opcode = TID.Opcode;
146}
147
148void MachineInstr::moveBefore(MachineInstr *MovePos) {
149 MovePos->getParent()->splice(MovePos, getParent(), getIterator());
150}
151
152/// getRegInfo - If this instruction is embedded into a MachineFunction,
153/// return the MachineRegisterInfo object for the current function, otherwise
154/// return null.
155MachineRegisterInfo *MachineInstr::getRegInfo() {
157 return &MBB->getParent()->getRegInfo();
158 return nullptr;
159}
160
161const MachineRegisterInfo *MachineInstr::getRegInfo() const {
162 if (const MachineBasicBlock *MBB = getParent())
163 return &MBB->getParent()->getRegInfo();
164 return nullptr;
165}
166
167void MachineInstr::removeRegOperandsFromUseLists(MachineRegisterInfo &MRI) {
168 for (MachineOperand &MO : operands())
169 if (MO.isReg())
171}
172
173void MachineInstr::addRegOperandsToUseLists(MachineRegisterInfo &MRI) {
174 for (MachineOperand &MO : operands())
175 if (MO.isReg())
177}
178
181 assert(MBB && "Use MachineInstrBuilder to add operands to dangling instrs");
182 MachineFunction *MF = MBB->getParent();
183 assert(MF && "Use MachineInstrBuilder to add operands to dangling instrs");
184 addOperand(*MF, Op);
185}
186
187/// Move NumOps MachineOperands from Src to Dst, with support for overlapping
188/// ranges. If MRI is non-null also update use-def chains.
190 unsigned NumOps, MachineRegisterInfo *MRI) {
191 if (MRI)
192 return MRI->moveOperands(Dst, Src, NumOps);
193 // MachineOperand is a trivially copyable type so we can just use memmove.
194 assert(Dst && Src && "Unknown operands");
195 std::memmove(Dst, Src, NumOps * sizeof(MachineOperand));
196}
197
198/// addOperand - Add the specified operand to the instruction. If it is an
199/// implicit operand, it is added to the end of the operand list. If it is
200/// an explicit operand it is added at the end of the explicit operand list
201/// (before the first implicit operand).
203 assert(isUInt<LLVM_MI_NUMOPERANDS_BITS>(NumOperands + 1) &&
204 "Cannot add more operands.");
205 assert(MCID && "Cannot add operands before providing an instr descriptor");
206
207 // Check if we're adding one of our existing operands.
208 if (&Op >= Operands && &Op < Operands + NumOperands) {
209 // This is unusual: MI->addOperand(MI->getOperand(i)).
210 // If adding Op requires reallocating or moving existing operands around,
211 // the Op reference could go stale. Support it by copying Op.
212 MachineOperand CopyOp(Op);
213 return addOperand(MF, CopyOp);
214 }
215
216 // Find the insert location for the new operand. Implicit registers go at
217 // the end, everything else goes before the implicit regs.
218 //
219 // FIXME: Allow mixed explicit and implicit operands on inline asm.
220 // InstrEmitter::EmitSpecialNode() is marking inline asm clobbers as
221 // implicit-defs, but they must not be moved around. See the FIXME in
222 // InstrEmitter.cpp.
223 unsigned OpNo = getNumOperands();
224 bool isImpReg = Op.isReg() && Op.isImplicit();
225 if (!isImpReg && !isInlineAsm()) {
226 while (OpNo && Operands[OpNo-1].isReg() && Operands[OpNo-1].isImplicit()) {
227 --OpNo;
228 assert(!Operands[OpNo].isTied() && "Cannot move tied operands");
229 }
230 }
231
232 // OpNo now points as the desired insertion point. Unless this is a variadic
233 // instruction, only implicit regs are allowed beyond MCID->getNumOperands().
234 // RegMask operands go between the explicit and implicit operands.
235 MachineRegisterInfo *MRI = getRegInfo();
236
237 // Determine if the Operands array needs to be reallocated.
238 // Save the old capacity and operand array.
239 OperandCapacity OldCap = CapOperands;
240 MachineOperand *OldOperands = Operands;
241 if (!OldOperands || OldCap.getSize() == getNumOperands()) {
242 CapOperands = OldOperands ? OldCap.getNext() : OldCap.get(1);
243 Operands = MF.allocateOperandArray(CapOperands);
244 // Move the operands before the insertion point.
245 if (OpNo)
246 moveOperands(Operands, OldOperands, OpNo, MRI);
247 }
248
249 // Move the operands following the insertion point.
250 if (OpNo != NumOperands)
251 moveOperands(Operands + OpNo + 1, OldOperands + OpNo, NumOperands - OpNo,
252 MRI);
253 ++NumOperands;
254
255 // Deallocate the old operand array.
256 if (OldOperands != Operands && OldOperands)
257 MF.deallocateOperandArray(OldCap, OldOperands);
258
259 // Copy Op into place. It still needs to be inserted into the MRI use lists.
260 MachineOperand *NewMO = new (Operands + OpNo) MachineOperand(Op);
261 NewMO->ParentMI = this;
262
263 // When adding a register operand, tell MRI about it.
264 if (NewMO->isReg()) {
265 // Ensure isOnRegUseList() returns false, regardless of Op's status.
266 NewMO->Contents.Reg.Prev = nullptr;
267 // Ignore existing ties. This is not a property that can be copied.
268 NewMO->TiedTo = 0;
269 // Add the new operand to MRI, but only for instructions in an MBB.
270 if (MRI)
271 MRI->addRegOperandToUseList(NewMO);
272 // The MCID operand information isn't accurate until we start adding
273 // explicit operands. The implicit operands are added first, then the
274 // explicits are inserted before them.
275 if (!isImpReg) {
276 // Tie uses to defs as indicated in MCInstrDesc.
277 if (NewMO->isUse()) {
278 int DefIdx = MCID->getOperandConstraint(OpNo, MCOI::TIED_TO);
279 if (DefIdx != -1)
280 tieOperands(DefIdx, OpNo);
281 }
282 // If the register operand is flagged as early, mark the operand as such.
283 if (MCID->getOperandConstraint(OpNo, MCOI::EARLY_CLOBBER) != -1)
284 NewMO->setIsEarlyClobber(true);
285 }
286 // Ensure debug instructions set debug flag on register uses.
287 if (NewMO->isUse() && isDebugInstr())
288 NewMO->setIsDebug();
289 }
290}
291
292void MachineInstr::removeOperand(unsigned OpNo) {
293 assert(OpNo < getNumOperands() && "Invalid operand number");
294 untieRegOperand(OpNo);
295
296#ifndef NDEBUG
297 // Moving tied operands would break the ties.
298 for (unsigned i = OpNo + 1, e = getNumOperands(); i != e; ++i)
299 if (Operands[i].isReg())
300 assert(!Operands[i].isTied() && "Cannot move tied operands");
301#endif
302
303 MachineRegisterInfo *MRI = getRegInfo();
304 if (MRI && Operands[OpNo].isReg())
305 MRI->removeRegOperandFromUseList(Operands + OpNo);
306
307 // Don't call the MachineOperand destructor. A lot of this code depends on
308 // MachineOperand having a trivial destructor anyway, and adding a call here
309 // wouldn't make it 'destructor-correct'.
310
311 if (unsigned N = NumOperands - 1 - OpNo)
312 moveOperands(Operands + OpNo, Operands + OpNo + 1, N, MRI);
313 --NumOperands;
314}
315
316void MachineInstr::setExtraInfo(MachineFunction &MF,
318 MCSymbol *PreInstrSymbol,
319 MCSymbol *PostInstrSymbol,
320 MDNode *HeapAllocMarker, MDNode *PCSections,
321 uint32_t CFIType, MDNode *MMRAs, Value *DS) {
322 bool HasPreInstrSymbol = PreInstrSymbol != nullptr;
323 bool HasPostInstrSymbol = PostInstrSymbol != nullptr;
324 bool HasHeapAllocMarker = HeapAllocMarker != nullptr;
325 bool HasPCSections = PCSections != nullptr;
326 bool HasCFIType = CFIType != 0;
327 bool HasMMRAs = MMRAs != nullptr;
328 bool HasDS = DS != nullptr;
329 int NumPointers = MMOs.size() + HasPreInstrSymbol + HasPostInstrSymbol +
330 HasHeapAllocMarker + HasPCSections + HasCFIType + HasMMRAs +
331 HasDS;
332
333 // Drop all extra info if there is none.
334 if (NumPointers <= 0) {
335 Info.clear();
336 return;
337 }
338
339 // If more than one pointer, then store out of line. Store heap alloc markers
340 // out of line because PointerSumType cannot hold more than 4 tag types with
341 // 32-bit pointers.
342 // FIXME: Maybe we should make the symbols in the extra info mutable?
343 else if (NumPointers > 1 || HasMMRAs || HasHeapAllocMarker || HasPCSections ||
344 HasCFIType || HasDS) {
345 Info.set<EIIK_OutOfLine>(
346 MF.createMIExtraInfo(MMOs, PreInstrSymbol, PostInstrSymbol,
347 HeapAllocMarker, PCSections, CFIType, MMRAs, DS));
348 return;
349 }
350
351 // Otherwise store the single pointer inline.
352 if (HasPreInstrSymbol)
353 Info.set<EIIK_PreInstrSymbol>(PreInstrSymbol);
354 else if (HasPostInstrSymbol)
355 Info.set<EIIK_PostInstrSymbol>(PostInstrSymbol);
356 else
357 Info.set<EIIK_MMO>(MMOs[0]);
358}
359
368
371 if (MMOs.empty()) {
372 dropMemRefs(MF);
373 return;
374 }
375
376 setExtraInfo(MF, MMOs, getPreInstrSymbol(), getPostInstrSymbol(),
379}
380
382 MachineMemOperand *MO) {
383 if (memoperands_empty()) {
384 setMemRefs(MF, {MO});
385 return;
386 }
387
390 MMOs.push_back(MO);
391 setMemRefs(MF, MMOs);
392}
393
394void MachineInstr::cloneMemRefs(MachineFunction &MF, const MachineInstr &MI) {
395 if (this == &MI)
396 // Nothing to do for a self-clone!
397 return;
398
399 assert(&MF == MI.getMF() &&
400 "Invalid machine functions when cloning memory refrences!");
401 // See if we can just steal the extra info already allocated for the
402 // instruction. We can do this whenever the pre- and post-instruction symbols
403 // are the same (including null).
404 if (getPreInstrSymbol() == MI.getPreInstrSymbol() &&
405 getPostInstrSymbol() == MI.getPostInstrSymbol() &&
406 getHeapAllocMarker() == MI.getHeapAllocMarker() &&
407 getPCSections() == MI.getPCSections() && getMMRAMetadata() &&
408 MI.getMMRAMetadata()) {
409 Info = MI.Info;
410 return;
411 }
412
413 // Otherwise, fall back on a copy-based clone.
414 setMemRefs(MF, MI.memoperands());
415}
416
417/// Check to see if the MMOs pointed to by the two MemRefs arrays are
418/// identical.
421 if (LHS.size() != RHS.size())
422 return false;
423
424 auto LHSPointees = make_pointee_range(LHS);
425 auto RHSPointees = make_pointee_range(RHS);
426 return std::equal(LHSPointees.begin(), LHSPointees.end(),
427 RHSPointees.begin());
428}
429
432 // Try handling easy numbers of MIs with simpler mechanisms.
433 if (MIs.empty()) {
434 dropMemRefs(MF);
435 return;
436 }
437 if (MIs.size() == 1) {
438 cloneMemRefs(MF, *MIs[0]);
439 return;
440 }
441 // Because an empty memoperands list provides *no* information and must be
442 // handled conservatively (assuming the instruction can do anything), the only
443 // way to merge with it is to drop all other memoperands.
444 if (MIs[0]->memoperands_empty()) {
445 dropMemRefs(MF);
446 return;
447 }
448
449 // Handle the general case.
451 // Start with the first instruction.
452 assert(&MF == MIs[0]->getMF() &&
453 "Invalid machine functions when cloning memory references!");
454 MergedMMOs.append(MIs[0]->memoperands_begin(), MIs[0]->memoperands_end());
455 // Now walk all the other instructions and accumulate any different MMOs.
456 for (const MachineInstr &MI : make_pointee_range(MIs.slice(1))) {
457 assert(&MF == MI.getMF() &&
458 "Invalid machine functions when cloning memory references!");
459
460 // Skip MIs with identical operands to the first. This is a somewhat
461 // arbitrary hack but will catch common cases without being quadratic.
462 // TODO: We could fully implement merge semantics here if needed.
463 if (hasIdenticalMMOs(MIs[0]->memoperands(), MI.memoperands()))
464 continue;
465
466 // Because an empty memoperands list provides *no* information and must be
467 // handled conservatively (assuming the instruction can do anything), the
468 // only way to merge with it is to drop all other memoperands.
469 if (MI.memoperands_empty()) {
470 dropMemRefs(MF);
471 return;
472 }
473
474 // Otherwise accumulate these into our temporary buffer of the merged state.
475 MergedMMOs.append(MI.memoperands_begin(), MI.memoperands_end());
476 }
477
478 setMemRefs(MF, MergedMMOs);
479}
480
482 // Do nothing if old and new symbols are the same.
483 if (Symbol == getPreInstrSymbol())
484 return;
485
486 // If there was only one symbol and we're removing it, just clear info.
487 if (!Symbol && Info.is<EIIK_PreInstrSymbol>()) {
488 Info.clear();
489 return;
490 }
491
492 setExtraInfo(MF, memoperands(), Symbol, getPostInstrSymbol(),
495}
496
498 // Do nothing if old and new symbols are the same.
499 if (Symbol == getPostInstrSymbol())
500 return;
501
502 // If there was only one symbol and we're removing it, just clear info.
503 if (!Symbol && Info.is<EIIK_PostInstrSymbol>()) {
504 Info.clear();
505 return;
506 }
507
508 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), Symbol,
511}
512
514 // Do nothing if old and new symbols are the same.
515 if (Marker == getHeapAllocMarker())
516 return;
517
518 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
521}
522
524 // Do nothing if old and new symbols are the same.
525 if (PCSections == getPCSections())
526 return;
527
528 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
529 getHeapAllocMarker(), PCSections, getCFIType(),
531}
532
534 // Do nothing if old and new types are the same.
535 if (Type == getCFIType())
536 return;
537
538 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
541}
542
544 // Do nothing if old and new symbols are the same.
545 if (MMRAs == getMMRAMetadata())
546 return;
547
548 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
551}
552
554 // Do nothing if old and new symbols are the same.
555 if (DS == getDeactivationSymbol())
556 return;
557
558 setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
560 getMMRAMetadata(), DS);
561}
562
564 const MachineInstr &MI) {
565 if (this == &MI)
566 // Nothing to do for a self-clone!
567 return;
568
569 assert(&MF == MI.getMF() &&
570 "Invalid machine functions when cloning instruction symbols!");
571
572 setPreInstrSymbol(MF, MI.getPreInstrSymbol());
573 setPostInstrSymbol(MF, MI.getPostInstrSymbol());
574 setHeapAllocMarker(MF, MI.getHeapAllocMarker());
575 setPCSections(MF, MI.getPCSections());
576 setMMRAMetadata(MF, MI.getMMRAMetadata());
577}
578
579uint32_t MachineInstr::mergeFlagsWith(const MachineInstr &Other) const {
580 // For now, the just return the union of the flags. If the flags get more
581 // complicated over time, we might need more logic here.
582 return getFlags() | Other.getFlags();
583}
584
586 uint32_t MIFlags = 0;
587 // Copy the wrapping flags.
588 if (const OverflowingBinaryOperator *OB =
590 if (OB->hasNoSignedWrap())
592 if (OB->hasNoUnsignedWrap())
594 } else if (const TruncInst *TI = dyn_cast<TruncInst>(&I)) {
595 if (TI->hasNoSignedWrap())
597 if (TI->hasNoUnsignedWrap())
599 } else if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
600 if (GEP->hasNoUnsignedSignedWrap())
602 if (GEP->hasNoUnsignedWrap())
604 if (GEP->isInBounds())
606 }
607
608 // Copy the nonneg flag.
610 if (PNI->hasNonNeg())
612 // Copy the disjoint flag.
613 } else if (const PossiblyDisjointInst *PD =
615 if (PD->isDisjoint())
617 }
618
619 // Copy the samesign flag.
620 if (const ICmpInst *ICmp = dyn_cast<ICmpInst>(&I))
621 if (ICmp->hasSameSign())
623
624 // Copy the nonnull flag.
625 if (const auto *ASC = dyn_cast<AddrSpaceCastInst>(&I))
626 if (ASC->hasNonNull())
628
629 // Copy the exact flag.
631 if (PE->isExact())
633
634 // Copy the fast-math flags.
636 const FastMathFlags Flags = FP->getFastMathFlags();
637 if (Flags.noNaNs())
639 if (Flags.noInfs())
641 if (Flags.noSignedZeros())
643 if (Flags.allowReciprocal())
645 if (Flags.allowContract())
647 if (Flags.approxFunc())
649 if (Flags.allowReassoc())
651 }
652
653 if (I.getMetadata(LLVMContext::MD_unpredictable))
655
656 return MIFlags;
657}
658
662
663bool MachineInstr::hasPropertyInBundle(uint64_t Mask, QueryType Type) const {
664 assert(!isBundledWithPred() && "Must be called on bundle header");
666 if (MII->getDesc().getFlags() & Mask) {
667 if (Type == AnyInBundle)
668 return true;
669 } else {
670 if (Type == AllInBundle && !MII->isBundle())
671 return false;
672 }
673 // This was the last instruction in the bundle.
674 if (!MII->isBundledWithSucc())
675 return Type == AllInBundle;
676 }
677}
678
679bool MachineInstr::isIdenticalTo(const MachineInstr &Other,
680 MICheckType Check) const {
681 // If opcodes or number of operands are not the same then the two
682 // instructions are obviously not identical.
683 if (Other.getOpcode() != getOpcode() ||
684 Other.getNumOperands() != getNumOperands())
685 return false;
686
687 if (isBundle()) {
688 // We have passed the test above that both instructions have the same
689 // opcode, so we know that both instructions are bundles here. Let's compare
690 // MIs inside the bundle.
691 assert(Other.isBundle() && "Expected that both instructions are bundles.");
694 // Loop until we analysed the last instruction inside at least one of the
695 // bundles.
696 while (I1->isBundledWithSucc() && I2->isBundledWithSucc()) {
697 ++I1;
698 ++I2;
699 if (!I1->isIdenticalTo(*I2, Check))
700 return false;
701 }
702 // If we've reached the end of just one of the two bundles, but not both,
703 // the instructions are not identical.
704 if (I1->isBundledWithSucc() || I2->isBundledWithSucc())
705 return false;
706 }
707
708 // Check operands to make sure they match.
709 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
710 const MachineOperand &MO = getOperand(i);
711 const MachineOperand &OMO = Other.getOperand(i);
712 if (!MO.isReg()) {
713 if (!MO.isIdenticalTo(OMO))
714 return false;
715 continue;
716 }
717
718 // Clients may or may not want to ignore defs when testing for equality.
719 // For example, machine CSE pass only cares about finding common
720 // subexpressions, so it's safe to ignore virtual register defs.
721 if (MO.isDef()) {
722 if (Check == IgnoreDefs)
723 continue;
724 else if (Check == IgnoreVRegDefs) {
725 if (!MO.getReg().isVirtual() || !OMO.getReg().isVirtual())
726 if (!MO.isIdenticalTo(OMO))
727 return false;
728 } else {
729 if (!MO.isIdenticalTo(OMO))
730 return false;
731 if (Check == CheckKillDead && MO.isDead() != OMO.isDead())
732 return false;
733 }
734 } else {
735 if (!MO.isIdenticalTo(OMO))
736 return false;
737 if (Check == CheckKillDead && MO.isKill() != OMO.isKill())
738 return false;
739 }
740 }
741 // If DebugLoc does not match then two debug instructions are not identical.
742 if (isDebugInstr())
743 if (getDebugLoc() && Other.getDebugLoc() &&
744 getDebugLoc() != Other.getDebugLoc())
745 return false;
746 // If pre- or post-instruction symbols do not match then the two instructions
747 // are not identical.
748 if (getPreInstrSymbol() != Other.getPreInstrSymbol() ||
749 getPostInstrSymbol() != Other.getPostInstrSymbol())
750 return false;
751 if (isCall()) {
752 // Call instructions with different CFI types are not identical.
753 if (getCFIType() != Other.getCFIType())
754 return false;
755 // Even if the call instructions have the same ops, they are not identical
756 // if they are for different globals (this may happen with indirect calls).
761 Other.getParent()->getParent()->tryGetCalledGlobal(&Other);
762 if (ThisCGI.Callee != OtherCGI.Callee ||
763 ThisCGI.TargetFlags != OtherCGI.TargetFlags)
764 return false;
765 }
766 }
767 if (getDeactivationSymbol() != Other.getDeactivationSymbol())
768 return false;
769
770 return true;
771}
772
773bool MachineInstr::isEquivalentDbgInstr(const MachineInstr &Other) const {
774 if (!isDebugValueLike() || !Other.isDebugValueLike())
775 return false;
776 if (getDebugLoc() != Other.getDebugLoc())
777 return false;
778 if (getDebugVariable() != Other.getDebugVariable())
779 return false;
780 if (getNumDebugOperands() != Other.getNumDebugOperands())
781 return false;
782 for (unsigned OpIdx = 0; OpIdx < getNumDebugOperands(); ++OpIdx)
783 if (!getDebugOperand(OpIdx).isIdenticalTo(Other.getDebugOperand(OpIdx)))
784 return false;
787 Other.getDebugExpression(), Other.isIndirectDebugValue()))
788 return false;
789 return true;
790}
791
793 return getParent()->getParent();
794}
795
797 assert(getParent() && "Not embedded in a basic block!");
798 return getParent()->remove(this);
799}
800
802 assert(getParent() && "Not embedded in a basic block!");
803 return getParent()->remove_instr(this);
804}
805
807 assert(getParent() && "Not embedded in a basic block!");
808 return getParent()->erase(this);
809}
810
812 assert(getParent() && "Not embedded in a basic block!");
813 getParent()->erase_instr(this);
814}
815
817 if (!isCall(Type))
818 return false;
819 switch (getOpcode()) {
820 case TargetOpcode::PATCHPOINT:
821 case TargetOpcode::STACKMAP:
822 case TargetOpcode::STATEPOINT:
823 case TargetOpcode::FENTRY_CALL:
824 return false;
825 }
826 return true;
827}
828
834
835template <typename Operand, typename Instruction>
836static iterator_range<
837 filter_iterator<Operand *, std::function<bool(Operand &Op)>>>
839 std::function<bool(Operand & Op)> OpUsesReg(
840 [Reg](Operand &Op) { return Op.isReg() && Op.getReg() == Reg; });
841 return make_filter_range(MI->debug_operands(), OpUsesReg);
842}
843
845 std::function<bool(const MachineOperand &Op)>>>
850
856
858 unsigned NumOperands = MCID->getNumOperands();
859 if (!MCID->isVariadic())
860 return NumOperands;
861
862 for (const MachineOperand &MO : operands_impl().drop_front(NumOperands)) {
863 // The operands must always be in the following order:
864 // - explicit reg defs,
865 // - other explicit operands (reg uses, immediates, etc.),
866 // - implicit reg defs
867 // - implicit reg uses
868 if (MO.isReg() && MO.isImplicit())
869 break;
870 ++NumOperands;
871 }
872 return NumOperands;
873}
874
876 unsigned NumDefs = MCID->getNumDefs();
877 if (!MCID->isVariadic())
878 return NumDefs;
879
880 for (const MachineOperand &MO : operands_impl().drop_front(NumDefs)) {
881 if (!MO.isReg() || !MO.isDef() || MO.isImplicit())
882 break;
883 ++NumDefs;
884 }
885 return NumDefs;
886}
887
889 assert(!isBundledWithPred() && "MI is already bundled with its predecessor");
892 --Pred;
893 assert(!Pred->isBundledWithSucc() && "Inconsistent bundle flags");
894 Pred->setFlag(BundledSucc);
895}
896
898 assert(!isBundledWithSucc() && "MI is already bundled with its successor");
901 ++Succ;
902 assert(!Succ->isBundledWithPred() && "Inconsistent bundle flags");
903 Succ->setFlag(BundledPred);
904}
905
907 assert(isBundledWithPred() && "MI isn't bundled with its predecessor");
910 --Pred;
911 assert(Pred->isBundledWithSucc() && "Inconsistent bundle flags");
912 Pred->clearFlag(BundledSucc);
913}
914
916 assert(isBundledWithSucc() && "MI isn't bundled with its successor");
919 ++Succ;
920 assert(Succ->isBundledWithPred() && "Inconsistent bundle flags");
921 Succ->clearFlag(BundledPred);
922}
923
925 if (isInlineAsm()) {
926 unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
927 if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
928 return true;
929 }
930 return false;
931}
932
934 assert(isInlineAsm() && "getInlineAsmDialect() only works for inline asms!");
935 unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
936 return InlineAsm::getDialect(ExtraInfo);
937}
938
940 unsigned *GroupNo) const {
941 assert(isInlineAsm() && "Expected an inline asm instruction");
942 assert(OpIdx < getNumOperands() && "OpIdx out of range");
943
944 // Ignore queries about the initial operands.
946 return -1;
947
948 unsigned Group = 0;
949 unsigned NumOps;
950 for (unsigned i = InlineAsm::MIOp_FirstOperand, e = getNumOperands(); i < e;
951 i += NumOps) {
952 const MachineOperand &FlagMO = getOperand(i);
953 // If we reach the implicit register operands, stop looking.
954 if (!FlagMO.isImm())
955 return -1;
956 const InlineAsm::Flag F(FlagMO.getImm());
957 NumOps = 1 + F.getNumOperandRegisters();
958 if (i + NumOps > OpIdx) {
959 if (GroupNo)
960 *GroupNo = Group;
961 return i;
962 }
963 ++Group;
964 }
965 return -1;
966}
967
969 assert(isDebugLabel() && "not a DBG_LABEL");
970 return cast<DILabel>(getOperand(0).getMetadata());
971}
972
974 assert((isDebugValueLike()) && "not a DBG_VALUE*");
975 unsigned VariableOp = isNonListDebugValue() ? 2 : 0;
976 return getOperand(VariableOp);
977}
978
980 assert((isDebugValueLike()) && "not a DBG_VALUE*");
981 unsigned VariableOp = isNonListDebugValue() ? 2 : 0;
982 return getOperand(VariableOp);
983}
984
988
990 assert((isDebugValueLike()) && "not a DBG_VALUE*");
991 unsigned ExpressionOp = isNonListDebugValue() ? 3 : 1;
992 return getOperand(ExpressionOp);
993}
994
996 assert((isDebugValueLike()) && "not a DBG_VALUE*");
997 unsigned ExpressionOp = isNonListDebugValue() ? 3 : 1;
998 return getOperand(ExpressionOp);
999}
1000
1004
1008
1011 const TargetInstrInfo *TII,
1012 const TargetRegisterInfo *TRI) const {
1013 assert(getParent() && "Can't have an MBB reference here!");
1014 assert(getMF() && "Can't have an MF reference here!");
1015 // Most opcodes have fixed constraints in their MCInstrDesc.
1016 if (!isInlineAsm())
1017 return TII->getRegClass(getDesc(), OpIdx);
1018
1019 if (!getOperand(OpIdx).isReg())
1020 return nullptr;
1021
1022 // For tied uses on inline asm, get the constraint from the def.
1023 unsigned DefIdx;
1024 if (getOperand(OpIdx).isUse() && isRegTiedToDefOperand(OpIdx, &DefIdx))
1025 OpIdx = DefIdx;
1026
1027 // Inline asm stores register class constraints in the flag word.
1028 int FlagIdx = findInlineAsmFlagIdx(OpIdx);
1029 if (FlagIdx < 0)
1030 return nullptr;
1031
1032 const InlineAsm::Flag F(getOperand(FlagIdx).getImm());
1033 unsigned RCID;
1034 if ((F.isRegUseKind() || F.isRegDefKind() || F.isRegDefEarlyClobberKind()) &&
1035 F.hasRegClassConstraint(RCID))
1036 return TRI->getRegClass(RCID);
1037
1038 // Assume that all registers in a memory operand are pointers.
1039 if (F.isMemKind())
1040 return TII->getInlineAsmMemoryOperandRegClass(F.getMemoryConstraintID());
1041
1042 return nullptr;
1043}
1044
1046 Register Reg, const TargetRegisterClass *CurRC, const TargetInstrInfo *TII,
1047 const TargetRegisterInfo *TRI, bool ExploreBundle) const {
1048 // Check every operands inside the bundle if we have
1049 // been asked to.
1050 if (ExploreBundle)
1051 for (ConstMIBundleOperands OpndIt(*this); OpndIt.isValid() && CurRC;
1052 ++OpndIt)
1053 CurRC = OpndIt->getParent()->getRegClassConstraintEffectForVRegImpl(
1054 OpndIt.getOperandNo(), Reg, CurRC, TII, TRI);
1055 else
1056 // Otherwise, just check the current operands.
1057 for (unsigned i = 0, e = NumOperands; i < e && CurRC; ++i)
1058 CurRC = getRegClassConstraintEffectForVRegImpl(i, Reg, CurRC, TII, TRI);
1059 return CurRC;
1060}
1061
1062const TargetRegisterClass *MachineInstr::getRegClassConstraintEffectForVRegImpl(
1063 unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC,
1064 const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const {
1065 assert(CurRC && "Invalid initial register class");
1066 // Check if Reg is constrained by some of its use/def from MI.
1067 const MachineOperand &MO = getOperand(OpIdx);
1068 if (!MO.isReg() || MO.getReg() != Reg)
1069 return CurRC;
1070 // If yes, accumulate the constraints through the operand.
1071 return getRegClassConstraintEffect(OpIdx, CurRC, TII, TRI);
1072}
1073
1075 unsigned OpIdx, const TargetRegisterClass *CurRC,
1076 const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const {
1077 const TargetRegisterClass *OpRC = getRegClassConstraint(OpIdx, TII, TRI);
1078 const MachineOperand &MO = getOperand(OpIdx);
1079 assert(MO.isReg() &&
1080 "Cannot get register constraints for non-register operand");
1081 assert(CurRC && "Invalid initial register class");
1082 if (unsigned SubIdx = MO.getSubReg()) {
1083 if (OpRC)
1084 CurRC = TRI->getMatchingSuperRegClass(CurRC, OpRC, SubIdx);
1085 else
1086 CurRC = TRI->getSubClassWithSubReg(CurRC, SubIdx);
1087 } else if (OpRC)
1088 CurRC = TRI->getCommonSubClass(CurRC, OpRC);
1089 return CurRC;
1090}
1091
1092/// Return the number of instructions inside the MI bundle, not counting the
1093/// header instruction.
1096 unsigned Size = 0;
1097 while (I->isBundledWithSucc()) {
1098 ++Size;
1099 ++I;
1100 }
1101 return Size;
1102}
1103
1104/// Returns true if the MachineInstr has an implicit-use operand of exactly
1105/// the given register (not considering sub/super-registers).
1107 for (const MachineOperand &MO : implicit_operands()) {
1108 if (MO.isReg() && MO.isUse() && MO.getReg() == Reg)
1109 return true;
1110 }
1111 return false;
1112}
1113
1114/// findRegisterUseOperandIdx() - Returns the MachineOperand that is a use of
1115/// the specific register or -1 if it is not found. It further tightens
1116/// the search criteria to a use that kills the register if isKill is true.
1118 const TargetRegisterInfo *TRI,
1119 bool isKill) const {
1120 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
1121 const MachineOperand &MO = getOperand(i);
1122 if (!MO.isReg() || !MO.isUse())
1123 continue;
1124 Register MOReg = MO.getReg();
1125 if (!MOReg)
1126 continue;
1127 if (MOReg == Reg || (TRI && Reg && MOReg && TRI->regsOverlap(MOReg, Reg)))
1128 if (!isKill || MO.isKill())
1129 return i;
1130 }
1131 return -1;
1132}
1133
1134bool MachineInstr::hasTiedAndOtherReadOf(Register Reg, unsigned SubReg) const {
1135 bool Tied = false;
1136 unsigned Reads = 0;
1137 for (const MachineOperand &MO : all_uses()) {
1138 if (MO.getReg() != Reg || MO.getSubReg() != SubReg)
1139 continue;
1140 ++Reads;
1141 // A tie its def already satisfies is not rewritten.
1142 Tied |= MO.isTied() &&
1144 }
1145 return Tied && Reads > 1;
1146}
1147
1148/// readsWritesVirtualRegister - Return a pair of bools (reads, writes)
1149/// indicating if this instruction reads or writes Reg. This also considers
1150/// partial defines.
1151std::pair<bool,bool>
1154 bool PartDef = false; // Partial redefine.
1155 bool FullDef = false; // Full define.
1156 bool Use = false;
1157
1158 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
1159 const MachineOperand &MO = getOperand(i);
1160 if (!MO.isReg() || MO.getReg() != Reg)
1161 continue;
1162 if (Ops)
1163 Ops->push_back(i);
1164 if (MO.isUse())
1165 Use |= !MO.isUndef();
1166 else if (MO.getSubReg() && !MO.isUndef())
1167 // A partial def undef doesn't count as reading the register.
1168 PartDef = true;
1169 else
1170 FullDef = true;
1171 }
1172 // A partial redefine uses Reg unless there is also a full define.
1173 return std::make_pair(Use || (PartDef && !FullDef), PartDef || FullDef);
1174}
1175
1176/// findRegisterDefOperandIdx() - Returns the operand index that is a def of
1177/// the specified register or -1 if it is not found. If isDead is true, defs
1178/// that are not dead are skipped. If TargetRegisterInfo is non-null, then it
1179/// also checks if there is a def of a super-register.
1181 const TargetRegisterInfo *TRI,
1182 bool isDead, bool Overlap) const {
1183 bool isPhys = Reg.isPhysical();
1184 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
1185 const MachineOperand &MO = getOperand(i);
1186 // Accept regmask operands when Overlap is set.
1187 // Ignore them when looking for a specific def operand (Overlap == false).
1188 if (isPhys && Overlap && MO.isRegMask() && MO.clobbersPhysReg(Reg))
1189 return i;
1190 if (!MO.isReg() || !MO.isDef())
1191 continue;
1192 Register MOReg = MO.getReg();
1193 bool Found = (MOReg == Reg);
1194 if (!Found && TRI && isPhys && MOReg.isPhysical()) {
1195 if (Overlap)
1196 Found = TRI->regsOverlap(MOReg, Reg);
1197 else
1198 Found = TRI->isSubRegister(MOReg, Reg);
1199 }
1200 if (Found && (!isDead || MO.isDead()))
1201 return i;
1202 }
1203 return -1;
1204}
1205
1206/// findFirstPredOperandIdx() - Find the index of the first operand in the
1207/// operand list that is used to represent the predicate. It returns -1 if
1208/// none is found.
1210 // Don't call MCID.findFirstPredOperandIdx() because this variant
1211 // is sometimes called on an instruction that's not yet complete, and
1212 // so the number of operands is less than the MCID indicates. In
1213 // particular, the PTX target does this.
1214 const MCInstrDesc &MCID = getDesc();
1215 if (MCID.isPredicable()) {
1216 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1217 if (MCID.operands()[i].isPredicate())
1218 return i;
1219 }
1220
1221 return -1;
1222}
1223
1224// MachineOperand::TiedTo is 4 bits wide.
1225const unsigned TiedMax = 15;
1226
1227/// tieOperands - Mark operands at DefIdx and UseIdx as tied to each other.
1228///
1229/// Use and def operands can be tied together, indicated by a non-zero TiedTo
1230/// field. TiedTo can have these values:
1231///
1232/// 0: Operand is not tied to anything.
1233/// 1 to TiedMax-1: Tied to getOperand(TiedTo-1).
1234/// TiedMax: Tied to an operand >= TiedMax-1.
1235///
1236/// The tied def must be one of the first TiedMax operands on a normal
1237/// instruction. INLINEASM instructions allow more tied defs.
1238///
1239/// A tied use and def of the same virtual register must use the same
1240/// subregister index.
1241///
1242void MachineInstr::tieOperands(unsigned DefIdx, unsigned UseIdx) {
1243 MachineOperand &DefMO = getOperand(DefIdx);
1244 MachineOperand &UseMO = getOperand(UseIdx);
1245 assert(DefMO.isDef() && "DefIdx must be a def operand");
1246 assert(UseMO.isUse() && "UseIdx must be a use operand");
1247 assert(!DefMO.isTied() && "Def is already tied to another use");
1248 assert(!UseMO.isTied() && "Use is already tied to another def");
1249
1250 if (DefIdx < TiedMax) {
1251 UseMO.TiedTo = DefIdx + 1;
1252 } else {
1253 // Inline asm can use the group descriptors to find tied operands,
1254 // statepoint tied operands are trivial to match (1-1 reg def with reg use),
1255 // but on normal instruction, the tied def must be within the first TiedMax
1256 // operands.
1257 assert((isInlineAsm() || getOpcode() == TargetOpcode::STATEPOINT) &&
1258 "DefIdx out of range");
1259 UseMO.TiedTo = TiedMax;
1260 }
1261
1262 // UseIdx can be out of range, we'll search for it in findTiedOperandIdx().
1263 DefMO.TiedTo = std::min(UseIdx + 1, TiedMax);
1264}
1265
1266/// Given the index of a tied register operand, find the operand it is tied to.
1267/// Defs are tied to uses and vice versa. Returns the index of the tied operand
1268/// which must exist.
1269unsigned MachineInstr::findTiedOperandIdx(unsigned OpIdx) const {
1270 const MachineOperand &MO = getOperand(OpIdx);
1271 assert(MO.isTied() && "Operand isn't tied");
1272
1273 // Normally TiedTo is in range.
1274 if (MO.TiedTo < TiedMax)
1275 return MO.TiedTo - 1;
1276
1277 // Uses on normal instructions can be out of range.
1278 if (!isInlineAsm() && getOpcode() != TargetOpcode::STATEPOINT) {
1279 // Normal tied defs must be in the 0..TiedMax-1 range.
1280 if (MO.isUse())
1281 return TiedMax - 1;
1282 // MO is a def. Search for the tied use.
1283 for (unsigned i = TiedMax - 1, e = getNumOperands(); i != e; ++i) {
1284 const MachineOperand &UseMO = getOperand(i);
1285 if (UseMO.isReg() && UseMO.isUse() && UseMO.TiedTo == OpIdx + 1)
1286 return i;
1287 }
1288 llvm_unreachable("Can't find tied use");
1289 }
1290
1291 if (getOpcode() == TargetOpcode::STATEPOINT) {
1292 // In STATEPOINT defs correspond 1-1 to GC pointer operands passed
1293 // on registers.
1294 StatepointOpers SO(this);
1295 unsigned CurUseIdx = SO.getFirstGCPtrIdx();
1296 assert(CurUseIdx != -1U && "only gc pointer statepoint operands can be tied");
1297 unsigned NumDefs = getNumDefs();
1298 for (unsigned CurDefIdx = 0; CurDefIdx < NumDefs; ++CurDefIdx) {
1299 while (!getOperand(CurUseIdx).isReg())
1300 CurUseIdx = StackMaps::getNextMetaArgIdx(this, CurUseIdx);
1301 if (OpIdx == CurDefIdx)
1302 return CurUseIdx;
1303 if (OpIdx == CurUseIdx)
1304 return CurDefIdx;
1305 CurUseIdx = StackMaps::getNextMetaArgIdx(this, CurUseIdx);
1306 }
1307 llvm_unreachable("Can't find tied use");
1308 }
1309
1310 // Now deal with inline asm by parsing the operand group descriptor flags.
1311 // Find the beginning of each operand group.
1312 SmallVector<unsigned, 8> GroupIdx;
1313 unsigned OpIdxGroup = ~0u;
1314 unsigned NumOps;
1315 for (unsigned i = InlineAsm::MIOp_FirstOperand, e = getNumOperands(); i < e;
1316 i += NumOps) {
1317 const MachineOperand &FlagMO = getOperand(i);
1318 assert(FlagMO.isImm() && "Invalid tied operand on inline asm");
1319 unsigned CurGroup = GroupIdx.size();
1320 GroupIdx.push_back(i);
1321 const InlineAsm::Flag F(FlagMO.getImm());
1322 NumOps = 1 + F.getNumOperandRegisters();
1323 // OpIdx belongs to this operand group.
1324 if (OpIdx > i && OpIdx < i + NumOps)
1325 OpIdxGroup = CurGroup;
1326 unsigned TiedGroup;
1327 if (!F.isUseOperandTiedToDef(TiedGroup))
1328 continue;
1329 // Operands in this group are tied to operands in TiedGroup which must be
1330 // earlier. Find the number of operands between the two groups.
1331 unsigned Delta = i - GroupIdx[TiedGroup];
1332
1333 // OpIdx is a use tied to TiedGroup.
1334 if (OpIdxGroup == CurGroup)
1335 return OpIdx - Delta;
1336
1337 // OpIdx is a def tied to this use group.
1338 if (OpIdxGroup == TiedGroup)
1339 return OpIdx + Delta;
1340 }
1341 llvm_unreachable("Invalid tied operand on inline asm");
1342}
1343
1344/// clearKillInfo - Clears kill flags on all operands.
1345///
1347 for (MachineOperand &MO : operands()) {
1348 if (MO.isReg() && MO.isUse())
1349 MO.setIsKill(false);
1350 }
1351}
1352
1354 unsigned SubIdx,
1355 const TargetRegisterInfo &RegInfo) {
1356 if (ToReg.isPhysical()) {
1357 if (SubIdx)
1358 ToReg = RegInfo.getSubReg(ToReg, SubIdx);
1359 for (MachineOperand &MO : operands()) {
1360 if (!MO.isReg() || MO.getReg() != FromReg)
1361 continue;
1362 MO.substPhysReg(ToReg, RegInfo);
1363 }
1364 } else {
1365 for (MachineOperand &MO : operands()) {
1366 if (!MO.isReg() || MO.getReg() != FromReg)
1367 continue;
1368 MO.substVirtReg(ToReg, SubIdx, RegInfo);
1369 }
1370 }
1371}
1372
1373/// isSafeToMove - Return true if it is safe to move this instruction. If
1374/// SawStore is set to true, it means that there is a store (or call) between
1375/// the instruction's location and its intended destination.
1376bool MachineInstr::isSafeToMove(bool &SawStore) const {
1377 // Ignore stuff that we obviously can't move.
1378 //
1379 // Treat volatile loads as stores. This is not strictly necessary for
1380 // volatiles, but it is required for atomic loads. It is not allowed to move
1381 // a load across an atomic load with Ordering > Monotonic.
1382 if (mayStore() || isCall() || isPHI() || hasOrderedMemoryRef()) {
1383 SawStore = true;
1384 return false;
1385 }
1386
1387 // Don't touch instructions that have non-trivial invariants. For example,
1388 // terminators have to be at the end of a basic block.
1389 if (isPosition() || isDebugInstr() || isTerminator() ||
1391 return false;
1392
1393 // Don't touch instructions which can have non-load/store effects.
1394 //
1395 // Inline asm has a "sideeffect" marker to indicate whether the asm has
1396 // intentional side-effects. Even if an inline asm is not "sideeffect",
1397 // though, it still can't be speculatively executed: the operation might
1398 // not be valid on the current target, or for some combinations of operands.
1399 // (Some transforms that move an instruction don't speculatively execute it;
1400 // we currently don't try to handle that distinction here.)
1401 //
1402 // Other instructions handled here include those that can raise FP
1403 // exceptions, x86 "DIV" instructions which trap on divide by zero, and
1404 // stack adjustments.
1406 isInlineAsm())
1407 return false;
1408
1409 // See if this instruction does a load. If so, we have to guarantee that the
1410 // loaded value doesn't change between the load and the its intended
1411 // destination. The check for isInvariantLoad gives the target the chance to
1412 // classify the load as always returning a constant, e.g. a constant pool
1413 // load.
1415 // Otherwise, this is a real load. If there is a store between the load and
1416 // end of block, we can't move it.
1417 return !SawStore;
1418
1419 return true;
1420}
1421
1423 // Don't delete frame allocation labels.
1424 // FIXME: Why is LOCAL_ESCAPE not considered in MachineInstr::isLabel?
1425 if (getOpcode() == TargetOpcode::LOCAL_ESCAPE)
1426 return false;
1427
1428 // Don't delete FAKE_USE.
1429 // FIXME: Why is FAKE_USE not considered in MachineInstr::isPosition?
1430 if (isFakeUse())
1431 return false;
1432
1433 // If we can move an instruction, we can remove it. Otherwise, it has
1434 // a side-effect of some sort.
1435 bool SawStore = false;
1436 return isPHI() || isSafeToMove(SawStore);
1437}
1438
1440 LiveRegUnits *LivePhysRegs) const {
1441 // Instructions without side-effects are dead iff they only define dead regs.
1442 // This function is hot and this loop returns early in the common case,
1443 // so only perform additional checks before this if absolutely necessary.
1444 for (const MachineOperand &MO : all_defs()) {
1445 Register Reg = MO.getReg();
1446 if (Reg.isPhysical()) {
1447 // Don't delete live physreg defs, or any reserved register defs.
1448 if (!LivePhysRegs || !LivePhysRegs->available(Reg) || MRI.isReserved(Reg))
1449 return false;
1450 } else {
1451 if (MO.isDead())
1452 continue;
1453 for (const MachineInstr &Use : MRI.use_nodbg_instructions(Reg)) {
1454 if (&Use != this)
1455 // This def has a non-debug use. Don't delete the instruction!
1456 return false;
1457 }
1458 }
1459 }
1460
1461 // Technically speaking inline asm without side effects and no defs can still
1462 // be deleted. But there is so much bad inline asm code out there, we should
1463 // let them be.
1464 if (isInlineAsm())
1465 return false;
1466
1467 // FIXME: See issue #105950 for why LIFETIME markers are considered dead here.
1468 if (isLifetimeMarker())
1469 return true;
1470
1471 // If there are no defs with uses, then we call the instruction dead so long
1472 // as we do not suspect it may have sideeffects.
1473 return wouldBeTriviallyDead();
1474}
1475
1477 BatchAAResults *AA, bool UseTBAA,
1478 const MachineMemOperand *MMOa,
1479 const MachineMemOperand *MMOb) {
1480 // The following interface to AA is fashioned after DAGCombiner::isAlias and
1481 // operates with MachineMemOperand offset with some important assumptions:
1482 // - LLVM fundamentally assumes flat address spaces.
1483 // - MachineOperand offset can *only* result from legalization and cannot
1484 // affect queries other than the trivial case of overlap checking.
1485 // - These offsets never wrap and never step outside of allocated objects.
1486 // - There should never be any negative offsets here.
1487 //
1488 // FIXME: Modify API to hide this math from "user"
1489 // Even before we go to AA we can reason locally about some memory objects. It
1490 // can save compile time, and possibly catch some corner cases not currently
1491 // covered.
1492
1493 int64_t OffsetA = MMOa->getOffset();
1494 int64_t OffsetB = MMOb->getOffset();
1495 int64_t MinOffset = std::min(OffsetA, OffsetB);
1496
1497 LocationSize WidthA = MMOa->getSize();
1498 LocationSize WidthB = MMOb->getSize();
1499 bool KnownWidthA = WidthA.hasValue();
1500 bool KnownWidthB = WidthB.hasValue();
1501 bool BothMMONonScalable = !WidthA.isScalable() && !WidthB.isScalable();
1502
1503 const Value *ValA = MMOa->getValue();
1504 const Value *ValB = MMOb->getValue();
1505 bool SameVal = (ValA && ValB && (ValA == ValB));
1506 if (!SameVal) {
1507 const PseudoSourceValue *PSVa = MMOa->getPseudoValue();
1508 const PseudoSourceValue *PSVb = MMOb->getPseudoValue();
1509 if (PSVa && ValB && !PSVa->mayAlias(&MFI))
1510 return false;
1511 if (PSVb && ValA && !PSVb->mayAlias(&MFI))
1512 return false;
1513 if (PSVa && PSVb && (PSVa == PSVb))
1514 SameVal = true;
1515 }
1516
1517 if (SameVal && BothMMONonScalable) {
1518 if (!KnownWidthA || !KnownWidthB)
1519 return true;
1520 int64_t MaxOffset = std::max(OffsetA, OffsetB);
1521 int64_t LowWidth = (MinOffset == OffsetA)
1522 ? WidthA.getValue().getKnownMinValue()
1523 : WidthB.getValue().getKnownMinValue();
1524 return (MinOffset + LowWidth > MaxOffset);
1525 }
1526
1527 if (!AA)
1528 return true;
1529
1530 if (!ValA || !ValB)
1531 return true;
1532
1533 assert((OffsetA >= 0) && "Negative MachineMemOperand offset");
1534 assert((OffsetB >= 0) && "Negative MachineMemOperand offset");
1535
1536 // If Scalable Location Size has non-zero offset, Width + Offset does not work
1537 // at the moment
1538 if ((WidthA.isScalable() && OffsetA > 0) ||
1539 (WidthB.isScalable() && OffsetB > 0))
1540 return true;
1541
1542 int64_t OverlapA =
1543 KnownWidthA ? WidthA.getValue().getKnownMinValue() + OffsetA - MinOffset
1545 int64_t OverlapB =
1546 KnownWidthB ? WidthB.getValue().getKnownMinValue() + OffsetB - MinOffset
1548
1549 LocationSize LocA = (WidthA.isScalable() || !KnownWidthA)
1550 ? WidthA
1551 : LocationSize::precise(OverlapA);
1552 LocationSize LocB = (WidthB.isScalable() || !KnownWidthB)
1553 ? WidthB
1554 : LocationSize::precise(OverlapB);
1555
1556 return !AA->isNoAlias(
1557 MemoryLocation(ValA, LocA, UseTBAA ? MMOa->getAAInfo() : AAMDNodes()),
1558 MemoryLocation(ValB, LocB, UseTBAA ? MMOb->getAAInfo() : AAMDNodes()));
1559}
1560
1562 bool UseTBAA) const {
1563 const MachineFunction *MF = getMF();
1565 const MachineFrameInfo &MFI = MF->getFrameInfo();
1566
1567 // Exclude call instruction which may alter the memory but can not be handled
1568 // by this function.
1569 if (isCall() || Other.isCall())
1570 return true;
1571
1572 // If neither instruction stores to memory, they can't alias in any
1573 // meaningful way, even if they read from the same address.
1574 if (!mayStore() && !Other.mayStore())
1575 return false;
1576
1577 // Both instructions must be memory operations to be able to alias.
1578 if (!mayLoadOrStore() || !Other.mayLoadOrStore())
1579 return false;
1580
1581 // Let the target decide if memory accesses cannot possibly overlap.
1582 if (TII->areMemAccessesTriviallyDisjoint(*this, Other))
1583 return false;
1584
1585 // Memory operations without memory operands may access anything. Be
1586 // conservative and assume `MayAlias`.
1587 if (memoperands_empty() || Other.memoperands_empty())
1588 return true;
1589
1590 // Skip if there are too many memory operands.
1591 auto NumChecks = getNumMemOperands() * Other.getNumMemOperands();
1592 if (NumChecks > TII->getMemOperandAACheckLimit())
1593 return true;
1594
1595 // Check each pair of memory operands from both instructions, which can't
1596 // alias only if all pairs won't alias.
1597 for (auto *MMOa : memoperands()) {
1598 for (auto *MMOb : Other.memoperands()) {
1599 if (!MMOa->isStore() && !MMOb->isStore())
1600 continue;
1601 if (MemOperandsHaveAlias(MFI, AA, UseTBAA, MMOa, MMOb))
1602 return true;
1603 }
1604 }
1605
1606 return false;
1607}
1608
1609bool MachineInstr::mayAlias(AAResults *AA, const MachineInstr &Other,
1610 bool UseTBAA) const {
1611 if (AA) {
1612 BatchAAResults BAA(*AA);
1613 return mayAlias(&BAA, Other, UseTBAA);
1614 }
1615 return mayAlias(static_cast<BatchAAResults *>(nullptr), Other, UseTBAA);
1616}
1617
1618/// hasOrderedMemoryRef - Return true if this instruction may have an ordered
1619/// or volatile memory reference, or if the information describing the memory
1620/// reference is not available. Return false if it is known to have no ordered
1621/// memory references.
1623 // An instruction known never to access memory won't have a volatile access.
1624 if (!mayStore() &&
1625 !mayLoad() &&
1626 !isCall() &&
1628 return false;
1629
1630 // Otherwise, if the instruction has no memory reference information,
1631 // conservatively assume it wasn't preserved.
1632 if (memoperands_empty())
1633 return true;
1634
1635 // Check if any of our memory operands are ordered.
1636 return llvm::any_of(memoperands(), [](const MachineMemOperand *MMO) {
1637 return !MMO->isUnordered();
1638 });
1639}
1640
1641/// isDereferenceableInvariantLoad - Return true if this instruction will never
1642/// trap and is loading from a location whose value is invariant across a run of
1643/// this function.
1645 // If the instruction doesn't load at all, it isn't an invariant load.
1646 if (!mayLoad())
1647 return false;
1648
1649 // If the instruction has lost its memoperands, conservatively assume that
1650 // it may not be an invariant load.
1651 if (memoperands_empty())
1652 return false;
1653
1654 const MachineFrameInfo &MFI = getParent()->getParent()->getFrameInfo();
1655
1656 for (MachineMemOperand *MMO : memoperands()) {
1657 if (!MMO->isUnordered())
1658 // If the memory operand has ordering side effects, we can't move the
1659 // instruction. Such an instruction is technically an invariant load,
1660 // but the caller code would need updated to expect that.
1661 return false;
1662 if (MMO->isStore()) return false;
1663 if (MMO->isInvariant() && MMO->isDereferenceable())
1664 continue;
1665
1666 // A load from a constant PseudoSourceValue is invariant.
1667 if (const PseudoSourceValue *PSV = MMO->getPseudoValue()) {
1668 if (PSV->isConstant(&MFI))
1669 continue;
1670 }
1671
1672 // Otherwise assume conservatively.
1673 return false;
1674 }
1675
1676 // Everything checks out.
1677 return true;
1678}
1679
1681 if (!isPHI())
1682 return {};
1683 assert(getNumOperands() >= 3 &&
1684 "It's illegal to have a PHI without source operands");
1685
1686 Register Reg = getOperand(1).getReg();
1687 for (unsigned i = 3, e = getNumOperands(); i < e; i += 2)
1688 if (getOperand(i).getReg() != Reg)
1689 return {};
1690 return Reg;
1691}
1692
1695 return true;
1696 if (isInlineAsm()) {
1697 unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
1698 if (ExtraInfo & InlineAsm::Extra_HasSideEffects)
1699 return true;
1700 }
1701
1702 return false;
1703}
1704
1706 return mayStore() || isCall() ||
1708}
1709
1710/// allDefsAreDead - Return true if all the defs of this instruction are dead.
1711///
1713 for (const MachineOperand &MO : operands()) {
1714 if (!MO.isReg() || MO.isUse())
1715 continue;
1716 if (!MO.isDead())
1717 return false;
1718 }
1719 return true;
1720}
1721
1723 for (const MachineOperand &MO : implicit_operands()) {
1724 if (!MO.isReg() || MO.isUse())
1725 continue;
1726 if (!MO.isDead())
1727 return false;
1728 }
1729 return true;
1730}
1731
1732/// copyImplicitOps - Copy implicit register operands from specified
1733/// instruction to this instruction.
1735 const MachineInstr &MI) {
1736 for (const MachineOperand &MO :
1737 llvm::drop_begin(MI.operands(), MI.getDesc().getNumOperands()))
1738 if ((MO.isReg() && MO.isImplicit()) || MO.isRegMask())
1739 addOperand(MF, MO);
1740}
1741
1743 const MCInstrDesc &MCID = getDesc();
1744 if (MCID.Opcode == TargetOpcode::STATEPOINT)
1745 return true;
1746 for (unsigned I = 0, E = getNumOperands(); I < E; ++I) {
1747 const auto &Operand = getOperand(I);
1748 if (!Operand.isReg() || Operand.isDef())
1749 // Ignore the defined registers as MCID marks only the uses as tied.
1750 continue;
1751 int ExpectedTiedIdx = MCID.getOperandConstraint(I, MCOI::TIED_TO);
1752 int TiedIdx = Operand.isTied() ? int(findTiedOperandIdx(I)) : -1;
1753 if (ExpectedTiedIdx != TiedIdx)
1754 return true;
1755 }
1756 return false;
1757}
1758
1760 const MachineRegisterInfo &MRI) const {
1761 const MachineOperand &Op = getOperand(OpIdx);
1762 if (!Op.isReg())
1763 return LLT{};
1764
1765 if (isVariadic() || OpIdx >= getNumExplicitOperands())
1766 return MRI.getType(Op.getReg());
1767
1768 auto &OpInfo = getDesc().operands()[OpIdx];
1769 if (!OpInfo.isGenericType())
1770 return MRI.getType(Op.getReg());
1771
1772 // The MIR parser requires a type on every generic register definition.
1773 if (PrintedTypes[OpInfo.getGenericTypeIndex()] && !Op.isDef())
1774 return LLT{};
1775
1776 LLT TypeToPrint = MRI.getType(Op.getReg());
1777 // Don't mark the type index printed if it wasn't actually printed: maybe
1778 // another operand with the same type index has an actual type attached:
1779 if (TypeToPrint.isValid())
1780 PrintedTypes.set(OpInfo.getGenericTypeIndex());
1781 return TypeToPrint;
1782}
1783
1784#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1786 dbgs() << " ";
1787 print(dbgs());
1788}
1789
1790LLVM_DUMP_METHOD void MachineInstr::dumprImpl(
1791 const MachineRegisterInfo &MRI, unsigned Depth, unsigned MaxDepth,
1792 SmallPtrSetImpl<const MachineInstr *> &AlreadySeenInstrs) const {
1793 if (Depth >= MaxDepth)
1794 return;
1795 if (!AlreadySeenInstrs.insert(this).second)
1796 return;
1797 // PadToColumn always inserts at least one space.
1798 // Don't mess up the alignment if we don't want any space.
1799 if (Depth)
1800 fdbgs().PadToColumn(Depth * 2);
1801 print(fdbgs());
1802 for (const MachineOperand &MO : operands()) {
1803 if (!MO.isReg() || MO.isDef())
1804 continue;
1805 Register Reg = MO.getReg();
1806 if (Reg.isPhysical())
1807 continue;
1808 const MachineInstr *NewMI = MRI.getUniqueVRegDef(Reg);
1809 if (NewMI == nullptr)
1810 continue;
1811 NewMI->dumprImpl(MRI, Depth + 1, MaxDepth, AlreadySeenInstrs);
1812 }
1813}
1814
1816 unsigned MaxDepth) const {
1817 SmallPtrSet<const MachineInstr *, 16> AlreadySeenInstrs;
1818 dumprImpl(MRI, 0, MaxDepth, AlreadySeenInstrs);
1819}
1820#endif
1821
1822void MachineInstr::print(raw_ostream &OS, bool IsStandalone, bool SkipOpers,
1823 bool SkipDebugLoc, bool AddNewLine,
1824 const TargetInstrInfo *TII) const {
1825 const Module *M = nullptr;
1826 const Function *F = nullptr;
1827 if (const MachineFunction *MF = getMFIfAvailable(*this)) {
1828 F = &MF->getFunction();
1829 M = F->getParent();
1830 if (!TII)
1831 TII = MF->getSubtarget().getInstrInfo();
1832 }
1833
1834 ModuleSlotTracker MST(M);
1835 if (F)
1836 MST.incorporateFunction(*F);
1837 print(OS, MST, IsStandalone, SkipOpers, SkipDebugLoc, AddNewLine, TII);
1838}
1839
1841 bool IsStandalone, bool SkipOpers, bool SkipDebugLoc,
1842 bool AddNewLine, const TargetInstrInfo *TII) const {
1843 // We can be a bit tidier if we know the MachineFunction.
1844 const TargetRegisterInfo *TRI = nullptr;
1845 const MachineRegisterInfo *MRI = nullptr;
1846 tryToGetTargetInfo(*this, TRI, MRI, TII);
1847
1848 if (isCFIInstruction())
1849 assert(getNumOperands() == 1 && "Expected 1 operand in CFI instruction");
1850
1851 SmallBitVector PrintedTypes(8);
1852 bool ShouldPrintRegisterTies = IsStandalone || hasComplexRegisterTies();
1853 auto GetTiedOperandIdx = [&](unsigned OpIdx) {
1854 if (!ShouldPrintRegisterTies)
1855 return 0U;
1856 const MachineOperand &MO = getOperand(OpIdx);
1857 if (MO.isReg() && MO.isTied() && !MO.isDef())
1858 return findTiedOperandIdx(OpIdx);
1859 return 0U;
1860 };
1861 unsigned StartOp = 0;
1862 unsigned e = getNumOperands();
1863
1864 // Print explicitly defined operands on the left of an assignment syntax.
1865 while (StartOp < e) {
1866 const MachineOperand &MO = getOperand(StartOp);
1867 if (!MO.isReg() || !MO.isDef() || MO.isImplicit())
1868 break;
1869
1870 if (StartOp != 0)
1871 OS << ", ";
1872
1873 LLT TypeToPrint = MRI ? getTypeToPrint(StartOp, PrintedTypes, *MRI) : LLT{};
1874 // tied operands are not printed for defs.
1875 MO.print(OS, MST, TypeToPrint, StartOp, /*PrintDef=*/false, IsStandalone,
1876 /*ShouldPrintRegisterTies=*/false, /*TiedOperandIdx=*/0, TRI);
1877 ++StartOp;
1878 }
1879
1880 if (StartOp != 0)
1881 OS << " = ";
1882
1884 OS << "frame-setup ";
1886 OS << "frame-destroy ";
1888 OS << "nnan ";
1890 OS << "ninf ";
1892 OS << "nsz ";
1894 OS << "arcp ";
1896 OS << "contract ";
1898 OS << "afn ";
1900 OS << "reassoc ";
1902 OS << "nuw ";
1904 OS << "nsw ";
1906 OS << "exact ";
1908 OS << "nofpexcept ";
1910 OS << "nomerge ";
1912 OS << "noconvergent ";
1914 OS << "nneg ";
1916 OS << "disjoint ";
1918 OS << "nusw ";
1920 OS << "samesign ";
1922 OS << "inbounds ";
1924 OS << "lr-split ";
1926 OS << "nonnull ";
1927
1928 // Print the opcode name.
1929 if (TII)
1930 OS << TII->getName(getOpcode());
1931 else
1932 OS << "UNKNOWN";
1933
1934 if (SkipOpers)
1935 return;
1936
1937 // Print the rest of the operands.
1938 bool FirstOp = true;
1939 unsigned AsmDescOp = ~0u;
1940 unsigned AsmOpCount = 0;
1941
1943 // Print asm string.
1944 OS << " ";
1945 const unsigned OpIdx = InlineAsm::MIOp_AsmString;
1946 LLT TypeToPrint = MRI ? getTypeToPrint(OpIdx, PrintedTypes, *MRI) : LLT{};
1947 unsigned TiedOperandIdx = GetTiedOperandIdx(OpIdx);
1948 getOperand(OpIdx).print(OS, MST, TypeToPrint, OpIdx, /*PrintDef=*/true,
1949 IsStandalone, ShouldPrintRegisterTies,
1950 TiedOperandIdx, TRI);
1951
1952 // Print HasSideEffects, MayLoad, MayStore, IsAlignStack
1953 unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
1954 if (ExtraInfo & InlineAsm::Extra_HasSideEffects)
1955 OS << " [sideeffect]";
1956 if (ExtraInfo & InlineAsm::Extra_MayLoad)
1957 OS << " [mayload]";
1958 if (ExtraInfo & InlineAsm::Extra_MayStore)
1959 OS << " [maystore]";
1960 if (ExtraInfo & InlineAsm::Extra_IsConvergent)
1961 OS << " [isconvergent]";
1962 if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
1963 OS << " [alignstack]";
1964 if (ExtraInfo & InlineAsm::Extra_MayUnwind)
1965 OS << " [unwind]";
1967 OS << " [attdialect]";
1969 OS << " [inteldialect]";
1970
1971 StartOp = AsmDescOp = InlineAsm::MIOp_FirstOperand;
1972 FirstOp = false;
1973 }
1974
1975 for (unsigned i = StartOp, e = getNumOperands(); i != e; ++i) {
1976 const MachineOperand &MO = getOperand(i);
1977
1978 if (FirstOp) FirstOp = false; else OS << ",";
1979 OS << " ";
1980
1981 if (isDebugValueLike() && MO.isMetadata()) {
1982 // Pretty print DBG_VALUE* instructions.
1983 auto *DIV = dyn_cast<DILocalVariable>(MO.getMetadata());
1984 if (DIV && !DIV->getName().empty())
1985 OS << "!\"" << DIV->getName() << '\"';
1986 else {
1987 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
1988 unsigned TiedOperandIdx = GetTiedOperandIdx(i);
1989 MO.print(OS, MST, TypeToPrint, i, /*PrintDef=*/true, IsStandalone,
1990 ShouldPrintRegisterTies, TiedOperandIdx, TRI);
1991 }
1992 } else if (isDebugLabel() && MO.isMetadata()) {
1993 // Pretty print DBG_LABEL instructions.
1994 auto *DIL = dyn_cast<DILabel>(MO.getMetadata());
1995 if (DIL && !DIL->getName().empty())
1996 OS << "\"" << DIL->getName() << '\"';
1997 else {
1998 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
1999 unsigned TiedOperandIdx = GetTiedOperandIdx(i);
2000 MO.print(OS, MST, TypeToPrint, i, /*PrintDef=*/true, IsStandalone,
2001 ShouldPrintRegisterTies, TiedOperandIdx, TRI);
2002 }
2003 } else if (i == AsmDescOp && MO.isImm()) {
2004 // Pretty print the inline asm operand descriptor.
2005 OS << '$' << AsmOpCount++;
2006 unsigned Flag = MO.getImm();
2007 const InlineAsm::Flag F(Flag);
2008 OS << ":[";
2009 OS << F.getKindName();
2010
2011 unsigned RCID;
2012 if (!F.isImmKind() && !F.isMemKind() && F.hasRegClassConstraint(RCID)) {
2013 if (TRI) {
2014 OS << ':' << TRI->getRegClassName(TRI->getRegClass(RCID));
2015 } else
2016 OS << ":RC" << RCID;
2017 }
2018
2019 if (F.isMemKind()) {
2020 const InlineAsm::ConstraintCode MCID = F.getMemoryConstraintID();
2021 OS << ":" << InlineAsm::getMemConstraintName(MCID);
2022 }
2023
2024 unsigned TiedTo;
2025 if (F.isUseOperandTiedToDef(TiedTo))
2026 OS << " tiedto:$" << TiedTo;
2027
2028 if ((F.isRegDefKind() || F.isRegDefEarlyClobberKind() ||
2029 F.isRegUseKind()) &&
2030 F.getRegMayBeFolded()) {
2031 OS << " foldable";
2032 }
2033
2034 OS << ']';
2035
2036 // Compute the index of the next operand descriptor.
2037 AsmDescOp += 1 + F.getNumOperandRegisters();
2038 } else if (MO.isImm() && isOperandSubregIdx(i)) {
2040 } else {
2041 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
2042 unsigned TiedOperandIdx = GetTiedOperandIdx(i);
2043 MO.print(OS, MST, TypeToPrint, i, /*PrintDef=*/true, IsStandalone,
2044 ShouldPrintRegisterTies, TiedOperandIdx, TRI);
2045 }
2046 }
2047
2048 // Print any optional symbols attached to this instruction as-if they were
2049 // operands.
2050 if (MCSymbol *PreInstrSymbol = getPreInstrSymbol()) {
2051 if (!FirstOp) {
2052 OS << ',';
2053 }
2054 OS << " pre-instr-symbol ";
2055 MachineOperand::printSymbol(OS, *PreInstrSymbol);
2056 }
2057 if (MCSymbol *PostInstrSymbol = getPostInstrSymbol()) {
2058 if (!FirstOp) {
2059 OS << ',';
2060 }
2061 OS << " post-instr-symbol ";
2062 MachineOperand::printSymbol(OS, *PostInstrSymbol);
2063 }
2064 if (MDNode *HeapAllocMarker = getHeapAllocMarker()) {
2065 if (!FirstOp) {
2066 OS << ',';
2067 }
2068 OS << " heap-alloc-marker ";
2069 HeapAllocMarker->printAsOperand(OS, MST);
2070 }
2071 if (MDNode *PCSections = getPCSections()) {
2072 if (!FirstOp) {
2073 OS << ',';
2074 }
2075 OS << " pcsections ";
2076 PCSections->printAsOperand(OS, MST);
2077 }
2078 if (MDNode *MMRA = getMMRAMetadata()) {
2079 if (!FirstOp) {
2080 OS << ',';
2081 }
2082 OS << " mmra ";
2083 MMRA->printAsOperand(OS, MST);
2084 }
2085 if (uint32_t CFIType = getCFIType()) {
2086 if (!FirstOp)
2087 OS << ',';
2088 OS << " cfi-type " << CFIType;
2089 }
2091 OS << ", deactivation-symbol " << getDeactivationSymbol()->getName();
2092
2093 if (DebugInstrNum) {
2094 if (!FirstOp)
2095 OS << ",";
2096 OS << " debug-instr-number " << DebugInstrNum;
2097 }
2098
2099 if (!SkipDebugLoc) {
2100 if (const DebugLoc &DL = getDebugLoc()) {
2101 if (!FirstOp)
2102 OS << ',';
2103 OS << " debug-location ";
2104 DL->printAsOperand(OS, MST);
2105 }
2106 }
2107
2108 if (!memoperands_empty()) {
2110 const LLVMContext *Context = nullptr;
2111 std::unique_ptr<LLVMContext> CtxPtr;
2112 const MachineFrameInfo *MFI = nullptr;
2113 if (const MachineFunction *MF = getMFIfAvailable(*this)) {
2114 MFI = &MF->getFrameInfo();
2115 Context = &MF->getFunction().getContext();
2116 } else {
2117 CtxPtr = std::make_unique<LLVMContext>();
2118 Context = CtxPtr.get();
2119 }
2120
2121 OS << " :: ";
2122 bool NeedComma = false;
2123 for (const MachineMemOperand *Op : memoperands()) {
2124 if (NeedComma)
2125 OS << ", ";
2126 Op->print(OS, MST, SSNs, *Context, MFI, TII);
2127 NeedComma = true;
2128 }
2129 }
2130
2131 if (SkipDebugLoc)
2132 return;
2133
2134 bool HaveSemi = false;
2135
2136 // Print debug location information.
2137 if (const DebugLoc &DL = getDebugLoc()) {
2138 if (!HaveSemi) {
2139 OS << ';';
2140 HaveSemi = true;
2141 }
2142 OS << ' ';
2143 DL.print(OS);
2144 }
2145
2146 // Print extra comments for DEBUG_VALUE and friends if they are well-formed.
2147 if ((isNonListDebugValue() && getNumOperands() >= 4) ||
2148 (isDebugValueList() && getNumOperands() >= 2) ||
2149 (isDebugRef() && getNumOperands() >= 3)) {
2150 if (getDebugVariableOp().isMetadata()) {
2151 if (!HaveSemi) {
2152 OS << ";";
2153 HaveSemi = true;
2154 }
2155 auto *DV = getDebugVariable();
2156 OS << " line no:" << DV->getLine();
2158 OS << " indirect";
2159 }
2160 }
2161 // TODO: DBG_LABEL
2162
2163 if (PrintMIAddrs)
2164 OS << " ; " << this;
2165
2166 if (AddNewLine)
2167 OS << '\n';
2168}
2169
2171 const TargetRegisterInfo *RegInfo,
2172 bool AddIfNotFound) {
2173 bool isPhysReg = IncomingReg.isPhysical();
2174 bool hasAliases = isPhysReg &&
2175 MCRegAliasIterator(IncomingReg, RegInfo, false).isValid();
2176 bool Found = false;
2178 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2179 MachineOperand &MO = getOperand(i);
2180 if (!MO.isReg() || !MO.isUse() || MO.isUndef())
2181 continue;
2182
2183 // DEBUG_VALUE nodes do not contribute to code generation and should
2184 // always be ignored. Failure to do so may result in trying to modify
2185 // KILL flags on DEBUG_VALUE nodes.
2186 if (MO.isDebug())
2187 continue;
2188
2189 Register Reg = MO.getReg();
2190 if (!Reg)
2191 continue;
2192
2193 if (Reg == IncomingReg) {
2194 if (!Found) {
2195 if (MO.isKill())
2196 // The register is already marked kill.
2197 return true;
2198 if (isPhysReg && isRegTiedToDefOperand(i))
2199 // Two-address uses of physregs must not be marked kill.
2200 return true;
2201 MO.setIsKill();
2202 Found = true;
2203 }
2204 } else if (hasAliases && MO.isKill() && Reg.isPhysical()) {
2205 // A super-register kill already exists.
2206 if (RegInfo->isSuperRegister(IncomingReg, Reg))
2207 return true;
2208 if (RegInfo->isSubRegister(IncomingReg, Reg))
2209 DeadOps.push_back(i);
2210 }
2211 }
2212
2213 // Trim unneeded kill operands.
2214 while (!DeadOps.empty()) {
2215 unsigned OpIdx = DeadOps.back();
2216 if (getOperand(OpIdx).isImplicit() &&
2217 (!isInlineAsm() || findInlineAsmFlagIdx(OpIdx) < 0))
2218 removeOperand(OpIdx);
2219 else
2220 getOperand(OpIdx).setIsKill(false);
2221 DeadOps.pop_back();
2222 }
2223
2224 // If not found, this means an alias of one of the operands is killed. Add a
2225 // new implicit operand if required.
2226 if (!Found && AddIfNotFound) {
2228 false /*IsDef*/,
2229 true /*IsImp*/,
2230 true /*IsKill*/));
2231 return true;
2232 }
2233 return Found;
2234}
2235
2237 const TargetRegisterInfo *RegInfo) {
2238 if (!Reg.isPhysical())
2239 RegInfo = nullptr;
2240 for (MachineOperand &MO : operands()) {
2241 if (!MO.isReg() || !MO.isUse() || !MO.isKill())
2242 continue;
2243 Register OpReg = MO.getReg();
2244 if ((RegInfo && RegInfo->regsOverlap(Reg, OpReg)) || Reg == OpReg)
2245 MO.setIsKill(false);
2246 }
2247}
2248
2250 const TargetRegisterInfo *RegInfo,
2251 bool AddIfNotFound) {
2252 bool isPhysReg = Reg.isPhysical();
2253 bool hasAliases = isPhysReg &&
2254 MCRegAliasIterator(Reg, RegInfo, false).isValid();
2255 bool Found = false;
2257 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
2258 MachineOperand &MO = getOperand(i);
2259 if (!MO.isReg() || !MO.isDef())
2260 continue;
2261 Register MOReg = MO.getReg();
2262 if (!MOReg)
2263 continue;
2264
2265 if (MOReg == Reg) {
2266 MO.setIsDead();
2267 Found = true;
2268 } else if (hasAliases && MO.isDead() && MOReg.isPhysical()) {
2269 // There exists a super-register that's marked dead.
2270 if (RegInfo->isSuperRegister(Reg, MOReg))
2271 return true;
2272 if (RegInfo->isSubRegister(Reg, MOReg))
2273 DeadOps.push_back(i);
2274 }
2275 }
2276
2277 // Trim unneeded dead operands.
2278 while (!DeadOps.empty()) {
2279 unsigned OpIdx = DeadOps.back();
2280 if (getOperand(OpIdx).isImplicit() &&
2281 (!isInlineAsm() || findInlineAsmFlagIdx(OpIdx) < 0))
2282 removeOperand(OpIdx);
2283 else
2284 getOperand(OpIdx).setIsDead(false);
2285 DeadOps.pop_back();
2286 }
2287
2288 // If not found, this means an alias of one of the operands is dead. Add a
2289 // new implicit operand if required.
2290 if (Found || !AddIfNotFound)
2291 return Found;
2292
2294 true /*IsDef*/,
2295 true /*IsImp*/,
2296 false /*IsKill*/,
2297 true /*IsDead*/));
2298 return true;
2299}
2300
2302 for (MachineOperand &MO : all_defs())
2303 if (MO.getReg() == Reg)
2304 MO.setIsDead(false);
2305}
2306
2308 for (MachineOperand &MO : all_defs())
2309 if (MO.getReg() == Reg && MO.getSubReg() != 0)
2310 MO.setIsUndef(IsUndef);
2311}
2312
2314 const TargetRegisterInfo *RegInfo) {
2315 if (Reg.isPhysical()) {
2316 MachineOperand *MO = findRegisterDefOperand(Reg, RegInfo, false, false);
2317 if (MO)
2318 return;
2319 } else {
2320 for (const MachineOperand &MO : all_defs()) {
2321 if (MO.getReg() == Reg && MO.getSubReg() == 0)
2322 return;
2323 }
2324 }
2326 true /*IsDef*/,
2327 true /*IsImp*/));
2328}
2329
2331 const TargetRegisterInfo &TRI) {
2332 bool HasRegMask = false;
2333 for (MachineOperand &MO : operands()) {
2334 if (MO.isRegMask()) {
2335 HasRegMask = true;
2336 continue;
2337 }
2338 if (!MO.isReg() || !MO.isDef()) continue;
2339 Register Reg = MO.getReg();
2340 if (!Reg.isPhysical())
2341 continue;
2342 // If there are no uses, including partial uses, the def is dead.
2343 if (llvm::none_of(UsedRegs,
2344 [&](MCRegister Use) { return TRI.regsOverlap(Use, Reg); }))
2345 MO.setIsDead();
2346 }
2347
2348 // This is a call with a register mask operand.
2349 // Mask clobbers are always dead, so add defs for the non-dead defines.
2350 if (HasRegMask)
2351 for (const Register &UsedReg : UsedRegs)
2352 addRegisterDefined(UsedReg, &TRI);
2353}
2354
2355unsigned
2357 // Build up a buffer of hash code components.
2358 SmallVector<size_t, 16> HashComponents;
2359 HashComponents.reserve(MI->getNumOperands() + 1);
2360 HashComponents.push_back(MI->getOpcode());
2361 for (const MachineOperand &MO : MI->operands()) {
2362 if (MO.isReg() && MO.isDef() && MO.getReg().isVirtual())
2363 continue; // Skip virtual register defs.
2364
2365 HashComponents.push_back(hash_value(MO));
2366 }
2367 return hash_combine_range(HashComponents);
2368}
2369
2371 // Find the source location cookie.
2372 const MDNode *LocMD = nullptr;
2373 for (unsigned i = getNumOperands(); i != 0; --i) {
2374 if (getOperand(i-1).isMetadata() &&
2375 (LocMD = getOperand(i-1).getMetadata()) &&
2376 LocMD->getNumOperands() != 0) {
2378 return LocMD;
2379 }
2380 }
2381
2382 return nullptr;
2383}
2384
2387 const MDNode *LocMD = getLocCookieMD();
2388 uint64_t LocCookie =
2389 LocMD
2390 ? mdconst::extract<ConstantInt>(LocMD->getOperand(0))->getZExtValue()
2391 : 0;
2393 Ctx.diagnose(DiagnosticInfoInlineAsm(LocCookie, Msg));
2394}
2395
2397 const Function &Fn = getMF()->getFunction();
2398 Fn.getContext().diagnose(
2400}
2401
2403 const MCInstrDesc &MCID, bool IsIndirect,
2404 Register Reg, const MDNode *Variable,
2405 const MDNode *Expr) {
2406 assert(isa<DILocalVariable>(Variable) && "not a variable");
2407 assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
2408 assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
2409 "Expected inlined-at fields to agree");
2410 auto MIB = BuildMI(MF, DL, MCID).addReg(Reg);
2411 if (IsIndirect)
2412 MIB.addImm(0U);
2413 else
2414 MIB.addReg(0U);
2415 return MIB.addMetadata(Variable).addMetadata(Expr);
2416}
2417
2419 const MCInstrDesc &MCID, bool IsIndirect,
2420 ArrayRef<MachineOperand> DebugOps,
2421 const MDNode *Variable, const MDNode *Expr) {
2422 assert(isa<DILocalVariable>(Variable) && "not a variable");
2423 assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
2424 assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
2425 "Expected inlined-at fields to agree");
2426 if (MCID.Opcode == TargetOpcode::DBG_VALUE) {
2427 assert(DebugOps.size() == 1 &&
2428 "DBG_VALUE must contain exactly one debug operand");
2429 MachineOperand DebugOp = DebugOps[0];
2430 if (DebugOp.isReg())
2431 return BuildMI(MF, DL, MCID, IsIndirect, DebugOp.getReg(), Variable,
2432 Expr);
2433
2434 auto MIB = BuildMI(MF, DL, MCID).add(DebugOp);
2435 if (IsIndirect)
2436 MIB.addImm(0U);
2437 else
2438 MIB.addReg(0U);
2439 return MIB.addMetadata(Variable).addMetadata(Expr);
2440 }
2441
2442 auto MIB = BuildMI(MF, DL, MCID);
2443 MIB.addMetadata(Variable).addMetadata(Expr);
2444 for (const MachineOperand &DebugOp : DebugOps)
2445 if (DebugOp.isReg())
2446 MIB.addReg(DebugOp.getReg());
2447 else
2448 MIB.add(DebugOp);
2449 return MIB;
2450}
2451
2454 const DebugLoc &DL, const MCInstrDesc &MCID,
2455 bool IsIndirect, Register Reg,
2456 const MDNode *Variable, const MDNode *Expr) {
2457 MachineFunction &MF = *BB.getParent();
2458 MachineInstr *MI = BuildMI(MF, DL, MCID, IsIndirect, Reg, Variable, Expr);
2459 BB.insert(I, MI);
2460 return MachineInstrBuilder(MF, MI);
2461}
2462
2465 const DebugLoc &DL, const MCInstrDesc &MCID,
2466 bool IsIndirect,
2467 ArrayRef<MachineOperand> DebugOps,
2468 const MDNode *Variable, const MDNode *Expr) {
2469 MachineFunction &MF = *BB.getParent();
2470 MachineInstr *MI =
2471 BuildMI(MF, DL, MCID, IsIndirect, DebugOps, Variable, Expr);
2472 BB.insert(I, MI);
2473 return MachineInstrBuilder(MF, *MI);
2474}
2475
2476/// Compute the new DIExpression to use with a DBG_VALUE for a spill slot.
2477/// This prepends DW_OP_deref when spilling an indirect DBG_VALUE.
2479 const MachineInstr &MI,
2480 const SmallVectorImpl<const MachineOperand *> &SpilledOperands) {
2481 assert(MI.getDebugVariable()->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
2482 "Expected inlined-at fields to agree");
2483
2484 const DIExpression *Expr = MI.getDebugExpression();
2485 if (MI.isIndirectDebugValue()) {
2486 assert(MI.getDebugOffset().getImm() == 0 &&
2487 "DBG_VALUE with nonzero offset");
2489 } else if (MI.isDebugValueList()) {
2490 // We will replace the spilled register with a frame index, so
2491 // immediately deref all references to the spilled register.
2492 std::array<uint64_t, 1> Ops{{dwarf::DW_OP_deref}};
2493 for (const MachineOperand *Op : SpilledOperands) {
2494 unsigned OpIdx = MI.getDebugOperandIndex(Op);
2495 Expr = DIExpression::appendOpsToArg(Expr, Ops, OpIdx);
2496 }
2497 }
2498 return Expr;
2499}
2501 Register SpillReg) {
2502 assert(MI.hasDebugOperandForReg(SpillReg) && "Spill Reg is not used in MI.");
2504 llvm::make_pointer_range(MI.getDebugOperandsForReg(SpillReg)));
2505 return computeExprForSpill(MI, SpillOperands);
2506}
2507
2510 const MachineInstr &Orig,
2511 int FrameIndex, Register SpillReg) {
2512 assert(!Orig.isDebugRef() &&
2513 "DBG_INSTR_REF should not reference a virtual register.");
2514 const DIExpression *Expr = computeExprForSpill(Orig, SpillReg);
2515 MachineInstrBuilder NewMI =
2516 BuildMI(BB, I, Orig.getDebugLoc(), Orig.getDesc());
2517 // Non-Variadic Operands: Location, Offset, Variable, Expression
2518 // Variadic Operands: Variable, Expression, Locations...
2519 if (Orig.isNonListDebugValue())
2520 NewMI.addFrameIndex(FrameIndex).addImm(0U);
2521 NewMI.addMetadata(Orig.getDebugVariable()).addMetadata(Expr);
2522 if (Orig.isDebugValueList()) {
2523 for (const MachineOperand &Op : Orig.debug_operands())
2524 if (Op.isReg() && Op.getReg() == SpillReg)
2525 NewMI.addFrameIndex(FrameIndex);
2526 else
2527 NewMI.add(MachineOperand(Op));
2528 }
2529 return NewMI;
2530}
2533 const MachineInstr &Orig, int FrameIndex,
2534 const SmallVectorImpl<const MachineOperand *> &SpilledOperands) {
2535 const DIExpression *Expr = computeExprForSpill(Orig, SpilledOperands);
2536 MachineInstrBuilder NewMI =
2537 BuildMI(BB, I, Orig.getDebugLoc(), Orig.getDesc());
2538 // Non-Variadic Operands: Location, Offset, Variable, Expression
2539 // Variadic Operands: Variable, Expression, Locations...
2540 if (Orig.isNonListDebugValue())
2541 NewMI.addFrameIndex(FrameIndex).addImm(0U);
2542 NewMI.addMetadata(Orig.getDebugVariable()).addMetadata(Expr);
2543 if (Orig.isDebugValueList()) {
2544 for (const MachineOperand &Op : Orig.debug_operands())
2545 if (is_contained(SpilledOperands, &Op))
2546 NewMI.addFrameIndex(FrameIndex);
2547 else
2548 NewMI.add(MachineOperand(Op));
2549 }
2550 return NewMI;
2551}
2552
2554 Register Reg) {
2555 const DIExpression *Expr = computeExprForSpill(Orig, Reg);
2556 if (Orig.isNonListDebugValue())
2558 for (MachineOperand &Op : Orig.getDebugOperandsForReg(Reg))
2559 Op.ChangeToFrameIndex(FrameIndex);
2560 Orig.getDebugExpressionOp().setMetadata(Expr);
2561}
2562
2565 MachineInstr &MI = *this;
2566 if (!MI.getOperand(0).isReg())
2567 return;
2568
2570 for (MachineBasicBlock::iterator DE = MI.getParent()->end();
2571 DI != DE; ++DI) {
2572 if (!DI->isDebugValue())
2573 return;
2574 if (DI->hasDebugOperandForReg(MI.getOperand(0).getReg()))
2575 DbgValues.push_back(&*DI);
2576 }
2577}
2578
2580 // Collect matching debug values.
2582
2583 if (!getOperand(0).isReg())
2584 return;
2585
2586 Register DefReg = getOperand(0).getReg();
2587 auto *MRI = getRegInfo();
2588 for (MachineInstr &DI : MRI->use_instructions(DefReg)) {
2589 if (!DI.isDebugValue())
2590 continue;
2591 if (DI.hasDebugOperandForReg(DefReg)) {
2592 DbgValues.push_back(&DI);
2593 }
2594 }
2595
2596 // Propagate Reg to debug value instructions.
2597 for (auto *DBI : DbgValues)
2598 for (MachineOperand &Op : DBI->getDebugOperandsForReg(DefReg))
2599 Op.setReg(Reg);
2600}
2601
2603
2605 const MachineFrameInfo &MFI) {
2606 std::optional<TypeSize> Size;
2607 for (const auto *A : Accesses) {
2608 if (MFI.isSpillSlotObjectIndex(
2609 cast<FixedStackPseudoSourceValue>(A->getPseudoValue())
2610 ->getFrameIndex())) {
2611 LocationSize S = A->getSize();
2612 if (!S.hasValue())
2614 if (!Size)
2615 Size = S.getValue();
2616 else
2617 Size = *Size + S.getValue();
2618 }
2619 }
2620 if (!Size)
2621 return LocationSize::precise(0);
2622 return LocationSize::precise(*Size);
2623}
2624
2625std::optional<LocationSize>
2627 int FI;
2628 if (TII->isStoreToStackSlotPostFE(*this, FI)) {
2629 const MachineFrameInfo &MFI = getMF()->getFrameInfo();
2630 if (MFI.isSpillSlotObjectIndex(FI))
2631 return (*memoperands_begin())->getSize();
2632 }
2633 return std::nullopt;
2634}
2635
2636std::optional<LocationSize>
2638 if (!mayStore())
2639 return std::nullopt;
2640
2642 if (TII->hasStoreToStackSlot(*this, Accesses))
2643 return getSpillSlotSize(Accesses, getMF()->getFrameInfo());
2644 return std::nullopt;
2645}
2646
2647std::optional<LocationSize>
2649 int FI;
2650 if (TII->isLoadFromStackSlotPostFE(*this, FI)) {
2651 const MachineFrameInfo &MFI = getMF()->getFrameInfo();
2652 if (MFI.isSpillSlotObjectIndex(FI))
2653 return (*memoperands_begin())->getSize();
2654 }
2655 return std::nullopt;
2656}
2657
2658std::optional<LocationSize>
2661 if (TII->hasLoadFromStackSlot(*this, Accesses))
2662 return getSpillSlotSize(Accesses, getMF()->getFrameInfo());
2663 return std::nullopt;
2664}
2665
2667 if (DebugInstrNum == 0)
2668 DebugInstrNum = getParent()->getParent()->getNewDebugInstrNum();
2669 return DebugInstrNum;
2670}
2671
2673 if (DebugInstrNum == 0)
2674 DebugInstrNum = MF.getNewDebugInstrNum();
2675 return DebugInstrNum;
2676}
2677
2678std::tuple<LLT, LLT> MachineInstr::getFirst2LLTs() const {
2679 return std::tuple(getRegInfo()->getType(getOperand(0).getReg()),
2680 getRegInfo()->getType(getOperand(1).getReg()));
2681}
2682
2683std::tuple<LLT, LLT, LLT> MachineInstr::getFirst3LLTs() const {
2684 return std::tuple(getRegInfo()->getType(getOperand(0).getReg()),
2685 getRegInfo()->getType(getOperand(1).getReg()),
2686 getRegInfo()->getType(getOperand(2).getReg()));
2687}
2688
2689std::tuple<LLT, LLT, LLT, LLT> MachineInstr::getFirst4LLTs() const {
2690 return std::tuple(getRegInfo()->getType(getOperand(0).getReg()),
2691 getRegInfo()->getType(getOperand(1).getReg()),
2692 getRegInfo()->getType(getOperand(2).getReg()),
2693 getRegInfo()->getType(getOperand(3).getReg()));
2694}
2695
2696std::tuple<LLT, LLT, LLT, LLT, LLT> MachineInstr::getFirst5LLTs() const {
2697 return std::tuple(getRegInfo()->getType(getOperand(0).getReg()),
2698 getRegInfo()->getType(getOperand(1).getReg()),
2699 getRegInfo()->getType(getOperand(2).getReg()),
2700 getRegInfo()->getType(getOperand(3).getReg()),
2701 getRegInfo()->getType(getOperand(4).getReg()));
2702}
2703
2704std::tuple<Register, LLT, Register, LLT>
2706 Register Reg0 = getOperand(0).getReg();
2707 Register Reg1 = getOperand(1).getReg();
2708 return std::tuple(Reg0, getRegInfo()->getType(Reg0), Reg1,
2709 getRegInfo()->getType(Reg1));
2710}
2711
2712std::tuple<Register, LLT, Register, LLT, Register, LLT>
2714 Register Reg0 = getOperand(0).getReg();
2715 Register Reg1 = getOperand(1).getReg();
2716 Register Reg2 = getOperand(2).getReg();
2717 return std::tuple(Reg0, getRegInfo()->getType(Reg0), Reg1,
2718 getRegInfo()->getType(Reg1), Reg2,
2719 getRegInfo()->getType(Reg2));
2720}
2721
2722std::tuple<Register, LLT, Register, LLT, Register, LLT, Register, LLT>
2724 Register Reg0 = getOperand(0).getReg();
2725 Register Reg1 = getOperand(1).getReg();
2726 Register Reg2 = getOperand(2).getReg();
2727 Register Reg3 = getOperand(3).getReg();
2728 return std::tuple(
2729 Reg0, getRegInfo()->getType(Reg0), Reg1, getRegInfo()->getType(Reg1),
2730 Reg2, getRegInfo()->getType(Reg2), Reg3, getRegInfo()->getType(Reg3));
2731}
2732
2734 LLT>
2736 Register Reg0 = getOperand(0).getReg();
2737 Register Reg1 = getOperand(1).getReg();
2738 Register Reg2 = getOperand(2).getReg();
2739 Register Reg3 = getOperand(3).getReg();
2740 Register Reg4 = getOperand(4).getReg();
2741 return std::tuple(
2742 Reg0, getRegInfo()->getType(Reg0), Reg1, getRegInfo()->getType(Reg1),
2743 Reg2, getRegInfo()->getType(Reg2), Reg3, getRegInfo()->getType(Reg3),
2744 Reg4, getRegInfo()->getType(Reg4));
2745}
2746
2749 assert(InsertBefore != nullptr && "invalid iterator");
2750 assert(InsertBefore->getParent() == this &&
2751 "iterator points to operand of other inst");
2752 if (Ops.empty())
2753 return;
2754
2755 // Do one pass to untie operands.
2757 for (const MachineOperand &MO : operands()) {
2758 if (MO.isReg() && MO.isTied()) {
2759 unsigned OpNo = getOperandNo(&MO);
2760 unsigned TiedTo = findTiedOperandIdx(OpNo);
2761 TiedOpIndices[OpNo] = TiedTo;
2762 untieRegOperand(OpNo);
2763 }
2764 }
2765
2766 unsigned OpIdx = getOperandNo(InsertBefore);
2767 SmallVector<MachineOperand> MovingOps(InsertBefore, operands_end());
2768
2769 for (unsigned I = getNumOperands(); I > OpIdx; --I)
2770 removeOperand(I - 1);
2771 for (const MachineOperand &MO : Ops)
2772 addOperand(MO);
2773 for (const MachineOperand &OpMoved : MovingOps)
2774 addOperand(OpMoved);
2775
2776 // Re-tie operands.
2777 for (auto [Tie1, Tie2] : TiedOpIndices) {
2778 if (Tie1 >= OpIdx)
2779 Tie1 += Ops.size();
2780 if (Tie2 >= OpIdx)
2781 Tie2 += Ops.size();
2782 tieOperands(Tie1, Tie2);
2783 }
2784}
2785
2786bool MachineInstr::mayFoldInlineAsmRegOp(unsigned OpId) const {
2787 assert(OpId && "expected non-zero operand id");
2788 assert(isInlineAsm() && "should only be used on inline asm");
2789
2790 if (!getOperand(OpId).isReg())
2791 return false;
2792
2793 const MachineOperand &MD = getOperand(OpId - 1);
2794 if (!MD.isImm())
2795 return false;
2796
2797 InlineAsm::Flag F(MD.getImm());
2798 if (F.isRegUseKind() || F.isRegDefKind() || F.isRegDefEarlyClobberKind())
2799 return F.getRegMayBeFolded();
2800 return false;
2801}
2802
2804 assert(isPHI());
2805
2806 // Phi might have multiple entries for MBB. Need to remove them all.
2807 unsigned RemovedCount = 0;
2808 for (unsigned N = getNumOperands(); N > 2; N -= 2) {
2809 if (getOperand(N - 1).getMBB() == &MBB) {
2810 removeOperand(N - 1);
2811 removeOperand(N - 2);
2812 RemovedCount += 2;
2813 }
2814 }
2815 return RemovedCount;
2816}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition Compiler.h:702
This file contains the declarations for the subclasses of Constant, which represent the different fla...
DXIL Forward Handle Accesses
Hexagon Common GEP
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
Module.h This file contains the declarations for the Module class.
const size_t AbstractManglingParser< Derived, Alloc >::NumOps
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
A set of register units.
Implement a low-level type suitable for MachineInstr level instruction selection.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first DebugLoc that has line number information, given a range of instructions.
const unsigned TiedMax
static void moveOperands(MachineOperand *Dst, MachineOperand *Src, unsigned NumOps, MachineRegisterInfo *MRI)
Move NumOps MachineOperands from Src to Dst, with support for overlapping ranges.
static cl::opt< bool > PrintMIAddrs("print-mi-addrs", cl::Hidden, cl::desc("Print addresses of MachineInstrs when dumping"))
static LocationSize getSpillSlotSize(const MMOList &Accesses, const MachineFrameInfo &MFI)
static const DIExpression * computeExprForSpill(const MachineInstr &MI, const SmallVectorImpl< const MachineOperand * > &SpilledOperands)
Compute the new DIExpression to use with a DBG_VALUE for a spill slot.
static bool MemOperandsHaveAlias(const MachineFrameInfo &MFI, BatchAAResults *AA, bool UseTBAA, const MachineMemOperand *MMOa, const MachineMemOperand *MMOb)
static iterator_range< filter_iterator< Operand *, std::function< bool(Operand &Op)> > > getDebugOperandsForRegHelper(Instruction *MI, Register Reg)
SmallVector< const MachineMemOperand *, 2 > MMOList
static void tryToGetTargetInfo(const MachineInstr &MI, const TargetRegisterInfo *&TRI, const MachineRegisterInfo *&MRI, const TargetInstrInfo *&TII)
static const MachineFunction * getMFIfAvailable(const MachineInstr &MI)
static bool hasIdenticalMMOs(ArrayRef< MachineMemOperand * > LHS, ArrayRef< MachineMemOperand * > RHS)
Check to see if the MMOs pointed to by the two MemRefs arrays are identical.
Register Reg
Register const TargetRegisterInfo * TRI
This file provides utility analysis objects describing memory locations.
This file contains the declarations for metadata subclasses.
static MCRegister getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
static bool isReg(const MCInst &MI, unsigned OpNo)
if(PassOpts->AAPipeline)
MachineRegisterInfo & MRI
static bool isValid(const char C)
Returns true if C is a valid mangled character: <0-9a-zA-Z_>.
SI Fold Operands
const char * Msg
This file contains some templates that are useful if you are working with the STL at all.
This file implements the SmallBitVector class.
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
Definition TapiFile.cpp:39
Value * RHS
Value * LHS
Capacity getNext() const
Get the next larger capacity.
size_t getSize() const
Get the number of elements in an array with this capacity.
static Capacity get(size_t N)
Get the capacity of an array that can hold at least N elements.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
size_t size() const
Get the array size.
Definition ArrayRef.h:141
bool empty() const
Check if the array is empty.
Definition ArrayRef.h:136
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition ArrayRef.h:185
This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR ch...
ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions.
DWARF expression.
LLVM_ABI bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
static LLVM_ABI bool isEqualExpression(const DIExpression *FirstExpr, bool FirstIndirect, const DIExpression *SecondExpr, bool SecondIndirect)
Determines whether two debug values should produce equivalent DWARF expressions, using their DIExpres...
static LLVM_ABI DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
static LLVM_ABI DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
A debug info location.
Definition DebugLoc.h:126
Diagnostic information for inline asm reporting.
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition Operator.h:202
Convenience struct for specifying and reasoning about fast-math flags.
Definition FMF.h:23
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition Function.cpp:352
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
This instruction compares its operands according to the predicate given to the constructor.
AsmDialect getDialect() const
Definition InlineAsm.h:76
static StringRef getMemConstraintName(ConstraintCode C)
Definition InlineAsm.h:499
constexpr bool isValid() const
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:76
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
A set of physical registers with utility functions to track liveness when walking backward/forward th...
LLVM_ABI bool available(const MachineRegisterInfo &MRI, MCRegister Reg) const
Returns true if register Reg and no aliasing register is in the set.
A set of register units used to track register liveness.
bool hasValue() const
static LocationSize precise(uint64_t Value)
static constexpr LocationSize beforeOrAfterPointer()
Any location before or after the base pointer (but still within the underlying object).
bool isScalable() const
TypeSize getValue() const
Describe properties that are true of each instruction in the target description file.
ArrayRef< MCOperandInfo > operands() const
MCRegAliasIterator enumerates all registers aliasing Reg.
Wrapper class representing physical registers. Should be passed by value.
Definition MCRegister.h:41
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
Metadata node.
Definition Metadata.h:1087
const MDOperand & getOperand(unsigned I) const
Definition Metadata.h:1443
unsigned getNumOperands() const
Return number of MDNode operands.
Definition Metadata.h:1449
bool isValid() const
isValid - Returns true until all the operands have been visited.
LLVM_ABI MachineInstr * remove_instr(MachineInstr *I)
Remove the possibly bundled instruction from the instruction list without deleting it.
LLVM_ABI instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
instr_iterator erase_instr(MachineInstr *I)
Remove an instruction from the instruction list and delete it.
MachineInstr * remove(MachineInstr *I)
Remove the unbundled instruction from the instruction list without deleting it.
Instructions::iterator instr_iterator
Instructions::const_iterator const_instr_iterator
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
LLVM_ABI instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.
CalledGlobalInfo tryGetCalledGlobal(const MachineInstr *MI) const
Tries to get the global and target flags for a call site, if the instruction is a call to a global.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr, MDNode *PCSections=nullptr, uint32_t CFIType=0, MDNode *MMRAs=nullptr, Value *DS=nullptr)
Allocate and construct an extra info structure for a MachineInstr.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
MachineOperand * allocateOperandArray(OperandCapacity Cap)
Allocate an array of MachineOperands.
void handleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineInstrBuilder & addReg(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addMetadata(const MDNode *MD) const
const MachineInstrBuilder & addFrameIndex(int Idx) const
Representation of each machine instruction.
bool mayRaiseFPException() const
Return true if this instruction could possibly raise a floating-point exception.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
LLVM_ABI void setRegisterDefReadUndef(Register Reg, bool IsUndef=true)
Mark all subregister defs of register Reg with the undef flag.
bool isDebugValueList() const
LLVM_ABI void bundleWithPred()
Bundle this instruction with its predecessor.
bool isPosition() const
bool isTerminator(QueryType Type=AnyInBundle) const
Returns true if this instruction part of the terminator for a basic block.
LLVM_ABI std::tuple< Register, LLT, Register, LLT, Register, LLT, Register, LLT, Register, LLT > getFirst5RegLLTs() const
LLVM_ABI iterator_range< filter_iterator< const MachineOperand *, std::function< bool(const MachineOperand &Op)> > > getDebugOperandsForReg(Register Reg) const
Returns a range of all of the operands that correspond to a debug use of Reg.
mop_range debug_operands()
Returns all operands that are used to determine the variable location for this DBG_VALUE instruction.
bool mayLoadOrStore(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read or modify memory.
LLVM_ABI void setCFIType(MachineFunction &MF, uint32_t Type)
Set the CFI type for the instruction.
LLVM_ABI MachineInstr * removeFromParent()
Unlink 'this' from the containing basic block, and return it without deleting it.
const MachineBasicBlock * getParent() const
MDNode * getMMRAMetadata() const
Helper to extract mmra.op metadata.
LLVM_ABI void bundleWithSucc()
Bundle this instruction with its successor.
uint32_t getCFIType() const
Helper to extract a CFI type hash if one has been added.
bool isDebugLabel() const
LLVM_ABI void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just prior to the instruction itself.
bool hasProperty(unsigned MCFlag, QueryType Type=AnyInBundle) const
Return true if the instruction (or in the case of a bundle, the instructions inside the bundle) has t...
LLVM_ABI bool isDereferenceableInvariantLoad() const
Return true if this load instruction never traps and points to a memory location whose value doesn't ...
void setFlags(unsigned flags)
QueryType
API for querying MachineInstr properties.
LLVM_ABI void addImplicitDefUseOperands(MachineFunction &MF)
Add all implicit def and use operands to this instruction.
filtered_mop_range all_defs()
Returns an iterator range over all operands that are (explicit or implicit) register defs.
LLVM_ABI std::tuple< LLT, LLT, LLT, LLT, LLT > getFirst5LLTs() const
bool isCall(QueryType Type=AnyInBundle) const
LLVM_ABI std::tuple< Register, LLT, Register, LLT, Register, LLT > getFirst3RegLLTs() const
bool getFlag(MIFlag Flag) const
Return whether an MI flag is set.
LLVM_ABI uint32_t mergeFlagsWith(const MachineInstr &Other) const
Return the MIFlags which represent both MachineInstrs.
LLVM_ABI const MachineOperand & getDebugExpressionOp() const
Return the operand for the complex address expression referenced by this DBG_VALUE instruction.
LLVM_ABI std::pair< bool, bool > readsWritesVirtualRegister(Register Reg, SmallVectorImpl< unsigned > *Ops=nullptr) const
Return a pair of bools (reads, writes) indicating if this instruction reads or writes Reg.
LLVM_ABI Register isConstantValuePHI() const
If the specified instruction is a PHI that always merges together the same virtual register,...
bool isRegTiedToDefOperand(unsigned UseOpIdx, unsigned *DefOpIdx=nullptr) const
Return true if the use operand of the specified index is tied to a def operand.
LLVM_ABI bool allImplicitDefsAreDead() const
Return true if all the implicit defs of this instruction are dead.
LLVM_ABI void cloneMemRefs(MachineFunction &MF, const MachineInstr &MI)
Clone another MachineInstr's memory reference descriptor list and replace ours with it.
LLVM_ABI const TargetRegisterClass * getRegClassConstraintEffectForVReg(Register Reg, const TargetRegisterClass *CurRC, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI, bool ExploreBundle=false) const
Applies the constraints (def/use) implied by this MI on Reg to the given CurRC.
LLVM_ABI bool isSafeToMove(bool &SawStore) const
Return true if it is safe to move this instruction.
LLVM_ABI bool mayAlias(BatchAAResults *AA, const MachineInstr &Other, bool UseTBAA) const
Returns true if this instruction's memory access aliases the memory access of Other.
bool isBundle() const
bool isDebugInstr() const
unsigned getNumDebugOperands() const
Returns the total number of operands which are debug locations.
unsigned getNumOperands() const
Retuns the total number of operands.
LLVM_ABI void addOperand(MachineFunction &MF, const MachineOperand &Op)
Add the specified operand to the instruction.
LLVM_ABI MachineInstr * removeFromBundle()
Unlink this instruction from its basic block and return it without deleting it.
LLVM_ABI void dumpr(const MachineRegisterInfo &MRI, unsigned MaxDepth=UINT_MAX) const
Print on dbgs() the current instruction and the instructions defining its operands and so on until we...
LLVM_ABI void copyIRFlags(const Instruction &I)
Copy all flags to MachineInst MIFlags.
bool isDebugValueLike() const
bool isInlineAsm() const
bool memoperands_empty() const
Return true if we don't have any memory operands which described the memory access done by this instr...
mmo_iterator memoperands_end() const
Access to memory operands of the instruction.
bool isDebugRef() const
LLVM_ABI void collectDebugValues(SmallVectorImpl< MachineInstr * > &DbgValues)
Scan instructions immediately following MI and collect any matching DBG_VALUEs.
LLVM_ABI std::optional< LocationSize > getRestoreSize(const TargetInstrInfo *TII) const
Return a valid size if the instruction is a restore instruction.
unsigned getOperandNo(const_mop_iterator I) const
Returns the number of the operand iterator I points to.
LLVM_ABI unsigned getNumExplicitOperands() const
Returns the number of non-implicit operands.
mop_range implicit_operands()
LLVM_ABI void setMemRefs(MachineFunction &MF, ArrayRef< MachineMemOperand * > MemRefs)
Assign this MachineInstr's memory reference descriptor list.
LLVM_ABI bool wouldBeTriviallyDead() const
Return true if this instruction would be trivially dead if all of its defined registers were dead.
bool isBundledWithPred() const
Return true if this instruction is part of a bundle, and it is not the first instruction in the bundl...
LLVM_ABI std::tuple< LLT, LLT > getFirst2LLTs() const
LLVM_ABI std::optional< LocationSize > getFoldedSpillSize(const TargetInstrInfo *TII) const
Return a valid size if the instruction is a folded spill instruction.
LLVM_ABI void unbundleFromPred()
Break bundle above this instruction.
LLVM_ABI void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI)
Copy implicit register operands from specified instruction to this instruction.
bool mayLoad(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read memory.
LLVM_ABI bool isStackAligningInlineAsm() const
LLVM_ABI void dropMemRefs(MachineFunction &MF)
Clear this MachineInstr's memory reference descriptor list.
mop_iterator operands_end()
LLVM_ABI int findRegisterUseOperandIdx(Register Reg, const TargetRegisterInfo *TRI, bool isKill=false) const
Returns the operand index that is a use of the specific register or -1 if it is not found.
MDNode * getPCSections() const
Helper to extract PCSections metadata target sections.
bool isCFIInstruction() const
LLVM_ABI int findFirstPredOperandIdx() const
Find the index of the first operand in the operand list that is used to represent the predicate.
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
LLVM_ABI unsigned getBundleSize() const
Return the number of instructions inside the MI bundle, excluding the bundle header.
LLVM_ABI void cloneMergedMemRefs(MachineFunction &MF, ArrayRef< const MachineInstr * > MIs)
Clone the merge of multiple MachineInstrs' memory reference descriptors list and replace ours with it...
mop_range operands()
LLVM_ABI bool isCandidateForAdditionalCallInfo(QueryType Type=IgnoreBundle) const
Return true if this is a call instruction that may have an additional information associated with it.
LLVM_ABI std::tuple< Register, LLT, Register, LLT, Register, LLT, Register, LLT > getFirst4RegLLTs() const
LLVM_ABI std::tuple< Register, LLT, Register, LLT > getFirst2RegLLTs() const
unsigned getNumMemOperands() const
Return the number of memory operands.
void clearFlag(MIFlag Flag)
clearFlag - Clear a MI flag.
LLVM_ABI std::optional< LocationSize > getFoldedRestoreSize(const TargetInstrInfo *TII) const
Return a valid size if the instruction is a folded restore instruction.
LLVM_ABI const TargetRegisterClass * getRegClassConstraintEffect(unsigned OpIdx, const TargetRegisterClass *CurRC, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const
Applies the constraints (def/use) implied by the OpIdx operand to the given CurRC.
bool isOperandSubregIdx(unsigned OpIdx) const
Return true if operand OpIdx is a subregister index.
LLVM_ABI InlineAsm::AsmDialect getInlineAsmDialect() const
LLVM_ABI bool hasUnmodeledSideEffects() const
Return true if this instruction has side effects that are not modeled by mayLoad / mayStore,...
LLVM_ABI bool isEquivalentDbgInstr(const MachineInstr &Other) const
Returns true if this instruction is a debug instruction that represents an identical debug value to O...
LLVM_ABI const DILabel * getDebugLabel() const
Return the debug label referenced by this DBG_LABEL instruction.
void untieRegOperand(unsigned OpIdx)
Break any tie involving OpIdx.
static LLVM_ABI uint32_t copyFlagsFromInstruction(const Instruction &I)
LLVM_ABI unsigned removePHIIncomingValueFor(const MachineBasicBlock &MBB)
Remove all incoming values of Phi instruction for the given block.
LLVM_ABI void insert(mop_iterator InsertBefore, ArrayRef< MachineOperand > Ops)
Inserts Ops BEFORE It. Can untie/retie tied operands.
LLVM_ABI void setDesc(const MCInstrDesc &TID)
Replace the instruction descriptor (thus opcode) of the current instruction with a new one.
bool isJumpTableDebugInfo() const
LLVM_ABI unsigned getNumExplicitDefs() const
Returns the number of non-implicit definitions.
LLVM_ABI void eraseFromBundle()
Unlink 'this' from its basic block and delete it.
LLVM_ABI void setHeapAllocMarker(MachineFunction &MF, MDNode *MD)
Set a marker on instructions that denotes where we should create and emit heap alloc site labels.
LLVM_ABI const DILocalVariable * getDebugVariable() const
Return the debug variable referenced by this DBG_VALUE instruction.
LLVM_ABI bool hasComplexRegisterTies() const
Return true when an instruction has tied register that can't be determined by the instruction's descr...
LLVM_ABI LLT getTypeToPrint(unsigned OpIdx, SmallBitVector &PrintedTypes, const MachineRegisterInfo &MRI) const
Debugging supportDetermine the generic type to be printed (if needed) on uses and defs.
bool isLifetimeMarker() const
LLVM_ABI void substituteRegister(Register FromReg, Register ToReg, unsigned SubIdx, const TargetRegisterInfo &RegInfo)
Replace all occurrences of FromReg with ToReg:SubIdx, properly composing subreg indices where necessa...
LLVM_ABI unsigned findTiedOperandIdx(unsigned OpIdx) const
Given the index of a tied register operand, find the operand it is tied to.
LLVM_ABI void tieOperands(unsigned DefIdx, unsigned UseIdx)
Add a tie between the register operands at DefIdx and UseIdx.
mmo_iterator memoperands_begin() const
Access to memory operands of the instruction.
LLVM_ABI void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI)
Clone another MachineInstr's pre- and post- instruction symbols and replace ours with it.
LLVM_ABI void changeDebugValuesDefReg(Register Reg)
Find all DBG_VALUEs that point to the register def in this instruction and point them to Reg instead.
LLVM_ABI bool isIdenticalTo(const MachineInstr &Other, MICheckType Check=CheckDefs) const
Return true if this instruction is identical to Other.
LLVM_ABI bool hasOrderedMemoryRef() const
Return true if this instruction may have an ordered or volatile memory reference, or if the informati...
LLVM_ABI void emitGenericError(const Twine &ErrMsg) const
LLVM_ABI const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
LLVM_ABI const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
ArrayRef< MachineMemOperand * > memoperands() const
Access to memory operands of the instruction.
LLVM_ABI void print(raw_ostream &OS, bool IsStandalone=true, bool SkipOpers=false, bool SkipDebugLoc=false, bool AddNewLine=true, const TargetInstrInfo *TII=nullptr) const
Print this MI to OS.
bool isNonListDebugValue() const
MachineOperand * mop_iterator
iterator/begin/end - Iterate over all operands of a machine instruction.
LLVM_ABI bool isLoadFoldBarrier() const
Returns true if it is illegal to fold a load across this instruction.
bool mayStore(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly modify memory.
void setFlag(MIFlag Flag)
Set a MI flag.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
LLVM_ABI bool isDead(const MachineRegisterInfo &MRI, LiveRegUnits *LivePhysRegs=nullptr) const
Check whether an MI is dead.
LLVM_ABI std::tuple< LLT, LLT, LLT > getFirst3LLTs() const
LLVM_ABI const MachineOperand & getDebugVariableOp() const
Return the operand for the debug variable referenced by this DBG_VALUE instruction.
LLVM_ABI void setPhysRegsDeadExcept(ArrayRef< Register > UsedRegs, const TargetRegisterInfo &TRI)
Mark every physreg used by this instruction as dead except those in the UsedRegs list.
LLVM_ABI void removeOperand(unsigned OpNo)
Erase an operand from an instruction, leaving it with one fewer operand than it started with.
friend class MachineFunction
filtered_mop_range all_uses()
Returns an iterator range over all operands that are (explicit or implicit) register uses.
MCSymbol * getPreInstrSymbol() const
Helper to extract a pre-instruction symbol if one has been added.
LLVM_ABI bool addRegisterKilled(Register IncomingReg, const TargetRegisterInfo *RegInfo, bool AddIfNotFound=false)
We have determined MI kills a register.
LLVM_ABI void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just after the instruction itself.
bool isDebugValue() const
LLVM_ABI void dump() const
const MachineOperand & getDebugOffset() const
Return the operand containing the offset to be used if this DBG_VALUE instruction is indirect; will b...
MachineOperand & getDebugOperand(unsigned Index)
LLVM_ABI std::optional< LocationSize > getSpillSize(const TargetInstrInfo *TII) const
Return a valid size if the instruction is a spill instruction.
bool isBundledWithSucc() const
Return true if this instruction is part of a bundle, and it is not the last instruction in the bundle...
LLVM_ABI void addRegisterDefined(Register Reg, const TargetRegisterInfo *RegInfo=nullptr)
We have determined MI defines a register.
MDNode * getHeapAllocMarker() const
Helper to extract a heap alloc marker if one has been added.
LLVM_ABI unsigned getDebugInstrNum()
Fetch the instruction number of this MachineInstr.
LLVM_ABI std::tuple< LLT, LLT, LLT, LLT > getFirst4LLTs() const
LLVM_ABI void clearRegisterDeads(Register Reg)
Clear all dead flags on operands defining register Reg.
LLVM_ABI void clearRegisterKills(Register Reg, const TargetRegisterInfo *RegInfo)
Clear all kill flags affecting Reg.
const MachineOperand & getOperand(unsigned i) const
LLVM_ABI void emitInlineAsmError(const Twine &ErrMsg) const
Emit an error referring to the source location of this instruction.
uint32_t getFlags() const
Return the MI flags bitvector.
bool isPseudoProbe() const
LLVM_ABI bool hasRegisterImplicitUseOperand(Register Reg) const
Returns true if the MachineInstr has an implicit-use operand of exactly the given register (not consi...
LLVM_ABI bool shouldUpdateAdditionalCallInfo() const
Return true if copying, moving, or erasing this instruction requires updating additional call info (s...
LLVM_ABI void setDeactivationSymbol(MachineFunction &MF, Value *DS)
Value * getDeactivationSymbol() const
MCSymbol * getPostInstrSymbol() const
Helper to extract a post-instruction symbol if one has been added.
LLVM_ABI void unbundleFromSucc()
Break bundle below this instruction.
LLVM_ABI void clearKillInfo()
Clears kill flags on all operands.
LLVM_ABI bool isDebugEntryValue() const
A DBG_VALUE is an entry value iff its debug expression contains the DW_OP_LLVM_entry_value operation.
bool isIndirectDebugValue() const
A DBG_VALUE is indirect iff the location operand is a register and the offset operand is an immediate...
unsigned getNumDefs() const
Returns the total number of definitions.
LLVM_ABI bool hasTiedAndOtherReadOf(Register Reg, unsigned SubReg) const
Return true if two operands read (Reg, SubReg) and one is tied to a def of another register.
LLVM_ABI void setPCSections(MachineFunction &MF, MDNode *MD)
bool isKill() const
LLVM_ABI const MDNode * getLocCookieMD() const
For inline asm, get the !srcloc metadata node if we have it, and decode the loc cookie from it.
LLVM_ABI int findRegisterDefOperandIdx(Register Reg, const TargetRegisterInfo *TRI, bool isDead=false, bool Overlap=false) const
Returns the operand index that is a def of the specified register or -1 if it is not found.
LLVM_ABI MachineInstrBundleIterator< MachineInstr > eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
bool isFakeUse() const
bool isVariadic(QueryType Type=IgnoreBundle) const
Return true if this instruction can have a variable number of operands.
LLVM_ABI int findInlineAsmFlagIdx(unsigned OpIdx, unsigned *GroupNo=nullptr) const
Find the index of the flag word operand that corresponds to operand OpIdx on an inline asm instructio...
LLVM_ABI bool allDefsAreDead() const
Return true if all the defs of this instruction are dead.
LLVM_ABI void setMMRAMetadata(MachineFunction &MF, MDNode *MMRAs)
LLVM_ABI const TargetRegisterClass * getRegClassConstraint(unsigned OpIdx, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const
Compute the static register class constraint for operand OpIdx.
LLVM_ABI void moveBefore(MachineInstr *MovePos)
Move the instruction before MovePos.
MachineOperand * findRegisterDefOperand(Register Reg, const TargetRegisterInfo *TRI, bool isDead=false, bool Overlap=false)
Wrapper for findRegisterDefOperandIdx, it returns a pointer to the MachineOperand rather than an inde...
LLVM_ABI void addMemOperand(MachineFunction &MF, MachineMemOperand *MO)
Add a MachineMemOperand to the machine instruction.
LLVM_ABI bool addRegisterDead(Register Reg, const TargetRegisterInfo *RegInfo, bool AddIfNotFound=false)
We have determined MI defined a register without a use.
LLVM_ABI bool mayFoldInlineAsmRegOp(unsigned OpId) const
Returns true if the register operand can be folded with a load or store into a frame index.
A description of a memory reference used in the backend.
LocationSize getSize() const
Return the size in bytes of the memory reference.
const PseudoSourceValue * getPseudoValue() const
bool isUnordered() const
Returns true if this memory operation doesn't have any ordering constraints other than normal aliasin...
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
const Value * getValue() const
Return the base address of the memory access.
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
MachineOperand class - Representation of each machine instruction operand.
unsigned getSubReg() const
LLVM_ABI void substVirtReg(Register Reg, unsigned SubIdx, const TargetRegisterInfo &)
substVirtReg - Substitute the current register with the virtual subregister Reg:SubReg.
static LLVM_ABI void printSubRegIdx(raw_ostream &OS, uint64_t Index, const TargetRegisterInfo *TRI)
Print a subreg index operand.
int64_t getImm() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isRegMask() const
isRegMask - Tests if this is a MO_RegisterMask operand.
const MDNode * getMetadata() const
void setIsDead(bool Val=true)
void setMetadata(const MDNode *MD)
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
LLVM_ABI void ChangeToImmediate(int64_t ImmVal, unsigned TargetFlags=0)
ChangeToImmediate - Replace this operand with a new immediate operand of the specified value.
bool isMetadata() const
isMetadata - Tests if this is a MO_Metadata operand.
LLVM_ABI void print(raw_ostream &os, const TargetRegisterInfo *TRI=nullptr) const
Print the MachineOperand to os.
void setIsKill(bool Val=true)
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
LLVM_ABI void substPhysReg(MCRegister Reg, const TargetRegisterInfo &)
substPhysReg - Substitute the current register with the physical register Reg, taking any existing Su...
void setIsEarlyClobber(bool Val=true)
void setIsUndef(bool Val=true)
void setIsDebug(bool Val=true)
Register getReg() const
getReg - Returns the register number.
LLVM_ABI bool isIdenticalTo(const MachineOperand &Other) const
Returns true if this operand is identical to the specified operand except for liveness related flags ...
static bool clobbersPhysReg(const uint32_t *RegMask, MCRegister PhysReg)
clobbersPhysReg - Returns true if this RegMask clobbers PhysReg.
static LLVM_ABI void printSymbol(raw_ostream &OS, MCSymbol &Sym)
Print a MCSymbol as an operand.
static MachineOperand CreateReg(Register 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)
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
LLVM_ABI void removeRegOperandFromUseList(MachineOperand *MO)
Remove MO from its use-def list.
LLVM_ABI void addRegOperandToUseList(MachineOperand *MO)
Add MO to the linked list of operands for its register.
Representation for a specific memory location.
LLVM_ABI void printAsOperand(raw_ostream &OS, const Module *M=nullptr) const
Print as operand.
Manage lifetime of a slot tracker for printing IR.
void incorporateFunction(const Function &F)
Incorporate the given function.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
Definition Operator.h:78
An or instruction, which can be marked as "disjoint", indicating that the inputs don't have a 1 in th...
Definition InstrTypes.h:439
A udiv, sdiv, lshr, or ashr instruction, which can be marked as "exact", indicating that no bits are ...
Definition Operator.h:156
Instruction that can have a nneg flag (zext/uitofp).
Definition InstrTypes.h:703
Special value supplied for machine level alias analysis.
virtual bool mayAlias(const MachineFrameInfo *) const
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
Wrapper class representing virtual and physical registers.
Definition Register.h:20
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
Definition Register.h:79
constexpr bool isPhysical() const
Return true if the specified register number is in the physical register namespace.
Definition Register.h:83
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
SmallBitVector & set()
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
static LLVM_ABI unsigned getNextMetaArgIdx(const MachineInstr *MI, unsigned CurIdx)
Get index of next meta operand.
MI-level Statepoint operands.
Definition StackMaps.h:159
LLVM_ABI int getFirstGCPtrIdx()
Get index of first GC pointer operand of -1 if there are none.
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetInstrInfo * getInstrInfo() const
This class represents a truncation of integer types.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
A Use represents the edge between a Value definition and its users.
Definition Use.h:35
LLVM Value Representation.
Definition Value.h:75
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
Definition Value.cpp:314
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
Definition TypeSize.h:166
formatted_raw_ostream & PadToColumn(unsigned NewCol)
PadToColumn - Align the output to some column number.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract Attribute helper functions.
Definition Attributor.h:166
@ UnmodeledSideEffects
std::enable_if_t< detail::IsValidPointer< X, Y >::value, bool > hasa(Y &&MD)
Check whether Metadata has a Value.
Definition Metadata.h:663
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
Definition Metadata.h:680
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition STLExtras.h:316
hash_code hash_value(const FixedPointSemantics &Val)
LLVM_ABI formatted_raw_ostream & fdbgs()
fdbgs() - This returns a reference to a formatted_raw_ostream for debug output.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
LLVM_ABI void updateDbgValueForSpill(MachineInstr &Orig, int FrameIndex, Register Reg)
Update a DBG_VALUE whose value has been spilled to FrameIndex.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1762
iterator_range< pointee_iterator< WrappedIteratorT > > make_pointee_range(RangeT &&Range)
Definition iterator.h:341
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:209
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1769
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
Definition MathExtras.h:190
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
Definition STLExtras.h:552
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
@ Other
Any other memory.
Definition ModRef.h:68
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition MCRegister.h:21
DWARFExpression::Operation Op
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1933
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
LLVM_ABI MachineInstr * buildDbgValueForSpill(MachineBasicBlock &BB, MachineBasicBlock::iterator I, const MachineInstr &Orig, int FrameIndex, Register SpillReg)
Clone a DBG_VALUE whose value has been spilled to FrameIndex.
iterator_range< pointer_iterator< WrappedIteratorT > > make_pointer_range(RangeT &&Range)
Definition iterator.h:368
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Definition STLExtras.h:1963
filter_iterator_impl< WrappedIteratorT, PredicateT, detail::fwd_or_bidi_tag< WrappedIteratorT > > filter_iterator
Defines filter_iterator to a suitable specialization of filter_iterator_impl, based on the underlying...
Definition STLExtras.h:539
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition Hashing.h:287
MCRegisterClass TargetRegisterClass
Definition FastISel.h:58
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:879
#define N
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition Metadata.h:775
static LLVM_ABI unsigned getHashValue(const MachineInstr *const &MI)