AMDGPU: Remove leftover implicit operands when folding immediates

[arsenm]

Summary

When constant folding an operation to a copy or an immediate
mov, the implicit uses/defs of the old instruction were left behind,
e.g. replacing v_or_b32 left the implicit exec use on the new copy.

[• tstellarAMD]

LGTM.

[arsenm]

r283471

lib/Target/AMDGPU/SIFoldOperands.cpp

default:
     return false;
   }
 }
 
 static unsigned getMovOpc(bool IsScalar) {
   return IsScalar ? AMDGPU::S_MOV_B32 : AMDGPU::V_MOV_B32_e32;
 }
 
+/// Remove any leftover implicit operands from mutating the instruction. e.g.
+/// if we replace an s_and_b32 with a copy, we don't need the implicit scc def
+/// anymore.
+static void stripExtraCopyOperands(MachineInstr &MI) {
+  const MCInstrDesc &Desc = MI.getDesc();
+  unsigned NumOps = Desc.getNumOperands() +
+                    Desc.getNumImplicitUses() +
+                    Desc.getNumImplicitDefs();
+
+  for (unsigned I = MI.getNumOperands() - 1; I >= NumOps; --I)
+    MI.RemoveOperand(I);
+}
+
+static void mutateCopyOp(MachineInstr &MI, const MCInstrDesc &NewDesc) {
+  MI.setDesc(NewDesc);
+  stripExtraCopyOperands(MI);
+}
+
 // Try to simplify operations with a constant that may appear after instruction
 // selection.
 static bool tryConstantFoldOp(MachineRegisterInfo &MRI,
                               const SIInstrInfo *TII,
                               MachineInstr *MI) {
   unsigned Opc = MI->getOpcode();
 
   if (Opc == AMDGPU::V_NOT_B32_e64 || Opc == AMDGPU::V_NOT_B32_e32 ||
       Opc == AMDGPU::S_NOT_B32) {
     MachineOperand &Src0 = MI->getOperand(1);
     if (Src0.isImm()) {
       Src0.setImm(~Src0.getImm());
-      MI->setDesc(TII->get(getMovOpc(Opc == AMDGPU::S_NOT_B32)));
+      mutateCopyOp(*MI, TII->get(getMovOpc(Opc == AMDGPU::S_NOT_B32)));
       return true;
     }
 
     return false;
   }
 
   if (!MI->isCommutable())
     return false;
if (Src0->isImm() && Src1->isImm()) {
     if (!evalBinaryInstruction(Opc, NewImm, Src0->getImm(), Src1->getImm()))
       return false;
 
     const SIRegisterInfo &TRI = TII->getRegisterInfo();
     bool IsSGPR = TRI.isSGPRReg(MRI, MI->getOperand(0).getReg());
 
     Src0->setImm(NewImm);
     MI->RemoveOperand(Src1Idx);
-    MI->setDesc(TII->get(getMovOpc(IsSGPR)));
+    mutateCopyOp(*MI, TII->get(getMovOpc(IsSGPR)));
     return true;
   }
 
   if (Src0->isImm() && !Src1->isImm()) {
     std::swap(Src0, Src1);
     std::swap(Src0Idx, Src1Idx);
   }
 
   int32_t Src1Val = static_cast<int32_t>(Src1->getImm());
   if (Opc == AMDGPU::V_OR_B32_e64 || Opc == AMDGPU::S_OR_B32) {
     if (Src1Val == 0) {
       // y = or x, 0 => y = copy x
       MI->RemoveOperand(Src1Idx);
-      MI->setDesc(TII->get(AMDGPU::COPY));
+      mutateCopyOp(*MI, TII->get(AMDGPU::COPY));
     } else if (Src1Val == -1) {
       // y = or x, -1 => y = v_mov_b32 -1
       MI->RemoveOperand(Src1Idx);
-      MI->setDesc(TII->get(getMovOpc(Opc == AMDGPU::S_OR_B32)));
+      mutateCopyOp(*MI, TII->get(getMovOpc(Opc == AMDGPU::S_OR_B32)));
     } else
       return false;
 
     return true;
   }
 
   if (MI->getOpcode() == AMDGPU::V_AND_B32_e64 ||
       MI->getOpcode() == AMDGPU::S_AND_B32) {
     if (Src1Val == 0) {
       // y = and x, 0 => y = v_mov_b32 0
       MI->RemoveOperand(Src0Idx);
-      MI->setDesc(TII->get(getMovOpc(Opc == AMDGPU::S_AND_B32)));
+      mutateCopyOp(*MI, TII->get(getMovOpc(Opc == AMDGPU::S_AND_B32)));
     } else if (Src1Val == -1) {
       // y = and x, -1 => y = copy x
       MI->RemoveOperand(Src1Idx);
-      MI->setDesc(TII->get(AMDGPU::COPY));
+      mutateCopyOp(*MI, TII->get(AMDGPU::COPY));
+      stripExtraCopyOperands(*MI);
     } else
       return false;
 
     return true;
   }
 
   if (MI->getOpcode() == AMDGPU::V_XOR_B32_e64 ||
       MI->getOpcode() == AMDGPU::S_XOR_B32) {
     if (Src1Val == 0) {
       // y = xor x, 0 => y = copy x
       MI->RemoveOperand(Src1Idx);
-      MI->setDesc(TII->get(AMDGPU::COPY));
+      mutateCopyOp(*MI, TII->get(AMDGPU::COPY));
     }
   }
 
   return false;
 }
 
 bool SIFoldOperands::runOnMachineFunction(MachineFunction &MF) {
   if (skipFunction(*MF.getFunction()))