//===- AMDGPURewriteOutArgumentsPass.cpp - Create struct returns ----------===// // // 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 attempts to replace out argument usage with a return of a /// struct. /// /// We can support returning a lot of values directly in registers, but /// idiomatic C code frequently uses a pointer argument to return a second value /// rather than returning a struct by value. GPU stack access is also quite /// painful, so we want to avoid that if possible. Passing a stack object /// pointer to a function also requires an additional address expansion code /// sequence to convert the pointer to be relative to the kernel's scratch wave /// offset register since the callee doesn't know what stack frame the incoming /// pointer is relative to. /// /// The goal is to try rewriting code that looks like this: /// /// int foo(int a, int b, int* out) { /// *out = bar(); /// return a + b; /// } /// /// into something like this: /// /// std::pair<int, int> foo(int a, int b) { /// return std::pair(a + b, bar()); /// } /// /// Typically the incoming pointer is a simple alloca for a temporary variable /// to use the API, which if replaced with a struct return will be easily SROA'd /// out when the stub function we create is inlined /// /// This pass introduces the struct return, but leaves the unused pointer /// arguments and introduces a new stub function calling the struct returning /// body. DeadArgumentElimination should be run after this to clean these up. // //===----------------------------------------------------------------------===// #include "AMDGPU.h" #include "Utils/AMDGPUBaseInfo.h" #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/MemoryDependenceAnalysis.h" #include "llvm/IR/AttributeMask.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Instructions.h" #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" #define DEBUG_TYPE … usingnamespacellvm; static cl::opt<bool> AnyAddressSpace( "amdgpu-any-address-space-out-arguments", cl::desc("Replace pointer out arguments with " "struct returns for non-private address space"), cl::Hidden, cl::init(false)); static cl::opt<unsigned> MaxNumRetRegs( "amdgpu-max-return-arg-num-regs", cl::desc("Approximately limit number of return registers for replacing out arguments"), cl::Hidden, cl::init(16)); STATISTIC(NumOutArgumentsReplaced, "Number out arguments moved to struct return values"); STATISTIC(NumOutArgumentFunctionsReplaced, "Number of functions with out arguments moved to struct return values"); namespace { class AMDGPURewriteOutArguments : public FunctionPass { … }; } // end anonymous namespace INITIALIZE_PASS_BEGIN(AMDGPURewriteOutArguments, DEBUG_TYPE, "AMDGPU Rewrite Out Arguments", false, false) INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass) INITIALIZE_PASS_END(AMDGPURewriteOutArguments, DEBUG_TYPE, "AMDGPU Rewrite Out Arguments", false, false) char AMDGPURewriteOutArguments::ID = …; Type *AMDGPURewriteOutArguments::getStoredType(Value &Arg) const { … } Type *AMDGPURewriteOutArguments::getOutArgumentType(Argument &Arg) const { … } bool AMDGPURewriteOutArguments::doInitialization(Module &M) { … } bool AMDGPURewriteOutArguments::runOnFunction(Function &F) { … } FunctionPass *llvm::createAMDGPURewriteOutArgumentsPass() { … }