AMDGPU: Don't look at dbg users for foldable operands

[dblaikie]

Test coverage?

[arsenm]

In D85679#2208613, @dblaikie wrote:

Test coverage?

It's only a theoretical compile time improvement

[dblaikie]

In D85679#2208717, @arsenm wrote:

In D85679#2208613, @dblaikie wrote:

Test coverage?

It's only a theoretical compile time improvement

Fair enough.

[arsenm]

da3f357de67833ff2ded813a02158f3ec6dc25a7

llvm/lib/Target/AMDGPU/SIFoldOperands.cpp

void SIFoldOperands::foldOperand(
 
   // Special case for REG_SEQUENCE: We can't fold literals into
   // REG_SEQUENCE instructions, so we have to fold them into the
   // uses of REG_SEQUENCE.
   if (UseMI->isRegSequence()) {
     Register RegSeqDstReg = UseMI->getOperand(0).getReg();
     unsigned RegSeqDstSubReg = UseMI->getOperand(UseOpIdx + 1).getImm();
 
-    MachineRegisterInfo::use_iterator Next;
-    for (MachineRegisterInfo::use_iterator
-           RSUse = MRI->use_begin(RegSeqDstReg), RSE = MRI->use_end();
+    MachineRegisterInfo::use_nodbg_iterator Next;
+    for (MachineRegisterInfo::use_nodbg_iterator
+           RSUse = MRI->use_nodbg_begin(RegSeqDstReg), RSE = MRI->use_nodbg_end();
          RSUse != RSE; RSUse = Next) {
       Next = std::next(RSUse);
 
       MachineInstr *RSUseMI = RSUse->getParent();
 
       if (tryToFoldACImm(TII, UseMI->getOperand(0), RSUseMI,
                          RSUse.getOperandNo(), FoldList))
         continue;
if (FoldingImmLike && UseMI->isCopy()) {
     // so would interfere with the register coalescer's logic which would avoid
     // redundant initalizations.
     if (DestReg.isPhysical() && SrcRC->contains(DestReg))
       return;
 
     const TargetRegisterClass *DestRC = TRI->getRegClassForReg(*MRI, DestReg);
     if (!DestReg.isPhysical()) {
       if (TRI->isSGPRClass(SrcRC) && TRI->hasVectorRegisters(DestRC)) {
-        MachineRegisterInfo::use_iterator NextUse;
+        MachineRegisterInfo::use_nodbg_iterator NextUse;
         SmallVector<FoldCandidate, 4> CopyUses;
-        for (MachineRegisterInfo::use_iterator Use = MRI->use_begin(DestReg),
-               E = MRI->use_end();
+        for (MachineRegisterInfo::use_nodbg_iterator Use = MRI->use_nodbg_begin(DestReg),
+               E = MRI->use_nodbg_end();
              Use != E; Use = NextUse) {
           NextUse = std::next(Use);
           // There's no point trying to fold into an implicit operand.
           if (Use->isImplicit())
             continue;
 
           FoldCandidate FC = FoldCandidate(Use->getParent(), Use.getOperandNo(),
                                            &UseMI->getOperand(1));
void SIFoldOperands::foldInstOperand(MachineInstr &MI,
   MachineOperand &Dst = MI.getOperand(0);
 
   bool FoldingImm = OpToFold.isImm() || OpToFold.isFI() || OpToFold.isGlobal();
   if (FoldingImm) {
     unsigned NumLiteralUses = 0;
     MachineOperand *NonInlineUse = nullptr;
     int NonInlineUseOpNo = -1;
 
-    MachineRegisterInfo::use_iterator NextUse;
-    for (MachineRegisterInfo::use_iterator
-           Use = MRI->use_begin(Dst.getReg()), E = MRI->use_end();
+    MachineRegisterInfo::use_nodbg_iterator NextUse;
+    for (MachineRegisterInfo::use_nodbg_iterator
+           Use = MRI->use_nodbg_begin(Dst.getReg()), E = MRI->use_nodbg_end();
          Use != E; Use = NextUse) {
       NextUse = std::next(Use);
       MachineInstr *UseMI = Use->getParent();
       unsigned OpNo = Use.getOperandNo();
 
       // Folding the immediate may reveal operations that can be constant
       // folded or replaced with a copy. This can happen for example after
       // frame indices are lowered to constants or from splitting 64-bit
       // constants.
       //
       // We may also encounter cases where one or both operands are
       // immediates materialized into a register, which would ordinarily not
       // be folded due to multiple uses or operand constraints.
 
       if (OpToFold.isImm() && tryConstantFoldOp(*MRI, TII, UseMI, &OpToFold)) {
         LLVM_DEBUG(dbgs() << "Constant folded " << *UseMI << '\n');
 
         // Some constant folding cases change the same immediate's use to a new
         // instruction, e.g. and x, 0 -> 0. Make sure we re-visit the user
         // again. The same constant folded instruction could also have a second
         // use operand.
-        NextUse = MRI->use_begin(Dst.getReg());
+        NextUse = MRI->use_nodbg_begin(Dst.getReg());
         FoldList.clear();
         continue;
       }
 
       // Try to fold any inline immediate uses, and then only fold other
       // constants if they have one use.
       //
       // The legality of the inline immediate must be checked based on the use
if (FoldingImm) {
     }
 
     if (NumLiteralUses == 1) {
       MachineInstr *UseMI = NonInlineUse->getParent();
       foldOperand(OpToFold, UseMI, NonInlineUseOpNo, FoldList, CopiesToReplace);
     }
   } else {
     // Folding register.
-    SmallVector <MachineRegisterInfo::use_iterator, 4> UsesToProcess;
-    for (MachineRegisterInfo::use_iterator
-           Use = MRI->use_begin(Dst.getReg()), E = MRI->use_end();
+    SmallVector <MachineRegisterInfo::use_nodbg_iterator, 4> UsesToProcess;
+    for (MachineRegisterInfo::use_nodbg_iterator
+           Use = MRI->use_nodbg_begin(Dst.getReg()), E = MRI->use_nodbg_end();
          Use != E; ++Use) {
       UsesToProcess.push_back(Use);
     }
     for (auto U : UsesToProcess) {
       MachineInstr *UseMI = U->getParent();
 
       foldOperand(OpToFold, UseMI, U.getOperandNo(),
         FoldList, CopiesToReplace);