[NewPM][AMDGPU] Port amdgpu-unify-metadata

[aeubanks]

Summary

And add to AMDGPU opt pipeline.

[aeubanks]

add amdgpu-unify-metadata to opt list to not pin to legacy PM

llvm/lib/Target/AMDGPU/AMDGPU.h

 ModulePass *createAMDGPUPrintfRuntimeBinding();
 void initializeAMDGPUPrintfRuntimeBindingPass(PassRegistry&);
 extern char &AMDGPUPrintfRuntimeBindingID;
 
 ModulePass* createAMDGPUUnifyMetadataPass();
 void initializeAMDGPUUnifyMetadataPass(PassRegistry&);
 extern char &AMDGPUUnifyMetadataID;
 
+struct AMDGPUUnifyMetadataPass : PassInfoMixin<AMDGPUUnifyMetadataPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
 void initializeSIOptimizeExecMaskingPreRAPass(PassRegistry&);
 extern char &SIOptimizeExecMaskingPreRAID;
 
 void initializeAMDGPUAnnotateUniformValuesPass(PassRegistry&);
 extern char &AMDGPUAnnotateUniformValuesPassID;
 
 void initializeAMDGPUCodeGenPreparePass(PassRegistry&);
 extern char &AMDGPUCodeGenPrepareID;

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

[EnableOpt](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
       if (EnableOpt)
         PM.add(createAMDGPUPromoteAllocaToVector());
   });
 }
 
 void AMDGPUTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB,
                                                        bool DebugPassManager) {
   PB.registerPipelineParsingCallback(
+      [](StringRef PassName, ModulePassManager &PM,
+         ArrayRef<PassBuilder::PipelineElement>) {
+        if (PassName == "amdgpu-unify-metadata") {
+          PM.addPass(AMDGPUUnifyMetadataPass());
+          return true;
+        }
+        return false;
+      });
+  PB.registerPipelineParsingCallback(
       [this](StringRef PassName, FunctionPassManager &PM,
              ArrayRef<PassBuilder::PipelineElement>) {
         if (PassName == "amdgpu-simplifylib") {
           PM.addPass(AMDGPUSimplifyLibCallsPass());
           return true;
         }
         if (PassName == "amdgpu-usenative") {
           PM.addPass(AMDGPUUseNativeCallsPass());
PB.registerPipelineStartEPCallback([DebugPassManager](
     PM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
   });
 
   PB.registerPipelineEarlySimplificationEPCallback(
       [](ModulePassManager &PM, PassBuilder::OptimizationLevel Level) {
         if (Level == PassBuilder::OptimizationLevel::O0)
           return;
 
+        PM.addPass(AMDGPUUnifyMetadataPass());
+
         if (InternalizeSymbols) {
           PM.addPass(InternalizePass(mustPreserveGV));
           PM.addPass(GlobalDCEPass());
         }
       });
 
   PB.registerCGSCCOptimizerLateEPCallback(
       [this, DebugPassManager](CGSCCPassManager &PM,

llvm/lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace llvm;
 
 namespace {
 
namespace {
   class AMDGPUUnifyMetadata : public ModulePass {
   public:
     static char ID;
 
     explicit AMDGPUUnifyMetadata() : ModulePass(ID) {}
 
   private:
     bool runOnModule(Module &M) override;
+  };
 
     /// Unify version metadata.
     /// \return true if changes are made.
     /// Assume the named metadata has operands each of which is a pair of
     /// integer constant, e.g.
     /// !Name = {!n1, !n2}
     /// !n1 = {i32 1, i32 2}
     /// !n2 = {i32 2, i32 0}
bool unifyExtensionMD(Module &M, StringRef Name) {
 
     NamedMD->eraseFromParent();
     NamedMD = M.getOrInsertNamedMetadata(Name);
     for (const auto &MD : All)
       NamedMD->addOperand(MDNode::get(M.getContext(), MD));
 
     return true;
   }
-};
+
+  bool unifyMetadataImpl(Module &M) {
+    const char *Vers[] = {kOCLMD::SpirVer, kOCLMD::OCLVer};
+    const char *Exts[] = {kOCLMD::UsedExt, kOCLMD::UsedOptCoreFeat,
+                          kOCLMD::CompilerOptions, kOCLMD::LLVMIdent};
+
+    bool Changed = false;
+
+    for (auto &I : Vers)
+      Changed |= unifyVersionMD(M, I, true);
+
+    for (auto &I : Exts)
+      Changed |= unifyExtensionMD(M, I);
+
+    return Changed;
+  }
 
   } // end anonymous namespace
 
   char AMDGPUUnifyMetadata::ID = 0;
 
   char &llvm::AMDGPUUnifyMetadataID = AMDGPUUnifyMetadata::ID;
 
   INITIALIZE_PASS(AMDGPUUnifyMetadata, "amdgpu-unify-metadata",
-                "Unify multiple OpenCL metadata due to linking",
-                false, false)
+                  "Unify multiple OpenCL metadata due to linking", false, false)
 
-ModulePass* llvm::createAMDGPUUnifyMetadataPass() {
+  ModulePass *llvm::createAMDGPUUnifyMetadataPass() {
     return new AMDGPUUnifyMetadata();
   }
 
   bool AMDGPUUnifyMetadata::runOnModule(Module &M) {
-  const char* Vers[] = {
-      kOCLMD::SpirVer,
-      kOCLMD::OCLVer
-  };
-  const char* Exts[] = {
-      kOCLMD::UsedExt,
-      kOCLMD::UsedOptCoreFeat,
-      kOCLMD::CompilerOptions,
-      kOCLMD::LLVMIdent
-  };
-
-  bool Changed = false;
-
-  for (auto &I : Vers)
-    Changed |= unifyVersionMD(M, I, true);
-
-  for (auto &I : Exts)
-    Changed |= unifyExtensionMD(M, I);
+    return unifyMetadataImpl(M);
+  }
 
-  return Changed;
+  PreservedAnalyses AMDGPUUnifyMetadataPass::run(Module &M,
+                                                 ModuleAnalysisManager &AM) {
+    return unifyMetadataImpl(M) ? PreservedAnalyses::none()
+                                : PreservedAnalyses::all();
   }

llvm/test/CodeGen/AMDGPU/unify-metadata.ll

 ; RUN: opt -mtriple=amdgcn--amdhsa -amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s
+; RUN: opt -mtriple=amdgcn--amdhsa -passes=amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s
 
 ; This test check that we have a singe metadata value after linking several
 ; modules for records such as opencl.ocl.version, llvm.ident and similar.
 
 ; ALL-DAG: !opencl.ocl.version = !{![[OCL_VER:[0-9]+]]}
 ; ALL-DAG: !llvm.ident = !{![[LLVM_IDENT_0:[0-9]+]], ![[LLVM_IDENT_1:[0-9]+]]}
 ; ALL-DAG: !opencl.used.extensions = !{![[USED_EXT_0:[0-9]+]], ![[USED_EXT_1:[0-9]+]], ![[USED_EXT_2:[0-9]+]]}
 

llvm/tools/opt/opt.cpp

 };
 
 // For use in NPM transition. Currently this contains most codegen-specific
 // passes. Remove passes from here when porting to the NPM.
 // TODO: use a codegen version of PassRegistry.def/PassBuilder::is*Pass() once
 // it exists.
 static bool shouldPinPassToLegacyPM(StringRef Pass) {
   std::vector<StringRef> PassNameExactToIgnore = {
-      "amdgpu-simplifylib", "amdgpu-usenative", "amdgpu-promote-alloca",
-      "amdgpu-promote-alloca-to-vector", "amdgpu-lower-kernel-attributes"};
+      "amdgpu-simplifylib",
+      "amdgpu-usenative",
+      "amdgpu-promote-alloca",
+      "amdgpu-promote-alloca-to-vector",
+      "amdgpu-lower-kernel-attributes",
+      "amdgpu-unify-metadata"};
   for (const auto &P : PassNameExactToIgnore)
     if (Pass == P)
       return false;
 
   std::vector<StringRef> PassNamePrefix = {
       "x86-",  "xcore-", "wasm-",    "systemz-", "ppc-",   "nvvm-",   "nvptx-",
       "mips-", "lanai-", "hexagon-", "bpf-",     "avr-",   "thumb2-", "arm-",
       "si-",   "gcn-",   "amdgpu-",  "aarch64-", "amdgcn-"};