AMDGPU: Process SDWA block at a time

[arsenm]

Summary

Right now this loops over the entire function every time there
is a change, which is not very efficient. There's no practical
reason to track this so globally, since the code motion optimization
passes should be sinking instructions with single uses and
the pass currently will not fold with multiple uses.

[rampitec]

I agree theoretically. Anyway, are there any regressions?

[arsenm]

In D43085#1002316, @rampitec wrote:

I agree theoretically. Anyway, are there any regressions?

None of the tests regressed. I tried a few small samples with multiple blocks and they all sank and were handled

[rampitec]

LGTM

[arsenm]

r324667

lib/Target/AMDGPU/SIPeepholeSDWA.cpp

 public:
   static char ID;
 
   SIPeepholeSDWA() : MachineFunctionPass(ID) {
     initializeSIPeepholeSDWAPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override;
-  void matchSDWAOperands(MachineFunction &MF);
+  void matchSDWAOperands(MachineBasicBlock &MF);
   std::unique_ptr<SDWAOperand> matchSDWAOperand(MachineInstr &MI);
   bool isConvertibleToSDWA(const MachineInstr &MI, const SISubtarget &ST) const;
   bool convertToSDWA(MachineInstr &MI, const SDWAOperandsVector &SDWAOperands);
   void legalizeScalarOperands(MachineInstr &MI, const SISubtarget &ST) const;
 
   StringRef getPassName() const override { return "SI Peephole SDWA"; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
return make_unique<SDWADstPreserveOperand>(
       OrDst, OrSDWADef, OrOtherDef, DstSel);
 
   }
   }
 
   return std::unique_ptr<SDWAOperand>(nullptr);
 }
 
-void SIPeepholeSDWA::matchSDWAOperands(MachineFunction &MF) {
-  for (MachineBasicBlock &MBB : MF) {
-    for (MachineInstr &MI : MBB) {
-      if (auto Operand = matchSDWAOperand(MI)) {
-        DEBUG(dbgs() << "Match: " << MI << "To: " << *Operand << '\n');
-        SDWAOperands[&MI] = std::move(Operand);
-        ++NumSDWAPatternsFound;
-      }
-    }
-  }
-}
+void SIPeepholeSDWA::matchSDWAOperands(MachineBasicBlock &MBB) {
 
 bool SIPeepholeSDWA::isConvertibleToSDWA(const MachineInstr &MI,
                                          const SISubtarget &ST) const {
   // Check if this is already an SDWA instruction
   unsigned Opc = MI.getOpcode();
   if (TII->isSDWA(Opc))
     return true;
 
bool SIPeepholeSDWA::runOnMachineFunction(MachineFunction &MF) {
   if (!ST.hasSDWA() || skipFunction(MF.getFunction()))
     return false;
 
   MRI = &MF.getRegInfo();
   TRI = ST.getRegisterInfo();
   TII = ST.getInstrInfo();
 
   // Find all SDWA operands in MF.
-  bool Changed = false;
   bool Ret = false;
+  for (MachineBasicBlock &MBB : MF) {
+    bool Changed = false;
     do {
-    matchSDWAOperands(MF);
+      matchSDWAOperands(MBB);
 
       for (const auto &OperandPair : SDWAOperands) {
         const auto &Operand = OperandPair.second;
         MachineInstr *PotentialMI = Operand->potentialToConvert(TII);
         if (PotentialMI && isConvertibleToSDWA(*PotentialMI, ST)) {
           PotentialMatches[PotentialMI].push_back(Operand.get());
         }
       }
 
       for (auto &PotentialPair : PotentialMatches) {
         MachineInstr &PotentialMI = *PotentialPair.first;
         convertToSDWA(PotentialMI, PotentialPair.second);
       }
 
       PotentialMatches.clear();
       SDWAOperands.clear();
 
       Changed = !ConvertedInstructions.empty();
 
       if (Changed)
         Ret = true;
-
       while (!ConvertedInstructions.empty())
         legalizeScalarOperands(*ConvertedInstructions.pop_back_val(), ST);
     } while (Changed);
+  }
 
   return Ret;
 }