[NFC][AMDGPU] Some cleanups in the SIOptimizeExecMasking pass.

[tsymalla]

Summary

Fix typos and remove an unused argument.

[tsymalla]

Fi clang-format issue.

llvm/lib/Target/AMDGPU/SIOptimizeExecMasking.cpp

class SIOptimizeExecMasking : public MachineFunctionPass {
   SmallVector<std::pair<MachineInstr *, MachineInstr *>, 1> OrXors;
 
   Register isCopyFromExec(const MachineInstr &MI) const;
   Register isCopyToExec(const MachineInstr &MI) const;
   bool removeTerminatorBit(MachineInstr &MI) const;
   MachineBasicBlock::reverse_iterator
   fixTerminators(MachineBasicBlock &MBB) const;
   MachineBasicBlock::reverse_iterator
-  findExecCopy(MachineBasicBlock &MBB, MachineBasicBlock::reverse_iterator I,
-               unsigned CopyToExec) const;
+  findExecCopy(MachineBasicBlock &MBB,
+               MachineBasicBlock::reverse_iterator I) const;
 
   bool isRegisterInUseBetween(MachineInstr &Stop, MachineInstr &Start,
                               MCRegister Reg, bool UseLiveOuts = false,
                               bool IgnoreStart = false) const;
   bool isRegisterInUseAfter(MachineInstr &Stop, MCRegister Reg) const;
   MachineInstr *findInstrBackwards(MachineInstr &Origin,
                                    std::function<bool(MachineInstr *)> Pred,
                                    ArrayRef<MCRegister> NonModifiableRegs,
if (removeTerminatorBit(*I)) {
         Seen = true;
       }
     }
   }
 
   return FirstNonTerm;
 }
 
-MachineBasicBlock::reverse_iterator
-SIOptimizeExecMasking::findExecCopy(MachineBasicBlock &MBB,
-                                    MachineBasicBlock::reverse_iterator I,
-                                    unsigned CopyToExec) const {
+MachineBasicBlock::reverse_iterator SIOptimizeExecMasking::findExecCopy(
+    MachineBasicBlock &MBB, MachineBasicBlock::reverse_iterator I) const {
   const unsigned InstLimit = 25;
 
   auto E = MBB.rend();
   for (unsigned N = 0; N <= InstLimit && I != E; ++I, ++N) {
     Register CopyFromExec = isCopyFromExec(*I);
     if (CopyFromExec.isValid())
       return I;
   }
bool SIOptimizeExecMasking::isRegisterInUseBetween(MachineInstr &Stop,
                                                    MCRegister Reg,
                                                    bool UseLiveOuts,
                                                    bool IgnoreStart) const {
   LivePhysRegs LR(*TRI);
   if (UseLiveOuts)
     LR.addLiveOuts(*Stop.getParent());
 
   MachineBasicBlock::reverse_iterator A(Start);
-  MachineBasicBlock::reverse_iterator E(Stop);
 
   if (IgnoreStart)
     ++A;
 
   for (; A != Stop.getParent()->rend() && A != Stop; ++A) {
     LR.stepBackward(*A);
   }
 
while (I != E && SearchCount++ < SearchLimit) {
       ++I;
     }
 
     if (!CopyToExec)
       continue;
 
     // Scan backwards to find the def.
     auto *CopyToExecInst = &*I;
-    auto CopyFromExecInst = findExecCopy(MBB, I, CopyToExec);
+    auto CopyFromExecInst = findExecCopy(MBB, I);
     if (CopyFromExecInst == E) {
       auto PrepareExecInst = std::next(I);
       if (PrepareExecInst == E)
         continue;
       // Fold exec = COPY (S_AND_B64 reg, exec) -> exec = S_AND_B64 reg, exec
       if (CopyToExecInst->getOperand(1).isKill() &&
           isLogicalOpOnExec(*PrepareExecInst) == CopyToExec) {
         LLVM_DEBUG(dbgs() << "Fold exec copy: " << *PrepareExecInst);
void SIOptimizeExecMasking::tryRecordVCmpxAndSaveexecSequence(
   if (!TRI->isSGPRReg(*MRI, SaveExecDest))
     return;
 
   MachineOperand *SaveExecSrc0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
   if (!SaveExecSrc0->isReg())
     return;
 
   // Tries to find a possibility to optimize a v_cmp ..., s_and_saveexec
-  // sequence by looking at an instance of a s_and_saveexec instruction. Returns
-  // a pointer to the v_cmp instruction if it is safe to replace the sequence
-  // (see the conditions in the function body). This is after register
+  // sequence by looking at an instance of an s_and_saveexec instruction.
+  // Returns a pointer to the v_cmp instruction if it is safe to replace the
+  // sequence (see the conditions in the function body). This is after register
   // allocation, so some checks on operand dependencies need to be considered.
   MachineInstr *VCmp = nullptr;
 
   // Try to find the last v_cmp instruction that defs the saveexec input
   // operand without any write to Exec or the saveexec input operand inbetween.
   VCmp = findInstrBackwards(
       MI,
       [&](MachineInstr *Check) {
if (Src0->isReg() && TRI->isSGPRReg(*MRI, Src0->getReg()) &&
     return;
 
   MachineOperand *Src1 = TII->getNamedOperand(*VCmp, AMDGPU::OpName::src1);
   if (Src1->isReg() && TRI->isSGPRReg(*MRI, Src1->getReg()) &&
       MI.modifiesRegister(Src1->getReg(), TRI))
     return;
 
   // Don't do the transformation if the destination operand is included in
-  // it's MBB Live-outs, meaning it's used in any of it's successors, leading
+  // it's MBB Live-outs, meaning it's used in any of its successors, leading
   // to incorrect code if the v_cmp and therefore the def of
   // the dest operand is removed.
   if (isLiveOut(*VCmp->getParent(), VCmpDest->getReg()))
     return;
 
   // If the v_cmp target is in use between v_cmp and s_and_saveexec or after the
   // s_and_saveexec, skip the optimization.
   if (isRegisterInUseBetween(*VCmp, MI, VCmpDest->getReg(), false, true) ||