[AMDGPU][NewPM] Port "AMDGPUResourceUsageAnalysis" to NPM (#130959)

Author: vikramRH

llvm/include/llvm/Passes/TargetPassRegistry.inc

@@ -187,12 +187,13 @@ PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) {
 #undef LOOP_ANALYSIS
 });
 
-PB.registerAnalysisRegistrationCallback([](MachineFunctionAnalysisManager &AM) {
+PB.registerAnalysisRegistrationCallback(
+    [=](MachineFunctionAnalysisManager &AM) {
 #define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)                           \
   AM.registerPass([&] { return CREATE_PASS; });
 #include GET_PASS_REGISTRY
 #undef MACHINE_FUNCTION_ANALYSIS
-});
+    });
 
 #undef GET_PASS_REGISTRY
 #endif // GET_PASS_REGISTRY

llvm/lib/Target/AMDGPU/AMDGPU.h

@@ -428,7 +428,7 @@ ModulePass *createAMDGPUPrintfRuntimeBinding();
 void initializeAMDGPUPrintfRuntimeBindingPass(PassRegistry&);
 extern char &AMDGPUPrintfRuntimeBindingID;
 
-void initializeAMDGPUResourceUsageAnalysisPass(PassRegistry &);
+void initializeAMDGPUResourceUsageAnalysisWrapperPassPass(PassRegistry &);
 extern char &AMDGPUResourceUsageAnalysisID;
 
 struct AMDGPUPrintfRuntimeBindingPass

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

@@ -646,7 +646,8 @@ bool AMDGPUAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
   if (!IsTargetStreamerInitialized)
     initTargetStreamer(*MF.getFunction().getParent());
 
-  ResourceUsage = &getAnalysis<AMDGPUResourceUsageAnalysis>();
+  ResourceUsage =
+      &getAnalysis<AMDGPUResourceUsageAnalysisWrapperPass>().getResourceInfo();
   CurrentProgramInfo.reset(MF);
 
   const AMDGPUMachineFunction *MFI = MF.getInfo<AMDGPUMachineFunction>();
@@ -668,9 +669,7 @@ bool AMDGPUAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
     OutStreamer->switchSection(ConfigSection);
   }
 
-  const AMDGPUResourceUsageAnalysis::SIFunctionResourceInfo &Info =
-      ResourceUsage->getResourceInfo();
-  RI.gatherResourceInfo(MF, Info, OutContext);
+  RI.gatherResourceInfo(MF, *ResourceUsage, OutContext);
 
   if (MFI->isModuleEntryFunction()) {
     getSIProgramInfo(CurrentProgramInfo, MF);
@@ -1677,8 +1676,8 @@ bool AMDGPUAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 }
 
 void AMDGPUAsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<AMDGPUResourceUsageAnalysis>();
-  AU.addPreserved<AMDGPUResourceUsageAnalysis>();
+  AU.addRequired<AMDGPUResourceUsageAnalysisWrapperPass>();
+  AU.addPreserved<AMDGPUResourceUsageAnalysisWrapperPass>();
   AU.addRequired<MachineModuleInfoWrapperPass>();
   AU.addPreserved<MachineModuleInfoWrapperPass>();
   AsmPrinter::getAnalysisUsage(AU);

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.h

@@ -43,7 +43,8 @@ class AMDGPUAsmPrinter final : public AsmPrinter {
   unsigned CodeObjectVersion;
   void initializeTargetID(const Module &M);
 
-  AMDGPUResourceUsageAnalysis *ResourceUsage;
+  const AMDGPUResourceUsageAnalysisWrapperPass::FunctionResourceInfo
+      *ResourceUsage;
 
   MCResourceInfo RI;
 

llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp

@@ -238,7 +238,7 @@ void MCResourceInfo::assignResourceInfoExpr(
 
 void MCResourceInfo::gatherResourceInfo(
     const MachineFunction &MF,
-    const AMDGPUResourceUsageAnalysis::SIFunctionResourceInfo &FRI,
+    const AMDGPUResourceUsageAnalysisWrapperPass::FunctionResourceInfo &FRI,
     MCContext &OutContext) {
   // Worst case VGPR use for non-hardware-entrypoints.
   MCSymbol *MaxVGPRSym = getMaxVGPRSymbol(OutContext);

llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.h

@@ -98,7 +98,7 @@ class MCResourceInfo {
   /// functions with indirect calls should be assigned the module level maximum.
   void gatherResourceInfo(
       const MachineFunction &MF,
-      const AMDGPUResourceUsageAnalysis::SIFunctionResourceInfo &FRI,
+      const AMDGPUResourceUsageAnalysisWrapperPass::FunctionResourceInfo &FRI,
       MCContext &OutContext);
 
   const MCExpr *createTotalNumVGPRs(const MachineFunction &MF, MCContext &Ctx);

llvm/lib/Target/AMDGPU/AMDGPUPassRegistry.def

@@ -94,6 +94,13 @@ FUNCTION_PASS_WITH_PARAMS(
     parseAMDGPUAtomicOptimizerStrategy, "strategy=dpp|iterative|none")
 #undef FUNCTION_PASS_WITH_PARAMS
 
+#ifndef MACHINE_FUNCTION_ANALYSIS
+#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)
+#endif
+
+MACHINE_FUNCTION_ANALYSIS("amdgpu-resource-usage", AMDGPUResourceUsageAnalysis(*static_cast<const GCNTargetMachine *>(this)))
+#undef MACHINE_FUNCTION_ANALYSIS
+
 #ifndef MACHINE_FUNCTION_PASS
 #define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
 #endif

llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.cpp

@@ -30,8 +30,9 @@ using namespace llvm::AMDGPU;
 
 #define DEBUG_TYPE "amdgpu-resource-usage"
 
-char llvm::AMDGPUResourceUsageAnalysis::ID = 0;
-char &llvm::AMDGPUResourceUsageAnalysisID = AMDGPUResourceUsageAnalysis::ID;
+char llvm::AMDGPUResourceUsageAnalysisWrapperPass::ID = 0;
+char &llvm::AMDGPUResourceUsageAnalysisID =
+    AMDGPUResourceUsageAnalysisWrapperPass::ID;
 
 // In code object v4 and older, we need to tell the runtime some amount ahead of
 // time if we don't know the true stack size. Assume a smaller number if this is
@@ -47,7 +48,7 @@ static cl::opt<uint32_t> clAssumedStackSizeForDynamicSizeObjects(
              "variable sized objects (in bytes)"),
     cl::Hidden, cl::init(4096));
 
-INITIALIZE_PASS(AMDGPUResourceUsageAnalysis, DEBUG_TYPE,
+INITIALIZE_PASS(AMDGPUResourceUsageAnalysisWrapperPass, DEBUG_TYPE,
                 "Function register usage analysis", true, true)
 
 static const Function *getCalleeFunction(const MachineOperand &Op) {
@@ -68,7 +69,8 @@ static bool hasAnyNonFlatUseOfReg(const MachineRegisterInfo &MRI,
   return false;
 }
 
-bool AMDGPUResourceUsageAnalysis::runOnMachineFunction(MachineFunction &MF) {
+bool AMDGPUResourceUsageAnalysisWrapperPass::runOnMachineFunction(
+    MachineFunction &MF) {
   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
   if (!TPC)
     return false;
@@ -90,14 +92,40 @@ bool AMDGPUResourceUsageAnalysis::runOnMachineFunction(MachineFunction &MF) {
       AssumedStackSizeForExternalCall = 0;
   }
 
-  ResourceInfo = analyzeResourceUsage(MF, AssumedStackSizeForDynamicSizeObjects,
-                                      AssumedStackSizeForExternalCall);
+  ResourceInfo = AMDGPUResourceUsageAnalysisImpl().analyzeResourceUsage(
+      MF, AssumedStackSizeForDynamicSizeObjects,
+      AssumedStackSizeForExternalCall);
 
   return false;
 }
 
-AMDGPUResourceUsageAnalysis::SIFunctionResourceInfo
-AMDGPUResourceUsageAnalysis::analyzeResourceUsage(
+AnalysisKey AMDGPUResourceUsageAnalysis::Key;
+AMDGPUResourceUsageAnalysis::Result
+AMDGPUResourceUsageAnalysis::run(MachineFunction &MF,
+                                 MachineFunctionAnalysisManager &MFAM) {
+  const MCSubtargetInfo &STI = *TM.getMCSubtargetInfo();
+
+  // By default, for code object v5 and later, track only the minimum scratch
+  // size
+  uint32_t AssumedStackSizeForDynamicSizeObjects =
+      clAssumedStackSizeForDynamicSizeObjects;
+  uint32_t AssumedStackSizeForExternalCall = clAssumedStackSizeForExternalCall;
+  if (AMDGPU::getAMDHSACodeObjectVersion(*MF.getFunction().getParent()) >=
+          AMDGPU::AMDHSA_COV5 ||
+      STI.getTargetTriple().getOS() == Triple::AMDPAL) {
+    if (!clAssumedStackSizeForDynamicSizeObjects.getNumOccurrences())
+      AssumedStackSizeForDynamicSizeObjects = 0;
+    if (!clAssumedStackSizeForExternalCall.getNumOccurrences())
+      AssumedStackSizeForExternalCall = 0;
+  }
+
+  return AMDGPUResourceUsageAnalysisImpl().analyzeResourceUsage(
+      MF, AssumedStackSizeForDynamicSizeObjects,
+      AssumedStackSizeForExternalCall);
+}
+
+AMDGPUResourceUsageAnalysisImpl::SIFunctionResourceInfo
+AMDGPUResourceUsageAnalysisImpl::analyzeResourceUsage(
     const MachineFunction &MF, uint32_t AssumedStackSizeForDynamicSizeObjects,
     uint32_t AssumedStackSizeForExternalCall) const {
   SIFunctionResourceInfo Info;

llvm/lib/Target/AMDGPU/AMDGPUResourceUsageAnalysis.h

@@ -17,14 +17,15 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class GCNSubtarget;
 class MachineFunction;
-class TargetMachine;
+class GCNTargetMachine;
 
-struct AMDGPUResourceUsageAnalysis : public MachineFunctionPass {
+struct AMDGPUResourceUsageAnalysisImpl {
 public:
   static char ID;
   // Track resource usage for callee functions.
@@ -44,23 +45,44 @@ struct AMDGPUResourceUsageAnalysis : public MachineFunctionPass {
     SmallVector<const Function *, 16> Callees;
   };
 
-  AMDGPUResourceUsageAnalysis() : MachineFunctionPass(ID) {}
+  SIFunctionResourceInfo
+  analyzeResourceUsage(const MachineFunction &MF,
+                       uint32_t AssumedStackSizeForDynamicSizeObjects,
+                       uint32_t AssumedStackSizeForExternalCall) const;
+};
+
+struct AMDGPUResourceUsageAnalysisWrapperPass : public MachineFunctionPass {
+  using FunctionResourceInfo =
+      AMDGPUResourceUsageAnalysisImpl::SIFunctionResourceInfo;
+  FunctionResourceInfo ResourceInfo;
+
+public:
+  static char ID;
+  AMDGPUResourceUsageAnalysisWrapperPass() : MachineFunctionPass(ID) {}
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
-  const SIFunctionResourceInfo &getResourceInfo() const { return ResourceInfo; }
+  const FunctionResourceInfo &getResourceInfo() const { return ResourceInfo; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     MachineFunctionPass::getAnalysisUsage(AU);
   }
+};
 
-private:
-  SIFunctionResourceInfo
-  analyzeResourceUsage(const MachineFunction &MF,
-                       uint32_t AssumedStackSizeForDynamicSizeObjects,
-                       uint32_t AssumedStackSizeForExternalCall) const;
-  SIFunctionResourceInfo ResourceInfo;
+class AMDGPUResourceUsageAnalysis
+    : public AnalysisInfoMixin<AMDGPUResourceUsageAnalysis> {
+  friend AnalysisInfoMixin<AMDGPUResourceUsageAnalysis>;
+  static AnalysisKey Key;
+
+  const GCNTargetMachine &TM;
+
+public:
+  using Result = AMDGPUResourceUsageAnalysisImpl::SIFunctionResourceInfo;
+  Result run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM);
+
+  AMDGPUResourceUsageAnalysis(const GCNTargetMachine &TM_) : TM(TM_) {}
 };
+
 } // namespace llvm
 #endif // LLVM_LIB_TARGET_AMDGPU_AMDGPURESOURCEUSAGEANALYSIS_H

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

@@ -27,6 +27,7 @@
 #include "AMDGPUPreloadKernArgProlog.h"
 #include "AMDGPURemoveIncompatibleFunctions.h"
 #include "AMDGPUReserveWWMRegs.h"
+#include "AMDGPUResourceUsageAnalysis.h"
 #include "AMDGPUSplitModule.h"
 #include "AMDGPUTargetObjectFile.h"
 #include "AMDGPUTargetTransformInfo.h"
@@ -557,7 +558,7 @@ extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUTarget() {
   initializeAMDGPUExternalAAWrapperPass(*PR);
   initializeAMDGPUImageIntrinsicOptimizerPass(*PR);
   initializeAMDGPUPrintfRuntimeBindingPass(*PR);
-  initializeAMDGPUResourceUsageAnalysisPass(*PR);
+  initializeAMDGPUResourceUsageAnalysisWrapperPassPass(*PR);
   initializeGCNNSAReassignLegacyPass(*PR);
   initializeGCNPreRAOptimizationsLegacyPass(*PR);
   initializeGCNPreRALongBranchRegLegacyPass(*PR);