← Back to branch summary

~ubuntu-branches/ubuntu/quantal/llvm-3.1/quantal

« back to all changes in this revision

Viewing changes to lib/Transforms/IPO/InlineAlways.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-04-01 23:45:03 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120401234503-c04qxrk7s9my53uy
Tags: 3.1~svn153852-1
New snapshot release

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Transforms/IPO/InlineAlways.cpp
32
32
 
33
33
  // AlwaysInliner only inlines functions that are mark as "always inline".
34
34
  class AlwaysInliner : public Inliner {
35
 
    InlineCostAnalyzer CA;
36
35
  public:
37
36
    // Use extremely low threshold.
38
37
    AlwaysInliner() : Inliner(ID, -2000000000, /*InsertLifetime*/true) {
43
42
      initializeAlwaysInlinerPass(*PassRegistry::getPassRegistry());
44
43
    }
45
44
    static char ID; // Pass identification, replacement for typeid
46
 
    InlineCost getInlineCost(CallSite CS) {
47
 
      Function *Callee = CS.getCalledFunction();
48
 
      // We assume indirect calls aren't calling an always-inline function.
49
 
      if (!Callee) return InlineCost::getNever();
50
 
 
51
 
      // We can't inline calls to external functions.
52
 
      // FIXME: We shouldn't even get here.
53
 
      if (Callee->isDeclaration()) return InlineCost::getNever();
54
 
 
55
 
      // Return never for anything not marked as always inline.
56
 
      if (!Callee->hasFnAttr(Attribute::AlwaysInline))
57
 
        return InlineCost::getNever();
58
 
 
59
 
      // We still have to check the inline cost in case there are reasons to
60
 
      // not inline which trump the always-inline attribute such as setjmp and
61
 
      // indirectbr.
62
 
      return CA.getInlineCost(CS);
63
 
    }
64
 
    float getInlineFudgeFactor(CallSite CS) {
65
 
      return CA.getInlineFudgeFactor(CS);
66
 
    }
67
 
    void resetCachedCostInfo(Function *Caller) {
68
 
      CA.resetCachedCostInfo(Caller);
69
 
    }
70
 
    void growCachedCostInfo(Function* Caller, Function* Callee) {
71
 
      CA.growCachedCostInfo(Caller, Callee);
72
 
    }
 
45
    virtual InlineCost getInlineCost(CallSite CS);
73
46
    virtual bool doFinalization(CallGraph &CG) {
74
47
      return removeDeadFunctions(CG, /*AlwaysInlineOnly=*/true);
75
48
    }
76
49
    virtual bool doInitialization(CallGraph &CG);
77
 
    void releaseMemory() {
78
 
      CA.clear();
79
 
    }
80
50
  };
81
51
}
82
52
 
93
63
  return new AlwaysInliner(InsertLifetime);
94
64
}
95
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
 
96
128
// doInitialization - Initializes the vector of functions that have not
97
129
// been annotated with the "always inline" attribute.
98
130
bool AlwaysInliner::doInitialization(CallGraph &CG) {
99
 
  CA.setTargetData(getAnalysisIfAvailable<TargetData>());
100
131
  return false;
101
132
}