[AMDGPU] Declutter applyPreexistingWaitcnt()

[stepthomas]

Summary

Declutter applyPreexistingWaitcnt() a little by abstracting the code
that updates the operands to S_WAITCNT and S_WAITCNT_VSCNT instructions
into discrete functions.

[foad]

Looks fine with or without nits addressed.

llvm/lib/Target/AMDGPU/SIInsertWaitcnts.cpp

848

Slightly neater to return early if they are equal.

855

I know you've copied it from elsewhere but NamedIdx is a terrible name. How about OpName?

917

This could also update the named operand simm16 for consistency. There's no particular rule about whether code like this should look up operand indexes or just hard code them.

[stepthomas]

llvm/lib/Target/AMDGPU/SIInsertWaitcnts.cpp

848

True. I'll change this.

855

That's certainly no worse, I'll update that too.

917

That would mean I could just have one "updateIfDifferent()" function, which is neater.

[stepthomas]

Apply review comments.

llvm/lib/Target/AMDGPU/SIInsertWaitcnts.cpp

 char SIInsertWaitcnts::ID = 0;
 
 char &llvm::SIInsertWaitcntsID = SIInsertWaitcnts::ID;
 
 FunctionPass *llvm::createSIInsertWaitcntsPass() {
   return new SIInsertWaitcnts();
 }
 
+static bool updateOperandIfDifferent(MachineInstr &MI, int OpIdx,
+                                     unsigned NewEnc) {
+  MachineOperand &MO = MI.getOperand(OpIdx);
+  if (NewEnc != MO.getImm()) {
+    MO.setImm(NewEnc);
+    return true;
+  }
+  return false;
+}
+
+static bool updateNamedOperandIfDifferent(MachineInstr &MI, uint16_t NamedIdx,
+                                          unsigned NewEnc) {
+  int OpIdx = AMDGPU::getNamedOperandIdx(MI.getOpcode(), NamedIdx);
+  assert(OpIdx >= 0);
+  return updateOperandIfDifferent(MI, OpIdx, NewEnc);
+}
+
 /// Combine consecutive waitcnt instructions that precede \p It and follow
 /// \p OldWaitcntInstr and apply any extra wait from waitcnt that were added
 /// by previous passes. Currently this pass conservatively assumes that these
 /// preexisting waitcnt are required for correctness.
 bool SIInsertWaitcnts::applyPreexistingWaitcnt(
     WaitcntBrackets &ScoreBrackets, MachineInstr &OldWaitcntInstr,
     AMDGPU::Waitcnt &Wait, MachineBasicBlock::instr_iterator It) const {
   bool Modified = false;
if (II.getOpcode() == AMDGPU::S_WAITCNT) {
         Modified = true;
       }
     }
   }
 
   // Updated encoding of merged waitcnt with the required wait.
   if (WaitcntInstr) {
     if (Wait.hasWaitExceptVsCnt()) {
-      unsigned NewEnc = AMDGPU::encodeWaitcnt(IV, Wait);
-      unsigned OldEnc = WaitcntInstr->getOperand(0).getImm();
-      if (OldEnc != NewEnc) {
-        WaitcntInstr->getOperand(0).setImm(NewEnc);
-        Modified = true;
-      }
+      Modified |= updateOperandIfDifferent(*WaitcntInstr, 0,
+                                           AMDGPU::encodeWaitcnt(IV, Wait));
       ScoreBrackets.applyWaitcnt(Wait);
       Wait.VmCnt = ~0u;
       Wait.LgkmCnt = ~0u;
       Wait.ExpCnt = ~0u;
 
       LLVM_DEBUG(It == OldWaitcntInstr.getParent()->end()
                      ? dbgs() << "applyPreexistingWaitcnt\n"
                               << "New Instr at block end: " << *WaitcntInstr
                               << '\n'
                      : dbgs() << "applyPreexistingWaitcnt\n"
                               << "Old Instr: " << *It
                               << "New Instr: " << *WaitcntInstr << '\n');
 
     } else {
       WaitcntInstr->eraseFromParent();
       Modified = true;
     }
   }
 
   if (WaitcntVsCntInstr) {
     if (Wait.hasWaitVsCnt()) {
       assert(ST->hasVscnt());
-      unsigned OldVSCnt =
-          TII->getNamedOperand(*WaitcntVsCntInstr, AMDGPU::OpName::simm16)
-              ->getImm();
-      if (Wait.VsCnt != OldVSCnt) {
-        TII->getNamedOperand(*WaitcntVsCntInstr, AMDGPU::OpName::simm16)
-            ->setImm(Wait.VsCnt);
-        Modified = true;
-      }
+      Modified |= updateNamedOperandIfDifferent(
+          *WaitcntVsCntInstr, AMDGPU::OpName::simm16, Wait.VsCnt);
       ScoreBrackets.applyWaitcnt(Wait);
       Wait.VsCnt = ~0u;
 
       LLVM_DEBUG(It == OldWaitcntInstr.getParent()->end()
                      ? dbgs() << "applyPreexistingWaitcnt\n"
                               << "New Instr at block end: "
                               << *WaitcntVsCntInstr << '\n'
                      : dbgs() << "applyPreexistingWaitcnt\n"