AMDGPU/SI: Fix creating v_mov_b32s without exec uses

[arsenm]

Summary

This will be caught by existing tests with a verifier check to be added in a future commit.

[arsenm]

Fix conflict with trunk from moving into separate function

[• tstellarAMD]

LGTM.

[arsenm]

r247229

lib/Target/AMDGPU/SIFoldOperands.cpp

static bool tryAddToFoldList(std::vector<FoldCandidate> &FoldList,
 
   FoldList.push_back(FoldCandidate(MI, OpNo, OpToFold));
   return true;
 }
 
 static void foldOperand(MachineOperand &OpToFold, MachineInstr *UseMI,
                         unsigned UseOpIdx,
                         std::vector<FoldCandidate> &FoldList,
+                        SmallVectorImpl<MachineInstr *> &CopiesToReplace,
                         const SIInstrInfo *TII, const SIRegisterInfo &TRI,
                         MachineRegisterInfo &MRI) {
   const MachineOperand &UseOp = UseMI->getOperand(UseOpIdx);
 
   // FIXME: Fold operands with subregs.
   if (UseOp.isReg() && ((UseOp.getSubReg() && OpToFold.isReg()) ||
       UseOp.isImplicit())) {
     return;
if (UseMI->getOpcode() == AMDGPU::COPY) {
         MRI.getRegClass(DestReg) :
         TRI.getPhysRegClass(DestReg);
 
       unsigned MovOp = TII->getMovOpcode(DestRC);
       if (MovOp == AMDGPU::COPY)
         return;
 
       UseMI->setDesc(TII->get(MovOp));
+      CopiesToReplace.push_back(UseMI);
     }
   }
 
   const MCInstrDesc &UseDesc = UseMI->getDesc();
 
   // Don't fold into target independent nodes.  Target independent opcodes
   // don't have defined register classes.
   if (UseDesc.isVariadic() ||
for (I = MBB.begin(); I != MBB.end(); I = Next) {
         continue;
 
       // FIXME: Fold operands with subregs.
       if (OpToFold.isReg() &&
           (!TargetRegisterInfo::isVirtualRegister(OpToFold.getReg()) ||
            OpToFold.getSubReg()))
         continue;
 
+
+      // We need mutate the operands of new mov instructions to add implicit
+      // uses of EXEC, but adding them invalidates the use_iterator, so defer
+      // this.
+      SmallVector<MachineInstr *, 4> CopiesToReplace;
+
       std::vector<FoldCandidate> FoldList;
       for (MachineRegisterInfo::use_iterator
            Use = MRI.use_begin(MI.getOperand(0).getReg()), E = MRI.use_end();
            Use != E; ++Use) {
 
         MachineInstr *UseMI = Use->getParent();
 
         foldOperand(OpToFold, UseMI, Use.getOperandNo(), FoldList,
-                    TII, TRI, MRI);
+                    CopiesToReplace, TII, TRI, MRI);
       }
 
+      // Make sure we add EXEC uses to any new v_mov instructions created.
+      for (MachineInstr *Copy : CopiesToReplace)
+        Copy->addImplicitDefUseOperands(MF);
+
       for (FoldCandidate &Fold : FoldList) {
         if (updateOperand(Fold, TRI)) {
           // Clear kill flags.
           if (!Fold.isImm()) {
             assert(Fold.OpToFold && Fold.OpToFold->isReg());
             Fold.OpToFold->setIsKill(false);
           }
           DEBUG(dbgs() << "Folded source from " << MI << " into OpNo " <<
                 Fold.UseOpNo << " of " << *Fold.UseMI << '\n');
         }
       }
     }
   }
   return false;
 }