Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Transforms/IPO/Inliner.h
Line
Count
Source
1
//===- Inliner.h - Inliner pass and infrastructure --------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLVM_TRANSFORMS_IPO_INLINER_H
10
#define LLVM_TRANSFORMS_IPO_INLINER_H
11
12
#include "llvm/Analysis/CGSCCPassManager.h"
13
#include "llvm/Analysis/CallGraphSCCPass.h"
14
#include "llvm/Analysis/InlineCost.h"
15
#include "llvm/Analysis/LazyCallGraph.h"
16
#include "llvm/IR/CallSite.h"
17
#include "llvm/IR/PassManager.h"
18
#include "llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h"
19
#include <utility>
20
21
namespace llvm {
22
23
class AssumptionCacheTracker;
24
class CallGraph;
25
class ProfileSummaryInfo;
26
27
/// This class contains all of the helper code which is used to perform the
28
/// inlining operations that do not depend on the policy. It contains the core
29
/// bottom-up inlining infrastructure that specific inliner passes use.
30
struct LegacyInlinerBase : public CallGraphSCCPass {
31
  explicit LegacyInlinerBase(char &ID);
32
  explicit LegacyInlinerBase(char &ID, bool InsertLifetime);
33
34
  /// For this class, we declare that we require and preserve the call graph.
35
  /// If the derived class implements this method, it should always explicitly
36
  /// call the implementation here.
37
  void getAnalysisUsage(AnalysisUsage &Info) const override;
38
39
  bool doInitialization(CallGraph &CG) override;
40
41
  /// Main run interface method, this implements the interface required by the
42
  /// Pass class.
43
  bool runOnSCC(CallGraphSCC &SCC) override;
44
45
  using llvm::Pass::doFinalization;
46
47
  /// Remove now-dead linkonce functions at the end of processing to avoid
48
  /// breaking the SCC traversal.
49
  bool doFinalization(CallGraph &CG) override;
50
51
  /// This method must be implemented by the subclass to determine the cost of
52
  /// inlining the specified call site.  If the cost returned is greater than
53
  /// the current inline threshold, the call site is not inlined.
54
  virtual InlineCost getInlineCost(CallSite CS) = 0;
55
56
  /// Remove dead functions.
57
  ///
58
  /// This also includes a hack in the form of the 'AlwaysInlineOnly' flag
59
  /// which restricts it to deleting functions with an 'AlwaysInline'
60
  /// attribute. This is useful for the InlineAlways pass that only wants to
61
  /// deal with that subset of the functions.
62
  bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly = false);
63
64
  /// This function performs the main work of the pass.  The default of
65
  /// Inlinter::runOnSCC() calls skipSCC() before calling this method, but
66
  /// derived classes which cannot be skipped can override that method and call
67
  /// this function unconditionally.
68
  bool inlineCalls(CallGraphSCC &SCC);
69
70
private:
71
  // Insert @llvm.lifetime intrinsics.
72
  bool InsertLifetime = true;
73
74
protected:
75
  AssumptionCacheTracker *ACT;
76
  ProfileSummaryInfo *PSI;
77
  ImportedFunctionsInliningStatistics ImportedFunctionsStats;
78
};
79
80
/// The inliner pass for the new pass manager.
81
///
82
/// This pass wires together the inlining utilities and the inline cost
83
/// analysis into a CGSCC pass. It considers every call in every function in
84
/// the SCC and tries to inline if profitable. It can be tuned with a number of
85
/// parameters to control what cost model is used and what tradeoffs are made
86
/// when making the decision.
87
///
88
/// It should be noted that the legacy inliners do considerably more than this
89
/// inliner pass does. They provide logic for manually merging allocas, and
90
/// doing considerable DCE including the DCE of dead functions. This pass makes
91
/// every attempt to be simpler. DCE of functions requires complex reasoning
92
/// about comdat groups, etc. Instead, it is expected that other more focused
93
/// passes be composed to achieve the same end result.
94
class InlinerPass : public PassInfoMixin<InlinerPass> {
95
public:
96
  InlinerPass(InlineParams Params = getInlineParams())
97
316
      : Params(std::move(Params)) {}
98
  ~InlinerPass();
99
  InlinerPass(InlinerPass &&Arg)
100
      : Params(std::move(Arg.Params)),
101
674
        ImportedFunctionsStats(std::move(Arg.ImportedFunctionsStats)) {}
102
103
  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
104
                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
105
106
private:
107
  InlineParams Params;
108
  std::unique_ptr<ImportedFunctionsInliningStatistics> ImportedFunctionsStats;
109
};
110
111
} // end namespace llvm
112
113
#endif // LLVM_TRANSFORMS_IPO_INLINER_H