[GreedyRA] Add some stats to remark emitter for Greedy RA.

[skatkov]

Summary

Adds couple of stats to remark emitter after Greedy RA:

1. Number of spill/reload instructions without used in statepoint like instruction which does not suffer from stack usage.
2. Cost of spill/reloads computed as block frequency for each stack usage.
3. Number of copy instructions with virtual register operands.
4. Cost of copies computed as block frequency for each copy.

While these numbers highly depends on MIR, they can show interesting information about changes in RA and even can be used as some metric.

[reames]

llvm/lib/CodeGen/RegAllocGreedy.cpp

3121

Please move the majority of the computation logic outside the ORE emit lambda. Leave only the output formatting there. (Just to be consistent with existing code.)

3133

You'll need to restructure this a bit on the changes I suggested for the review adding getNonFoldableRange.

I'll mention that I found the current structure quite confusing. I'd suggest adjusting naming to be clear that what you're interested in is zero cost folding, not whether these is a fold. To the point where it might be useful to have stasts to track each separately.

3156

You need to find some alternate naming here. You're not counting spills, you're counting usages of spills.

You might want to count "folded reloads" and "folded spills" separately?

As an aside, extending the existing reportNumberOfSplillsReloads to report a function level summary as well as the loop level detail would seem quite helpful.

Actually, the more I look at this, the more I think what you actually want is to extend the existing reportNumberOfSplillsReloads logic after extending it the function level.

[skatkov]

abandon in favor of other solution.

llvm/lib/CodeGen/RegAllocGreedy.cpp

private:
 
   bool isUnusedCalleeSavedReg(MCRegister PhysReg) const;
 
   /// Compute and report the number of spills and reloads for a loop.
   void reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
                                     unsigned &FoldedReloads, unsigned &Spills,
                                     unsigned &FoldedSpills);
 
+  void reportCostOfSplillsReloads();
+
   /// Report the number of spills and reloads for each loop.
   void reportNumberOfSplillsReloads() {
     for (MachineLoop *L : *Loops) {
       unsigned Reloads, FoldedReloads, Spills, FoldedSpills;
       reportNumberOfSplillsReloads(L, Reloads, FoldedReloads, Spills,
                                    FoldedSpills);
     }
+    reportCostOfSplillsReloads();
   }
 };
 
 } // end anonymous namespace
 
 char RAGreedy::ID = 0;
 char &llvm::RAGreedyID = RAGreedy::ID;
 
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::reportCostOfSplillsReloads() {
+  using namespace ore;
+
+  ORE->emit([&]() {
+    float TotalMemWeight = 0.0f;
+    unsigned TotalMemCount = 0;
+    float TotalCopyWeight = 0.0f;
+    unsigned TotalCopyCount = 0;
+    const MachineFrameInfo &MFI = MF->getFrameInfo();
+    for (MachineBasicBlock &MBB : *MF) {
+      unsigned MemCount = 0;
+      unsigned CopyCount = 0;
+      for (MachineInstr &MI : MBB) {
+        std::pair<unsigned, unsigned> NonFoldabelRange =
+            TII->getNonFoldableRange(MI);
+        if (any_of(MI.operands(), [&](MachineOperand &MO) {
+              return MO.isFI() && MFI.isSpillSlotObjectIndex(MO.getIndex()) &&
+                     MI.getOperandNo(&MO) >= NonFoldabelRange.first &&
+                     MI.getOperandNo(&MO) < NonFoldabelRange.second;
+            }))
+          ++MemCount;
+        if (MI.isCopy()) {
+          MachineOperand &Dest = MI.getOperand(0);
+          MachineOperand &Src = MI.getOperand(1);
+          if (Dest.isReg() && Src.isReg() && Dest.getReg().isVirtual() &&
+              Src.getReg().isVirtual())
+            ++CopyCount;
+        }
+      }
+      float BlocFreq = MBFI->getBlockFreqRelativeToEntryBlock(&MBB);
+      TotalMemWeight += MemCount * BlocFreq;
+      TotalMemCount += MemCount;
+      TotalCopyWeight += CopyCount * BlocFreq;
+      TotalCopyCount += CopyCount;
+    }
+
+    MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "SpillReloadCost",
+                                        DebugLoc(), &MF->front());
+    R << NV("Total Spill Count", TotalMemCount);
+    R << NV("Total Spill Cost", TotalMemWeight);
+    R << NV("Total Copy Count", TotalCopyCount);
+    R << NV("Total Copy Cost", TotalCopyWeight);
+    return R;
+  });
+}
+
 void RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
                                             unsigned &FoldedReloads,
                                             unsigned &Spills,
                                             unsigned &FoldedSpills) {
   Reloads = 0;
   FoldedReloads = 0;
   Spills = 0;
   FoldedSpills = 0;