[GreedyRA ORE] Extract stats in RAGreedyStats struct. NFC.

[skatkov]

Summary

Combine all collected stats into separate struct RAGreedyStats
with add and report methods.

The motivation is to extend the number of statistics to capture and instead of
adding new parameters, just combine all of them into one structure.
Additionally I plan to use report from different places in future to report data
for function as well.

[thegameg]

LGTM. Doesn't seem like there are any tests testing this remark, maybe you can add one if you have something handy?

[skatkov]

In D100012#2673142, @thegameg wrote:

LGTM. Doesn't seem like there are any tests testing this remark, maybe you can add one if you have something handy?

There are some tests
./CodeGen/AArch64/arm64-spill-remarks-treshold-hotness.ll
./CodeGen/AArch64/arm64-spill-remarks.ll

I'll probably add something like this.

[thegameg]

In D100012#2673146, @skatkov wrote:

In D100012#2673142, @thegameg wrote:

LGTM. Doesn't seem like there are any tests testing this remark, maybe you can add one if you have something handy?

There are some tests
./CodeGen/AArch64/arm64-spill-remarks-treshold-hotness.ll
./CodeGen/AArch64/arm64-spill-remarks.ll

I'll probably add something like this.

Looks like I missed that! Should be fine as is then.

llvm/lib/CodeGen/RegAllocGreedy.cpp

private:
   };
   using HintsInfo = SmallVector<HintInfo, 4>;
 
   BlockFrequency getBrokenHintFreq(const HintsInfo &, MCRegister);
   void collectHintInfo(Register, HintsInfo &);
 
   bool isUnusedCalleeSavedReg(MCRegister PhysReg) const;
 
+  /// Greedy RA statistic to remark.
+  struct RAGreedyStats {
+    unsigned Reloads = 0;
+    unsigned FoldedReloads = 0;
+    unsigned Spills = 0;
+    unsigned FoldedSpills = 0;
+
+    bool isEmpty() {
+      return !(Reloads || FoldedReloads || Spills || FoldedSpills);
+    }
+
+    void add(RAGreedyStats other) {
+      Reloads += other.Reloads;
+      FoldedReloads += other.FoldedReloads;
+      Spills += other.Spills;
+      FoldedSpills += other.FoldedSpills;
+    }
+
+    void report(MachineOptimizationRemarkMissed &R);
+  };
+
   /// Compute and report the number of spills and reloads for a loop.
-  void reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
-                                    unsigned &FoldedReloads, unsigned &Spills,
-                                    unsigned &FoldedSpills);
+  RAGreedyStats reportNumberOfSplillsReloads(MachineLoop *L);
 
   /// Report the number of spills and reloads for each loop.
   void reportNumberOfSplillsReloads();
 };
 
 } // end anonymous namespace
 
 char RAGreedy::ID = 0;
if (VerifyEnabled)
       MF->verify(this, "After spilling");
   }
 
   // The live virtual register requesting allocation was spilled, so tell
   // the caller not to allocate anything during this round.
   return 0;
 }
 
-void RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
-                                            unsigned &FoldedReloads,
-                                            unsigned &Spills,
-                                            unsigned &FoldedSpills) {
-  Reloads = 0;
-  FoldedReloads = 0;
-  Spills = 0;
-  FoldedSpills = 0;
+void RAGreedy::RAGreedyStats::report(MachineOptimizationRemarkMissed &R) {
+  using namespace ore;
+  if (Spills)
+    R << NV("NumSpills", Spills) << " spills ";
+  if (FoldedSpills)
+    R << NV("NumFoldedSpills", FoldedSpills) << " folded spills ";
+  if (Reloads)
+    R << NV("NumReloads", Reloads) << " reloads ";
+  if (FoldedReloads)
+    R << NV("NumFoldedReloads", FoldedReloads) << " folded reloads ";
+}
+
+RAGreedy::RAGreedyStats RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L) {
+  RAGreedyStats Stats;
 
   // Sum up the spill and reloads in subloops.
-  for (MachineLoop *SubLoop : *L) {
-    unsigned SubReloads;
-    unsigned SubFoldedReloads;
-    unsigned SubSpills;
-    unsigned SubFoldedSpills;
-
-    reportNumberOfSplillsReloads(SubLoop, SubReloads, SubFoldedReloads,
-                                 SubSpills, SubFoldedSpills);
-    Reloads += SubReloads;
-    FoldedReloads += SubFoldedReloads;
-    Spills += SubSpills;
-    FoldedSpills += SubFoldedSpills;
-  }
+  for (MachineLoop *SubLoop : *L)
+    Stats.add(reportNumberOfSplillsReloads(SubLoop));
 
   const MachineFrameInfo &MFI = MF->getFrameInfo();
   int FI;
 
   for (MachineBasicBlock *MBB : L->getBlocks())
     // Handle blocks that were not included in subloops.
     if (Loops->getLoopFor(MBB) == L)
       for (MachineInstr &MI : *MBB) {
         SmallVector<const MachineMemOperand *, 2> Accesses;
         auto isSpillSlotAccess = [&MFI](const MachineMemOperand *A) {
           return MFI.isSpillSlotObjectIndex(
               cast<FixedStackPseudoSourceValue>(A->getPseudoValue())
                   ->getFrameIndex());
         };
 
         if (TII->isLoadFromStackSlot(MI, FI) && MFI.isSpillSlotObjectIndex(FI))
-          ++Reloads;
+          ++Stats.Reloads;
         else if (TII->hasLoadFromStackSlot(MI, Accesses) &&
                  llvm::any_of(Accesses, isSpillSlotAccess))
-          ++FoldedReloads;
+          ++Stats.FoldedReloads;
         else if (TII->isStoreToStackSlot(MI, FI) &&
                  MFI.isSpillSlotObjectIndex(FI))
-          ++Spills;
+          ++Stats.Spills;
         else if (TII->hasStoreToStackSlot(MI, Accesses) &&
                  llvm::any_of(Accesses, isSpillSlotAccess))
-          ++FoldedSpills;
+          ++Stats.FoldedSpills;
       }
 
-  if (Reloads || FoldedReloads || Spills || FoldedSpills) {
+  if (!Stats.isEmpty()) {
     using namespace ore;
 
     ORE->emit([&]() {
       MachineOptimizationRemarkMissed R(DEBUG_TYPE, "LoopSpillReload",
                                         L->getStartLoc(), L->getHeader());
-      if (Spills)
-        R << NV("NumSpills", Spills) << " spills ";
-      if (FoldedSpills)
-        R << NV("NumFoldedSpills", FoldedSpills) << " folded spills ";
-      if (Reloads)
-        R << NV("NumReloads", Reloads) << " reloads ";
-      if (FoldedReloads)
-        R << NV("NumFoldedReloads", FoldedReloads) << " folded reloads ";
+      Stats.report(R);
       R << "generated in loop";
       return R;
     });
   }
+  return Stats;
 }
 
 void RAGreedy::reportNumberOfSplillsReloads() {
   if (!ORE->allowExtraAnalysis(DEBUG_TYPE))
     return;
-  for (MachineLoop *L : *Loops) {
-    unsigned Reloads, FoldedReloads, Spills, FoldedSpills;
-    reportNumberOfSplillsReloads(L, Reloads, FoldedReloads, Spills,
-                                 FoldedSpills);
-  }
+  for (MachineLoop *L : *Loops)
+    reportNumberOfSplillsReloads(L);
 }
 
 bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {
   LLVM_DEBUG(dbgs() << "********** GREEDY REGISTER ALLOCATION **********\n"
                     << "********** Function: " << mf.getName() << '\n');
 
   MF = &mf;
   TRI = MF->getSubtarget().getRegisterInfo();