95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 //===- InlineCost.cpp - Cost analysis for inliner -------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
3 // The LLVM Compiler Infrastructure
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5 // This file is distributed under the University of Illinois Open Source
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 // License. See LICENSE.TXT for details.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10 // This file implements inline cost analysis.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12 //===----------------------------------------------------------------------===//
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 #include "llvm/Analysis/InlineCost.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15 #include "llvm/ADT/STLExtras.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 #include "llvm/ADT/SetVector.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 #include "llvm/ADT/SmallPtrSet.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18 #include "llvm/ADT/SmallVector.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
19 #include "llvm/ADT/Statistic.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
20 #include "llvm/Analysis/AssumptionCache.h"
|
|
121
|
21 #include "llvm/Analysis/BlockFrequencyInfo.h"
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
22 #include "llvm/Analysis/CodeMetrics.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
23 #include "llvm/Analysis/ConstantFolding.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24 #include "llvm/Analysis/InstructionSimplify.h"
|
|
120
|
25 #include "llvm/Analysis/ProfileSummaryInfo.h"
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
26 #include "llvm/Analysis/TargetTransformInfo.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
27 #include "llvm/IR/CallSite.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
28 #include "llvm/IR/CallingConv.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
29 #include "llvm/IR/DataLayout.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
30 #include "llvm/IR/GetElementPtrTypeIterator.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
31 #include "llvm/IR/GlobalAlias.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
32 #include "llvm/IR/InstVisitor.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
33 #include "llvm/IR/IntrinsicInst.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
34 #include "llvm/IR/Operator.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
35 #include "llvm/Support/Debug.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
36 #include "llvm/Support/raw_ostream.h"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
37
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
38 using namespace llvm;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
39
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
40 #define DEBUG_TYPE "inline-cost"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
41
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
42 STATISTIC(NumCallsAnalyzed, "Number of call sites analyzed");
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
43
|
|
120
|
44 static cl::opt<int> InlineThreshold(
|
|
100
|
45 "inline-threshold", cl::Hidden, cl::init(225), cl::ZeroOrMore,
|
|
|
46 cl::desc("Control the amount of inlining to perform (default = 225)"));
|
|
|
47
|
|
|
48 static cl::opt<int> HintThreshold(
|
|
|
49 "inlinehint-threshold", cl::Hidden, cl::init(325),
|
|
|
50 cl::desc("Threshold for inlining functions with inline hint"));
|
|
|
51
|
|
121
|
52 static cl::opt<int>
|
|
|
53 ColdCallSiteThreshold("inline-cold-callsite-threshold", cl::Hidden,
|
|
|
54 cl::init(45),
|
|
|
55 cl::desc("Threshold for inlining cold callsites"));
|
|
|
56
|
|
100
|
57 // We introduce this threshold to help performance of instrumentation based
|
|
|
58 // PGO before we actually hook up inliner with analysis passes such as BPI and
|
|
|
59 // BFI.
|
|
|
60 static cl::opt<int> ColdThreshold(
|
|
121
|
61 "inlinecold-threshold", cl::Hidden, cl::init(45),
|
|
100
|
62 cl::desc("Threshold for inlining functions with cold attribute"));
|
|
|
63
|
|
120
|
64 static cl::opt<int>
|
|
|
65 HotCallSiteThreshold("hot-callsite-threshold", cl::Hidden, cl::init(3000),
|
|
|
66 cl::ZeroOrMore,
|
|
|
67 cl::desc("Threshold for hot callsites "));
|
|
|
68
|
|
121
|
69 static cl::opt<int> LocallyHotCallSiteThreshold(
|
|
|
70 "locally-hot-callsite-threshold", cl::Hidden, cl::init(525), cl::ZeroOrMore,
|
|
|
71 cl::desc("Threshold for locally hot callsites "));
|
|
|
72
|
|
|
73 static cl::opt<int> ColdCallSiteRelFreq(
|
|
|
74 "cold-callsite-rel-freq", cl::Hidden, cl::init(2), cl::ZeroOrMore,
|
|
|
75 cl::desc("Maxmimum block frequency, expressed as a percentage of caller's "
|
|
|
76 "entry frequency, for a callsite to be cold in the absence of "
|
|
|
77 "profile information."));
|
|
|
78
|
|
|
79 static cl::opt<int> HotCallSiteRelFreq(
|
|
|
80 "hot-callsite-rel-freq", cl::Hidden, cl::init(60), cl::ZeroOrMore,
|
|
|
81 cl::desc("Minimum block frequency, expressed as a multiple of caller's "
|
|
|
82 "entry frequency, for a callsite to be hot in the absence of "
|
|
|
83 "profile information."));
|
|
|
84
|
|
|
85 static cl::opt<bool> OptComputeFullInlineCost(
|
|
|
86 "inline-cost-full", cl::Hidden, cl::init(false),
|
|
|
87 cl::desc("Compute the full inline cost of a call site even when the cost "
|
|
|
88 "exceeds the threshold."));
|
|
|
89
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
90 namespace {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
91
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
92 class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
93 typedef InstVisitor<CallAnalyzer, bool> Base;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
94 friend class InstVisitor<CallAnalyzer, bool>;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
95
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
96 /// The TargetTransformInfo available for this compilation.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
97 const TargetTransformInfo &TTI;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
98
|
|
120
|
99 /// Getter for the cache of @llvm.assume intrinsics.
|
|
|
100 std::function<AssumptionCache &(Function &)> &GetAssumptionCache;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
101
|
|
121
|
102 /// Getter for BlockFrequencyInfo
|
|
|
103 Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI;
|
|
|
104
|
|
120
|
105 /// Profile summary information.
|
|
|
106 ProfileSummaryInfo *PSI;
|
|
|
107
|
|
|
108 /// The called function.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
109 Function &F;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
110
|
|
121
|
111 // Cache the DataLayout since we use it a lot.
|
|
|
112 const DataLayout &DL;
|
|
|
113
|
|
|
114 /// The OptimizationRemarkEmitter available for this compilation.
|
|
|
115 OptimizationRemarkEmitter *ORE;
|
|
|
116
|
|
120
|
117 /// The candidate callsite being analyzed. Please do not use this to do
|
|
|
118 /// analysis in the caller function; we want the inline cost query to be
|
|
|
119 /// easily cacheable. Instead, use the cover function paramHasAttr.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
120 CallSite CandidateCS;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
121
|
|
120
|
122 /// Tunable parameters that control the analysis.
|
|
|
123 const InlineParams &Params;
|
|
|
124
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
125 int Threshold;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
126 int Cost;
|
|
121
|
127 bool ComputeFullInlineCost;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
128
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
129 bool IsCallerRecursive;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
130 bool IsRecursiveCall;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
131 bool ExposesReturnsTwice;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
132 bool HasDynamicAlloca;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
133 bool ContainsNoDuplicateCall;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
134 bool HasReturn;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
135 bool HasIndirectBr;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
136 bool HasFrameEscape;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
137
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
138 /// Number of bytes allocated statically by the callee.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
139 uint64_t AllocatedSize;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
140 unsigned NumInstructions, NumVectorInstructions;
|
|
121
|
141 int VectorBonus, TenPercentVectorBonus;
|
|
|
142 // Bonus to be applied when the callee has only one reachable basic block.
|
|
|
143 int SingleBBBonus;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
144
|
|
120
|
145 /// While we walk the potentially-inlined instructions, we build up and
|
|
|
146 /// maintain a mapping of simplified values specific to this callsite. The
|
|
|
147 /// idea is to propagate any special information we have about arguments to
|
|
|
148 /// this call through the inlinable section of the function, and account for
|
|
|
149 /// likely simplifications post-inlining. The most important aspect we track
|
|
|
150 /// is CFG altering simplifications -- when we prove a basic block dead, that
|
|
|
151 /// can cause dramatic shifts in the cost of inlining a function.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
152 DenseMap<Value *, Constant *> SimplifiedValues;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
153
|
|
120
|
154 /// Keep track of the values which map back (through function arguments) to
|
|
|
155 /// allocas on the caller stack which could be simplified through SROA.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
156 DenseMap<Value *, Value *> SROAArgValues;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
157
|
|
120
|
158 /// The mapping of caller Alloca values to their accumulated cost savings. If
|
|
|
159 /// we have to disable SROA for one of the allocas, this tells us how much
|
|
|
160 /// cost must be added.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
161 DenseMap<Value *, int> SROAArgCosts;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
162
|
|
120
|
163 /// Keep track of values which map to a pointer base and constant offset.
|
|
|
164 DenseMap<Value *, std::pair<Value *, APInt>> ConstantOffsetPtrs;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
165
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
166 // Custom simplification helper routines.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
167 bool isAllocaDerivedArg(Value *V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
168 bool lookupSROAArgAndCost(Value *V, Value *&Arg,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
169 DenseMap<Value *, int>::iterator &CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
170 void disableSROA(DenseMap<Value *, int>::iterator CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
171 void disableSROA(Value *V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
172 void accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
173 int InstructionCost);
|
|
121
|
174 bool isGEPFree(GetElementPtrInst &GEP);
|
|
|
175 bool canFoldInboundsGEP(GetElementPtrInst &I);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
176 bool accumulateGEPOffset(GEPOperator &GEP, APInt &Offset);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
177 bool simplifyCallSite(Function *F, CallSite CS);
|
|
121
|
178 template <typename Callable>
|
|
|
179 bool simplifyInstruction(Instruction &I, Callable Evaluate);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
180 ConstantInt *stripAndComputeInBoundsConstantOffsets(Value *&V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
181
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
182 /// Return true if the given argument to the function being considered for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
183 /// inlining has the given attribute set either at the call site or the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
184 /// function declaration. Primarily used to inspect call site specific
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
185 /// attributes since these can be more precise than the ones on the callee
|
|
100
|
186 /// itself.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
187 bool paramHasAttr(Argument *A, Attribute::AttrKind Attr);
|
|
120
|
188
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
189 /// Return true if the given value is known non null within the callee if
|
|
100
|
190 /// inlined through this particular callsite.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
191 bool isKnownNonNullInCallee(Value *V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
192
|
|
100
|
193 /// Update Threshold based on callsite properties such as callee
|
|
|
194 /// attributes and callee hotness for PGO builds. The Callee is explicitly
|
|
|
195 /// passed to support analyzing indirect calls whose target is inferred by
|
|
|
196 /// analysis.
|
|
|
197 void updateThreshold(CallSite CS, Function &Callee);
|
|
|
198
|
|
120
|
199 /// Return true if size growth is allowed when inlining the callee at CS.
|
|
|
200 bool allowSizeGrowth(CallSite CS);
|
|
|
201
|
|
121
|
202 /// Return true if \p CS is a cold callsite.
|
|
|
203 bool isColdCallSite(CallSite CS, BlockFrequencyInfo *CallerBFI);
|
|
|
204
|
|
|
205 /// Return a higher threshold if \p CS is a hot callsite.
|
|
|
206 Optional<int> getHotCallSiteThreshold(CallSite CS,
|
|
|
207 BlockFrequencyInfo *CallerBFI);
|
|
|
208
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209 // Custom analysis routines.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
210 bool analyzeBlock(BasicBlock *BB, SmallPtrSetImpl<const Value *> &EphValues);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
211
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
212 // Disable several entry points to the visitor so we don't accidentally use
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
213 // them by declaring but not defining them here.
|
|
120
|
214 void visit(Module *);
|
|
|
215 void visit(Module &);
|
|
|
216 void visit(Function *);
|
|
|
217 void visit(Function &);
|
|
|
218 void visit(BasicBlock *);
|
|
|
219 void visit(BasicBlock &);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221 // Provide base case for our instruction visit.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
222 bool visitInstruction(Instruction &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
223
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
224 // Our visit overrides.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
225 bool visitAlloca(AllocaInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
226 bool visitPHI(PHINode &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
227 bool visitGetElementPtr(GetElementPtrInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
228 bool visitBitCast(BitCastInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229 bool visitPtrToInt(PtrToIntInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
230 bool visitIntToPtr(IntToPtrInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
231 bool visitCastInst(CastInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
232 bool visitUnaryInstruction(UnaryInstruction &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
233 bool visitCmpInst(CmpInst &I);
|
|
121
|
234 bool visitAnd(BinaryOperator &I);
|
|
|
235 bool visitOr(BinaryOperator &I);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
236 bool visitSub(BinaryOperator &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
237 bool visitBinaryOperator(BinaryOperator &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
238 bool visitLoad(LoadInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
239 bool visitStore(StoreInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
240 bool visitExtractValue(ExtractValueInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
241 bool visitInsertValue(InsertValueInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
242 bool visitCallSite(CallSite CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
243 bool visitReturnInst(ReturnInst &RI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
244 bool visitBranchInst(BranchInst &BI);
|
|
121
|
245 bool visitSelectInst(SelectInst &SI);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
246 bool visitSwitchInst(SwitchInst &SI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247 bool visitIndirectBrInst(IndirectBrInst &IBI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
248 bool visitResumeInst(ResumeInst &RI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
249 bool visitCleanupReturnInst(CleanupReturnInst &RI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
250 bool visitCatchReturnInst(CatchReturnInst &RI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
251 bool visitUnreachableInst(UnreachableInst &I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
252
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
253 public:
|
|
120
|
254 CallAnalyzer(const TargetTransformInfo &TTI,
|
|
|
255 std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
|
|
121
|
256 Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI,
|
|
|
257 ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE,
|
|
|
258 Function &Callee, CallSite CSArg, const InlineParams &Params)
|
|
|
259 : TTI(TTI), GetAssumptionCache(GetAssumptionCache), GetBFI(GetBFI),
|
|
|
260 PSI(PSI), F(Callee), DL(F.getParent()->getDataLayout()), ORE(ORE),
|
|
120
|
261 CandidateCS(CSArg), Params(Params), Threshold(Params.DefaultThreshold),
|
|
121
|
262 Cost(0), ComputeFullInlineCost(OptComputeFullInlineCost ||
|
|
|
263 Params.ComputeFullInlineCost || ORE),
|
|
|
264 IsCallerRecursive(false), IsRecursiveCall(false),
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
265 ExposesReturnsTwice(false), HasDynamicAlloca(false),
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
266 ContainsNoDuplicateCall(false), HasReturn(false), HasIndirectBr(false),
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
267 HasFrameEscape(false), AllocatedSize(0), NumInstructions(0),
|
|
121
|
268 NumVectorInstructions(0), VectorBonus(0), SingleBBBonus(0),
|
|
|
269 NumConstantArgs(0), NumConstantOffsetPtrArgs(0), NumAllocaArgs(0),
|
|
|
270 NumConstantPtrCmps(0), NumConstantPtrDiffs(0),
|
|
|
271 NumInstructionsSimplified(0), SROACostSavings(0),
|
|
|
272 SROACostSavingsLost(0) {}
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
273
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
274 bool analyzeCall(CallSite CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
275
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
276 int getThreshold() { return Threshold; }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
277 int getCost() { return Cost; }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
278
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
279 // Keep a bunch of stats about the cost savings found so we can print them
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
280 // out when debugging.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
281 unsigned NumConstantArgs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
282 unsigned NumConstantOffsetPtrArgs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
283 unsigned NumAllocaArgs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
284 unsigned NumConstantPtrCmps;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
285 unsigned NumConstantPtrDiffs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
286 unsigned NumInstructionsSimplified;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
287 unsigned SROACostSavings;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
288 unsigned SROACostSavingsLost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
289
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
290 void dump();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
291 };
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
292
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
293 } // namespace
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
294
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295 /// \brief Test whether the given value is an Alloca-derived function argument.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
296 bool CallAnalyzer::isAllocaDerivedArg(Value *V) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
297 return SROAArgValues.count(V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
298 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
299
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
300 /// \brief Lookup the SROA-candidate argument and cost iterator which V maps to.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
301 /// Returns false if V does not map to a SROA-candidate.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
302 bool CallAnalyzer::lookupSROAArgAndCost(
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
303 Value *V, Value *&Arg, DenseMap<Value *, int>::iterator &CostIt) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
304 if (SROAArgValues.empty() || SROAArgCosts.empty())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
305 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
306
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
307 DenseMap<Value *, Value *>::iterator ArgIt = SROAArgValues.find(V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
308 if (ArgIt == SROAArgValues.end())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
309 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
310
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
311 Arg = ArgIt->second;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
312 CostIt = SROAArgCosts.find(Arg);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
313 return CostIt != SROAArgCosts.end();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
314 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
315
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
316 /// \brief Disable SROA for the candidate marked by this cost iterator.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
317 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
318 /// This marks the candidate as no longer viable for SROA, and adds the cost
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
319 /// savings associated with it back into the inline cost measurement.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
320 void CallAnalyzer::disableSROA(DenseMap<Value *, int>::iterator CostIt) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
321 // If we're no longer able to perform SROA we need to undo its cost savings
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
322 // and prevent subsequent analysis.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
323 Cost += CostIt->second;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
324 SROACostSavings -= CostIt->second;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
325 SROACostSavingsLost += CostIt->second;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
326 SROAArgCosts.erase(CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
327 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
328
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
329 /// \brief If 'V' maps to a SROA candidate, disable SROA for it.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
330 void CallAnalyzer::disableSROA(Value *V) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
331 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
332 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
333 if (lookupSROAArgAndCost(V, SROAArg, CostIt))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
334 disableSROA(CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
335 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
336
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
337 /// \brief Accumulate the given cost for a particular SROA candidate.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
338 void CallAnalyzer::accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
339 int InstructionCost) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
340 CostIt->second += InstructionCost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
341 SROACostSavings += InstructionCost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
342 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
343
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
344 /// \brief Accumulate a constant GEP offset into an APInt if possible.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
345 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
346 /// Returns false if unable to compute the offset for any reason. Respects any
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
347 /// simplified values known during the analysis of this callsite.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
348 bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
349 unsigned IntPtrWidth = DL.getPointerSizeInBits();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
350 assert(IntPtrWidth == Offset.getBitWidth());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
351
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
352 for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
353 GTI != GTE; ++GTI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
354 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
355 if (!OpC)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
356 if (Constant *SimpleOp = SimplifiedValues.lookup(GTI.getOperand()))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
357 OpC = dyn_cast<ConstantInt>(SimpleOp);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
358 if (!OpC)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
359 return false;
|
|
120
|
360 if (OpC->isZero())
|
|
|
361 continue;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
362
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
363 // Handle a struct index, which adds its field offset to the pointer.
|
|
121
|
364 if (StructType *STy = GTI.getStructTypeOrNull()) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
365 unsigned ElementIdx = OpC->getZExtValue();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
366 const StructLayout *SL = DL.getStructLayout(STy);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
367 Offset += APInt(IntPtrWidth, SL->getElementOffset(ElementIdx));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
368 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
369 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
370
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
371 APInt TypeSize(IntPtrWidth, DL.getTypeAllocSize(GTI.getIndexedType()));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
372 Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
374 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
375 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
376
|
|
121
|
377 /// \brief Use TTI to check whether a GEP is free.
|
|
|
378 ///
|
|
|
379 /// Respects any simplified values known during the analysis of this callsite.
|
|
|
380 bool CallAnalyzer::isGEPFree(GetElementPtrInst &GEP) {
|
|
|
381 SmallVector<Value *, 4> Operands;
|
|
|
382 Operands.push_back(GEP.getOperand(0));
|
|
|
383 for (User::op_iterator I = GEP.idx_begin(), E = GEP.idx_end(); I != E; ++I)
|
|
|
384 if (Constant *SimpleOp = SimplifiedValues.lookup(*I))
|
|
|
385 Operands.push_back(SimpleOp);
|
|
|
386 else
|
|
|
387 Operands.push_back(*I);
|
|
|
388 return TargetTransformInfo::TCC_Free == TTI.getUserCost(&GEP, Operands);
|
|
|
389 }
|
|
|
390
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
391 bool CallAnalyzer::visitAlloca(AllocaInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
392 // Check whether inlining will turn a dynamic alloca into a static
|
|
120
|
393 // alloca and handle that case.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
394 if (I.isArrayAllocation()) {
|
|
120
|
395 Constant *Size = SimplifiedValues.lookup(I.getArraySize());
|
|
|
396 if (auto *AllocSize = dyn_cast_or_null<ConstantInt>(Size)) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
397 Type *Ty = I.getAllocatedType();
|
|
120
|
398 AllocatedSize = SaturatingMultiplyAdd(
|
|
|
399 AllocSize->getLimitedValue(), DL.getTypeAllocSize(Ty), AllocatedSize);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
400 return Base::visitAlloca(I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
401 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
402 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
403
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
404 // Accumulate the allocated size.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
405 if (I.isStaticAlloca()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
406 Type *Ty = I.getAllocatedType();
|
|
120
|
407 AllocatedSize = SaturatingAdd(DL.getTypeAllocSize(Ty), AllocatedSize);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
408 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
409
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
410 // We will happily inline static alloca instructions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
411 if (I.isStaticAlloca())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
412 return Base::visitAlloca(I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
413
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
414 // FIXME: This is overly conservative. Dynamic allocas are inefficient for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
415 // a variety of reasons, and so we would like to not inline them into
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
416 // functions which don't currently have a dynamic alloca. This simply
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
417 // disables inlining altogether in the presence of a dynamic alloca.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
418 HasDynamicAlloca = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
419 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
420 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
421
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
422 bool CallAnalyzer::visitPHI(PHINode &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
423 // FIXME: We should potentially be tracking values through phi nodes,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
424 // especially when they collapse to a single value due to deleted CFG edges
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
425 // during inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
426
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
427 // FIXME: We need to propagate SROA *disabling* through phi nodes, even
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
428 // though we don't want to propagate it's bonuses. The idea is to disable
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
429 // SROA if it *might* be used in an inappropriate manner.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
430
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
431 // Phi nodes are always zero-cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
432 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
433 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
434
|
|
121
|
435 /// \brief Check we can fold GEPs of constant-offset call site argument pointers.
|
|
|
436 /// This requires target data and inbounds GEPs.
|
|
|
437 ///
|
|
|
438 /// \return true if the specified GEP can be folded.
|
|
|
439 bool CallAnalyzer::canFoldInboundsGEP(GetElementPtrInst &I) {
|
|
|
440 // Check if we have a base + offset for the pointer.
|
|
|
441 std::pair<Value *, APInt> BaseAndOffset =
|
|
|
442 ConstantOffsetPtrs.lookup(I.getPointerOperand());
|
|
|
443 if (!BaseAndOffset.first)
|
|
|
444 return false;
|
|
|
445
|
|
|
446 // Check if the offset of this GEP is constant, and if so accumulate it
|
|
|
447 // into Offset.
|
|
|
448 if (!accumulateGEPOffset(cast<GEPOperator>(I), BaseAndOffset.second))
|
|
|
449 return false;
|
|
|
450
|
|
|
451 // Add the result as a new mapping to Base + Offset.
|
|
|
452 ConstantOffsetPtrs[&I] = BaseAndOffset;
|
|
|
453
|
|
|
454 return true;
|
|
|
455 }
|
|
|
456
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
457 bool CallAnalyzer::visitGetElementPtr(GetElementPtrInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
458 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
459 DenseMap<Value *, int>::iterator CostIt;
|
|
120
|
460 bool SROACandidate =
|
|
|
461 lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
462
|
|
121
|
463 // Lambda to check whether a GEP's indices are all constant.
|
|
|
464 auto IsGEPOffsetConstant = [&](GetElementPtrInst &GEP) {
|
|
|
465 for (User::op_iterator I = GEP.idx_begin(), E = GEP.idx_end(); I != E; ++I)
|
|
|
466 if (!isa<Constant>(*I) && !SimplifiedValues.lookup(*I))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
467 return false;
|
|
121
|
468 return true;
|
|
|
469 };
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
470
|
|
121
|
471 if ((I.isInBounds() && canFoldInboundsGEP(I)) || IsGEPOffsetConstant(I)) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
472 if (SROACandidate)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
473 SROAArgValues[&I] = SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
474
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
475 // Constant GEPs are modeled as free.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
476 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
477 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
478
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
479 // Variable GEPs will require math and will disable SROA.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
480 if (SROACandidate)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
481 disableSROA(CostIt);
|
|
121
|
482 return isGEPFree(I);
|
|
|
483 }
|
|
|
484
|
|
|
485 /// Simplify \p I if its operands are constants and update SimplifiedValues.
|
|
|
486 /// \p Evaluate is a callable specific to instruction type that evaluates the
|
|
|
487 /// instruction when all the operands are constants.
|
|
|
488 template <typename Callable>
|
|
|
489 bool CallAnalyzer::simplifyInstruction(Instruction &I, Callable Evaluate) {
|
|
|
490 SmallVector<Constant *, 2> COps;
|
|
|
491 for (Value *Op : I.operands()) {
|
|
|
492 Constant *COp = dyn_cast<Constant>(Op);
|
|
|
493 if (!COp)
|
|
|
494 COp = SimplifiedValues.lookup(Op);
|
|
|
495 if (!COp)
|
|
|
496 return false;
|
|
|
497 COps.push_back(COp);
|
|
|
498 }
|
|
|
499 auto *C = Evaluate(COps);
|
|
|
500 if (!C)
|
|
|
501 return false;
|
|
|
502 SimplifiedValues[&I] = C;
|
|
|
503 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
504 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
505
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
506 bool CallAnalyzer::visitBitCast(BitCastInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
507 // Propagate constants through bitcasts.
|
|
121
|
508 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
509 return ConstantExpr::getBitCast(COps[0], I.getType());
|
|
|
510 }))
|
|
|
511 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
512
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
513 // Track base/offsets through casts
|
|
120
|
514 std::pair<Value *, APInt> BaseAndOffset =
|
|
|
515 ConstantOffsetPtrs.lookup(I.getOperand(0));
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
516 // Casts don't change the offset, just wrap it up.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
517 if (BaseAndOffset.first)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
518 ConstantOffsetPtrs[&I] = BaseAndOffset;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
519
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
520 // Also look for SROA candidates here.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
521 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
522 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
523 if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
524 SROAArgValues[&I] = SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
525
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
526 // Bitcasts are always zero cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
527 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
528 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
529
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
530 bool CallAnalyzer::visitPtrToInt(PtrToIntInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
531 // Propagate constants through ptrtoint.
|
|
121
|
532 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
533 return ConstantExpr::getPtrToInt(COps[0], I.getType());
|
|
|
534 }))
|
|
|
535 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
536
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
537 // Track base/offset pairs when converted to a plain integer provided the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
538 // integer is large enough to represent the pointer.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
539 unsigned IntegerSize = I.getType()->getScalarSizeInBits();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
540 if (IntegerSize >= DL.getPointerSizeInBits()) {
|
|
120
|
541 std::pair<Value *, APInt> BaseAndOffset =
|
|
|
542 ConstantOffsetPtrs.lookup(I.getOperand(0));
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
543 if (BaseAndOffset.first)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
544 ConstantOffsetPtrs[&I] = BaseAndOffset;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
545 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
546
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
547 // This is really weird. Technically, ptrtoint will disable SROA. However,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
548 // unless that ptrtoint is *used* somewhere in the live basic blocks after
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
549 // inlining, it will be nuked, and SROA should proceed. All of the uses which
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
550 // would block SROA would also block SROA if applied directly to a pointer,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
551 // and so we can just add the integer in here. The only places where SROA is
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
552 // preserved either cannot fire on an integer, or won't in-and-of themselves
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
553 // disable SROA (ext) w/o some later use that we would see and disable.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
554 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
555 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
556 if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
557 SROAArgValues[&I] = SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
558
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
559 return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
560 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
561
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
562 bool CallAnalyzer::visitIntToPtr(IntToPtrInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
563 // Propagate constants through ptrtoint.
|
|
121
|
564 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
565 return ConstantExpr::getIntToPtr(COps[0], I.getType());
|
|
|
566 }))
|
|
|
567 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
568
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
569 // Track base/offset pairs when round-tripped through a pointer without
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
570 // modifications provided the integer is not too large.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
571 Value *Op = I.getOperand(0);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
572 unsigned IntegerSize = Op->getType()->getScalarSizeInBits();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
573 if (IntegerSize <= DL.getPointerSizeInBits()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
574 std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Op);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
575 if (BaseAndOffset.first)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
576 ConstantOffsetPtrs[&I] = BaseAndOffset;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
577 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
578
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
579 // "Propagate" SROA here in the same manner as we do for ptrtoint above.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
580 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
581 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
582 if (lookupSROAArgAndCost(Op, SROAArg, CostIt))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
583 SROAArgValues[&I] = SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
584
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
585 return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
586 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
587
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
588 bool CallAnalyzer::visitCastInst(CastInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
589 // Propagate constants through ptrtoint.
|
|
121
|
590 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
591 return ConstantExpr::getCast(I.getOpcode(), COps[0], I.getType());
|
|
|
592 }))
|
|
|
593 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
594
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
595 // Disable SROA in the face of arbitrary casts we don't whitelist elsewhere.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
596 disableSROA(I.getOperand(0));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
597
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
598 return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
599 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
600
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
601 bool CallAnalyzer::visitUnaryInstruction(UnaryInstruction &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
602 Value *Operand = I.getOperand(0);
|
|
121
|
603 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
604 return ConstantFoldInstOperands(&I, COps[0], DL);
|
|
|
605 }))
|
|
|
606 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
607
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
608 // Disable any SROA on the argument to arbitrary unary operators.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
609 disableSROA(Operand);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
610
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
611 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
612 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
613
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
614 bool CallAnalyzer::paramHasAttr(Argument *A, Attribute::AttrKind Attr) {
|
|
121
|
615 return CandidateCS.paramHasAttr(A->getArgNo(), Attr);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
616 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
617
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
618 bool CallAnalyzer::isKnownNonNullInCallee(Value *V) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
619 // Does the *call site* have the NonNull attribute set on an argument? We
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
620 // use the attribute on the call site to memoize any analysis done in the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
621 // caller. This will also trip if the callee function has a non-null
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
622 // parameter attribute, but that's a less interesting case because hopefully
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
623 // the callee would already have been simplified based on that.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
624 if (Argument *A = dyn_cast<Argument>(V))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
625 if (paramHasAttr(A, Attribute::NonNull))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
626 return true;
|
|
120
|
627
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
628 // Is this an alloca in the caller? This is distinct from the attribute case
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
629 // above because attributes aren't updated within the inliner itself and we
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
630 // always want to catch the alloca derived case.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
631 if (isAllocaDerivedArg(V))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
632 // We can actually predict the result of comparisons between an
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
633 // alloca-derived value and null. Note that this fires regardless of
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
634 // SROA firing.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
635 return true;
|
|
120
|
636
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
637 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
638 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
639
|
|
120
|
640 bool CallAnalyzer::allowSizeGrowth(CallSite CS) {
|
|
|
641 // If the normal destination of the invoke or the parent block of the call
|
|
|
642 // site is unreachable-terminated, there is little point in inlining this
|
|
|
643 // unless there is literally zero cost.
|
|
|
644 // FIXME: Note that it is possible that an unreachable-terminated block has a
|
|
|
645 // hot entry. For example, in below scenario inlining hot_call_X() may be
|
|
|
646 // beneficial :
|
|
|
647 // main() {
|
|
|
648 // hot_call_1();
|
|
|
649 // ...
|
|
|
650 // hot_call_N()
|
|
|
651 // exit(0);
|
|
|
652 // }
|
|
|
653 // For now, we are not handling this corner case here as it is rare in real
|
|
|
654 // code. In future, we should elaborate this based on BPI and BFI in more
|
|
|
655 // general threshold adjusting heuristics in updateThreshold().
|
|
|
656 Instruction *Instr = CS.getInstruction();
|
|
|
657 if (InvokeInst *II = dyn_cast<InvokeInst>(Instr)) {
|
|
|
658 if (isa<UnreachableInst>(II->getNormalDest()->getTerminator()))
|
|
|
659 return false;
|
|
|
660 } else if (isa<UnreachableInst>(Instr->getParent()->getTerminator()))
|
|
|
661 return false;
|
|
|
662
|
|
|
663 return true;
|
|
|
664 }
|
|
|
665
|
|
121
|
666 bool CallAnalyzer::isColdCallSite(CallSite CS, BlockFrequencyInfo *CallerBFI) {
|
|
|
667 // If global profile summary is available, then callsite's coldness is
|
|
|
668 // determined based on that.
|
|
|
669 if (PSI && PSI->hasProfileSummary())
|
|
|
670 return PSI->isColdCallSite(CS, CallerBFI);
|
|
|
671
|
|
|
672 // Otherwise we need BFI to be available.
|
|
|
673 if (!CallerBFI)
|
|
|
674 return false;
|
|
|
675
|
|
|
676 // Determine if the callsite is cold relative to caller's entry. We could
|
|
|
677 // potentially cache the computation of scaled entry frequency, but the added
|
|
|
678 // complexity is not worth it unless this scaling shows up high in the
|
|
|
679 // profiles.
|
|
|
680 const BranchProbability ColdProb(ColdCallSiteRelFreq, 100);
|
|
|
681 auto CallSiteBB = CS.getInstruction()->getParent();
|
|
|
682 auto CallSiteFreq = CallerBFI->getBlockFreq(CallSiteBB);
|
|
|
683 auto CallerEntryFreq =
|
|
|
684 CallerBFI->getBlockFreq(&(CS.getCaller()->getEntryBlock()));
|
|
|
685 return CallSiteFreq < CallerEntryFreq * ColdProb;
|
|
|
686 }
|
|
|
687
|
|
|
688 Optional<int>
|
|
|
689 CallAnalyzer::getHotCallSiteThreshold(CallSite CS,
|
|
|
690 BlockFrequencyInfo *CallerBFI) {
|
|
|
691
|
|
|
692 // If global profile summary is available, then callsite's hotness is
|
|
|
693 // determined based on that.
|
|
|
694 if (PSI && PSI->hasProfileSummary() && PSI->isHotCallSite(CS, CallerBFI))
|
|
|
695 return Params.HotCallSiteThreshold;
|
|
|
696
|
|
|
697 // Otherwise we need BFI to be available and to have a locally hot callsite
|
|
|
698 // threshold.
|
|
|
699 if (!CallerBFI || !Params.LocallyHotCallSiteThreshold)
|
|
|
700 return None;
|
|
|
701
|
|
|
702 // Determine if the callsite is hot relative to caller's entry. We could
|
|
|
703 // potentially cache the computation of scaled entry frequency, but the added
|
|
|
704 // complexity is not worth it unless this scaling shows up high in the
|
|
|
705 // profiles.
|
|
|
706 auto CallSiteBB = CS.getInstruction()->getParent();
|
|
|
707 auto CallSiteFreq = CallerBFI->getBlockFreq(CallSiteBB).getFrequency();
|
|
|
708 auto CallerEntryFreq = CallerBFI->getEntryFreq();
|
|
|
709 if (CallSiteFreq >= CallerEntryFreq * HotCallSiteRelFreq)
|
|
|
710 return Params.LocallyHotCallSiteThreshold;
|
|
|
711
|
|
|
712 // Otherwise treat it normally.
|
|
|
713 return None;
|
|
|
714 }
|
|
|
715
|
|
100
|
716 void CallAnalyzer::updateThreshold(CallSite CS, Function &Callee) {
|
|
120
|
717 // If no size growth is allowed for this inlining, set Threshold to 0.
|
|
|
718 if (!allowSizeGrowth(CS)) {
|
|
|
719 Threshold = 0;
|
|
|
720 return;
|
|
|
721 }
|
|
|
722
|
|
100
|
723 Function *Caller = CS.getCaller();
|
|
|
724
|
|
120
|
725 // return min(A, B) if B is valid.
|
|
|
726 auto MinIfValid = [](int A, Optional<int> B) {
|
|
|
727 return B ? std::min(A, B.getValue()) : A;
|
|
|
728 };
|
|
100
|
729
|
|
120
|
730 // return max(A, B) if B is valid.
|
|
|
731 auto MaxIfValid = [](int A, Optional<int> B) {
|
|
|
732 return B ? std::max(A, B.getValue()) : A;
|
|
|
733 };
|
|
100
|
734
|
|
121
|
735 // Various bonus percentages. These are multiplied by Threshold to get the
|
|
|
736 // bonus values.
|
|
|
737 // SingleBBBonus: This bonus is applied if the callee has a single reachable
|
|
|
738 // basic block at the given callsite context. This is speculatively applied
|
|
|
739 // and withdrawn if more than one basic block is seen.
|
|
|
740 //
|
|
|
741 // Vector bonuses: We want to more aggressively inline vector-dense kernels
|
|
|
742 // and apply this bonus based on the percentage of vector instructions. A
|
|
|
743 // bonus is applied if the vector instructions exceed 50% and half that amount
|
|
|
744 // is applied if it exceeds 10%. Note that these bonuses are some what
|
|
|
745 // arbitrary and evolved over time by accident as much as because they are
|
|
|
746 // principled bonuses.
|
|
|
747 // FIXME: It would be nice to base the bonus values on something more
|
|
|
748 // scientific.
|
|
|
749 //
|
|
|
750 // LstCallToStaticBonus: This large bonus is applied to ensure the inlining
|
|
|
751 // of the last call to a static function as inlining such functions is
|
|
|
752 // guaranteed to reduce code size.
|
|
|
753 //
|
|
|
754 // These bonus percentages may be set to 0 based on properties of the caller
|
|
|
755 // and the callsite.
|
|
|
756 int SingleBBBonusPercent = 50;
|
|
|
757 int VectorBonusPercent = 150;
|
|
|
758 int LastCallToStaticBonus = InlineConstants::LastCallToStaticBonus;
|
|
|
759
|
|
|
760 // Lambda to set all the above bonus and bonus percentages to 0.
|
|
|
761 auto DisallowAllBonuses = [&]() {
|
|
|
762 SingleBBBonusPercent = 0;
|
|
|
763 VectorBonusPercent = 0;
|
|
|
764 LastCallToStaticBonus = 0;
|
|
|
765 };
|
|
|
766
|
|
120
|
767 // Use the OptMinSizeThreshold or OptSizeThreshold knob if they are available
|
|
|
768 // and reduce the threshold if the caller has the necessary attribute.
|
|
121
|
769 if (Caller->optForMinSize()) {
|
|
120
|
770 Threshold = MinIfValid(Threshold, Params.OptMinSizeThreshold);
|
|
121
|
771 // For minsize, we want to disable the single BB bonus and the vector
|
|
|
772 // bonuses, but not the last-call-to-static bonus. Inlining the last call to
|
|
|
773 // a static function will, at the minimum, eliminate the parameter setup and
|
|
|
774 // call/return instructions.
|
|
|
775 SingleBBBonusPercent = 0;
|
|
|
776 VectorBonusPercent = 0;
|
|
|
777 } else if (Caller->optForSize())
|
|
120
|
778 Threshold = MinIfValid(Threshold, Params.OptSizeThreshold);
|
|
|
779
|
|
121
|
780 // Adjust the threshold based on inlinehint attribute and profile based
|
|
|
781 // hotness information if the caller does not have MinSize attribute.
|
|
|
782 if (!Caller->optForMinSize()) {
|
|
|
783 if (Callee.hasFnAttribute(Attribute::InlineHint))
|
|
|
784 Threshold = MaxIfValid(Threshold, Params.HintThreshold);
|
|
100
|
785
|
|
121
|
786 // FIXME: After switching to the new passmanager, simplify the logic below
|
|
|
787 // by checking only the callsite hotness/coldness as we will reliably
|
|
|
788 // have local profile information.
|
|
|
789 //
|
|
|
790 // Callsite hotness and coldness can be determined if sample profile is
|
|
|
791 // used (which adds hotness metadata to calls) or if caller's
|
|
|
792 // BlockFrequencyInfo is available.
|
|
|
793 BlockFrequencyInfo *CallerBFI = GetBFI ? &((*GetBFI)(*Caller)) : nullptr;
|
|
|
794 auto HotCallSiteThreshold = getHotCallSiteThreshold(CS, CallerBFI);
|
|
|
795 if (!Caller->optForSize() && HotCallSiteThreshold) {
|
|
|
796 DEBUG(dbgs() << "Hot callsite.\n");
|
|
|
797 // FIXME: This should update the threshold only if it exceeds the
|
|
|
798 // current threshold, but AutoFDO + ThinLTO currently relies on this
|
|
|
799 // behavior to prevent inlining of hot callsites during ThinLTO
|
|
|
800 // compile phase.
|
|
|
801 Threshold = HotCallSiteThreshold.getValue();
|
|
|
802 } else if (isColdCallSite(CS, CallerBFI)) {
|
|
|
803 DEBUG(dbgs() << "Cold callsite.\n");
|
|
|
804 // Do not apply bonuses for a cold callsite including the
|
|
|
805 // LastCallToStatic bonus. While this bonus might result in code size
|
|
|
806 // reduction, it can cause the size of a non-cold caller to increase
|
|
|
807 // preventing it from being inlined.
|
|
|
808 DisallowAllBonuses();
|
|
|
809 Threshold = MinIfValid(Threshold, Params.ColdCallSiteThreshold);
|
|
|
810 } else if (PSI) {
|
|
|
811 // Use callee's global profile information only if we have no way of
|
|
|
812 // determining this via callsite information.
|
|
|
813 if (PSI->isFunctionEntryHot(&Callee)) {
|
|
|
814 DEBUG(dbgs() << "Hot callee.\n");
|
|
|
815 // If callsite hotness can not be determined, we may still know
|
|
|
816 // that the callee is hot and treat it as a weaker hint for threshold
|
|
|
817 // increase.
|
|
|
818 Threshold = MaxIfValid(Threshold, Params.HintThreshold);
|
|
|
819 } else if (PSI->isFunctionEntryCold(&Callee)) {
|
|
|
820 DEBUG(dbgs() << "Cold callee.\n");
|
|
|
821 // Do not apply bonuses for a cold callee including the
|
|
|
822 // LastCallToStatic bonus. While this bonus might result in code size
|
|
|
823 // reduction, it can cause the size of a non-cold caller to increase
|
|
|
824 // preventing it from being inlined.
|
|
|
825 DisallowAllBonuses();
|
|
|
826 Threshold = MinIfValid(Threshold, Params.ColdThreshold);
|
|
|
827 }
|
|
|
828 }
|
|
|
829 }
|
|
120
|
830
|
|
|
831 // Finally, take the target-specific inlining threshold multiplier into
|
|
|
832 // account.
|
|
|
833 Threshold *= TTI.getInliningThresholdMultiplier();
|
|
121
|
834
|
|
|
835 SingleBBBonus = Threshold * SingleBBBonusPercent / 100;
|
|
|
836 VectorBonus = Threshold * VectorBonusPercent / 100;
|
|
|
837
|
|
|
838 bool OnlyOneCallAndLocalLinkage =
|
|
|
839 F.hasLocalLinkage() && F.hasOneUse() && &F == CS.getCalledFunction();
|
|
|
840 // If there is only one call of the function, and it has internal linkage,
|
|
|
841 // the cost of inlining it drops dramatically. It may seem odd to update
|
|
|
842 // Cost in updateThreshold, but the bonus depends on the logic in this method.
|
|
|
843 if (OnlyOneCallAndLocalLinkage)
|
|
|
844 Cost -= LastCallToStaticBonus;
|
|
100
|
845 }
|
|
|
846
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
847 bool CallAnalyzer::visitCmpInst(CmpInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
848 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
849 // First try to handle simplified comparisons.
|
|
121
|
850 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
851 return ConstantExpr::getCompare(I.getPredicate(), COps[0], COps[1]);
|
|
|
852 }))
|
|
|
853 return true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
854
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
855 if (I.getOpcode() == Instruction::FCmp)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
856 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
857
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
858 // Otherwise look for a comparison between constant offset pointers with
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
859 // a common base.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
860 Value *LHSBase, *RHSBase;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
861 APInt LHSOffset, RHSOffset;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
862 std::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
863 if (LHSBase) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
864 std::tie(RHSBase, RHSOffset) = ConstantOffsetPtrs.lookup(RHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
865 if (RHSBase && LHSBase == RHSBase) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
866 // We have common bases, fold the icmp to a constant based on the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
867 // offsets.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
868 Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
869 Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
870 if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
871 SimplifiedValues[&I] = C;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
872 ++NumConstantPtrCmps;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
873 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
874 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
875 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
876 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
877
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
878 // If the comparison is an equality comparison with null, we can simplify it
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
879 // if we know the value (argument) can't be null
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
880 if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1)) &&
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
881 isKnownNonNullInCallee(I.getOperand(0))) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
882 bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
883 SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
884 : ConstantInt::getFalse(I.getType());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
885 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
886 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
887 // Finally check for SROA candidates in comparisons.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
888 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
889 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
890 if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
891 if (isa<ConstantPointerNull>(I.getOperand(1))) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
892 accumulateSROACost(CostIt, InlineConstants::InstrCost);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
893 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
894 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
895
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
896 disableSROA(CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
897 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
898
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
899 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
900 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
901
|
|
121
|
902 bool CallAnalyzer::visitOr(BinaryOperator &I) {
|
|
|
903 // This is necessary because the generic simplify instruction only works if
|
|
|
904 // both operands are constants.
|
|
|
905 for (unsigned i = 0; i < 2; ++i) {
|
|
|
906 if (ConstantInt *C = dyn_cast_or_null<ConstantInt>(
|
|
|
907 SimplifiedValues.lookup(I.getOperand(i))))
|
|
|
908 if (C->isAllOnesValue()) {
|
|
|
909 SimplifiedValues[&I] = C;
|
|
|
910 return true;
|
|
|
911 }
|
|
|
912 }
|
|
|
913 return Base::visitOr(I);
|
|
|
914 }
|
|
|
915
|
|
|
916 bool CallAnalyzer::visitAnd(BinaryOperator &I) {
|
|
|
917 // This is necessary because the generic simplify instruction only works if
|
|
|
918 // both operands are constants.
|
|
|
919 for (unsigned i = 0; i < 2; ++i) {
|
|
|
920 if (ConstantInt *C = dyn_cast_or_null<ConstantInt>(
|
|
|
921 SimplifiedValues.lookup(I.getOperand(i))))
|
|
|
922 if (C->isZero()) {
|
|
|
923 SimplifiedValues[&I] = C;
|
|
|
924 return true;
|
|
|
925 }
|
|
|
926 }
|
|
|
927 return Base::visitAnd(I);
|
|
|
928 }
|
|
|
929
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
930 bool CallAnalyzer::visitSub(BinaryOperator &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
931 // Try to handle a special case: we can fold computing the difference of two
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
932 // constant-related pointers.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
933 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
934 Value *LHSBase, *RHSBase;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
935 APInt LHSOffset, RHSOffset;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
936 std::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
937 if (LHSBase) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
938 std::tie(RHSBase, RHSOffset) = ConstantOffsetPtrs.lookup(RHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
939 if (RHSBase && LHSBase == RHSBase) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
940 // We have common bases, fold the subtract to a constant based on the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
941 // offsets.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
942 Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
943 Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
944 if (Constant *C = ConstantExpr::getSub(CLHS, CRHS)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
945 SimplifiedValues[&I] = C;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
946 ++NumConstantPtrDiffs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
947 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
948 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
949 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
950 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
951
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
952 // Otherwise, fall back to the generic logic for simplifying and handling
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
953 // instructions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
954 return Base::visitSub(I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
955 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
956
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
957 bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
958 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
|
|
121
|
959 auto Evaluate = [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
960 Value *SimpleV = nullptr;
|
|
|
961 if (auto FI = dyn_cast<FPMathOperator>(&I))
|
|
|
962 SimpleV = SimplifyFPBinOp(I.getOpcode(), COps[0], COps[1],
|
|
|
963 FI->getFastMathFlags(), DL);
|
|
|
964 else
|
|
|
965 SimpleV = SimplifyBinOp(I.getOpcode(), COps[0], COps[1], DL);
|
|
|
966 return dyn_cast_or_null<Constant>(SimpleV);
|
|
|
967 };
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
968
|
|
121
|
969 if (simplifyInstruction(I, Evaluate))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
970 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
971
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
972 // Disable any SROA on arguments to arbitrary, unsimplified binary operators.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
973 disableSROA(LHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
974 disableSROA(RHS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
975
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
976 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
977 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
978
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
979 bool CallAnalyzer::visitLoad(LoadInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
980 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
981 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
982 if (lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
983 if (I.isSimple()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
984 accumulateSROACost(CostIt, InlineConstants::InstrCost);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
985 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
986 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
987
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
988 disableSROA(CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
989 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
990
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
991 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
992 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
993
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
994 bool CallAnalyzer::visitStore(StoreInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
995 Value *SROAArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
996 DenseMap<Value *, int>::iterator CostIt;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
997 if (lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
998 if (I.isSimple()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
999 accumulateSROACost(CostIt, InlineConstants::InstrCost);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1000 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1001 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1002
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1003 disableSROA(CostIt);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1004 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1005
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1006 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1007 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1008
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1009 bool CallAnalyzer::visitExtractValue(ExtractValueInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1010 // Constant folding for extract value is trivial.
|
|
121
|
1011 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
1012 return ConstantExpr::getExtractValue(COps[0], I.getIndices());
|
|
|
1013 }))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1014 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1015
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1016 // SROA can look through these but give them a cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1017 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1018 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1019
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1020 bool CallAnalyzer::visitInsertValue(InsertValueInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1021 // Constant folding for insert value is trivial.
|
|
121
|
1022 if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
|
|
|
1023 return ConstantExpr::getInsertValue(/*AggregateOperand*/ COps[0],
|
|
|
1024 /*InsertedValueOperand*/ COps[1],
|
|
|
1025 I.getIndices());
|
|
|
1026 }))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1027 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1028
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1029 // SROA can look through these but give them a cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1030 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1031 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1032
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1033 /// \brief Try to simplify a call site.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1034 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1035 /// Takes a concrete function and callsite and tries to actually simplify it by
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1036 /// analyzing the arguments and call itself with instsimplify. Returns true if
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1037 /// it has simplified the callsite to some other entity (a constant), making it
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1038 /// free.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1039 bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1040 // FIXME: Using the instsimplify logic directly for this is inefficient
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1041 // because we have to continually rebuild the argument list even when no
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1042 // simplifications can be performed. Until that is fixed with remapping
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1043 // inside of instsimplify, directly constant fold calls here.
|
|
121
|
1044 if (!canConstantFoldCallTo(CS, F))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1045 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1046
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1047 // Try to re-map the arguments to constants.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1048 SmallVector<Constant *, 4> ConstantArgs;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1049 ConstantArgs.reserve(CS.arg_size());
|
|
120
|
1050 for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E;
|
|
|
1051 ++I) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1052 Constant *C = dyn_cast<Constant>(*I);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1053 if (!C)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1054 C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(*I));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1055 if (!C)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1056 return false; // This argument doesn't map to a constant.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1057
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1058 ConstantArgs.push_back(C);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1059 }
|
|
121
|
1060 if (Constant *C = ConstantFoldCall(CS, F, ConstantArgs)) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1061 SimplifiedValues[CS.getInstruction()] = C;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1062 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1063 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1064
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1065 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1066 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1067
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1068 bool CallAnalyzer::visitCallSite(CallSite CS) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1069 if (CS.hasFnAttr(Attribute::ReturnsTwice) &&
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1070 !F.hasFnAttribute(Attribute::ReturnsTwice)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1071 // This aborts the entire analysis.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1072 ExposesReturnsTwice = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1073 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1074 }
|
|
120
|
1075 if (CS.isCall() && cast<CallInst>(CS.getInstruction())->cannotDuplicate())
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1076 ContainsNoDuplicateCall = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1077
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1078 if (Function *F = CS.getCalledFunction()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1079 // When we have a concrete function, first try to simplify it directly.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1080 if (simplifyCallSite(F, CS))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1081 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1082
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1083 // Next check if it is an intrinsic we know about.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1084 // FIXME: Lift this into part of the InstVisitor.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1085 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1086 switch (II->getIntrinsicID()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1087 default:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1088 return Base::visitCallSite(CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1089
|
|
120
|
1090 case Intrinsic::load_relative:
|
|
|
1091 // This is normally lowered to 4 LLVM instructions.
|
|
|
1092 Cost += 3 * InlineConstants::InstrCost;
|
|
|
1093 return false;
|
|
|
1094
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1095 case Intrinsic::memset:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1096 case Intrinsic::memcpy:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1097 case Intrinsic::memmove:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1098 // SROA can usually chew through these intrinsics, but they aren't free.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1099 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1100 case Intrinsic::localescape:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1101 HasFrameEscape = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1102 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1103 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1104 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1105
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1106 if (F == CS.getInstruction()->getParent()->getParent()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1107 // This flag will fully abort the analysis, so don't bother with anything
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1108 // else.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1109 IsRecursiveCall = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1110 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1111 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1112
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1113 if (TTI.isLoweredToCall(F)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1114 // We account for the average 1 instruction per call argument setup
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1115 // here.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1116 Cost += CS.arg_size() * InlineConstants::InstrCost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1117
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1118 // Everything other than inline ASM will also have a significant cost
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1119 // merely from making the call.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1120 if (!isa<InlineAsm>(CS.getCalledValue()))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1121 Cost += InlineConstants::CallPenalty;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1122 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1123
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1124 return Base::visitCallSite(CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1125 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1126
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1127 // Otherwise we're in a very special case -- an indirect function call. See
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1128 // if we can be particularly clever about this.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1129 Value *Callee = CS.getCalledValue();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1130
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1131 // First, pay the price of the argument setup. We account for the average
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1132 // 1 instruction per call argument setup here.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1133 Cost += CS.arg_size() * InlineConstants::InstrCost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1134
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1135 // Next, check if this happens to be an indirect function call to a known
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1136 // function in this inline context. If not, we've done all we can.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1137 Function *F = dyn_cast_or_null<Function>(SimplifiedValues.lookup(Callee));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1138 if (!F)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1139 return Base::visitCallSite(CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1140
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1141 // If we have a constant that we are calling as a function, we can peer
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1142 // through it and see the function target. This happens not infrequently
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1143 // during devirtualization and so we want to give it a hefty bonus for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1144 // inlining, but cap that bonus in the event that inlining wouldn't pan
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1145 // out. Pretend to inline the function, with a custom threshold.
|
|
120
|
1146 auto IndirectCallParams = Params;
|
|
|
1147 IndirectCallParams.DefaultThreshold = InlineConstants::IndirectCallThreshold;
|
|
121
|
1148 CallAnalyzer CA(TTI, GetAssumptionCache, GetBFI, PSI, ORE, *F, CS,
|
|
|
1149 IndirectCallParams);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1150 if (CA.analyzeCall(CS)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1151 // We were able to inline the indirect call! Subtract the cost from the
|
|
100
|
1152 // threshold to get the bonus we want to apply, but don't go below zero.
|
|
|
1153 Cost -= std::max(0, CA.getThreshold() - CA.getCost());
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1154 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1155
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1156 return Base::visitCallSite(CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1157 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1158
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1159 bool CallAnalyzer::visitReturnInst(ReturnInst &RI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1160 // At least one return instruction will be free after inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1161 bool Free = !HasReturn;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1162 HasReturn = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1163 return Free;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1164 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1165
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1166 bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1167 // We model unconditional branches as essentially free -- they really
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1168 // shouldn't exist at all, but handling them makes the behavior of the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1169 // inliner more regular and predictable. Interestingly, conditional branches
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1170 // which will fold away are also free.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1171 return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1172 dyn_cast_or_null<ConstantInt>(
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1173 SimplifiedValues.lookup(BI.getCondition()));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1174 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1175
|
|
121
|
1176 bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
|
|
|
1177 bool CheckSROA = SI.getType()->isPointerTy();
|
|
|
1178 Value *TrueVal = SI.getTrueValue();
|
|
|
1179 Value *FalseVal = SI.getFalseValue();
|
|
|
1180
|
|
|
1181 Constant *TrueC = dyn_cast<Constant>(TrueVal);
|
|
|
1182 if (!TrueC)
|
|
|
1183 TrueC = SimplifiedValues.lookup(TrueVal);
|
|
|
1184 Constant *FalseC = dyn_cast<Constant>(FalseVal);
|
|
|
1185 if (!FalseC)
|
|
|
1186 FalseC = SimplifiedValues.lookup(FalseVal);
|
|
|
1187 Constant *CondC =
|
|
|
1188 dyn_cast_or_null<Constant>(SimplifiedValues.lookup(SI.getCondition()));
|
|
|
1189
|
|
|
1190 if (!CondC) {
|
|
|
1191 // Select C, X, X => X
|
|
|
1192 if (TrueC == FalseC && TrueC) {
|
|
|
1193 SimplifiedValues[&SI] = TrueC;
|
|
|
1194 return true;
|
|
|
1195 }
|
|
|
1196
|
|
|
1197 if (!CheckSROA)
|
|
|
1198 return Base::visitSelectInst(SI);
|
|
|
1199
|
|
|
1200 std::pair<Value *, APInt> TrueBaseAndOffset =
|
|
|
1201 ConstantOffsetPtrs.lookup(TrueVal);
|
|
|
1202 std::pair<Value *, APInt> FalseBaseAndOffset =
|
|
|
1203 ConstantOffsetPtrs.lookup(FalseVal);
|
|
|
1204 if (TrueBaseAndOffset == FalseBaseAndOffset && TrueBaseAndOffset.first) {
|
|
|
1205 ConstantOffsetPtrs[&SI] = TrueBaseAndOffset;
|
|
|
1206
|
|
|
1207 Value *SROAArg;
|
|
|
1208 DenseMap<Value *, int>::iterator CostIt;
|
|
|
1209 if (lookupSROAArgAndCost(TrueVal, SROAArg, CostIt))
|
|
|
1210 SROAArgValues[&SI] = SROAArg;
|
|
|
1211 return true;
|
|
|
1212 }
|
|
|
1213
|
|
|
1214 return Base::visitSelectInst(SI);
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 // Select condition is a constant.
|
|
|
1218 Value *SelectedV = CondC->isAllOnesValue()
|
|
|
1219 ? TrueVal
|
|
|
1220 : (CondC->isNullValue()) ? FalseVal : nullptr;
|
|
|
1221 if (!SelectedV) {
|
|
|
1222 // Condition is a vector constant that is not all 1s or all 0s. If all
|
|
|
1223 // operands are constants, ConstantExpr::getSelect() can handle the cases
|
|
|
1224 // such as select vectors.
|
|
|
1225 if (TrueC && FalseC) {
|
|
|
1226 if (auto *C = ConstantExpr::getSelect(CondC, TrueC, FalseC)) {
|
|
|
1227 SimplifiedValues[&SI] = C;
|
|
|
1228 return true;
|
|
|
1229 }
|
|
|
1230 }
|
|
|
1231 return Base::visitSelectInst(SI);
|
|
|
1232 }
|
|
|
1233
|
|
|
1234 // Condition is either all 1s or all 0s. SI can be simplified.
|
|
|
1235 if (Constant *SelectedC = dyn_cast<Constant>(SelectedV)) {
|
|
|
1236 SimplifiedValues[&SI] = SelectedC;
|
|
|
1237 return true;
|
|
|
1238 }
|
|
|
1239
|
|
|
1240 if (!CheckSROA)
|
|
|
1241 return true;
|
|
|
1242
|
|
|
1243 std::pair<Value *, APInt> BaseAndOffset =
|
|
|
1244 ConstantOffsetPtrs.lookup(SelectedV);
|
|
|
1245 if (BaseAndOffset.first) {
|
|
|
1246 ConstantOffsetPtrs[&SI] = BaseAndOffset;
|
|
|
1247
|
|
|
1248 Value *SROAArg;
|
|
|
1249 DenseMap<Value *, int>::iterator CostIt;
|
|
|
1250 if (lookupSROAArgAndCost(SelectedV, SROAArg, CostIt))
|
|
|
1251 SROAArgValues[&SI] = SROAArg;
|
|
|
1252 }
|
|
|
1253
|
|
|
1254 return true;
|
|
|
1255 }
|
|
|
1256
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1257 bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1258 // We model unconditional switches as free, see the comments on handling
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1259 // branches.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1260 if (isa<ConstantInt>(SI.getCondition()))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1261 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1262 if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1263 if (isa<ConstantInt>(V))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1264 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1265
|
|
121
|
1266 // Assume the most general case where the switch is lowered into
|
|
|
1267 // either a jump table, bit test, or a balanced binary tree consisting of
|
|
|
1268 // case clusters without merging adjacent clusters with the same
|
|
|
1269 // destination. We do not consider the switches that are lowered with a mix
|
|
|
1270 // of jump table/bit test/binary search tree. The cost of the switch is
|
|
|
1271 // proportional to the size of the tree or the size of jump table range.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1272 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1273 // NB: We convert large switches which are just used to initialize large phi
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1274 // nodes to lookup tables instead in simplify-cfg, so this shouldn't prevent
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1275 // inlining those. It will prevent inlining in cases where the optimization
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1276 // does not (yet) fire.
|
|
121
|
1277
|
|
|
1278 // Maximum valid cost increased in this function.
|
|
|
1279 int CostUpperBound = INT_MAX - InlineConstants::InstrCost - 1;
|
|
|
1280
|
|
|
1281 // Exit early for a large switch, assuming one case needs at least one
|
|
|
1282 // instruction.
|
|
|
1283 // FIXME: This is not true for a bit test, but ignore such case for now to
|
|
|
1284 // save compile-time.
|
|
|
1285 int64_t CostLowerBound =
|
|
|
1286 std::min((int64_t)CostUpperBound,
|
|
|
1287 (int64_t)SI.getNumCases() * InlineConstants::InstrCost + Cost);
|
|
|
1288
|
|
|
1289 if (CostLowerBound > Threshold && !ComputeFullInlineCost) {
|
|
|
1290 Cost = CostLowerBound;
|
|
|
1291 return false;
|
|
|
1292 }
|
|
|
1293
|
|
|
1294 unsigned JumpTableSize = 0;
|
|
|
1295 unsigned NumCaseCluster =
|
|
|
1296 TTI.getEstimatedNumberOfCaseClusters(SI, JumpTableSize);
|
|
|
1297
|
|
|
1298 // If suitable for a jump table, consider the cost for the table size and
|
|
|
1299 // branch to destination.
|
|
|
1300 if (JumpTableSize) {
|
|
|
1301 int64_t JTCost = (int64_t)JumpTableSize * InlineConstants::InstrCost +
|
|
|
1302 4 * InlineConstants::InstrCost;
|
|
|
1303
|
|
|
1304 Cost = std::min((int64_t)CostUpperBound, JTCost + Cost);
|
|
|
1305 return false;
|
|
|
1306 }
|
|
|
1307
|
|
|
1308 // Considering forming a binary search, we should find the number of nodes
|
|
|
1309 // which is same as the number of comparisons when lowered. For a given
|
|
|
1310 // number of clusters, n, we can define a recursive function, f(n), to find
|
|
|
1311 // the number of nodes in the tree. The recursion is :
|
|
|
1312 // f(n) = 1 + f(n/2) + f (n - n/2), when n > 3,
|
|
|
1313 // and f(n) = n, when n <= 3.
|
|
|
1314 // This will lead a binary tree where the leaf should be either f(2) or f(3)
|
|
|
1315 // when n > 3. So, the number of comparisons from leaves should be n, while
|
|
|
1316 // the number of non-leaf should be :
|
|
|
1317 // 2^(log2(n) - 1) - 1
|
|
|
1318 // = 2^log2(n) * 2^-1 - 1
|
|
|
1319 // = n / 2 - 1.
|
|
|
1320 // Considering comparisons from leaf and non-leaf nodes, we can estimate the
|
|
|
1321 // number of comparisons in a simple closed form :
|
|
|
1322 // n + n / 2 - 1 = n * 3 / 2 - 1
|
|
|
1323 if (NumCaseCluster <= 3) {
|
|
|
1324 // Suppose a comparison includes one compare and one conditional branch.
|
|
|
1325 Cost += NumCaseCluster * 2 * InlineConstants::InstrCost;
|
|
|
1326 return false;
|
|
|
1327 }
|
|
|
1328
|
|
|
1329 int64_t ExpectedNumberOfCompare = 3 * (int64_t)NumCaseCluster / 2 - 1;
|
|
|
1330 int64_t SwitchCost =
|
|
|
1331 ExpectedNumberOfCompare * 2 * InlineConstants::InstrCost;
|
|
|
1332
|
|
|
1333 Cost = std::min((int64_t)CostUpperBound, SwitchCost + Cost);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1334 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1335 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1336
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1337 bool CallAnalyzer::visitIndirectBrInst(IndirectBrInst &IBI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1338 // We never want to inline functions that contain an indirectbr. This is
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1339 // incorrect because all the blockaddress's (in static global initializers
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1340 // for example) would be referring to the original function, and this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1341 // indirect jump would jump from the inlined copy of the function into the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1342 // original function which is extremely undefined behavior.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1343 // FIXME: This logic isn't really right; we can safely inline functions with
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1344 // indirectbr's as long as no other function or global references the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1345 // blockaddress of a block within the current function.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1346 HasIndirectBr = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1347 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1348 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1349
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1350 bool CallAnalyzer::visitResumeInst(ResumeInst &RI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1351 // FIXME: It's not clear that a single instruction is an accurate model for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1352 // the inline cost of a resume instruction.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1353 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1354 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1355
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1356 bool CallAnalyzer::visitCleanupReturnInst(CleanupReturnInst &CRI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1357 // FIXME: It's not clear that a single instruction is an accurate model for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1358 // the inline cost of a cleanupret instruction.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1359 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1360 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1361
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1362 bool CallAnalyzer::visitCatchReturnInst(CatchReturnInst &CRI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1363 // FIXME: It's not clear that a single instruction is an accurate model for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1364 // the inline cost of a catchret instruction.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1365 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1366 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1367
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1368 bool CallAnalyzer::visitUnreachableInst(UnreachableInst &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1369 // FIXME: It might be reasonably to discount the cost of instructions leading
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1370 // to unreachable as they have the lowest possible impact on both runtime and
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1371 // code size.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1372 return true; // No actual code is needed for unreachable.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1373 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1374
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1375 bool CallAnalyzer::visitInstruction(Instruction &I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1376 // Some instructions are free. All of the free intrinsics can also be
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1377 // handled by SROA, etc.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1378 if (TargetTransformInfo::TCC_Free == TTI.getUserCost(&I))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1379 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1380
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1381 // We found something we don't understand or can't handle. Mark any SROA-able
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1382 // values in the operand list as no longer viable.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1383 for (User::op_iterator OI = I.op_begin(), OE = I.op_end(); OI != OE; ++OI)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1384 disableSROA(*OI);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1385
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1386 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1387 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1388
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1389 /// \brief Analyze a basic block for its contribution to the inline cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1390 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1391 /// This method walks the analyzer over every instruction in the given basic
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1392 /// block and accounts for their cost during inlining at this callsite. It
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1393 /// aborts early if the threshold has been exceeded or an impossible to inline
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1394 /// construct has been detected. It returns false if inlining is no longer
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1395 /// viable, and true if inlining remains viable.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1396 bool CallAnalyzer::analyzeBlock(BasicBlock *BB,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1397 SmallPtrSetImpl<const Value *> &EphValues) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1398 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1399 // FIXME: Currently, the number of instructions in a function regardless of
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1400 // our ability to simplify them during inline to constants or dead code,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1401 // are actually used by the vector bonus heuristic. As long as that's true,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1402 // we have to special case debug intrinsics here to prevent differences in
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1403 // inlining due to debug symbols. Eventually, the number of unsimplified
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1404 // instructions shouldn't factor into the cost computation, but until then,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1405 // hack around it here.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1406 if (isa<DbgInfoIntrinsic>(I))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1407 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1408
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1409 // Skip ephemeral values.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1410 if (EphValues.count(&*I))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1411 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1412
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1413 ++NumInstructions;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1414 if (isa<ExtractElementInst>(I) || I->getType()->isVectorTy())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1415 ++NumVectorInstructions;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1416
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1417 // If the instruction is floating point, and the target says this operation
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1418 // is expensive or the function has the "use-soft-float" attribute, this may
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1419 // eventually become a library call. Treat the cost as such.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1420 if (I->getType()->isFloatingPointTy()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1421 // If the function has the "use-soft-float" attribute, mark it as
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1422 // expensive.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1423 if (TTI.getFPOpCost(I->getType()) == TargetTransformInfo::TCC_Expensive ||
|
|
121
|
1424 (F.getFnAttribute("use-soft-float").getValueAsString() == "true"))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1425 Cost += InlineConstants::CallPenalty;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1426 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1427
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1428 // If the instruction simplified to a constant, there is no cost to this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1429 // instruction. Visit the instructions using our InstVisitor to account for
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1430 // all of the per-instruction logic. The visit tree returns true if we
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1431 // consumed the instruction in any way, and false if the instruction's base
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1432 // cost should count against inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1433 if (Base::visit(&*I))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1434 ++NumInstructionsSimplified;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1435 else
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1436 Cost += InlineConstants::InstrCost;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1437
|
|
121
|
1438 using namespace ore;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1439 // If the visit this instruction detected an uninlinable pattern, abort.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1440 if (IsRecursiveCall || ExposesReturnsTwice || HasDynamicAlloca ||
|
|
121
|
1441 HasIndirectBr || HasFrameEscape) {
|
|
|
1442 if (ORE)
|
|
|
1443 ORE->emit([&]() {
|
|
|
1444 return OptimizationRemarkMissed(DEBUG_TYPE, "NeverInline",
|
|
|
1445 CandidateCS.getInstruction())
|
|
|
1446 << NV("Callee", &F)
|
|
|
1447 << " has uninlinable pattern and cost is not fully computed";
|
|
|
1448 });
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1449 return false;
|
|
121
|
1450 }
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1451
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1452 // If the caller is a recursive function then we don't want to inline
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1453 // functions which allocate a lot of stack space because it would increase
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1454 // the caller stack usage dramatically.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1455 if (IsCallerRecursive &&
|
|
121
|
1456 AllocatedSize > InlineConstants::TotalAllocaSizeRecursiveCaller) {
|
|
|
1457 if (ORE)
|
|
|
1458 ORE->emit([&]() {
|
|
|
1459 return OptimizationRemarkMissed(DEBUG_TYPE, "NeverInline",
|
|
|
1460 CandidateCS.getInstruction())
|
|
|
1461 << NV("Callee", &F)
|
|
|
1462 << " is recursive and allocates too much stack space. Cost is "
|
|
|
1463 "not fully computed";
|
|
|
1464 });
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1465 return false;
|
|
121
|
1466 }
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1467
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1468 // Check if we've past the maximum possible threshold so we don't spin in
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1469 // huge basic blocks that will never inline.
|
|
121
|
1470 if (Cost >= Threshold && !ComputeFullInlineCost)
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1471 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1472 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1473
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1474 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1475 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1476
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1477 /// \brief Compute the base pointer and cumulative constant offsets for V.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1478 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1479 /// This strips all constant offsets off of V, leaving it the base pointer, and
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1480 /// accumulates the total constant offset applied in the returned constant. It
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1481 /// returns 0 if V is not a pointer, and returns the constant '0' if there are
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1482 /// no constant offsets applied.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1483 ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1484 if (!V->getType()->isPointerTy())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1485 return nullptr;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1486
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1487 unsigned IntPtrWidth = DL.getPointerSizeInBits();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1488 APInt Offset = APInt::getNullValue(IntPtrWidth);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1489
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1490 // Even though we don't look through PHI nodes, we could be called on an
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1491 // instruction in an unreachable block, which may be on a cycle.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1492 SmallPtrSet<Value *, 4> Visited;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1493 Visited.insert(V);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1494 do {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1495 if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1496 if (!GEP->isInBounds() || !accumulateGEPOffset(*GEP, Offset))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1497 return nullptr;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1498 V = GEP->getPointerOperand();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1499 } else if (Operator::getOpcode(V) == Instruction::BitCast) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1500 V = cast<Operator>(V)->getOperand(0);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1501 } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
|
|
120
|
1502 if (GA->isInterposable())
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1503 break;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1504 V = GA->getAliasee();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1505 } else {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1506 break;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1507 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1508 assert(V->getType()->isPointerTy() && "Unexpected operand type!");
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1509 } while (Visited.insert(V).second);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1510
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1511 Type *IntPtrTy = DL.getIntPtrType(V->getContext());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1512 return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1513 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1514
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1515 /// \brief Analyze a call site for potential inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1516 ///
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1517 /// Returns true if inlining this call is viable, and false if it is not
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1518 /// viable. It computes the cost and adjusts the threshold based on numerous
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1519 /// factors and heuristics. If this method returns false but the computed cost
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1520 /// is below the computed threshold, then inlining was forcibly disabled by
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1521 /// some artifact of the routine.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1522 bool CallAnalyzer::analyzeCall(CallSite CS) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1523 ++NumCallsAnalyzed;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1524
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1525 // Perform some tweaks to the cost and threshold based on the direct
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1526 // callsite information.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1527
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1528 // We want to more aggressively inline vector-dense kernels, so up the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1529 // threshold, and we'll lower it if the % of vector instructions gets too
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1530 // low. Note that these bonuses are some what arbitrary and evolved over time
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1531 // by accident as much as because they are principled bonuses.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1532 //
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1533 // FIXME: It would be nice to remove all such bonuses. At least it would be
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1534 // nice to base the bonus values on something more scientific.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1535 assert(NumInstructions == 0);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1536 assert(NumVectorInstructions == 0);
|
|
100
|
1537
|
|
|
1538 // Update the threshold based on callsite properties
|
|
|
1539 updateThreshold(CS, F);
|
|
|
1540
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1541 // Speculatively apply all possible bonuses to Threshold. If cost exceeds
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1542 // this Threshold any time, and cost cannot decrease, we can stop processing
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1543 // the rest of the function body.
|
|
121
|
1544 Threshold += (SingleBBBonus + VectorBonus);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1545
|
|
121
|
1546 // Give out bonuses for the callsite, as the instructions setting them up
|
|
|
1547 // will be gone after inlining.
|
|
|
1548 Cost -= getCallsiteCost(CS, DL);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1549
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1550 // If this function uses the coldcc calling convention, prefer not to inline
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1551 // it.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1552 if (F.getCallingConv() == CallingConv::Cold)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1553 Cost += InlineConstants::ColdccPenalty;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1554
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1555 // Check if we're done. This can happen due to bonuses and penalties.
|
|
121
|
1556 if (Cost >= Threshold && !ComputeFullInlineCost)
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1557 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1558
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1559 if (F.empty())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1560 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1561
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1562 Function *Caller = CS.getInstruction()->getParent()->getParent();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1563 // Check if the caller function is recursive itself.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1564 for (User *U : Caller->users()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1565 CallSite Site(U);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1566 if (!Site)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1567 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1568 Instruction *I = Site.getInstruction();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1569 if (I->getParent()->getParent() == Caller) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1570 IsCallerRecursive = true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1571 break;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1572 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1573 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1574
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1575 // Populate our simplified values by mapping from function arguments to call
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1576 // arguments with known important simplifications.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1577 CallSite::arg_iterator CAI = CS.arg_begin();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1578 for (Function::arg_iterator FAI = F.arg_begin(), FAE = F.arg_end();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1579 FAI != FAE; ++FAI, ++CAI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1580 assert(CAI != CS.arg_end());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1581 if (Constant *C = dyn_cast<Constant>(CAI))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1582 SimplifiedValues[&*FAI] = C;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1583
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1584 Value *PtrArg = *CAI;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1585 if (ConstantInt *C = stripAndComputeInBoundsConstantOffsets(PtrArg)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1586 ConstantOffsetPtrs[&*FAI] = std::make_pair(PtrArg, C->getValue());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1587
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1588 // We can SROA any pointer arguments derived from alloca instructions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1589 if (isa<AllocaInst>(PtrArg)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1590 SROAArgValues[&*FAI] = PtrArg;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1591 SROAArgCosts[PtrArg] = 0;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1592 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1593 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1594 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1595 NumConstantArgs = SimplifiedValues.size();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1596 NumConstantOffsetPtrArgs = ConstantOffsetPtrs.size();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1597 NumAllocaArgs = SROAArgValues.size();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1598
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1599 // FIXME: If a caller has multiple calls to a callee, we end up recomputing
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1600 // the ephemeral values multiple times (and they're completely determined by
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1601 // the callee, so this is purely duplicate work).
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1602 SmallPtrSet<const Value *, 32> EphValues;
|
|
120
|
1603 CodeMetrics::collectEphemeralValues(&F, &GetAssumptionCache(F), EphValues);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1604
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1605 // The worklist of live basic blocks in the callee *after* inlining. We avoid
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1606 // adding basic blocks of the callee which can be proven to be dead for this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1607 // particular call site in order to get more accurate cost estimates. This
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1608 // requires a somewhat heavyweight iteration pattern: we need to walk the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1609 // basic blocks in a breadth-first order as we insert live successors. To
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1610 // accomplish this, prioritizing for small iterations because we exit after
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1611 // crossing our threshold, we use a small-size optimized SetVector.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1612 typedef SetVector<BasicBlock *, SmallVector<BasicBlock *, 16>,
|
|
120
|
1613 SmallPtrSet<BasicBlock *, 16>>
|
|
|
1614 BBSetVector;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1615 BBSetVector BBWorklist;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1616 BBWorklist.insert(&F.getEntryBlock());
|
|
121
|
1617 bool SingleBB = true;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1618 // Note that we *must not* cache the size, this loop grows the worklist.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1619 for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1620 // Bail out the moment we cross the threshold. This means we'll under-count
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1621 // the cost, but only when undercounting doesn't matter.
|
|
121
|
1622 if (Cost >= Threshold && !ComputeFullInlineCost)
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1623 break;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1624
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1625 BasicBlock *BB = BBWorklist[Idx];
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1626 if (BB->empty())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1627 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1628
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1629 // Disallow inlining a blockaddress. A blockaddress only has defined
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1630 // behavior for an indirect branch in the same function, and we do not
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1631 // currently support inlining indirect branches. But, the inliner may not
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1632 // see an indirect branch that ends up being dead code at a particular call
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1633 // site. If the blockaddress escapes the function, e.g., via a global
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1634 // variable, inlining may lead to an invalid cross-function reference.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1635 if (BB->hasAddressTaken())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1636 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1637
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1638 // Analyze the cost of this block. If we blow through the threshold, this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1639 // returns false, and we can bail on out.
|
|
120
|
1640 if (!analyzeBlock(BB, EphValues))
|
|
|
1641 return false;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1642
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1643 TerminatorInst *TI = BB->getTerminator();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1644
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1645 // Add in the live successors by first checking whether we have terminator
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1646 // that may be simplified based on the values simplified by this call.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1647 if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1648 if (BI->isConditional()) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1649 Value *Cond = BI->getCondition();
|
|
120
|
1650 if (ConstantInt *SimpleCond =
|
|
|
1651 dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1652 BBWorklist.insert(BI->getSuccessor(SimpleCond->isZero() ? 1 : 0));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1653 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1654 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1655 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1656 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1657 Value *Cond = SI->getCondition();
|
|
120
|
1658 if (ConstantInt *SimpleCond =
|
|
|
1659 dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
|
|
121
|
1660 BBWorklist.insert(SI->findCaseValue(SimpleCond)->getCaseSuccessor());
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1661 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1662 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1663 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1664
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1665 // If we're unable to select a particular successor, just count all of
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1666 // them.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1667 for (unsigned TIdx = 0, TSize = TI->getNumSuccessors(); TIdx != TSize;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1668 ++TIdx)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1669 BBWorklist.insert(TI->getSuccessor(TIdx));
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1670
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1671 // If we had any successors at this point, than post-inlining is likely to
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1672 // have them as well. Note that we assume any basic blocks which existed
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1673 // due to branches or switches which folded above will also fold after
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1674 // inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1675 if (SingleBB && TI->getNumSuccessors() > 1) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1676 // Take off the bonus we applied to the threshold.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1677 Threshold -= SingleBBBonus;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1678 SingleBB = false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1679 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1680 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1681
|
|
121
|
1682 bool OnlyOneCallAndLocalLinkage =
|
|
|
1683 F.hasLocalLinkage() && F.hasOneUse() && &F == CS.getCalledFunction();
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1684 // If this is a noduplicate call, we can still inline as long as
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1685 // inlining this would cause the removal of the caller (so the instruction
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1686 // is not actually duplicated, just moved).
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1687 if (!OnlyOneCallAndLocalLinkage && ContainsNoDuplicateCall)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1688 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1689
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1690 // We applied the maximum possible vector bonus at the beginning. Now,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1691 // subtract the excess bonus, if any, from the Threshold before
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1692 // comparing against Cost.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1693 if (NumVectorInstructions <= NumInstructions / 10)
|
|
121
|
1694 Threshold -= VectorBonus;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1695 else if (NumVectorInstructions <= NumInstructions / 2)
|
|
121
|
1696 Threshold -= VectorBonus/2;
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1697
|
|
120
|
1698 return Cost < std::max(1, Threshold);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1699 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1700
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1701 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1702 /// \brief Dump stats about this call's analysis.
|
|
120
|
1703 LLVM_DUMP_METHOD void CallAnalyzer::dump() {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1704 #define DEBUG_PRINT_STAT(x) dbgs() << " " #x ": " << x << "\n"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1705 DEBUG_PRINT_STAT(NumConstantArgs);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1706 DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1707 DEBUG_PRINT_STAT(NumAllocaArgs);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1708 DEBUG_PRINT_STAT(NumConstantPtrCmps);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1709 DEBUG_PRINT_STAT(NumConstantPtrDiffs);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1710 DEBUG_PRINT_STAT(NumInstructionsSimplified);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1711 DEBUG_PRINT_STAT(NumInstructions);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1712 DEBUG_PRINT_STAT(SROACostSavings);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1713 DEBUG_PRINT_STAT(SROACostSavingsLost);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1714 DEBUG_PRINT_STAT(ContainsNoDuplicateCall);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1715 DEBUG_PRINT_STAT(Cost);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1716 DEBUG_PRINT_STAT(Threshold);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1717 #undef DEBUG_PRINT_STAT
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1718 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1719 #endif
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1720
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1721 /// \brief Test that there are no attribute conflicts between Caller and Callee
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1722 /// that prevent inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1723 static bool functionsHaveCompatibleAttributes(Function *Caller,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1724 Function *Callee,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1725 TargetTransformInfo &TTI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1726 return TTI.areInlineCompatible(Caller, Callee) &&
|
|
100
|
1727 AttributeFuncs::areInlineCompatible(*Caller, *Callee);
|
|
|
1728 }
|
|
|
1729
|
|
121
|
1730 int llvm::getCallsiteCost(CallSite CS, const DataLayout &DL) {
|
|
|
1731 int Cost = 0;
|
|
|
1732 for (unsigned I = 0, E = CS.arg_size(); I != E; ++I) {
|
|
|
1733 if (CS.isByValArgument(I)) {
|
|
|
1734 // We approximate the number of loads and stores needed by dividing the
|
|
|
1735 // size of the byval type by the target's pointer size.
|
|
|
1736 PointerType *PTy = cast<PointerType>(CS.getArgument(I)->getType());
|
|
|
1737 unsigned TypeSize = DL.getTypeSizeInBits(PTy->getElementType());
|
|
|
1738 unsigned PointerSize = DL.getPointerSizeInBits();
|
|
|
1739 // Ceiling division.
|
|
|
1740 unsigned NumStores = (TypeSize + PointerSize - 1) / PointerSize;
|
|
|
1741
|
|
|
1742 // If it generates more than 8 stores it is likely to be expanded as an
|
|
|
1743 // inline memcpy so we take that as an upper bound. Otherwise we assume
|
|
|
1744 // one load and one store per word copied.
|
|
|
1745 // FIXME: The maxStoresPerMemcpy setting from the target should be used
|
|
|
1746 // here instead of a magic number of 8, but it's not available via
|
|
|
1747 // DataLayout.
|
|
|
1748 NumStores = std::min(NumStores, 8U);
|
|
|
1749
|
|
|
1750 Cost += 2 * NumStores * InlineConstants::InstrCost;
|
|
|
1751 } else {
|
|
|
1752 // For non-byval arguments subtract off one instruction per call
|
|
|
1753 // argument.
|
|
|
1754 Cost += InlineConstants::InstrCost;
|
|
|
1755 }
|
|
|
1756 }
|
|
|
1757 // The call instruction also disappears after inlining.
|
|
|
1758 Cost += InlineConstants::InstrCost + InlineConstants::CallPenalty;
|
|
|
1759 return Cost;
|
|
|
1760 }
|
|
|
1761
|
|
120
|
1762 InlineCost llvm::getInlineCost(
|
|
|
1763 CallSite CS, const InlineParams &Params, TargetTransformInfo &CalleeTTI,
|
|
|
1764 std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
|
|
121
|
1765 Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
|
|
|
1766 ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE) {
|
|
120
|
1767 return getInlineCost(CS, CS.getCalledFunction(), Params, CalleeTTI,
|
|
121
|
1768 GetAssumptionCache, GetBFI, PSI, ORE);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1769 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1770
|
|
120
|
1771 InlineCost llvm::getInlineCost(
|
|
|
1772 CallSite CS, Function *Callee, const InlineParams &Params,
|
|
|
1773 TargetTransformInfo &CalleeTTI,
|
|
|
1774 std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
|
|
121
|
1775 Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
|
|
|
1776 ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE) {
|
|
100
|
1777
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1778 // Cannot inline indirect calls.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1779 if (!Callee)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1780 return llvm::InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1781
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1782 // Calls to functions with always-inline attributes should be inlined
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1783 // whenever possible.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1784 if (CS.hasFnAttr(Attribute::AlwaysInline)) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1785 if (isInlineViable(*Callee))
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1786 return llvm::InlineCost::getAlways();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1787 return llvm::InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1788 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1789
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1790 // Never inline functions with conflicting attributes (unless callee has
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1791 // always-inline attribute).
|
|
121
|
1792 Function *Caller = CS.getCaller();
|
|
|
1793 if (!functionsHaveCompatibleAttributes(Caller, Callee, CalleeTTI))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1794 return llvm::InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1795
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1796 // Don't inline this call if the caller has the optnone attribute.
|
|
121
|
1797 if (Caller->hasFnAttribute(Attribute::OptimizeNone))
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1798 return llvm::InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1799
|
|
120
|
1800 // Don't inline functions which can be interposed at link-time. Don't inline
|
|
|
1801 // functions marked noinline or call sites marked noinline.
|
|
121
|
1802 // Note: inlining non-exact non-interposable functions is fine, since we know
|
|
120
|
1803 // we have *a* correct implementation of the source level function.
|
|
|
1804 if (Callee->isInterposable() || Callee->hasFnAttribute(Attribute::NoInline) ||
|
|
|
1805 CS.isNoInline())
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1806 return llvm::InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1807
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1808 DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName()
|
|
121
|
1809 << "... (caller:" << Caller->getName() << ")\n");
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1810
|
|
121
|
1811 CallAnalyzer CA(CalleeTTI, GetAssumptionCache, GetBFI, PSI, ORE, *Callee, CS,
|
|
|
1812 Params);
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1813 bool ShouldInline = CA.analyzeCall(CS);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1814
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1815 DEBUG(CA.dump());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1816
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1817 // Check if there was a reason to force inlining or no inlining.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1818 if (!ShouldInline && CA.getCost() < CA.getThreshold())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1819 return InlineCost::getNever();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1820 if (ShouldInline && CA.getCost() >= CA.getThreshold())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1821 return InlineCost::getAlways();
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1822
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1823 return llvm::InlineCost::get(CA.getCost(), CA.getThreshold());
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1824 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1825
|
|
100
|
1826 bool llvm::isInlineViable(Function &F) {
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1827 bool ReturnsTwice = F.hasFnAttribute(Attribute::ReturnsTwice);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1828 for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1829 // Disallow inlining of functions which contain indirect branches or
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1830 // blockaddresses.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1831 if (isa<IndirectBrInst>(BI->getTerminator()) || BI->hasAddressTaken())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1832 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1833
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1834 for (auto &II : *BI) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1835 CallSite CS(&II);
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1836 if (!CS)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1837 continue;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1838
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1839 // Disallow recursive calls.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1840 if (&F == CS.getCalledFunction())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1841 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1842
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1843 // Disallow calls which expose returns-twice to a function not previously
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1844 // attributed as such.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1845 if (!ReturnsTwice && CS.isCall() &&
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1846 cast<CallInst>(CS.getInstruction())->canReturnTwice())
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1847 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1848
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1849 // Disallow inlining functions that call @llvm.localescape. Doing this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1850 // correctly would require major changes to the inliner.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1851 if (CS.getCalledFunction() &&
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1852 CS.getCalledFunction()->getIntrinsicID() ==
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1853 llvm::Intrinsic::localescape)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1854 return false;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1855 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1856 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1857
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1858 return true;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1859 }
|
|
120
|
1860
|
|
|
1861 // APIs to create InlineParams based on command line flags and/or other
|
|
|
1862 // parameters.
|
|
|
1863
|
|
|
1864 InlineParams llvm::getInlineParams(int Threshold) {
|
|
|
1865 InlineParams Params;
|
|
|
1866
|
|
|
1867 // This field is the threshold to use for a callee by default. This is
|
|
|
1868 // derived from one or more of:
|
|
|
1869 // * optimization or size-optimization levels,
|
|
|
1870 // * a value passed to createFunctionInliningPass function, or
|
|
|
1871 // * the -inline-threshold flag.
|
|
|
1872 // If the -inline-threshold flag is explicitly specified, that is used
|
|
|
1873 // irrespective of anything else.
|
|
|
1874 if (InlineThreshold.getNumOccurrences() > 0)
|
|
|
1875 Params.DefaultThreshold = InlineThreshold;
|
|
|
1876 else
|
|
|
1877 Params.DefaultThreshold = Threshold;
|
|
|
1878
|
|
|
1879 // Set the HintThreshold knob from the -inlinehint-threshold.
|
|
|
1880 Params.HintThreshold = HintThreshold;
|
|
|
1881
|
|
|
1882 // Set the HotCallSiteThreshold knob from the -hot-callsite-threshold.
|
|
|
1883 Params.HotCallSiteThreshold = HotCallSiteThreshold;
|
|
|
1884
|
|
121
|
1885 // If the -locally-hot-callsite-threshold is explicitly specified, use it to
|
|
|
1886 // populate LocallyHotCallSiteThreshold. Later, we populate
|
|
|
1887 // Params.LocallyHotCallSiteThreshold from -locally-hot-callsite-threshold if
|
|
|
1888 // we know that optimization level is O3 (in the getInlineParams variant that
|
|
|
1889 // takes the opt and size levels).
|
|
|
1890 // FIXME: Remove this check (and make the assignment unconditional) after
|
|
|
1891 // addressing size regression issues at O2.
|
|
|
1892 if (LocallyHotCallSiteThreshold.getNumOccurrences() > 0)
|
|
|
1893 Params.LocallyHotCallSiteThreshold = LocallyHotCallSiteThreshold;
|
|
|
1894
|
|
|
1895 // Set the ColdCallSiteThreshold knob from the -inline-cold-callsite-threshold.
|
|
|
1896 Params.ColdCallSiteThreshold = ColdCallSiteThreshold;
|
|
|
1897
|
|
120
|
1898 // Set the OptMinSizeThreshold and OptSizeThreshold params only if the
|
|
|
1899 // -inlinehint-threshold commandline option is not explicitly given. If that
|
|
|
1900 // option is present, then its value applies even for callees with size and
|
|
|
1901 // minsize attributes.
|
|
|
1902 // If the -inline-threshold is not specified, set the ColdThreshold from the
|
|
|
1903 // -inlinecold-threshold even if it is not explicitly passed. If
|
|
|
1904 // -inline-threshold is specified, then -inlinecold-threshold needs to be
|
|
|
1905 // explicitly specified to set the ColdThreshold knob
|
|
|
1906 if (InlineThreshold.getNumOccurrences() == 0) {
|
|
|
1907 Params.OptMinSizeThreshold = InlineConstants::OptMinSizeThreshold;
|
|
|
1908 Params.OptSizeThreshold = InlineConstants::OptSizeThreshold;
|
|
|
1909 Params.ColdThreshold = ColdThreshold;
|
|
|
1910 } else if (ColdThreshold.getNumOccurrences() > 0) {
|
|
|
1911 Params.ColdThreshold = ColdThreshold;
|
|
|
1912 }
|
|
|
1913 return Params;
|
|
|
1914 }
|
|
|
1915
|
|
|
1916 InlineParams llvm::getInlineParams() {
|
|
|
1917 return getInlineParams(InlineThreshold);
|
|
|
1918 }
|
|
|
1919
|
|
|
1920 // Compute the default threshold for inlining based on the opt level and the
|
|
|
1921 // size opt level.
|
|
|
1922 static int computeThresholdFromOptLevels(unsigned OptLevel,
|
|
|
1923 unsigned SizeOptLevel) {
|
|
|
1924 if (OptLevel > 2)
|
|
|
1925 return InlineConstants::OptAggressiveThreshold;
|
|
|
1926 if (SizeOptLevel == 1) // -Os
|
|
|
1927 return InlineConstants::OptSizeThreshold;
|
|
|
1928 if (SizeOptLevel == 2) // -Oz
|
|
|
1929 return InlineConstants::OptMinSizeThreshold;
|
|
|
1930 return InlineThreshold;
|
|
|
1931 }
|
|
|
1932
|
|
|
1933 InlineParams llvm::getInlineParams(unsigned OptLevel, unsigned SizeOptLevel) {
|
|
121
|
1934 auto Params =
|
|
|
1935 getInlineParams(computeThresholdFromOptLevels(OptLevel, SizeOptLevel));
|
|
|
1936 // At O3, use the value of -locally-hot-callsite-threshold option to populate
|
|
|
1937 // Params.LocallyHotCallSiteThreshold. Below O3, this flag has effect only
|
|
|
1938 // when it is specified explicitly.
|
|
|
1939 if (OptLevel > 2)
|
|
|
1940 Params.LocallyHotCallSiteThreshold = LocallyHotCallSiteThreshold;
|
|
|
1941 return Params;
|
|
120
|
1942 }
|
