================ @@ -0,0 +1,425 @@ +//===-- AMDGPUMachineLevelInliner.cpp - AMDGPU Machine Level Inliner ----===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "AMDGPUMachineLevelInliner.h" +#include "AMDGPU.h" +#include "AMDGPUMachineModuleInfo.h" +#include "AMDGPUSubtarget.h" +#include "SIInstrInfo.h" +#include "SIMachineFunctionInfo.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/CodeGen/MachineFrameInfo.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineInstr.h" +#include "llvm/CodeGen/MachineModuleInfo.h" +#include "llvm/IR/CallingConv.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/LegacyPassManagers.h" +#include "llvm/IR/Module.h" +#include "llvm/IR/PassTimingInfo.h" +#include "llvm/InitializePasses.h" +#include "llvm/Pass.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/TimeProfiler.h" +#include "llvm/Support/raw_ostream.h" + +using namespace llvm; + +#define DEBUG_TYPE "amdgpu-machine-level-inliner" + +namespace { +class AMDGPUInliningPassManager : public FPPassManager { +public: + static char ID; + + explicit AMDGPUInliningPassManager() : FPPassManager(ID) {} + + bool runOnFunction(Function &F) override; + void getAnalysisUsage(AnalysisUsage &AU) const override; + + bool doFinalization(Module &M) override; + + StringRef getPassName() const override { + return "AMDGPU Inlining Pass Manager"; + } +}; + +/// AMDGPUInliningAnchor - A machine function pass that serves as an anchor for +/// setting up the AMDGPU inlining pass manager infrastructure. It makes sure +/// the inliner is run via an AMDGPUInliningPassManager. It can be run well in +/// advance of the inliner as long as there are only FunctionPasses in between. +class AMDGPUInliningAnchor : public MachineFunctionPass { +public: + static char ID; // Pass identification + + AMDGPUInliningAnchor() : MachineFunctionPass(ID) {} + + // We don't really need to process any functions here. + bool runOnMachineFunction(MachineFunction &MF) override { return false; } + + void getAnalysisUsage(AnalysisUsage &AU) const override; + StringRef getPassName() const override; + + /// Prepare the pass manager stack for the inliner. This will push an + /// `AMDGPUInliningPassManager` onto the stack. + void preparePassManager(PMStack &Stack) override; +}; + +} // end anonymous namespace. + +// Pass identification +char AMDGPUMachineLevelInliner::ID = 0; +char AMDGPUInliningPassManager::ID = 0; +char AMDGPUInliningAnchor::ID = 0; + +char &llvm::AMDGPUMachineLevelInlinerID = AMDGPUMachineLevelInliner::ID; +char &llvm::AMDGPUInliningAnchorID = AMDGPUInliningAnchor::ID; + +INITIALIZE_PASS_BEGIN(AMDGPUMachineLevelInliner, DEBUG_TYPE, + "AMDGPU Machine Level Inliner", false, false) +INITIALIZE_PASS_DEPENDENCY(MachineModuleInfoWrapperPass) +INITIALIZE_PASS_DEPENDENCY(AMDGPUInliningAnchor) +INITIALIZE_PASS_END(AMDGPUMachineLevelInliner, DEBUG_TYPE, + "AMDGPU Machine Level Inliner", false, false) + +INITIALIZE_PASS_BEGIN(AMDGPUInliningAnchor, "amdgpu-inlining-anchor", + "AMDGPU Inlining Anchor", false, true) +INITIALIZE_PASS_DEPENDENCY(MachineModuleInfoWrapperPass) +INITIALIZE_PASS_END(AMDGPUInliningAnchor, "amdgpu-inlining-anchor", + "AMDGPU Inlining Anchor", false, true) + +AMDGPUMachineLevelInliner::AMDGPUMachineLevelInliner() + : MachineFunctionPass(ID) { + initializeAMDGPUMachineLevelInlinerPass(*PassRegistry::getPassRegistry()); +} + +void AMDGPUMachineLevelInliner::getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired<MachineModuleInfoWrapperPass>(); + AU.addRequired<AMDGPUInliningAnchor>(); + AU.addPreserved<MachineModuleInfoWrapperPass>(); + MachineFunctionPass::getAnalysisUsage(AU); +} + +bool AMDGPUMachineLevelInliner::runOnMachineFunction(MachineFunction &MF) { + MachineModuleInfo &MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI(); + + Function &F = MF.getFunction(); + if (shouldInlineCallsTo(F)) { + // Mark the function as machine-inlined in AMDGPUMachineModuleInfo. This + // tells the inlining pass manager to stop processing it. + auto &AMMMI = MMI.getObjFileInfo<AMDGPUMachineModuleInfo>(); + AMMMI.addMachineInlinedFunction(F); + + return false; + } + + bool Changed = false; + + // Can't inline anything if there aren't any calls. + MachineFrameInfo &MFI = MF.getFrameInfo(); + if (!MFI.hasCalls() && !MFI.hasTailCall()) + return false; + + // Collect calls to inline. + SmallVector<MachineInstr *, 4> CallsToInline; + const SIInstrInfo *TII = MF.getSubtarget<GCNSubtarget>().getInstrInfo(); + + for (auto &MBB : MF) { + for (auto &MI : MBB) { + if (!MI.isCall()) + continue; + + const MachineOperand *CalleeOp = + TII->getNamedOperand(MI, AMDGPU::OpName::callee); + if (CalleeOp && CalleeOp->isGlobal()) { + if (auto *CalledFunc = dyn_cast<Function>(CalleeOp->getGlobal())) { + // Partial inlining is not supported yet, because the inlining pass + // manager does not run the rest of the pass pipeline on functions + // that get inlined (including outputting code for them). + if (CalledFunc == &F) + report_fatal_error("Recursive calls in whole wave functions are " + "not supported yet"); + + if (shouldInlineCallsTo(*CalledFunc)) { + CallsToInline.push_back(&MI); + } + } ---------------- shiltian wrote:
early exist https://github.com/llvm/llvm-project/pull/169476 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
