lib/Transforms/IPO/InlineAlways.cpp

   1 //===- InlineAlways.cpp - Code to inline always_inline functions ----------===//
   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 // This file implements a custom inliner that handles only functions that
  11 // are marked as "always inline".
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "inline"
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/Instructions.h"
  18 #include "llvm/IntrinsicInst.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Type.h"
  21 #include "llvm/Analysis/CallGraph.h"
  22 #include "llvm/Analysis/InlineCost.h"
  23 #include "llvm/Support/CallSite.h"
  24 #include "llvm/Transforms/IPO.h"
  25 #include "llvm/Transforms/IPO/InlinerPass.h"
  26 #include "llvm/Target/TargetData.h"
  27 #include "llvm/ADT/SmallPtrSet.h"
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33   // AlwaysInliner only inlines functions that are mark as "always inline".
  34   class AlwaysInliner : public Inliner {
  35   public:
  36     // Use extremely low threshold.
  37     AlwaysInliner() : Inliner(ID, -2000000000, /*InsertLifetime*/true) {
  38       initializeAlwaysInlinerPass(*PassRegistry::getPassRegistry());
  39     }
  40     AlwaysInliner(bool InsertLifetime) : Inliner(ID, -2000000000,
  41                                                  InsertLifetime) {
  42       initializeAlwaysInlinerPass(*PassRegistry::getPassRegistry());
  43     }
  44     static char ID; // Pass identification, replacement for typeid
  45     virtual InlineCost getInlineCost(CallSite CS);
  46     virtual bool doFinalization(CallGraph &CG) {
  47       return removeDeadFunctions(CG, /*AlwaysInlineOnly=*/true);
  48     }
  49     virtual bool doInitialization(CallGraph &CG);
  50   };
  51 }
  52
  53 char AlwaysInliner::ID = 0;
  54 INITIALIZE_PASS_BEGIN(AlwaysInliner, "always-inline",
  55                 "Inliner for always_inline functions", false, false)
  56 INITIALIZE_AG_DEPENDENCY(CallGraph)
  57 INITIALIZE_PASS_END(AlwaysInliner, "always-inline",
  58                 "Inliner for always_inline functions", false, false)
  59
  60 Pass *llvm::createAlwaysInlinerPass() { return new AlwaysInliner(); }
  61
  62 Pass *llvm::createAlwaysInlinerPass(bool InsertLifetime) {
  63   return new AlwaysInliner(InsertLifetime);
  64 }
  65
  66 /// \brief Minimal filter to detect invalid constructs for inlining.
  67 static bool isInlineViable(Function &F) {
  68   bool ReturnsTwice = F.getFnAttributes().hasReturnsTwiceAttr();
  69   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
  70     // Disallow inlining of functions which contain an indirect branch.
  71     if (isa<IndirectBrInst>(BI->getTerminator()))
  72       return false;
  73
  74     for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
  75          ++II) {
  76       CallSite CS(II);
  77       if (!CS)
  78         continue;
  79
  80       // Disallow recursive calls.
  81       if (&F == CS.getCalledFunction())
  82         return false;
  83
  84       // Disallow calls which expose returns-twice to a function not previously
  85       // attributed as such.
  86       if (!ReturnsTwice && CS.isCall() &&
  87           cast<CallInst>(CS.getInstruction())->canReturnTwice())
  88         return false;
  89     }
  90   }
  91
  92   return true;
  93 }
  94
  95 /// \brief Get the inline cost for the always-inliner.
  96 ///
  97 /// The always inliner *only* handles functions which are marked with the
  98 /// attribute to force inlining. As such, it is dramatically simpler and avoids
  99 /// using the powerful (but expensive) inline cost analysis. Instead it uses
 100 /// a very simple and boring direct walk of the instructions looking for
 101 /// impossible-to-inline constructs.
 102 ///
 103 /// Note, it would be possible to go to some lengths to cache the information
 104 /// computed here, but as we only expect to do this for relatively few and
 105 /// small functions which have the explicit attribute to force inlining, it is
 106 /// likely not worth it in practice.
 107 InlineCost AlwaysInliner::getInlineCost(CallSite CS) {
 108   Function *Callee = CS.getCalledFunction();
 109   // We assume indirect calls aren't calling an always-inline function.
 110   if (!Callee) return InlineCost::getNever();
 111
 112   // We can't inline calls to external functions.
 113   // FIXME: We shouldn't even get here.
 114   if (Callee->isDeclaration()) return InlineCost::getNever();
 115
 116   // Return never for anything not marked as always inline.
 117   if (!Callee->getFnAttributes().hasAlwaysInlineAttr())
 118     return InlineCost::getNever();
 119
 120   // Do some minimal analysis to preclude non-viable functions.
 121   if (!isInlineViable(*Callee))
 122     return InlineCost::getNever();
 123
 124   // Otherwise, force inlining.
 125   return InlineCost::getAlways();
 126 }
 127
 128 // doInitialization - Initializes the vector of functions that have not
 129 // been annotated with the "always inline" attribute.
 130 bool AlwaysInliner::doInitialization(CallGraph &CG) {
 131   return false;
 132 }