AMDGPU: Port AMDGPUCtorDtorLowering to new PM

[arsenm]

f23f26032d136cce25a3711afb92203dbe6fdeba

llvm/lib/Target/AMDGPU/AMDGPU.h

 FunctionPass *createAMDGPUAtomicOptimizerPass();
 void initializeAMDGPUAtomicOptimizerPass(PassRegistry &);
 extern char &AMDGPUAtomicOptimizerID;
 
 ModulePass *createAMDGPULowerIntrinsicsPass();
 void initializeAMDGPULowerIntrinsicsPass(PassRegistry &);
 extern char &AMDGPULowerIntrinsicsID;
 
-ModulePass *createAMDGPUCtorDtorLoweringPass();
-void initializeAMDGPUCtorDtorLoweringPass(PassRegistry &);
-extern char &AMDGPUCtorDtorLoweringID;
+ModulePass *createAMDGPUCtorDtorLoweringLegacyPass();
+void initializeAMDGPUCtorDtorLoweringLegacyPass(PassRegistry &);
+extern char &AMDGPUCtorDtorLoweringLegacyPassID;
 
 FunctionPass *createAMDGPULowerKernelArgumentsPass();
 void initializeAMDGPULowerKernelArgumentsPass(PassRegistry &);
 extern char &AMDGPULowerKernelArgumentsID;
 
 FunctionPass *createAMDGPUPromoteKernelArgumentsPass();
 void initializeAMDGPUPromoteKernelArgumentsPass(PassRegistry &);
 extern char &AMDGPUPromoteKernelArgumentsID;

llvm/lib/Target/AMDGPU/AMDGPUCtorDtorLowering.h

+//===-- AMDGPUCtorDtorLowering.h --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUCTORDTORLOWERING_H
+#define LLVM_LIB_TARGET_AMDGPU_AMDGPUCTORDTORLOWERING_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class Module;
+
+/// Lower llvm.global_ctors and llvm.global_dtors to special kernels.
+class AMDGPUCtorDtorLoweringPass
+    : public PassInfoMixin<AMDGPUCtorDtorLoweringPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUCTORDTORLOWERING_H

llvm/lib/Target/AMDGPU/AMDGPUCtorDtorLowering.cpp

 //===-- AMDGPUCtorDtorLowering.cpp - Handle global ctors and dtors --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This pass creates a unified init and fini kernel with the required metadata
 //===----------------------------------------------------------------------===//
 
+#include "AMDGPUCtorDtorLowering.h"
 #include "AMDGPU.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "amdgpu-lower-ctor-dtor"
 
 namespace {
-class AMDGPUCtorDtorLowering final : public ModulePass {
-  bool runOnModule(Module &M) override;
 
-public:
-  Function *createInitOrFiniKernelFunction(Module &M, bool IsCtor) {
-    StringRef InitOrFiniKernelName = "amdgcn.device.init";
-    if (!IsCtor)
-      InitOrFiniKernelName = "amdgcn.device.fini";
+static Function *createInitOrFiniKernelFunction(Module &M, bool IsCtor) {
 
-    Function *InitOrFiniKernel = Function::createWithDefaultAttr(
-        FunctionType::get(Type::getVoidTy(M.getContext()), false),
-        GlobalValue::ExternalLinkage, 0, InitOrFiniKernelName, &M);
-    BasicBlock *InitOrFiniKernelBB =
-        BasicBlock::Create(M.getContext(), "", InitOrFiniKernel);
-    ReturnInst::Create(M.getContext(), InitOrFiniKernelBB);
 
-    InitOrFiniKernel->setCallingConv(CallingConv::AMDGPU_KERNEL);
-    if (IsCtor)
-      InitOrFiniKernel->addFnAttr("device-init");
-    else
-      InitOrFiniKernel->addFnAttr("device-fini");
-    return InitOrFiniKernel;
-  }
 
-  bool createInitOrFiniKernel(Module &M, StringRef GlobalName, bool IsCtor) {
-    GlobalVariable *GV = M.getGlobalVariable(GlobalName);
-    if (!GV || !GV->hasInitializer())
-      return false;
-    ConstantArray *GA = dyn_cast<ConstantArray>(GV->getInitializer());
-    if (!GA || GA->getNumOperands() == 0)
-      return false;
+static bool createInitOrFiniKernel(Module &M, StringRef GlobalName,
+                                   bool IsCtor) {
 
-    Function *InitOrFiniKernel = createInitOrFiniKernelFunction(M, IsCtor);
-    IRBuilder<> IRB(InitOrFiniKernel->getEntryBlock().getTerminator());
 
-    FunctionType *ConstructorTy = InitOrFiniKernel->getFunctionType();
 
-    for (Value *V : GA->operands()) {
-      auto *CS = cast<ConstantStruct>(V);
-      IRB.CreateCall(ConstructorTy, CS->getOperand(1));
-    }
 
-    appendToUsed(M, {InitOrFiniKernel});
-    return true;
-  }
 
+static bool lowerCtorsAndDtors(Module &M) {
+  bool Modified = false;
+  Modified |= createInitOrFiniKernel(M, "llvm.global_ctors", /*IsCtor =*/true);
+  Modified |= createInitOrFiniKernel(M, "llvm.global_dtors", /*IsCtor =*/false);
+  return Modified;
+}
+
+class AMDGPUCtorDtorLoweringLegacy final : public ModulePass {
+public:
   static char ID;
-  AMDGPUCtorDtorLowering() : ModulePass(ID) {}
+  AMDGPUCtorDtorLoweringLegacy() : ModulePass(ID) {}
+  bool runOnModule(Module &M) override {
+    return lowerCtorsAndDtors(M);
+  }
 };
-} // End anonymous namespace
 
-char AMDGPUCtorDtorLowering::ID = 0;
-char &llvm::AMDGPUCtorDtorLoweringID = AMDGPUCtorDtorLowering::ID;
-INITIALIZE_PASS(AMDGPUCtorDtorLowering, DEBUG_TYPE,
-                "Lower ctors and dtors for AMDGPU", false, false)
+} // End anonymous namespace
 
-ModulePass *llvm::createAMDGPUCtorDtorLoweringPass() {
-  return new AMDGPUCtorDtorLowering();
+PreservedAnalyses AMDGPUCtorDtorLoweringPass::run(Module &M,
+                                                  ModuleAnalysisManager &AM) {
+  lowerCtorsAndDtors(M);
+  return PreservedAnalyses::all();
 }
 
-bool AMDGPUCtorDtorLowering::runOnModule(Module &M) {
-  bool Modified = false;
-  Modified |= createInitOrFiniKernel(M, "llvm.global_ctors", /*IsCtor =*/true);
-  Modified |= createInitOrFiniKernel(M, "llvm.global_dtors", /*IsCtor =*/false);
-  return Modified;
+char AMDGPUCtorDtorLoweringLegacy::ID = 0;
+char &llvm::AMDGPUCtorDtorLoweringLegacyPassID =
+    AMDGPUCtorDtorLoweringLegacy::ID;
+INITIALIZE_PASS(AMDGPUCtorDtorLoweringLegacy, DEBUG_TYPE,
+                "Lower ctors and dtors for AMDGPU", false, false)
+
+ModulePass *llvm::createAMDGPUCtorDtorLoweringLegacyPass() {
+  return new AMDGPUCtorDtorLoweringLegacy();
 }

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

 /// The AMDGPU target machine contains all of the hardware specific
 /// information  needed to emit code for SI+ GPUs.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPUTargetMachine.h"
 #include "AMDGPU.h"
 #include "AMDGPUAliasAnalysis.h"
+#include "AMDGPUCtorDtorLowering.h"
 #include "AMDGPUExportClustering.h"
 #include "AMDGPUIGroupLP.h"
 #include "AMDGPUMacroFusion.h"
 #include "AMDGPUTargetObjectFile.h"
 #include "AMDGPUTargetTransformInfo.h"
 #include "GCNIterativeScheduler.h"
 #include "GCNSchedStrategy.h"
 #include "GCNVOPDUtils.h"
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUTarget() {
   initializeSIFixSGPRCopiesPass(*PR);
   initializeSIFixVGPRCopiesPass(*PR);
   initializeSIFoldOperandsPass(*PR);
   initializeSIPeepholeSDWAPass(*PR);
   initializeSIShrinkInstructionsPass(*PR);
   initializeSIOptimizeExecMaskingPreRAPass(*PR);
   initializeSIOptimizeVGPRLiveRangePass(*PR);
   initializeSILoadStoreOptimizerPass(*PR);
-  initializeAMDGPUCtorDtorLoweringPass(*PR);
+  initializeAMDGPUCtorDtorLoweringLegacyPass(*PR);
   initializeAMDGPUAlwaysInlinePass(*PR);
   initializeAMDGPUAttributorPass(*PR);
   initializeAMDGPUAnnotateKernelFeaturesPass(*PR);
   initializeAMDGPUAnnotateUniformValuesPass(*PR);
   initializeAMDGPUArgumentUsageInfoPass(*PR);
   initializeAMDGPUAtomicOptimizerPass(*PR);
   initializeAMDGPULowerKernelArgumentsPass(*PR);
   initializeAMDGPUPromoteKernelArgumentsPass(*PR);
PB.registerPipelineParsingCallback(
         if (PassName == "amdgpu-replace-lds-use-with-pointer") {
           PM.addPass(AMDGPUReplaceLDSUseWithPointerPass());
           return true;
         }
         if (PassName == "amdgpu-lower-module-lds") {
           PM.addPass(AMDGPULowerModuleLDSPass());
           return true;
         }
+        if (PassName == "amdgpu-lower-ctor-dtor") {
+          PM.addPass(AMDGPUCtorDtorLoweringPass());
+          return true;
+        }
         return false;
       });
   PB.registerPipelineParsingCallback(
       [this](StringRef PassName, FunctionPassManager &PM,
              ArrayRef<PassBuilder::PipelineElement>) {
         if (PassName == "amdgpu-simplifylib") {
           PM.addPass(AMDGPUSimplifyLibCallsPass(*this));
           return true;
void AMDGPUPassConfig::addIRPasses() {
   const AMDGPUTargetMachine &TM = getAMDGPUTargetMachine();
 
   // There is no reason to run these.
   disablePass(&StackMapLivenessID);
   disablePass(&FuncletLayoutID);
   disablePass(&PatchableFunctionID);
 
   addPass(createAMDGPUPrintfRuntimeBinding());
-  addPass(createAMDGPUCtorDtorLoweringPass());
+  addPass(createAMDGPUCtorDtorLoweringLegacyPass());
 
   // A call to propagate attributes pass in the backend in case opt was not run.
   addPass(createAMDGPUPropagateAttributesEarlyPass(&TM));
 
   addPass(createAMDGPULowerIntrinsicsPass());
 
   // Function calls are not supported, so make sure we inline everything.
   addPass(createAMDGPUAlwaysInlinePass());

llvm/test/CodeGen/AMDGPU/lower-ctor-dtor.ll

 ; RUN: opt -S -mtriple=amdgcn--  -amdgpu-lower-ctor-dtor < %s | FileCheck %s
+; RUN: opt -S -mtriple=amdgcn--  -passes=amdgpu-lower-ctor-dtor < %s | FileCheck %s
 ; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx700 -filetype=obj -o - < %s | llvm-readelf -s - 2>&1 | FileCheck %s -check-prefix=CHECK-VIS
 
 @llvm.global_ctors = appending addrspace(1) global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 1, void ()* @foo, i8* null }]
 @llvm.global_dtors = appending addrspace(1) global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 1, void ()* @bar, i8* null }]
 
 ; CHECK-LABEL: amdgpu_kernel void @amdgcn.device.init() #0
 ; CHECK-NEXT: call void @foo
 
define internal void @foo() {
   ret void
 }
 
 define internal void @bar() {
   ret void
 }
 
 ; CHECK: attributes #0 = { "device-init" }
-; CHECK: attributes #1 = { "device-fini" } 
+; CHECK: attributes #1 = { "device-fini" }