LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU - AMDGPUAlwaysInlinePass.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 28 42 66.7 %
Date: 2018-10-16 05:50:02 Functions: 5 6 83.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AMDGPUAlwaysInlinePass.cpp - Promote Allocas ----------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : /// \file
      11             : /// This pass marks all internal functions as always_inline and creates
      12             : /// duplicates of all other functions and marks the duplicates as always_inline.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #include "AMDGPU.h"
      17             : #include "AMDGPUTargetMachine.h"
      18             : #include "Utils/AMDGPUBaseInfo.h"
      19             : #include "llvm/ADT/SmallPtrSet.h"
      20             : #include "llvm/IR/Module.h"
      21             : #include "llvm/Transforms/Utils/Cloning.h"
      22             : 
      23             : using namespace llvm;
      24             : 
      25             : namespace {
      26             : 
      27             : static cl::opt<bool> StressCalls(
      28             :   "amdgpu-stress-function-calls",
      29             :   cl::Hidden,
      30             :   cl::desc("Force all functions to be noinline"),
      31             :   cl::init(false));
      32             : 
      33             : class AMDGPUAlwaysInline : public ModulePass {
      34             :   bool GlobalOpt;
      35             : 
      36             :   void recursivelyVisitUsers(GlobalValue &GV,
      37             :                              SmallPtrSetImpl<Function *> &FuncsToAlwaysInline);
      38             : public:
      39             :   static char ID;
      40             : 
      41        2214 :   AMDGPUAlwaysInline(bool GlobalOpt = false) :
      42        2214 :     ModulePass(ID), GlobalOpt(GlobalOpt) { }
      43             :   bool runOnModule(Module &M) override;
      44             : 
      45        2197 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
      46             :     AU.setPreservesAll();
      47        2197 :  }
      48             : };
      49             : 
      50             : } // End anonymous namespace
      51             : 
      52      197401 : INITIALIZE_PASS(AMDGPUAlwaysInline, "amdgpu-always-inline",
      53             :                 "AMDGPU Inline All Functions", false, false)
      54             : 
      55             : char AMDGPUAlwaysInline::ID = 0;
      56             : 
      57           0 : void AMDGPUAlwaysInline::recursivelyVisitUsers(
      58             :   GlobalValue &GV,
      59             :   SmallPtrSetImpl<Function *> &FuncsToAlwaysInline) {
      60             :   SmallVector<User *, 16> Stack;
      61             : 
      62             :   SmallPtrSet<const Value *, 8> Visited;
      63             : 
      64           0 :   for (User *U : GV.users())
      65           0 :     Stack.push_back(U);
      66             : 
      67           0 :   while (!Stack.empty()) {
      68             :     User *U = Stack.pop_back_val();
      69           0 :     if (!Visited.insert(U).second)
      70           0 :       continue;
      71             : 
      72             :     if (Instruction *I = dyn_cast<Instruction>(U)) {
      73           0 :       Function *F = I->getParent()->getParent();
      74           0 :       if (!AMDGPU::isEntryFunctionCC(F->getCallingConv())) {
      75           0 :         FuncsToAlwaysInline.insert(F);
      76           0 :         Stack.push_back(F);
      77             :       }
      78             : 
      79             :       // No need to look at further users, but we do need to inline any callers.
      80           0 :       continue;
      81             :     }
      82             : 
      83           0 :     for (User *UU : U->users())
      84           0 :       Stack.push_back(UU);
      85             :   }
      86           0 : }
      87             : 
      88        2196 : bool AMDGPUAlwaysInline::runOnModule(Module &M) {
      89             :   std::vector<GlobalAlias*> AliasesToRemove;
      90             : 
      91             :   SmallPtrSet<Function *, 8> FuncsToAlwaysInline;
      92             :   SmallPtrSet<Function *, 8> FuncsToNoInline;
      93             : 
      94        2205 :   for (GlobalAlias &A : M.aliases()) {
      95             :     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
      96           7 :       A.replaceAllUsesWith(F);
      97           7 :       AliasesToRemove.push_back(&A);
      98             :     }
      99             : 
     100             :     // FIXME: If the aliasee isn't a function, it's some kind of constant expr
     101             :     // cast that won't be inlined through.
     102             :   }
     103             : 
     104        2196 :   if (GlobalOpt) {
     105        2198 :     for (GlobalAlias* A : AliasesToRemove) {
     106           6 :       A->eraseFromParent();
     107             :     }
     108             :   }
     109             : 
     110             :   // Always force inlining of any function that uses an LDS global address. This
     111             :   // is something of a workaround because we don't have a way of supporting LDS
     112             :   // objects defined in functions. LDS is always allocated by a kernel, and it
     113             :   // is difficult to manage LDS usage if a function may be used by multiple
     114             :   // kernels.
     115             :   //
     116             :   // OpenCL doesn't allow declaring LDS in non-kernels, so in practice this
     117             :   // should only appear when IPO passes manages to move LDs defined in a kernel
     118             :   // into a single user function.
     119             : 
     120        2507 :   for (GlobalVariable &GV : M.globals()) {
     121             :     // TODO: Region address
     122             :     unsigned AS = GV.getType()->getAddressSpace();
     123         311 :     if (AS != AMDGPUAS::LOCAL_ADDRESS && AS != AMDGPUAS::REGION_ADDRESS)
     124             :       continue;
     125             : 
     126         173 :     recursivelyVisitUsers(GV, FuncsToAlwaysInline);
     127             :   }
     128             : 
     129        2196 :   if (!AMDGPUTargetMachine::EnableFunctionCalls || StressCalls) {
     130             :     auto IncompatAttr
     131        2195 :       = StressCalls ? Attribute::AlwaysInline : Attribute::NoInline;
     132             : 
     133       28129 :     for (Function &F : M) {
     134       26117 :       if (!F.isDeclaration() && !F.use_empty() &&
     135             :           !F.hasFnAttribute(IncompatAttr)) {
     136          53 :         if (StressCalls) {
     137           6 :           if (!FuncsToAlwaysInline.count(&F))
     138           2 :             FuncsToNoInline.insert(&F);
     139             :         } else
     140          47 :           FuncsToAlwaysInline.insert(&F);
     141             :       }
     142             :     }
     143             :   }
     144             : 
     145        2266 :   for (Function *F : FuncsToAlwaysInline)
     146             :     F->addFnAttr(Attribute::AlwaysInline);
     147             : 
     148        2198 :   for (Function *F : FuncsToNoInline)
     149             :     F->addFnAttr(Attribute::NoInline);
     150             : 
     151        2196 :   return !FuncsToAlwaysInline.empty() || !FuncsToNoInline.empty();
     152             : }
     153             : 
     154        2211 : ModulePass *llvm::createAMDGPUAlwaysInlinePass(bool GlobalOpt) {
     155        2211 :   return new AMDGPUAlwaysInline(GlobalOpt);
     156             : }
     157             : 

Generated by: LCOV version 1.13