xref: /llvm-project/llvm/lib/CodeGen/MachineOperand.cpp (revision f487edae49368e1fb620a3597c61deef4275aa86) 
1 //===- lib/CodeGen/MachineOperand.cpp -------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 /// \file Methods common to all machine operands.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/CodeGen/MachineOperand.h"
15 #include "llvm/ADT/StringExtras.h"
16 #include "llvm/Analysis/Loads.h"
17 #include "llvm/CodeGen/MIRPrinter.h"
18 #include "llvm/CodeGen/MachineFrameInfo.h"
19 #include "llvm/CodeGen/MachineJumpTableInfo.h"
20 #include "llvm/CodeGen/MachineRegisterInfo.h"
21 #include "llvm/CodeGen/TargetInstrInfo.h"
22 #include "llvm/CodeGen/TargetRegisterInfo.h"
23 #include "llvm/Config/llvm-config.h"
24 #include "llvm/IR/Constants.h"
25 #include "llvm/IR/IRPrintingPasses.h"
26 #include "llvm/IR/ModuleSlotTracker.h"
27 #include "llvm/Target/TargetIntrinsicInfo.h"
28 #include "llvm/Target/TargetMachine.h"
29 
30 using namespace llvm;
31 
32 static cl::opt<int>
33     PrintRegMaskNumRegs("print-regmask-num-regs",
34                         cl::desc("Number of registers to limit to when "
35                                  "printing regmask operands in IR dumps. "
36                                  "unlimited = -1"),
37                         cl::init(32), cl::Hidden);
38 
39 static const MachineFunction *getMFIfAvailable(const MachineOperand &MO) {
40   if (const MachineInstr *MI = MO.getParent())
41     if (const MachineBasicBlock *MBB = MI->getParent())
42       if (const MachineFunction *MF = MBB->getParent())
43         return MF;
44   return nullptr;
45 }
46 static MachineFunction *getMFIfAvailable(MachineOperand &MO) {
47   return const_cast<MachineFunction *>(
48       getMFIfAvailable(const_cast<const MachineOperand &>(MO)));
49 }
50 
51 void MachineOperand::setReg(unsigned Reg) {
52   if (getReg() == Reg)
53     return; // No change.
54 
55   // Clear the IsRenamable bit to keep it conservatively correct.
56   IsRenamable = false;
57 
58   // Otherwise, we have to change the register.  If this operand is embedded
59   // into a machine function, we need to update the old and new register's
60   // use/def lists.
61   if (MachineFunction *MF = getMFIfAvailable(*this)) {
62     MachineRegisterInfo &MRI = MF->getRegInfo();
63     MRI.removeRegOperandFromUseList(this);
64     SmallContents.RegNo = Reg;
65     MRI.addRegOperandToUseList(this);
66     return;
67   }
68 
69   // Otherwise, just change the register, no problem.  :)
70   SmallContents.RegNo = Reg;
71 }
72 
73 void MachineOperand::substVirtReg(unsigned Reg, unsigned SubIdx,
74                                   const TargetRegisterInfo &TRI) {
75   assert(TargetRegisterInfo::isVirtualRegister(Reg));
76   if (SubIdx && getSubReg())
77     SubIdx = TRI.composeSubRegIndices(SubIdx, getSubReg());
78   setReg(Reg);
79   if (SubIdx)
80     setSubReg(SubIdx);
81 }
82 
83 void MachineOperand::substPhysReg(unsigned Reg, const TargetRegisterInfo &TRI) {
84   assert(TargetRegisterInfo::isPhysicalRegister(Reg));
85   if (getSubReg()) {
86     Reg = TRI.getSubReg(Reg, getSubReg());
87     // Note that getSubReg() may return 0 if the sub-register doesn't exist.
88     // That won't happen in legal code.
89     setSubReg(0);
90     if (isDef())
91       setIsUndef(false);
92   }
93   setReg(Reg);
94 }
95 
96 /// Change a def to a use, or a use to a def.
97 void MachineOperand::setIsDef(bool Val) {
98   assert(isReg() && "Wrong MachineOperand accessor");
99   assert((!Val || !isDebug()) && "Marking a debug operation as def");
100   if (IsDef == Val)
101     return;
102   assert(!IsDeadOrKill && "Changing def/use with dead/kill set not supported");
103   // MRI may keep uses and defs in different list positions.
104   if (MachineFunction *MF = getMFIfAvailable(*this)) {
105     MachineRegisterInfo &MRI = MF->getRegInfo();
106     MRI.removeRegOperandFromUseList(this);
107     IsDef = Val;
108     MRI.addRegOperandToUseList(this);
109     return;
110   }
111   IsDef = Val;
112 }
113 
114 bool MachineOperand::isRenamable() const {
115   assert(isReg() && "Wrong MachineOperand accessor");
116   assert(TargetRegisterInfo::isPhysicalRegister(getReg()) &&
117          "isRenamable should only be checked on physical registers");
118   if (!IsRenamable)
119     return false;
120 
121   const MachineInstr *MI = getParent();
122   if (!MI)
123     return true;
124 
125   if (isDef())
126     return !MI->hasExtraDefRegAllocReq(MachineInstr::IgnoreBundle);
127 
128   assert(isUse() && "Reg is not def or use");
129   return !MI->hasExtraSrcRegAllocReq(MachineInstr::IgnoreBundle);
130 }
131 
132 void MachineOperand::setIsRenamable(bool Val) {
133   assert(isReg() && "Wrong MachineOperand accessor");
134   assert(TargetRegisterInfo::isPhysicalRegister(getReg()) &&
135          "setIsRenamable should only be called on physical registers");
136   IsRenamable = Val;
137 }
138 
139 // If this operand is currently a register operand, and if this is in a
140 // function, deregister the operand from the register's use/def list.
141 void MachineOperand::removeRegFromUses() {
142   if (!isReg() || !isOnRegUseList())
143     return;
144 
145   if (MachineFunction *MF = getMFIfAvailable(*this))
146     MF->getRegInfo().removeRegOperandFromUseList(this);
147 }
148 
149 /// ChangeToImmediate - Replace this operand with a new immediate operand of
150 /// the specified value.  If an operand is known to be an immediate already,
151 /// the setImm method should be used.
152 void MachineOperand::ChangeToImmediate(int64_t ImmVal) {
153   assert((!isReg() || !isTied()) && "Cannot change a tied operand into an imm");
154 
155   removeRegFromUses();
156 
157   OpKind = MO_Immediate;
158   Contents.ImmVal = ImmVal;
159 }
160 
161 void MachineOperand::ChangeToFPImmediate(const ConstantFP *FPImm) {
162   assert((!isReg() || !isTied()) && "Cannot change a tied operand into an imm");
163 
164   removeRegFromUses();
165 
166   OpKind = MO_FPImmediate;
167   Contents.CFP = FPImm;
168 }
169 
170 void MachineOperand::ChangeToES(const char *SymName,
171                                 unsigned char TargetFlags) {
172   assert((!isReg() || !isTied()) &&
173          "Cannot change a tied operand into an external symbol");
174 
175   removeRegFromUses();
176 
177   OpKind = MO_ExternalSymbol;
178   Contents.OffsetedInfo.Val.SymbolName = SymName;
179   setOffset(0); // Offset is always 0.
180   setTargetFlags(TargetFlags);
181 }
182 
183 void MachineOperand::ChangeToMCSymbol(MCSymbol *Sym) {
184   assert((!isReg() || !isTied()) &&
185          "Cannot change a tied operand into an MCSymbol");
186 
187   removeRegFromUses();
188 
189   OpKind = MO_MCSymbol;
190   Contents.Sym = Sym;
191 }
192 
193 void MachineOperand::ChangeToFrameIndex(int Idx) {
194   assert((!isReg() || !isTied()) &&
195          "Cannot change a tied operand into a FrameIndex");
196 
197   removeRegFromUses();
198 
199   OpKind = MO_FrameIndex;
200   setIndex(Idx);
201 }
202 
203 void MachineOperand::ChangeToTargetIndex(unsigned Idx, int64_t Offset,
204                                          unsigned char TargetFlags) {
205   assert((!isReg() || !isTied()) &&
206          "Cannot change a tied operand into a FrameIndex");
207 
208   removeRegFromUses();
209 
210   OpKind = MO_TargetIndex;
211   setIndex(Idx);
212   setOffset(Offset);
213   setTargetFlags(TargetFlags);
214 }
215 
216 /// ChangeToRegister - Replace this operand with a new register operand of
217 /// the specified value.  If an operand is known to be an register already,
218 /// the setReg method should be used.
219 void MachineOperand::ChangeToRegister(unsigned Reg, bool isDef, bool isImp,
220                                       bool isKill, bool isDead, bool isUndef,
221                                       bool isDebug) {
222   MachineRegisterInfo *RegInfo = nullptr;
223   if (MachineFunction *MF = getMFIfAvailable(*this))
224     RegInfo = &MF->getRegInfo();
225   // If this operand is already a register operand, remove it from the
226   // register's use/def lists.
227   bool WasReg = isReg();
228   if (RegInfo && WasReg)
229     RegInfo->removeRegOperandFromUseList(this);
230 
231   // Change this to a register and set the reg#.
232   assert(!(isDead && !isDef) && "Dead flag on non-def");
233   assert(!(isKill && isDef) && "Kill flag on def");
234   OpKind = MO_Register;
235   SmallContents.RegNo = Reg;
236   SubReg_TargetFlags = 0;
237   IsDef = isDef;
238   IsImp = isImp;
239   IsDeadOrKill = isKill | isDead;
240   IsRenamable = false;
241   IsUndef = isUndef;
242   IsInternalRead = false;
243   IsEarlyClobber = false;
244   IsDebug = isDebug;
245   // Ensure isOnRegUseList() returns false.
246   Contents.Reg.Prev = nullptr;
247   // Preserve the tie when the operand was already a register.
248   if (!WasReg)
249     TiedTo = 0;
250 
251   // If this operand is embedded in a function, add the operand to the
252   // register's use/def list.
253   if (RegInfo)
254     RegInfo->addRegOperandToUseList(this);
255 }
256 
257 /// isIdenticalTo - Return true if this operand is identical to the specified
258 /// operand. Note that this should stay in sync with the hash_value overload
259 /// below.
260 bool MachineOperand::isIdenticalTo(const MachineOperand &Other) const {
261   if (getType() != Other.getType() ||
262       getTargetFlags() != Other.getTargetFlags())
263     return false;
264 
265   switch (getType()) {
266   case MachineOperand::MO_Register:
267     return getReg() == Other.getReg() && isDef() == Other.isDef() &&
268            getSubReg() == Other.getSubReg();
269   case MachineOperand::MO_Immediate:
270     return getImm() == Other.getImm();
271   case MachineOperand::MO_CImmediate:
272     return getCImm() == Other.getCImm();
273   case MachineOperand::MO_FPImmediate:
274     return getFPImm() == Other.getFPImm();
275   case MachineOperand::MO_MachineBasicBlock:
276     return getMBB() == Other.getMBB();
277   case MachineOperand::MO_FrameIndex:
278     return getIndex() == Other.getIndex();
279   case MachineOperand::MO_ConstantPoolIndex:
280   case MachineOperand::MO_TargetIndex:
281     return getIndex() == Other.getIndex() && getOffset() == Other.getOffset();
282   case MachineOperand::MO_JumpTableIndex:
283     return getIndex() == Other.getIndex();
284   case MachineOperand::MO_GlobalAddress:
285     return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset();
286   case MachineOperand::MO_ExternalSymbol:
287     return strcmp(getSymbolName(), Other.getSymbolName()) == 0 &&
288            getOffset() == Other.getOffset();
289   case MachineOperand::MO_BlockAddress:
290     return getBlockAddress() == Other.getBlockAddress() &&
291            getOffset() == Other.getOffset();
292   case MachineOperand::MO_RegisterMask:
293   case MachineOperand::MO_RegisterLiveOut: {
294     // Shallow compare of the two RegMasks
295     const uint32_t *RegMask = getRegMask();
296     const uint32_t *OtherRegMask = Other.getRegMask();
297     if (RegMask == OtherRegMask)
298       return true;
299 
300     if (const MachineFunction *MF = getMFIfAvailable(*this)) {
301       // Calculate the size of the RegMask
302       const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
303       unsigned RegMaskSize = (TRI->getNumRegs() + 31) / 32;
304 
305       // Deep compare of the two RegMasks
306       return std::equal(RegMask, RegMask + RegMaskSize, OtherRegMask);
307     }
308     // We don't know the size of the RegMask, so we can't deep compare the two
309     // reg masks.
310     return false;
311   }
312   case MachineOperand::MO_MCSymbol:
313     return getMCSymbol() == Other.getMCSymbol();
314   case MachineOperand::MO_CFIIndex:
315     return getCFIIndex() == Other.getCFIIndex();
316   case MachineOperand::MO_Metadata:
317     return getMetadata() == Other.getMetadata();
318   case MachineOperand::MO_IntrinsicID:
319     return getIntrinsicID() == Other.getIntrinsicID();
320   case MachineOperand::MO_Predicate:
321     return getPredicate() == Other.getPredicate();
322   }
323   llvm_unreachable("Invalid machine operand type");
324 }
325 
326 // Note: this must stay exactly in sync with isIdenticalTo above.
327 hash_code llvm::hash_value(const MachineOperand &MO) {
328   switch (MO.getType()) {
329   case MachineOperand::MO_Register:
330     // Register operands don't have target flags.
331     return hash_combine(MO.getType(), MO.getReg(), MO.getSubReg(), MO.isDef());
332   case MachineOperand::MO_Immediate:
333     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getImm());
334   case MachineOperand::MO_CImmediate:
335     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getCImm());
336   case MachineOperand::MO_FPImmediate:
337     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getFPImm());
338   case MachineOperand::MO_MachineBasicBlock:
339     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getMBB());
340   case MachineOperand::MO_FrameIndex:
341     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getIndex());
342   case MachineOperand::MO_ConstantPoolIndex:
343   case MachineOperand::MO_TargetIndex:
344     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getIndex(),
345                         MO.getOffset());
346   case MachineOperand::MO_JumpTableIndex:
347     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getIndex());
348   case MachineOperand::MO_ExternalSymbol:
349     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getOffset(),
350                         MO.getSymbolName());
351   case MachineOperand::MO_GlobalAddress:
352     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getGlobal(),
353                         MO.getOffset());
354   case MachineOperand::MO_BlockAddress:
355     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getBlockAddress(),
356                         MO.getOffset());
357   case MachineOperand::MO_RegisterMask:
358   case MachineOperand::MO_RegisterLiveOut:
359     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getRegMask());
360   case MachineOperand::MO_Metadata:
361     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getMetadata());
362   case MachineOperand::MO_MCSymbol:
363     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getMCSymbol());
364   case MachineOperand::MO_CFIIndex:
365     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getCFIIndex());
366   case MachineOperand::MO_IntrinsicID:
367     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getIntrinsicID());
368   case MachineOperand::MO_Predicate:
369     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getPredicate());
370   }
371   llvm_unreachable("Invalid machine operand type");
372 }
373 
374 // Try to crawl up to the machine function and get TRI and IntrinsicInfo from
375 // it.
376 static void tryToGetTargetInfo(const MachineOperand &MO,
377                                const TargetRegisterInfo *&TRI,
378                                const TargetIntrinsicInfo *&IntrinsicInfo) {
379   if (const MachineFunction *MF = getMFIfAvailable(MO)) {
380     TRI = MF->getSubtarget().getRegisterInfo();
381     IntrinsicInfo = MF->getTarget().getIntrinsicInfo();
382   }
383 }
384 
385 static const char *getTargetIndexName(const MachineFunction &MF, int Index) {
386   const auto *TII = MF.getSubtarget().getInstrInfo();
387   assert(TII && "expected instruction info");
388   auto Indices = TII->getSerializableTargetIndices();
389   auto Found = find_if(Indices, [&](const std::pair<int, const char *> &I) {
390     return I.first == Index;
391   });
392   if (Found != Indices.end())
393     return Found->second;
394   return nullptr;
395 }
396 
397 static const char *getTargetFlagName(const TargetInstrInfo *TII, unsigned TF) {
398   auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
399   for (const auto &I : Flags) {
400     if (I.first == TF) {
401       return I.second;
402     }
403   }
404   return nullptr;
405 }
406 
407 static void printCFIRegister(unsigned DwarfReg, raw_ostream &OS,
408                              const TargetRegisterInfo *TRI) {
409   if (!TRI) {
410     OS << "%dwarfreg." << DwarfReg;
411     return;
412   }
413 
414   int Reg = TRI->getLLVMRegNum(DwarfReg, true);
415   if (Reg == -1) {
416     OS << "<badreg>";
417     return;
418   }
419   OS << printReg(Reg, TRI);
420 }
421 
422 static void printIRBlockReference(raw_ostream &OS, const BasicBlock &BB,
423                                   ModuleSlotTracker &MST) {
424   OS << "%ir-block.";
425   if (BB.hasName()) {
426     printLLVMNameWithoutPrefix(OS, BB.getName());
427     return;
428   }
429   Optional<int> Slot;
430   if (const Function *F = BB.getParent()) {
431     if (F == MST.getCurrentFunction()) {
432       Slot = MST.getLocalSlot(&BB);
433     } else if (const Module *M = F->getParent()) {
434       ModuleSlotTracker CustomMST(M, /*ShouldInitializeAllMetadata=*/false);
435       CustomMST.incorporateFunction(*F);
436       Slot = CustomMST.getLocalSlot(&BB);
437     }
438   }
439   if (Slot)
440     MachineOperand::printIRSlotNumber(OS, *Slot);
441   else
442     OS << "<unknown>";
443 }
444 
445 static void printIRValueReference(raw_ostream &OS, const Value &V,
446                                   ModuleSlotTracker &MST) {
447   if (isa<GlobalValue>(V)) {
448     V.printAsOperand(OS, /*PrintType=*/false, MST);
449     return;
450   }
451   if (isa<Constant>(V)) {
452     // Machine memory operands can load/store to/from constant value pointers.
453     OS << '`';
454     V.printAsOperand(OS, /*PrintType=*/true, MST);
455     OS << '`';
456     return;
457   }
458   OS << "%ir.";
459   if (V.hasName()) {
460     printLLVMNameWithoutPrefix(OS, V.getName());
461     return;
462   }
463   MachineOperand::printIRSlotNumber(OS, MST.getLocalSlot(&V));
464 }
465 
466 static void printSyncScope(raw_ostream &OS, const LLVMContext &Context,
467                            SyncScope::ID SSID,
468                            SmallVectorImpl<StringRef> &SSNs) {
469   switch (SSID) {
470   case SyncScope::System:
471     break;
472   default:
473     if (SSNs.empty())
474       Context.getSyncScopeNames(SSNs);
475 
476     OS << "syncscope(\"";
477     PrintEscapedString(SSNs[SSID], OS);
478     OS << "\") ";
479     break;
480   }
481 }
482 
483 static const char *getTargetMMOFlagName(const TargetInstrInfo &TII,
484                                         unsigned TMMOFlag) {
485   auto Flags = TII.getSerializableMachineMemOperandTargetFlags();
486   for (const auto &I : Flags) {
487     if (I.first == TMMOFlag) {
488       return I.second;
489     }
490   }
491   return nullptr;
492 }
493 
494 static void printFrameIndex(raw_ostream& OS, int FrameIndex, bool IsFixed,
495                             const MachineFrameInfo *MFI) {
496   StringRef Name;
497   if (MFI) {
498     IsFixed = MFI->isFixedObjectIndex(FrameIndex);
499     if (const AllocaInst *Alloca = MFI->getObjectAllocation(FrameIndex))
500       if (Alloca->hasName())
501         Name = Alloca->getName();
502     if (IsFixed)
503       FrameIndex -= MFI->getObjectIndexBegin();
504   }
505   MachineOperand::printStackObjectReference(OS, FrameIndex, IsFixed, Name);
506 }
507 
508 void MachineOperand::printSubRegIdx(raw_ostream &OS, uint64_t Index,
509                                     const TargetRegisterInfo *TRI) {
510   OS << "%subreg.";
511   if (TRI)
512     OS << TRI->getSubRegIndexName(Index);
513   else
514     OS << Index;
515 }
516 
517 void MachineOperand::printTargetFlags(raw_ostream &OS,
518                                       const MachineOperand &Op) {
519   if (!Op.getTargetFlags())
520     return;
521   const MachineFunction *MF = getMFIfAvailable(Op);
522   if (!MF)
523     return;
524 
525   const auto *TII = MF->getSubtarget().getInstrInfo();
526   assert(TII && "expected instruction info");
527   auto Flags = TII->decomposeMachineOperandsTargetFlags(Op.getTargetFlags());
528   OS << "target-flags(";
529   const bool HasDirectFlags = Flags.first;
530   const bool HasBitmaskFlags = Flags.second;
531   if (!HasDirectFlags && !HasBitmaskFlags) {
532     OS << "<unknown>) ";
533     return;
534   }
535   if (HasDirectFlags) {
536     if (const auto *Name = getTargetFlagName(TII, Flags.first))
537       OS << Name;
538     else
539       OS << "<unknown target flag>";
540   }
541   if (!HasBitmaskFlags) {
542     OS << ") ";
543     return;
544   }
545   bool IsCommaNeeded = HasDirectFlags;
546   unsigned BitMask = Flags.second;
547   auto BitMasks = TII->getSerializableBitmaskMachineOperandTargetFlags();
548   for (const auto &Mask : BitMasks) {
549     // Check if the flag's bitmask has the bits of the current mask set.
550     if ((BitMask & Mask.first) == Mask.first) {
551       if (IsCommaNeeded)
552         OS << ", ";
553       IsCommaNeeded = true;
554       OS << Mask.second;
555       // Clear the bits which were serialized from the flag's bitmask.
556       BitMask &= ~(Mask.first);
557     }
558   }
559   if (BitMask) {
560     // When the resulting flag's bitmask isn't zero, we know that we didn't
561     // serialize all of the bit flags.
562     if (IsCommaNeeded)
563       OS << ", ";
564     OS << "<unknown bitmask target flag>";
565   }
566   OS << ") ";
567 }
568 
569 void MachineOperand::printSymbol(raw_ostream &OS, MCSymbol &Sym) {
570   OS << "<mcsymbol " << Sym << ">";
571 }
572 
573 void MachineOperand::printStackObjectReference(raw_ostream &OS,
574                                                unsigned FrameIndex,
575                                                bool IsFixed, StringRef Name) {
576   if (IsFixed) {
577     OS << "%fixed-stack." << FrameIndex;
578     return;
579   }
580 
581   OS << "%stack." << FrameIndex;
582   if (!Name.empty())
583     OS << '.' << Name;
584 }
585 
586 void MachineOperand::printOperandOffset(raw_ostream &OS, int64_t Offset) {
587   if (Offset == 0)
588     return;
589   if (Offset < 0) {
590     OS << " - " << -Offset;
591     return;
592   }
593   OS << " + " << Offset;
594 }
595 
596 void MachineOperand::printIRSlotNumber(raw_ostream &OS, int Slot) {
597   if (Slot == -1)
598     OS << "<badref>";
599   else
600     OS << Slot;
601 }
602 
603 static void printCFI(raw_ostream &OS, const MCCFIInstruction &CFI,
604                      const TargetRegisterInfo *TRI) {
605   switch (CFI.getOperation()) {
606   case MCCFIInstruction::OpSameValue:
607     OS << "same_value ";
608     if (MCSymbol *Label = CFI.getLabel())
609       MachineOperand::printSymbol(OS, *Label);
610     printCFIRegister(CFI.getRegister(), OS, TRI);
611     break;
612   case MCCFIInstruction::OpRememberState:
613     OS << "remember_state ";
614     if (MCSymbol *Label = CFI.getLabel())
615       MachineOperand::printSymbol(OS, *Label);
616     break;
617   case MCCFIInstruction::OpRestoreState:
618     OS << "restore_state ";
619     if (MCSymbol *Label = CFI.getLabel())
620       MachineOperand::printSymbol(OS, *Label);
621     break;
622   case MCCFIInstruction::OpOffset:
623     OS << "offset ";
624     if (MCSymbol *Label = CFI.getLabel())
625       MachineOperand::printSymbol(OS, *Label);
626     printCFIRegister(CFI.getRegister(), OS, TRI);
627     OS << ", " << CFI.getOffset();
628     break;
629   case MCCFIInstruction::OpDefCfaRegister:
630     OS << "def_cfa_register ";
631     if (MCSymbol *Label = CFI.getLabel())
632       MachineOperand::printSymbol(OS, *Label);
633     printCFIRegister(CFI.getRegister(), OS, TRI);
634     break;
635   case MCCFIInstruction::OpDefCfaOffset:
636     OS << "def_cfa_offset ";
637     if (MCSymbol *Label = CFI.getLabel())
638       MachineOperand::printSymbol(OS, *Label);
639     OS << CFI.getOffset();
640     break;
641   case MCCFIInstruction::OpDefCfa:
642     OS << "def_cfa ";
643     if (MCSymbol *Label = CFI.getLabel())
644       MachineOperand::printSymbol(OS, *Label);
645     printCFIRegister(CFI.getRegister(), OS, TRI);
646     OS << ", " << CFI.getOffset();
647     break;
648   case MCCFIInstruction::OpRelOffset:
649     OS << "rel_offset ";
650     if (MCSymbol *Label = CFI.getLabel())
651       MachineOperand::printSymbol(OS, *Label);
652     printCFIRegister(CFI.getRegister(), OS, TRI);
653     OS << ", " << CFI.getOffset();
654     break;
655   case MCCFIInstruction::OpAdjustCfaOffset:
656     OS << "adjust_cfa_offset ";
657     if (MCSymbol *Label = CFI.getLabel())
658       MachineOperand::printSymbol(OS, *Label);
659     OS << CFI.getOffset();
660     break;
661   case MCCFIInstruction::OpRestore:
662     OS << "restore ";
663     if (MCSymbol *Label = CFI.getLabel())
664       MachineOperand::printSymbol(OS, *Label);
665     printCFIRegister(CFI.getRegister(), OS, TRI);
666     break;
667   case MCCFIInstruction::OpEscape: {
668     OS << "escape ";
669     if (MCSymbol *Label = CFI.getLabel())
670       MachineOperand::printSymbol(OS, *Label);
671     if (!CFI.getValues().empty()) {
672       size_t e = CFI.getValues().size() - 1;
673       for (size_t i = 0; i < e; ++i)
674         OS << format("0x%02x", uint8_t(CFI.getValues()[i])) << ", ";
675       OS << format("0x%02x", uint8_t(CFI.getValues()[e])) << ", ";
676     }
677     break;
678   }
679   case MCCFIInstruction::OpUndefined:
680     OS << "undefined ";
681     if (MCSymbol *Label = CFI.getLabel())
682       MachineOperand::printSymbol(OS, *Label);
683     printCFIRegister(CFI.getRegister(), OS, TRI);
684     break;
685   case MCCFIInstruction::OpRegister:
686     OS << "register ";
687     if (MCSymbol *Label = CFI.getLabel())
688       MachineOperand::printSymbol(OS, *Label);
689     printCFIRegister(CFI.getRegister(), OS, TRI);
690     OS << ", ";
691     printCFIRegister(CFI.getRegister2(), OS, TRI);
692     break;
693   case MCCFIInstruction::OpWindowSave:
694     OS << "window_save ";
695     if (MCSymbol *Label = CFI.getLabel())
696       MachineOperand::printSymbol(OS, *Label);
697     break;
698   default:
699     // TODO: Print the other CFI Operations.
700     OS << "<unserializable cfi directive>";
701     break;
702   }
703 }
704 
705 void MachineOperand::print(raw_ostream &OS, const TargetRegisterInfo *TRI,
706                            const TargetIntrinsicInfo *IntrinsicInfo) const {
707   print(OS, LLT{}, TRI, IntrinsicInfo);
708 }
709 
710 void MachineOperand::print(raw_ostream &OS, LLT TypeToPrint,
711                            const TargetRegisterInfo *TRI,
712                            const TargetIntrinsicInfo *IntrinsicInfo) const {
713   tryToGetTargetInfo(*this, TRI, IntrinsicInfo);
714   ModuleSlotTracker DummyMST(nullptr);
715   print(OS, DummyMST, TypeToPrint, /*PrintDef=*/false, /*IsStandalone=*/true,
716         /*ShouldPrintRegisterTies=*/true,
717         /*TiedOperandIdx=*/0, TRI, IntrinsicInfo);
718 }
719 
720 void MachineOperand::print(raw_ostream &OS, ModuleSlotTracker &MST,
721                            LLT TypeToPrint, bool PrintDef, bool IsStandalone,
722                            bool ShouldPrintRegisterTies,
723                            unsigned TiedOperandIdx,
724                            const TargetRegisterInfo *TRI,
725                            const TargetIntrinsicInfo *IntrinsicInfo) const {
726   printTargetFlags(OS, *this);
727   switch (getType()) {
728   case MachineOperand::MO_Register: {
729     unsigned Reg = getReg();
730     if (isImplicit())
731       OS << (isDef() ? "implicit-def " : "implicit ");
732     else if (PrintDef && isDef())
733       // Print the 'def' flag only when the operand is defined after '='.
734       OS << "def ";
735     if (isInternalRead())
736       OS << "internal ";
737     if (isDead())
738       OS << "dead ";
739     if (isKill())
740       OS << "killed ";
741     if (isUndef())
742       OS << "undef ";
743     if (isEarlyClobber())
744       OS << "early-clobber ";
745     if (isDebug())
746       OS << "debug-use ";
747     if (TargetRegisterInfo::isPhysicalRegister(getReg()) && isRenamable())
748       OS << "renamable ";
749 
750     const MachineRegisterInfo *MRI = nullptr;
751     if (TargetRegisterInfo::isVirtualRegister(Reg)) {
752       if (const MachineFunction *MF = getMFIfAvailable(*this)) {
753         MRI = &MF->getRegInfo();
754       }
755     }
756 
757     OS << printReg(Reg, TRI, 0, MRI);
758     // Print the sub register.
759     if (unsigned SubReg = getSubReg()) {
760       if (TRI)
761         OS << '.' << TRI->getSubRegIndexName(SubReg);
762       else
763         OS << ".subreg" << SubReg;
764     }
765     // Print the register class / bank.
766     if (TargetRegisterInfo::isVirtualRegister(Reg)) {
767       if (const MachineFunction *MF = getMFIfAvailable(*this)) {
768         const MachineRegisterInfo &MRI = MF->getRegInfo();
769         if (IsStandalone || !PrintDef || MRI.def_empty(Reg)) {
770           OS << ':';
771           OS << printRegClassOrBank(Reg, MRI, TRI);
772         }
773       }
774     }
775     // Print ties.
776     if (ShouldPrintRegisterTies && isTied() && !isDef())
777       OS << "(tied-def " << TiedOperandIdx << ")";
778     // Print types.
779     if (TypeToPrint.isValid())
780       OS << '(' << TypeToPrint << ')';
781     break;
782   }
783   case MachineOperand::MO_Immediate:
784     OS << getImm();
785     break;
786   case MachineOperand::MO_CImmediate:
787     getCImm()->printAsOperand(OS, /*PrintType=*/true, MST);
788     break;
789   case MachineOperand::MO_FPImmediate:
790     getFPImm()->printAsOperand(OS, /*PrintType=*/true, MST);
791     break;
792   case MachineOperand::MO_MachineBasicBlock:
793     OS << printMBBReference(*getMBB());
794     break;
795   case MachineOperand::MO_FrameIndex: {
796     int FrameIndex = getIndex();
797     bool IsFixed = false;
798     const MachineFrameInfo *MFI = nullptr;
799     if (const MachineFunction *MF = getMFIfAvailable(*this))
800       MFI = &MF->getFrameInfo();
801     printFrameIndex(OS, FrameIndex, IsFixed, MFI);
802     break;
803   }
804   case MachineOperand::MO_ConstantPoolIndex:
805     OS << "%const." << getIndex();
806     printOperandOffset(OS, getOffset());
807     break;
808   case MachineOperand::MO_TargetIndex: {
809     OS << "target-index(";
810     const char *Name = "<unknown>";
811     if (const MachineFunction *MF = getMFIfAvailable(*this))
812       if (const auto *TargetIndexName = getTargetIndexName(*MF, getIndex()))
813         Name = TargetIndexName;
814     OS << Name << ')';
815     printOperandOffset(OS, getOffset());
816     break;
817   }
818   case MachineOperand::MO_JumpTableIndex:
819     OS << printJumpTableEntryReference(getIndex());
820     break;
821   case MachineOperand::MO_GlobalAddress:
822     getGlobal()->printAsOperand(OS, /*PrintType=*/false, MST);
823     printOperandOffset(OS, getOffset());
824     break;
825   case MachineOperand::MO_ExternalSymbol: {
826     StringRef Name = getSymbolName();
827     OS << '&';
828     if (Name.empty()) {
829       OS << "\"\"";
830     } else {
831       printLLVMNameWithoutPrefix(OS, Name);
832     }
833     printOperandOffset(OS, getOffset());
834     break;
835   }
836   case MachineOperand::MO_BlockAddress: {
837     OS << "blockaddress(";
838     getBlockAddress()->getFunction()->printAsOperand(OS, /*PrintType=*/false,
839                                                      MST);
840     OS << ", ";
841     printIRBlockReference(OS, *getBlockAddress()->getBasicBlock(), MST);
842     OS << ')';
843     MachineOperand::printOperandOffset(OS, getOffset());
844     break;
845   }
846   case MachineOperand::MO_RegisterMask: {
847     OS << "<regmask";
848     if (TRI) {
849       unsigned NumRegsInMask = 0;
850       unsigned NumRegsEmitted = 0;
851       for (unsigned i = 0; i < TRI->getNumRegs(); ++i) {
852         unsigned MaskWord = i / 32;
853         unsigned MaskBit = i % 32;
854         if (getRegMask()[MaskWord] & (1 << MaskBit)) {
855           if (PrintRegMaskNumRegs < 0 ||
856               NumRegsEmitted <= static_cast<unsigned>(PrintRegMaskNumRegs)) {
857             OS << " " << printReg(i, TRI);
858             NumRegsEmitted++;
859           }
860           NumRegsInMask++;
861         }
862       }
863       if (NumRegsEmitted != NumRegsInMask)
864         OS << " and " << (NumRegsInMask - NumRegsEmitted) << " more...";
865     } else {
866       OS << " ...";
867     }
868     OS << ">";
869     break;
870   }
871   case MachineOperand::MO_RegisterLiveOut: {
872     const uint32_t *RegMask = getRegLiveOut();
873     OS << "liveout(";
874     if (!TRI) {
875       OS << "<unknown>";
876     } else {
877       bool IsCommaNeeded = false;
878       for (unsigned Reg = 0, E = TRI->getNumRegs(); Reg < E; ++Reg) {
879         if (RegMask[Reg / 32] & (1U << (Reg % 32))) {
880           if (IsCommaNeeded)
881             OS << ", ";
882           OS << printReg(Reg, TRI);
883           IsCommaNeeded = true;
884         }
885       }
886     }
887     OS << ")";
888     break;
889   }
890   case MachineOperand::MO_Metadata:
891     getMetadata()->printAsOperand(OS, MST);
892     break;
893   case MachineOperand::MO_MCSymbol:
894     printSymbol(OS, *getMCSymbol());
895     break;
896   case MachineOperand::MO_CFIIndex: {
897     if (const MachineFunction *MF = getMFIfAvailable(*this))
898       printCFI(OS, MF->getFrameInstructions()[getCFIIndex()], TRI);
899     else
900       OS << "<cfi directive>";
901     break;
902   }
903   case MachineOperand::MO_IntrinsicID: {
904     Intrinsic::ID ID = getIntrinsicID();
905     if (ID < Intrinsic::num_intrinsics)
906       OS << "intrinsic(@" << Intrinsic::getName(ID, None) << ')';
907     else if (IntrinsicInfo)
908       OS << "intrinsic(@" << IntrinsicInfo->getName(ID) << ')';
909     else
910       OS << "intrinsic(" << ID << ')';
911     break;
912   }
913   case MachineOperand::MO_Predicate: {
914     auto Pred = static_cast<CmpInst::Predicate>(getPredicate());
915     OS << (CmpInst::isIntPredicate(Pred) ? "int" : "float") << "pred("
916        << CmpInst::getPredicateName(Pred) << ')';
917     break;
918   }
919   }
920 }
921 
922 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
923 LLVM_DUMP_METHOD void MachineOperand::dump() const { dbgs() << *this << '\n'; }
924 #endif
925 
926 //===----------------------------------------------------------------------===//
927 // MachineMemOperand Implementation
928 //===----------------------------------------------------------------------===//
929 
930 /// getAddrSpace - Return the LLVM IR address space number that this pointer
931 /// points into.
932 unsigned MachinePointerInfo::getAddrSpace() const { return AddrSpace; }
933 
934 /// isDereferenceable - Return true if V is always dereferenceable for
935 /// Offset + Size byte.
936 bool MachinePointerInfo::isDereferenceable(unsigned Size, LLVMContext &C,
937                                            const DataLayout &DL) const {
938   if (!V.is<const Value *>())
939     return false;
940 
941   const Value *BasePtr = V.get<const Value *>();
942   if (BasePtr == nullptr)
943     return false;
944 
945   return isDereferenceableAndAlignedPointer(
946       BasePtr, 1, APInt(DL.getPointerSizeInBits(), Offset + Size), DL);
947 }
948 
949 /// getConstantPool - Return a MachinePointerInfo record that refers to the
950 /// constant pool.
951 MachinePointerInfo MachinePointerInfo::getConstantPool(MachineFunction &MF) {
952   return MachinePointerInfo(MF.getPSVManager().getConstantPool());
953 }
954 
955 /// getFixedStack - Return a MachinePointerInfo record that refers to the
956 /// the specified FrameIndex.
957 MachinePointerInfo MachinePointerInfo::getFixedStack(MachineFunction &MF,
958                                                      int FI, int64_t Offset) {
959   return MachinePointerInfo(MF.getPSVManager().getFixedStack(FI), Offset);
960 }
961 
962 MachinePointerInfo MachinePointerInfo::getJumpTable(MachineFunction &MF) {
963   return MachinePointerInfo(MF.getPSVManager().getJumpTable());
964 }
965 
966 MachinePointerInfo MachinePointerInfo::getGOT(MachineFunction &MF) {
967   return MachinePointerInfo(MF.getPSVManager().getGOT());
968 }
969 
970 MachinePointerInfo MachinePointerInfo::getStack(MachineFunction &MF,
971                                                 int64_t Offset, uint8_t ID) {
972   return MachinePointerInfo(MF.getPSVManager().getStack(), Offset, ID);
973 }
974 
975 MachinePointerInfo MachinePointerInfo::getUnknownStack(MachineFunction &MF) {
976   return MachinePointerInfo(MF.getDataLayout().getAllocaAddrSpace());
977 }
978 
979 MachineMemOperand::MachineMemOperand(MachinePointerInfo ptrinfo, Flags f,
980                                      uint64_t s, uint64_t a,
981                                      const AAMDNodes &AAInfo,
982                                      const MDNode *Ranges, SyncScope::ID SSID,
983                                      AtomicOrdering Ordering,
984                                      AtomicOrdering FailureOrdering)
985     : PtrInfo(ptrinfo), Size(s), FlagVals(f), BaseAlignLog2(Log2_32(a) + 1),
986       AAInfo(AAInfo), Ranges(Ranges) {
987   assert((PtrInfo.V.isNull() || PtrInfo.V.is<const PseudoSourceValue *>() ||
988           isa<PointerType>(PtrInfo.V.get<const Value *>()->getType())) &&
989          "invalid pointer value");
990   assert(getBaseAlignment() == a && "Alignment is not a power of 2!");
991   assert((isLoad() || isStore()) && "Not a load/store!");
992 
993   AtomicInfo.SSID = static_cast<unsigned>(SSID);
994   assert(getSyncScopeID() == SSID && "Value truncated");
995   AtomicInfo.Ordering = static_cast<unsigned>(Ordering);
996   assert(getOrdering() == Ordering && "Value truncated");
997   AtomicInfo.FailureOrdering = static_cast<unsigned>(FailureOrdering);
998   assert(getFailureOrdering() == FailureOrdering && "Value truncated");
999 }
1000 
1001 /// Profile - Gather unique data for the object.
1002 ///
1003 void MachineMemOperand::Profile(FoldingSetNodeID &ID) const {
1004   ID.AddInteger(getOffset());
1005   ID.AddInteger(Size);
1006   ID.AddPointer(getOpaqueValue());
1007   ID.AddInteger(getFlags());
1008   ID.AddInteger(getBaseAlignment());
1009 }
1010 
1011 void MachineMemOperand::refineAlignment(const MachineMemOperand *MMO) {
1012   // The Value and Offset may differ due to CSE. But the flags and size
1013   // should be the same.
1014   assert(MMO->getFlags() == getFlags() && "Flags mismatch!");
1015   assert(MMO->getSize() == getSize() && "Size mismatch!");
1016 
1017   if (MMO->getBaseAlignment() >= getBaseAlignment()) {
1018     // Update the alignment value.
1019     BaseAlignLog2 = Log2_32(MMO->getBaseAlignment()) + 1;
1020     // Also update the base and offset, because the new alignment may
1021     // not be applicable with the old ones.
1022     PtrInfo = MMO->PtrInfo;
1023   }
1024 }
1025 
1026 /// getAlignment - Return the minimum known alignment in bytes of the
1027 /// actual memory reference.
1028 uint64_t MachineMemOperand::getAlignment() const {
1029   return MinAlign(getBaseAlignment(), getOffset());
1030 }
1031 
1032 void MachineMemOperand::print(raw_ostream &OS) const {
1033   ModuleSlotTracker DummyMST(nullptr);
1034   print(OS, DummyMST);
1035 }
1036 
1037 void MachineMemOperand::print(raw_ostream &OS, ModuleSlotTracker &MST) const {
1038   SmallVector<StringRef, 0> SSNs;
1039   LLVMContext Ctx;
1040   print(OS, MST, SSNs, Ctx, nullptr, nullptr);
1041 }
1042 
1043 void MachineMemOperand::print(raw_ostream &OS, ModuleSlotTracker &MST,
1044                               SmallVectorImpl<StringRef> &SSNs,
1045                               const LLVMContext &Context,
1046                               const MachineFrameInfo *MFI,
1047                               const TargetInstrInfo *TII) const {
1048   OS << '(';
1049   if (isVolatile())
1050     OS << "volatile ";
1051   if (isNonTemporal())
1052     OS << "non-temporal ";
1053   if (isDereferenceable())
1054     OS << "dereferenceable ";
1055   if (isInvariant())
1056     OS << "invariant ";
1057   if (getFlags() & MachineMemOperand::MOTargetFlag1)
1058     OS << '"' << getTargetMMOFlagName(*TII, MachineMemOperand::MOTargetFlag1)
1059        << "\" ";
1060   if (getFlags() & MachineMemOperand::MOTargetFlag2)
1061     OS << '"' << getTargetMMOFlagName(*TII, MachineMemOperand::MOTargetFlag2)
1062        << "\" ";
1063   if (getFlags() & MachineMemOperand::MOTargetFlag3)
1064     OS << '"' << getTargetMMOFlagName(*TII, MachineMemOperand::MOTargetFlag3)
1065        << "\" ";
1066 
1067   assert((isLoad() || isStore()) &&
1068          "machine memory operand must be a load or store (or both)");
1069   if (isLoad())
1070     OS << "load ";
1071   if (isStore())
1072     OS << "store ";
1073 
1074   printSyncScope(OS, Context, getSyncScopeID(), SSNs);
1075 
1076   if (getOrdering() != AtomicOrdering::NotAtomic)
1077     OS << toIRString(getOrdering()) << ' ';
1078   if (getFailureOrdering() != AtomicOrdering::NotAtomic)
1079     OS << toIRString(getFailureOrdering()) << ' ';
1080 
1081   OS << getSize();
1082   if (const Value *Val = getValue()) {
1083     OS << ((isLoad() && isStore()) ? " on " : isLoad() ? " from " : " into ");
1084     printIRValueReference(OS, *Val, MST);
1085   } else if (const PseudoSourceValue *PVal = getPseudoValue()) {
1086     OS << ((isLoad() && isStore()) ? " on " : isLoad() ? " from " : " into ");
1087     assert(PVal && "Expected a pseudo source value");
1088     switch (PVal->kind()) {
1089     case PseudoSourceValue::Stack:
1090       OS << "stack";
1091       break;
1092     case PseudoSourceValue::GOT:
1093       OS << "got";
1094       break;
1095     case PseudoSourceValue::JumpTable:
1096       OS << "jump-table";
1097       break;
1098     case PseudoSourceValue::ConstantPool:
1099       OS << "constant-pool";
1100       break;
1101     case PseudoSourceValue::FixedStack: {
1102       int FrameIndex = cast<FixedStackPseudoSourceValue>(PVal)->getFrameIndex();
1103       bool IsFixed = true;
1104       printFrameIndex(OS, FrameIndex, IsFixed, MFI);
1105       break;
1106     }
1107     case PseudoSourceValue::GlobalValueCallEntry:
1108       OS << "call-entry ";
1109       cast<GlobalValuePseudoSourceValue>(PVal)->getValue()->printAsOperand(
1110           OS, /*PrintType=*/false, MST);
1111       break;
1112     case PseudoSourceValue::ExternalSymbolCallEntry:
1113       OS << "call-entry &";
1114       printLLVMNameWithoutPrefix(
1115           OS, cast<ExternalSymbolPseudoSourceValue>(PVal)->getSymbol());
1116       break;
1117     case PseudoSourceValue::TargetCustom:
1118       // FIXME: This is not necessarily the correct MIR serialization format for
1119       // a custom pseudo source value, but at least it allows
1120       // -print-machineinstrs to work on a target with custom pseudo source
1121       // values.
1122       OS << "custom ";
1123       PVal->printCustom(OS);
1124       break;
1125     }
1126   }
1127   MachineOperand::printOperandOffset(OS, getOffset());
1128   if (getBaseAlignment() != getSize())
1129     OS << ", align " << getBaseAlignment();
1130   auto AAInfo = getAAInfo();
1131   if (AAInfo.TBAA) {
1132     OS << ", !tbaa ";
1133     AAInfo.TBAA->printAsOperand(OS, MST);
1134   }
1135   if (AAInfo.Scope) {
1136     OS << ", !alias.scope ";
1137     AAInfo.Scope->printAsOperand(OS, MST);
1138   }
1139   if (AAInfo.NoAlias) {
1140     OS << ", !noalias ";
1141     AAInfo.NoAlias->printAsOperand(OS, MST);
1142   }
1143   if (getRanges()) {
1144     OS << ", !range ";
1145     getRanges()->printAsOperand(OS, MST);
1146   }
1147   // FIXME: Implement addrspace printing/parsing in MIR.
1148   // For now, print this even though parsing it is not available in MIR.
1149   if (unsigned AS = getAddrSpace())
1150     OS << ", addrspace " << AS;
1151 
1152   OS << ')';
1153 }
1154