Home | History | Annotate | Download | only in IPO 
      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.hasFnAttr(Attribute::ReturnsTwice);
     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->hasFnAttr(Attribute::AlwaysInline))
    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 }
    133