[AMDGPU] Turn AMDGPUUnifyMetadata back into module pass

[rampitec]

Summary

With the adjustPassManager interface that is now possible to use custom early module passes.

[vpykhtin]

LGTM, but what it is for ? :-)

llvm/trunk/lib/Target/AMDGPU/AMDGPU.h

 
 Pass *createAMDGPUStructurizeCFGPass();
 FunctionPass *createAMDGPUISelDag(TargetMachine &TM,
                                   CodeGenOpt::Level OptLevel);
 ModulePass *createAMDGPUAlwaysInlinePass();
 ModulePass *createAMDGPUOpenCLImageTypeLoweringPass();
 FunctionPass *createAMDGPUAnnotateUniformValues();
 
-FunctionPass* createAMDGPUUnifyMetadataPass();
+ModulePass* createAMDGPUUnifyMetadataPass();
 void initializeAMDGPUUnifyMetadataPass(PassRegistry&);
 extern char &AMDGPUUnifyMetadataID;
 
 void initializeSIFixControlFlowLiveIntervalsPass(PassRegistry&);
 extern char &SIFixControlFlowLiveIntervalsID;
 
 void initializeAMDGPUAnnotateUniformValuesPass(PassRegistry&);
 extern char &AMDGPUAnnotateUniformValuesPassID;

llvm/trunk/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

StringRef AMDGPUTargetMachine::getFeatureString(const Function &F) const {
 
   return FSAttr.hasAttribute(Attribute::None) ?
     getTargetFeatureString() :
     FSAttr.getValueAsString();
 }
 
 void AMDGPUTargetMachine::adjustPassManager(PassManagerBuilder &Builder) {
   Builder.addExtension(
-    PassManagerBuilder::EP_EarlyAsPossible,
+    PassManagerBuilder::EP_ModuleOptimizerEarly,
     [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
       PM.add(createAMDGPUUnifyMetadataPass());
     });
 }
 
 //===----------------------------------------------------------------------===//
 // R600 Target Machine (R600 -> Cayman)
 //===----------------------------------------------------------------------===//

llvm/trunk/lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp

namespace kOCLMD {
     const char UsedExt[]            = "opencl.used.extensions";
     const char UsedOptCoreFeat[]    = "opencl.used.optional.core.features";
     const char CompilerOptions[]    = "opencl.compiler.options";
     const char LLVMIdent[]          = "llvm.ident";
 
   } // end namespace kOCLMD
 
   /// \brief Unify multiple OpenCL metadata due to linking.
-  class AMDGPUUnifyMetadata : public FunctionPass {
+  class AMDGPUUnifyMetadata : public ModulePass {
   public:
     static char ID;
-
-    explicit AMDGPUUnifyMetadata() : FunctionPass(ID) {}
+    explicit AMDGPUUnifyMetadata() : ModulePass(ID) {};
 
   private:
-    // This should really be a module pass but we have to run it as early
-    // as possible, so given function passes are executed first and
-    // TargetMachine::addEarlyAsPossiblePasses() expects only function passes
-    // it has to be a function pass.
     virtual bool runOnModule(Module &M);
 
-    // \todo: Convert to a module pass.
-    bool runOnFunction(Function &F) override;
-
     /// \brief 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}
     /// Keep the largest version as the sole operand if PickFirst is false.

 char AMDGPUUnifyMetadata::ID = 0;
 
 char &llvm::AMDGPUUnifyMetadataID = AMDGPUUnifyMetadata::ID;
 
 INITIALIZE_PASS(AMDGPUUnifyMetadata, "amdgpu-unify-metadata",
                 "Unify multiple OpenCL metadata due to linking",
                 false, false)
 
-FunctionPass* llvm::createAMDGPUUnifyMetadataPass() {
+ModulePass* llvm::createAMDGPUUnifyMetadataPass() {
   return new AMDGPUUnifyMetadata();
 }
 
 bool AMDGPUUnifyMetadata::runOnModule(Module &M) {
   const char* Vers[] = {
       kOCLMD::SpirVer,
       kOCLMD::OCLVer
   };
bool AMDGPUUnifyMetadata::runOnModule(Module &M) {
   for (auto &I : Vers)
     Changed |= unifyVersionMD(M, I, true);
 
   for (auto &I : Exts)
     Changed |= unifyExtensionMD(M, I);
 
   return Changed;
 }
-
-bool AMDGPUUnifyMetadata::runOnFunction(Function &F) {
-  return runOnModule(*F.getParent());
-}

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

 ; RUN: opt -mtriple=amdgcn--amdhsa -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]+]]}
 
 ; ALL-DAG: ![[OCL_VER]] = !{i32 1, i32 2}
 ; ALL-DAG: ![[LLVM_IDENT_0]] = !{!"clang version 4.0"}
 ; ALL-DAG: ![[LLVM_IDENT_1]] = !{!"clang version 4.0 (rLXXXXXX)"}
 ; ALL-DAG: ![[USED_EXT_0]] = !{!"cl_images"}
 ; ALL-DAG: ![[USED_EXT_1]] = !{!"cl_khr_fp16"}
 ; ALL-DAG: ![[USED_EXT_2]] = !{!"cl_doubles"}
 
-define void @test() {
-   ret void
-}
-
 !opencl.ocl.version = !{!1, !0, !0, !0}
 !llvm.ident = !{!2, !2, !2, !2, !6}
 !opencl.used.extensions = !{!3, !3, !4, !5}
 
 !0 = !{i32 2, i32 0}
 !1 = !{i32 1, i32 2}
 !2 = !{!"clang version 4.0"}
 !3 = !{!"cl_images", !"cl_khr_fp16"}
 !4 = !{!"cl_images", !"cl_doubles"}
 !5 = !{}
 !6 = !{!"clang version 4.0 (rLXXXXXX)"}