LLVM  3.7.0
InlineCost.cpp
Go to the documentation of this file.
1 //===- InlineCost.cpp - Cost analysis for inliner -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements inline cost analysis.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SetVector.h"
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/Statistic.h"
25 #include "llvm/IR/CallSite.h"
26 #include "llvm/IR/CallingConv.h"
27 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/GlobalAlias.h"
30 #include "llvm/IR/InstVisitor.h"
31 #include "llvm/IR/IntrinsicInst.h"
32 #include "llvm/IR/Operator.h"
33 #include "llvm/Support/Debug.h"
35 
36 using namespace llvm;
37 
38 #define DEBUG_TYPE "inline-cost"
39 
40 STATISTIC(NumCallsAnalyzed, "Number of call sites analyzed");
41 
42 namespace {
43 
44 class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
46  friend class InstVisitor<CallAnalyzer, bool>;
47 
48  /// The TargetTransformInfo available for this compilation.
49  const TargetTransformInfo &TTI;
50 
51  /// The cache of @llvm.assume intrinsics.
53 
54  // The called function.
55  Function &F;
56 
57  // The candidate callsite being analyzed. Please do not use this to do
58  // analysis in the caller function; we want the inline cost query to be
59  // easily cacheable. Instead, use the cover function paramHasAttr.
60  CallSite CandidateCS;
61 
62  int Threshold;
63  int Cost;
64 
65  bool IsCallerRecursive;
66  bool IsRecursiveCall;
67  bool ExposesReturnsTwice;
68  bool HasDynamicAlloca;
69  bool ContainsNoDuplicateCall;
70  bool HasReturn;
71  bool HasIndirectBr;
72  bool HasFrameEscape;
73 
74  /// Number of bytes allocated statically by the callee.
75  uint64_t AllocatedSize;
76  unsigned NumInstructions, NumVectorInstructions;
77  int FiftyPercentVectorBonus, TenPercentVectorBonus;
78  int VectorBonus;
79 
80  // While we walk the potentially-inlined instructions, we build up and
81  // maintain a mapping of simplified values specific to this callsite. The
82  // idea is to propagate any special information we have about arguments to
83  // this call through the inlinable section of the function, and account for
84  // likely simplifications post-inlining. The most important aspect we track
85  // is CFG altering simplifications -- when we prove a basic block dead, that
86  // can cause dramatic shifts in the cost of inlining a function.
87  DenseMap<Value *, Constant *> SimplifiedValues;
88 
89  // Keep track of the values which map back (through function arguments) to
90  // allocas on the caller stack which could be simplified through SROA.
91  DenseMap<Value *, Value *> SROAArgValues;
92 
93  // The mapping of caller Alloca values to their accumulated cost savings. If
94  // we have to disable SROA for one of the allocas, this tells us how much
95  // cost must be added.
96  DenseMap<Value *, int> SROAArgCosts;
97 
98  // Keep track of values which map to a pointer base and constant offset.
100 
101  // Custom simplification helper routines.
102  bool isAllocaDerivedArg(Value *V);
103  bool lookupSROAArgAndCost(Value *V, Value *&Arg,
105  void disableSROA(DenseMap<Value *, int>::iterator CostIt);
106  void disableSROA(Value *V);
107  void accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
108  int InstructionCost);
109  bool isGEPOffsetConstant(GetElementPtrInst &GEP);
110  bool accumulateGEPOffset(GEPOperator &GEP, APInt &Offset);
111  bool simplifyCallSite(Function *F, CallSite CS);
112  ConstantInt *stripAndComputeInBoundsConstantOffsets(Value *&V);
113 
114  /// Return true if the given argument to the function being considered for
115  /// inlining has the given attribute set either at the call site or the
116  /// function declaration. Primarily used to inspect call site specific
117  /// attributes since these can be more precise than the ones on the callee
118  /// itself.
119  bool paramHasAttr(Argument *A, Attribute::AttrKind Attr);
120 
121  /// Return true if the given value is known non null within the callee if
122  /// inlined through this particular callsite.
123  bool isKnownNonNullInCallee(Value *V);
124 
125  // Custom analysis routines.
126  bool analyzeBlock(BasicBlock *BB, SmallPtrSetImpl<const Value *> &EphValues);
127 
128  // Disable several entry points to the visitor so we don't accidentally use
129  // them by declaring but not defining them here.
130  void visit(Module *); void visit(Module &);
131  void visit(Function *); void visit(Function &);
132  void visit(BasicBlock *); void visit(BasicBlock &);
133 
134  // Provide base case for our instruction visit.
135  bool visitInstruction(Instruction &I);
136 
137  // Our visit overrides.
138  bool visitAlloca(AllocaInst &I);
139  bool visitPHI(PHINode &I);
140  bool visitGetElementPtr(GetElementPtrInst &I);
141  bool visitBitCast(BitCastInst &I);
142  bool visitPtrToInt(PtrToIntInst &I);
143  bool visitIntToPtr(IntToPtrInst &I);
144  bool visitCastInst(CastInst &I);
145  bool visitUnaryInstruction(UnaryInstruction &I);
146  bool visitCmpInst(CmpInst &I);
147  bool visitSub(BinaryOperator &I);
148  bool visitBinaryOperator(BinaryOperator &I);
149  bool visitLoad(LoadInst &I);
150  bool visitStore(StoreInst &I);
151  bool visitExtractValue(ExtractValueInst &I);
152  bool visitInsertValue(InsertValueInst &I);
153  bool visitCallSite(CallSite CS);
154  bool visitReturnInst(ReturnInst &RI);
155  bool visitBranchInst(BranchInst &BI);
156  bool visitSwitchInst(SwitchInst &SI);
157  bool visitIndirectBrInst(IndirectBrInst &IBI);
158  bool visitResumeInst(ResumeInst &RI);
159  bool visitUnreachableInst(UnreachableInst &I);
160 
161 public:
162  CallAnalyzer(const TargetTransformInfo &TTI, AssumptionCacheTracker *ACT,
163  Function &Callee, int Threshold, CallSite CSArg)
164  : TTI(TTI), ACT(ACT), F(Callee), CandidateCS(CSArg), Threshold(Threshold),
165  Cost(0), IsCallerRecursive(false), IsRecursiveCall(false),
166  ExposesReturnsTwice(false), HasDynamicAlloca(false),
167  ContainsNoDuplicateCall(false), HasReturn(false), HasIndirectBr(false),
168  HasFrameEscape(false), AllocatedSize(0), NumInstructions(0),
169  NumVectorInstructions(0), FiftyPercentVectorBonus(0),
170  TenPercentVectorBonus(0), VectorBonus(0), NumConstantArgs(0),
171  NumConstantOffsetPtrArgs(0), NumAllocaArgs(0), NumConstantPtrCmps(0),
172  NumConstantPtrDiffs(0), NumInstructionsSimplified(0),
173  SROACostSavings(0), SROACostSavingsLost(0) {}
174 
175  bool analyzeCall(CallSite CS);
176 
177  int getThreshold() { return Threshold; }
178  int getCost() { return Cost; }
179 
180  // Keep a bunch of stats about the cost savings found so we can print them
181  // out when debugging.
182  unsigned NumConstantArgs;
183  unsigned NumConstantOffsetPtrArgs;
184  unsigned NumAllocaArgs;
185  unsigned NumConstantPtrCmps;
186  unsigned NumConstantPtrDiffs;
187  unsigned NumInstructionsSimplified;
188  unsigned SROACostSavings;
189  unsigned SROACostSavingsLost;
190 
191  void dump();
192 };
193 
194 } // namespace
195 
196 /// \brief Test whether the given value is an Alloca-derived function argument.
197 bool CallAnalyzer::isAllocaDerivedArg(Value *V) {
198  return SROAArgValues.count(V);
199 }
200 
201 /// \brief Lookup the SROA-candidate argument and cost iterator which V maps to.
202 /// Returns false if V does not map to a SROA-candidate.
203 bool CallAnalyzer::lookupSROAArgAndCost(
204  Value *V, Value *&Arg, DenseMap<Value *, int>::iterator &CostIt) {
205  if (SROAArgValues.empty() || SROAArgCosts.empty())
206  return false;
207 
208  DenseMap<Value *, Value *>::iterator ArgIt = SROAArgValues.find(V);
209  if (ArgIt == SROAArgValues.end())
210  return false;
211 
212  Arg = ArgIt->second;
213  CostIt = SROAArgCosts.find(Arg);
214  return CostIt != SROAArgCosts.end();
215 }
216 
217 /// \brief Disable SROA for the candidate marked by this cost iterator.
218 ///
219 /// This marks the candidate as no longer viable for SROA, and adds the cost
220 /// savings associated with it back into the inline cost measurement.
221 void CallAnalyzer::disableSROA(DenseMap<Value *, int>::iterator CostIt) {
222  // If we're no longer able to perform SROA we need to undo its cost savings
223  // and prevent subsequent analysis.
224  Cost += CostIt->second;
225  SROACostSavings -= CostIt->second;
226  SROACostSavingsLost += CostIt->second;
227  SROAArgCosts.erase(CostIt);
228 }
229 
230 /// \brief If 'V' maps to a SROA candidate, disable SROA for it.
231 void CallAnalyzer::disableSROA(Value *V) {
232  Value *SROAArg;
234  if (lookupSROAArgAndCost(V, SROAArg, CostIt))
235  disableSROA(CostIt);
236 }
237 
238 /// \brief Accumulate the given cost for a particular SROA candidate.
239 void CallAnalyzer::accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
240  int InstructionCost) {
241  CostIt->second += InstructionCost;
242  SROACostSavings += InstructionCost;
243 }
244 
245 /// \brief Check whether a GEP's indices are all constant.
246 ///
247 /// Respects any simplified values known during the analysis of this callsite.
248 bool CallAnalyzer::isGEPOffsetConstant(GetElementPtrInst &GEP) {
249  for (User::op_iterator I = GEP.idx_begin(), E = GEP.idx_end(); I != E; ++I)
250  if (!isa<Constant>(*I) && !SimplifiedValues.lookup(*I))
251  return false;
252 
253  return true;
254 }
255 
256 /// \brief Accumulate a constant GEP offset into an APInt if possible.
257 ///
258 /// Returns false if unable to compute the offset for any reason. Respects any
259 /// simplified values known during the analysis of this callsite.
260 bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) {
261  const DataLayout &DL = F.getParent()->getDataLayout();
262  unsigned IntPtrWidth = DL.getPointerSizeInBits();
263  assert(IntPtrWidth == Offset.getBitWidth());
264 
265  for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
266  GTI != GTE; ++GTI) {
267  ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
268  if (!OpC)
269  if (Constant *SimpleOp = SimplifiedValues.lookup(GTI.getOperand()))
270  OpC = dyn_cast<ConstantInt>(SimpleOp);
271  if (!OpC)
272  return false;
273  if (OpC->isZero()) continue;
274 
275  // Handle a struct index, which adds its field offset to the pointer.
276  if (StructType *STy = dyn_cast<StructType>(*GTI)) {
277  unsigned ElementIdx = OpC->getZExtValue();
278  const StructLayout *SL = DL.getStructLayout(STy);
279  Offset += APInt(IntPtrWidth, SL->getElementOffset(ElementIdx));
280  continue;
281  }
282 
283  APInt TypeSize(IntPtrWidth, DL.getTypeAllocSize(GTI.getIndexedType()));
284  Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize;
285  }
286  return true;
287 }
288 
289 bool CallAnalyzer::visitAlloca(AllocaInst &I) {
290  // Check whether inlining will turn a dynamic alloca into a static
291  // alloca, and handle that case.
292  if (I.isArrayAllocation()) {
293  if (Constant *Size = SimplifiedValues.lookup(I.getArraySize())) {
294  ConstantInt *AllocSize = dyn_cast<ConstantInt>(Size);
295  assert(AllocSize && "Allocation size not a constant int?");
296  Type *Ty = I.getAllocatedType();
297  AllocatedSize += Ty->getPrimitiveSizeInBits() * AllocSize->getZExtValue();
298  return Base::visitAlloca(I);
299  }
300  }
301 
302  // Accumulate the allocated size.
303  if (I.isStaticAlloca()) {
304  const DataLayout &DL = F.getParent()->getDataLayout();
305  Type *Ty = I.getAllocatedType();
306  AllocatedSize += DL.getTypeAllocSize(Ty);
307  }
308 
309  // We will happily inline static alloca instructions.
310  if (I.isStaticAlloca())
311  return Base::visitAlloca(I);
312 
313  // FIXME: This is overly conservative. Dynamic allocas are inefficient for
314  // a variety of reasons, and so we would like to not inline them into
315  // functions which don't currently have a dynamic alloca. This simply
316  // disables inlining altogether in the presence of a dynamic alloca.
317  HasDynamicAlloca = true;
318  return false;
319 }
320 
321 bool CallAnalyzer::visitPHI(PHINode &I) {
322  // FIXME: We should potentially be tracking values through phi nodes,
323  // especially when they collapse to a single value due to deleted CFG edges
324  // during inlining.
325 
326  // FIXME: We need to propagate SROA *disabling* through phi nodes, even
327  // though we don't want to propagate it's bonuses. The idea is to disable
328  // SROA if it *might* be used in an inappropriate manner.
329 
330  // Phi nodes are always zero-cost.
331  return true;
332 }
333 
334 bool CallAnalyzer::visitGetElementPtr(GetElementPtrInst &I) {
335  Value *SROAArg;
337  bool SROACandidate = lookupSROAArgAndCost(I.getPointerOperand(),
338  SROAArg, CostIt);
339 
340  // Try to fold GEPs of constant-offset call site argument pointers. This
341  // requires target data and inbounds GEPs.
342  if (I.isInBounds()) {
343  // Check if we have a base + offset for the pointer.
344  Value *Ptr = I.getPointerOperand();
345  std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Ptr);
346  if (BaseAndOffset.first) {
347  // Check if the offset of this GEP is constant, and if so accumulate it
348  // into Offset.
349  if (!accumulateGEPOffset(cast<GEPOperator>(I), BaseAndOffset.second)) {
350  // Non-constant GEPs aren't folded, and disable SROA.
351  if (SROACandidate)
352  disableSROA(CostIt);
353  return false;
354  }
355 
356  // Add the result as a new mapping to Base + Offset.
357  ConstantOffsetPtrs[&I] = BaseAndOffset;
358 
359  // Also handle SROA candidates here, we already know that the GEP is
360  // all-constant indexed.
361  if (SROACandidate)
362  SROAArgValues[&I] = SROAArg;
363 
364  return true;
365  }
366  }
367 
368  if (isGEPOffsetConstant(I)) {
369  if (SROACandidate)
370  SROAArgValues[&I] = SROAArg;
371 
372  // Constant GEPs are modeled as free.
373  return true;
374  }
375 
376  // Variable GEPs will require math and will disable SROA.
377  if (SROACandidate)
378  disableSROA(CostIt);
379  return false;
380 }
381 
382 bool CallAnalyzer::visitBitCast(BitCastInst &I) {
383  // Propagate constants through bitcasts.
384  Constant *COp = dyn_cast<Constant>(I.getOperand(0));
385  if (!COp)
386  COp = SimplifiedValues.lookup(I.getOperand(0));
387  if (COp)
388  if (Constant *C = ConstantExpr::getBitCast(COp, I.getType())) {
389  SimplifiedValues[&I] = C;
390  return true;
391  }
392 
393  // Track base/offsets through casts
394  std::pair<Value *, APInt> BaseAndOffset
395  = ConstantOffsetPtrs.lookup(I.getOperand(0));
396  // Casts don't change the offset, just wrap it up.
397  if (BaseAndOffset.first)
398  ConstantOffsetPtrs[&I] = BaseAndOffset;
399 
400  // Also look for SROA candidates here.
401  Value *SROAArg;
403  if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
404  SROAArgValues[&I] = SROAArg;
405 
406  // Bitcasts are always zero cost.
407  return true;
408 }
409 
410 bool CallAnalyzer::visitPtrToInt(PtrToIntInst &I) {
411  // Propagate constants through ptrtoint.
412  Constant *COp = dyn_cast<Constant>(I.getOperand(0));
413  if (!COp)
414  COp = SimplifiedValues.lookup(I.getOperand(0));
415  if (COp)
416  if (Constant *C = ConstantExpr::getPtrToInt(COp, I.getType())) {
417  SimplifiedValues[&I] = C;
418  return true;
419  }
420 
421  // Track base/offset pairs when converted to a plain integer provided the
422  // integer is large enough to represent the pointer.
423  unsigned IntegerSize = I.getType()->getScalarSizeInBits();
424  const DataLayout &DL = F.getParent()->getDataLayout();
425  if (IntegerSize >= DL.getPointerSizeInBits()) {
426  std::pair<Value *, APInt> BaseAndOffset
427  = ConstantOffsetPtrs.lookup(I.getOperand(0));
428  if (BaseAndOffset.first)
429  ConstantOffsetPtrs[&I] = BaseAndOffset;
430  }
431 
432  // This is really weird. Technically, ptrtoint will disable SROA. However,
433  // unless that ptrtoint is *used* somewhere in the live basic blocks after
434  // inlining, it will be nuked, and SROA should proceed. All of the uses which
435  // would block SROA would also block SROA if applied directly to a pointer,
436  // and so we can just add the integer in here. The only places where SROA is
437  // preserved either cannot fire on an integer, or won't in-and-of themselves
438  // disable SROA (ext) w/o some later use that we would see and disable.
439  Value *SROAArg;
441  if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt))
442  SROAArgValues[&I] = SROAArg;
443 
444  return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
445 }
446 
447 bool CallAnalyzer::visitIntToPtr(IntToPtrInst &I) {
448  // Propagate constants through ptrtoint.
449  Constant *COp = dyn_cast<Constant>(I.getOperand(0));
450  if (!COp)
451  COp = SimplifiedValues.lookup(I.getOperand(0));
452  if (COp)
453  if (Constant *C = ConstantExpr::getIntToPtr(COp, I.getType())) {
454  SimplifiedValues[&I] = C;
455  return true;
456  }
457 
458  // Track base/offset pairs when round-tripped through a pointer without
459  // modifications provided the integer is not too large.
460  Value *Op = I.getOperand(0);
461  unsigned IntegerSize = Op->getType()->getScalarSizeInBits();
462  const DataLayout &DL = F.getParent()->getDataLayout();
463  if (IntegerSize <= DL.getPointerSizeInBits()) {
464  std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Op);
465  if (BaseAndOffset.first)
466  ConstantOffsetPtrs[&I] = BaseAndOffset;
467  }
468 
469  // "Propagate" SROA here in the same manner as we do for ptrtoint above.
470  Value *SROAArg;
472  if (lookupSROAArgAndCost(Op, SROAArg, CostIt))
473  SROAArgValues[&I] = SROAArg;
474 
475  return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
476 }
477 
478 bool CallAnalyzer::visitCastInst(CastInst &I) {
479  // Propagate constants through ptrtoint.
480  Constant *COp = dyn_cast<Constant>(I.getOperand(0));
481  if (!COp)
482  COp = SimplifiedValues.lookup(I.getOperand(0));
483  if (COp)
484  if (Constant *C = ConstantExpr::getCast(I.getOpcode(), COp, I.getType())) {
485  SimplifiedValues[&I] = C;
486  return true;
487  }
488 
489  // Disable SROA in the face of arbitrary casts we don't whitelist elsewhere.
490  disableSROA(I.getOperand(0));
491 
492  return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
493 }
494 
495 bool CallAnalyzer::visitUnaryInstruction(UnaryInstruction &I) {
496  Value *Operand = I.getOperand(0);
497  Constant *COp = dyn_cast<Constant>(Operand);
498  if (!COp)
499  COp = SimplifiedValues.lookup(Operand);
500  if (COp) {
501  const DataLayout &DL = F.getParent()->getDataLayout();
503  COp, DL)) {
504  SimplifiedValues[&I] = C;
505  return true;
506  }
507  }
508 
509  // Disable any SROA on the argument to arbitrary unary operators.
510  disableSROA(Operand);
511 
512  return false;
513 }
514 
515 bool CallAnalyzer::paramHasAttr(Argument *A, Attribute::AttrKind Attr) {
516  unsigned ArgNo = A->getArgNo();
517  return CandidateCS.paramHasAttr(ArgNo+1, Attr);
518 }
519 
520 bool CallAnalyzer::isKnownNonNullInCallee(Value *V) {
521  // Does the *call site* have the NonNull attribute set on an argument? We
522  // use the attribute on the call site to memoize any analysis done in the
523  // caller. This will also trip if the callee function has a non-null
524  // parameter attribute, but that's a less interesting case because hopefully
525  // the callee would already have been simplified based on that.
526  if (Argument *A = dyn_cast<Argument>(V))
527  if (paramHasAttr(A, Attribute::NonNull))
528  return true;
529 
530  // Is this an alloca in the caller? This is distinct from the attribute case
531  // above because attributes aren't updated within the inliner itself and we
532  // always want to catch the alloca derived case.
533  if (isAllocaDerivedArg(V))
534  // We can actually predict the result of comparisons between an
535  // alloca-derived value and null. Note that this fires regardless of
536  // SROA firing.
537  return true;
538 
539  return false;
540 }
541 
542 bool CallAnalyzer::visitCmpInst(CmpInst &I) {
543  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
544  // First try to handle simplified comparisons.
545  if (!isa<Constant>(LHS))
546  if (Constant *SimpleLHS = SimplifiedValues.lookup(LHS))
547  LHS = SimpleLHS;
548  if (!isa<Constant>(RHS))
549  if (Constant *SimpleRHS = SimplifiedValues.lookup(RHS))
550  RHS = SimpleRHS;
551  if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
552  if (Constant *CRHS = dyn_cast<Constant>(RHS))
553  if (Constant *C = ConstantExpr::getCompare(I.getPredicate(), CLHS, CRHS)) {
554  SimplifiedValues[&I] = C;
555  return true;
556  }
557  }
558 
559  if (I.getOpcode() == Instruction::FCmp)
560  return false;
561 
562  // Otherwise look for a comparison between constant offset pointers with
563  // a common base.
564  Value *LHSBase, *RHSBase;
565  APInt LHSOffset, RHSOffset;
566  std::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
567  if (LHSBase) {
568  std::tie(RHSBase, RHSOffset) = ConstantOffsetPtrs.lookup(RHS);
569  if (RHSBase && LHSBase == RHSBase) {
570  // We have common bases, fold the icmp to a constant based on the
571  // offsets.
572  Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
573  Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
574  if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
575  SimplifiedValues[&I] = C;
576  ++NumConstantPtrCmps;
577  return true;
578  }
579  }
580  }
581 
582  // If the comparison is an equality comparison with null, we can simplify it
583  // if we know the value (argument) can't be null
584  if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1)) &&
585  isKnownNonNullInCallee(I.getOperand(0))) {
586  bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;
587  SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
589  return true;
590  }
591  // Finally check for SROA candidates in comparisons.
592  Value *SROAArg;
594  if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt)) {
595  if (isa<ConstantPointerNull>(I.getOperand(1))) {
596  accumulateSROACost(CostIt, InlineConstants::InstrCost);
597  return true;
598  }
599 
600  disableSROA(CostIt);
601  }
602 
603  return false;
604 }
605 
606 bool CallAnalyzer::visitSub(BinaryOperator &I) {
607  // Try to handle a special case: we can fold computing the difference of two
608  // constant-related pointers.
609  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
610  Value *LHSBase, *RHSBase;
611  APInt LHSOffset, RHSOffset;
612  std::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
613  if (LHSBase) {
614  std::tie(RHSBase, RHSOffset) = ConstantOffsetPtrs.lookup(RHS);
615  if (RHSBase && LHSBase == RHSBase) {
616  // We have common bases, fold the subtract to a constant based on the
617  // offsets.
618  Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
619  Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
620  if (Constant *C = ConstantExpr::getSub(CLHS, CRHS)) {
621  SimplifiedValues[&I] = C;
622  ++NumConstantPtrDiffs;
623  return true;
624  }
625  }
626  }
627 
628  // Otherwise, fall back to the generic logic for simplifying and handling
629  // instructions.
630  return Base::visitSub(I);
631 }
632 
633 bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
634  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
635  const DataLayout &DL = F.getParent()->getDataLayout();
636  if (!isa<Constant>(LHS))
637  if (Constant *SimpleLHS = SimplifiedValues.lookup(LHS))
638  LHS = SimpleLHS;
639  if (!isa<Constant>(RHS))
640  if (Constant *SimpleRHS = SimplifiedValues.lookup(RHS))
641  RHS = SimpleRHS;
642  Value *SimpleV = nullptr;
643  if (auto FI = dyn_cast<FPMathOperator>(&I))
644  SimpleV =
645  SimplifyFPBinOp(I.getOpcode(), LHS, RHS, FI->getFastMathFlags(), DL);
646  else
647  SimpleV = SimplifyBinOp(I.getOpcode(), LHS, RHS, DL);
648 
649  if (Constant *C = dyn_cast_or_null<Constant>(SimpleV)) {
650  SimplifiedValues[&I] = C;
651  return true;
652  }
653 
654  // Disable any SROA on arguments to arbitrary, unsimplified binary operators.
655  disableSROA(LHS);
656  disableSROA(RHS);
657 
658  return false;
659 }
660 
661 bool CallAnalyzer::visitLoad(LoadInst &I) {
662  Value *SROAArg;
664  if (lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt)) {
665  if (I.isSimple()) {
666  accumulateSROACost(CostIt, InlineConstants::InstrCost);
667  return true;
668  }
669 
670  disableSROA(CostIt);
671  }
672 
673  return false;
674 }
675 
676 bool CallAnalyzer::visitStore(StoreInst &I) {
677  Value *SROAArg;
679  if (lookupSROAArgAndCost(I.getPointerOperand(), SROAArg, CostIt)) {
680  if (I.isSimple()) {
681  accumulateSROACost(CostIt, InlineConstants::InstrCost);
682  return true;
683  }
684 
685  disableSROA(CostIt);
686  }
687 
688  return false;
689 }
690 
691 bool CallAnalyzer::visitExtractValue(ExtractValueInst &I) {
692  // Constant folding for extract value is trivial.
694  if (!C)
695  C = SimplifiedValues.lookup(I.getAggregateOperand());
696  if (C) {
697  SimplifiedValues[&I] = ConstantExpr::getExtractValue(C, I.getIndices());
698  return true;
699  }
700 
701  // SROA can look through these but give them a cost.
702  return false;
703 }
704 
705 bool CallAnalyzer::visitInsertValue(InsertValueInst &I) {
706  // Constant folding for insert value is trivial.
708  if (!AggC)
709  AggC = SimplifiedValues.lookup(I.getAggregateOperand());
711  if (!InsertedC)
712  InsertedC = SimplifiedValues.lookup(I.getInsertedValueOperand());
713  if (AggC && InsertedC) {
714  SimplifiedValues[&I] = ConstantExpr::getInsertValue(AggC, InsertedC,
715  I.getIndices());
716  return true;
717  }
718 
719  // SROA can look through these but give them a cost.
720  return false;
721 }
722 
723 /// \brief Try to simplify a call site.
724 ///
725 /// Takes a concrete function and callsite and tries to actually simplify it by
726 /// analyzing the arguments and call itself with instsimplify. Returns true if
727 /// it has simplified the callsite to some other entity (a constant), making it
728 /// free.
729 bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS) {
730  // FIXME: Using the instsimplify logic directly for this is inefficient
731  // because we have to continually rebuild the argument list even when no
732  // simplifications can be performed. Until that is fixed with remapping
733  // inside of instsimplify, directly constant fold calls here.
734  if (!canConstantFoldCallTo(F))
735  return false;
736 
737  // Try to re-map the arguments to constants.
738  SmallVector<Constant *, 4> ConstantArgs;
739  ConstantArgs.reserve(CS.arg_size());
740  for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
741  I != E; ++I) {
742  Constant *C = dyn_cast<Constant>(*I);
743  if (!C)
744  C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(*I));
745  if (!C)
746  return false; // This argument doesn't map to a constant.
747 
748  ConstantArgs.push_back(C);
749  }
750  if (Constant *C = ConstantFoldCall(F, ConstantArgs)) {
751  SimplifiedValues[CS.getInstruction()] = C;
752  return true;
753  }
754 
755  return false;
756 }
757 
758 bool CallAnalyzer::visitCallSite(CallSite CS) {
761  // This aborts the entire analysis.
762  ExposesReturnsTwice = true;
763  return false;
764  }
765  if (CS.isCall() &&
766  cast<CallInst>(CS.getInstruction())->cannotDuplicate())
767  ContainsNoDuplicateCall = true;
768 
769  if (Function *F = CS.getCalledFunction()) {
770  // When we have a concrete function, first try to simplify it directly.
771  if (simplifyCallSite(F, CS))
772  return true;
773 
774  // Next check if it is an intrinsic we know about.
775  // FIXME: Lift this into part of the InstVisitor.
776  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
777  switch (II->getIntrinsicID()) {
778  default:
779  return Base::visitCallSite(CS);
780 
781  case Intrinsic::memset:
782  case Intrinsic::memcpy:
783  case Intrinsic::memmove:
784  // SROA can usually chew through these intrinsics, but they aren't free.
785  return false;
786  case Intrinsic::localescape:
787  HasFrameEscape = true;
788  return false;
789  }
790  }
791 
792  if (F == CS.getInstruction()->getParent()->getParent()) {
793  // This flag will fully abort the analysis, so don't bother with anything
794  // else.
795  IsRecursiveCall = true;
796  return false;
797  }
798 
799  if (TTI.isLoweredToCall(F)) {
800  // We account for the average 1 instruction per call argument setup
801  // here.
802  Cost += CS.arg_size() * InlineConstants::InstrCost;
803 
804  // Everything other than inline ASM will also have a significant cost
805  // merely from making the call.
806  if (!isa<InlineAsm>(CS.getCalledValue()))
808  }
809 
810  return Base::visitCallSite(CS);
811  }
812 
813  // Otherwise we're in a very special case -- an indirect function call. See
814  // if we can be particularly clever about this.
815  Value *Callee = CS.getCalledValue();
816 
817  // First, pay the price of the argument setup. We account for the average
818  // 1 instruction per call argument setup here.
819  Cost += CS.arg_size() * InlineConstants::InstrCost;
820 
821  // Next, check if this happens to be an indirect function call to a known
822  // function in this inline context. If not, we've done all we can.
823  Function *F = dyn_cast_or_null<Function>(SimplifiedValues.lookup(Callee));
824  if (!F)
825  return Base::visitCallSite(CS);
826 
827  // If we have a constant that we are calling as a function, we can peer
828  // through it and see the function target. This happens not infrequently
829  // during devirtualization and so we want to give it a hefty bonus for
830  // inlining, but cap that bonus in the event that inlining wouldn't pan
831  // out. Pretend to inline the function, with a custom threshold.
832  CallAnalyzer CA(TTI, ACT, *F, InlineConstants::IndirectCallThreshold, CS);
833  if (CA.analyzeCall(CS)) {
834  // We were able to inline the indirect call! Subtract the cost from the
835  // bonus we want to apply, but don't go below zero.
836  Cost -= std::max(0, InlineConstants::IndirectCallThreshold - CA.getCost());
837  }
838 
839  return Base::visitCallSite(CS);
840 }
841 
842 bool CallAnalyzer::visitReturnInst(ReturnInst &RI) {
843  // At least one return instruction will be free after inlining.
844  bool Free = !HasReturn;
845  HasReturn = true;
846  return Free;
847 }
848 
849 bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
850  // We model unconditional branches as essentially free -- they really
851  // shouldn't exist at all, but handling them makes the behavior of the
852  // inliner more regular and predictable. Interestingly, conditional branches
853  // which will fold away are also free.
854  return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
855  dyn_cast_or_null<ConstantInt>(
856  SimplifiedValues.lookup(BI.getCondition()));
857 }
858 
859 bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
860  // We model unconditional switches as free, see the comments on handling
861  // branches.
862  if (isa<ConstantInt>(SI.getCondition()))
863  return true;
864  if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
865  if (isa<ConstantInt>(V))
866  return true;
867 
868  // Otherwise, we need to accumulate a cost proportional to the number of
869  // distinct successor blocks. This fan-out in the CFG cannot be represented
870  // for free even if we can represent the core switch as a jumptable that
871  // takes a single instruction.
872  //
873  // NB: We convert large switches which are just used to initialize large phi
874  // nodes to lookup tables instead in simplify-cfg, so this shouldn't prevent
875  // inlining those. It will prevent inlining in cases where the optimization
876  // does not (yet) fire.
877  SmallPtrSet<BasicBlock *, 8> SuccessorBlocks;
878  SuccessorBlocks.insert(SI.getDefaultDest());
879  for (auto I = SI.case_begin(), E = SI.case_end(); I != E; ++I)
880  SuccessorBlocks.insert(I.getCaseSuccessor());
881  // Add cost corresponding to the number of distinct destinations. The first
882  // we model as free because of fallthrough.
883  Cost += (SuccessorBlocks.size() - 1) * InlineConstants::InstrCost;
884  return false;
885 }
886 
887 bool CallAnalyzer::visitIndirectBrInst(IndirectBrInst &IBI) {
888  // We never want to inline functions that contain an indirectbr. This is
889  // incorrect because all the blockaddress's (in static global initializers
890  // for example) would be referring to the original function, and this
891  // indirect jump would jump from the inlined copy of the function into the
892  // original function which is extremely undefined behavior.
893  // FIXME: This logic isn't really right; we can safely inline functions with
894  // indirectbr's as long as no other function or global references the
895  // blockaddress of a block within the current function.
896  HasIndirectBr = true;
897  return false;
898 }
899 
900 bool CallAnalyzer::visitResumeInst(ResumeInst &RI) {
901  // FIXME: It's not clear that a single instruction is an accurate model for
902  // the inline cost of a resume instruction.
903  return false;
904 }
905 
906 bool CallAnalyzer::visitUnreachableInst(UnreachableInst &I) {
907  // FIXME: It might be reasonably to discount the cost of instructions leading
908  // to unreachable as they have the lowest possible impact on both runtime and
909  // code size.
910  return true; // No actual code is needed for unreachable.
911 }
912 
913 bool CallAnalyzer::visitInstruction(Instruction &I) {
914  // Some instructions are free. All of the free intrinsics can also be
915  // handled by SROA, etc.
916  if (TargetTransformInfo::TCC_Free == TTI.getUserCost(&I))
917  return true;
918 
919  // We found something we don't understand or can't handle. Mark any SROA-able
920  // values in the operand list as no longer viable.
921  for (User::op_iterator OI = I.op_begin(), OE = I.op_end(); OI != OE; ++OI)
922  disableSROA(*OI);
923 
924  return false;
925 }
926 
927 
928 /// \brief Analyze a basic block for its contribution to the inline cost.
929 ///
930 /// This method walks the analyzer over every instruction in the given basic
931 /// block and accounts for their cost during inlining at this callsite. It
932 /// aborts early if the threshold has been exceeded or an impossible to inline
933 /// construct has been detected. It returns false if inlining is no longer
934 /// viable, and true if inlining remains viable.
935 bool CallAnalyzer::analyzeBlock(BasicBlock *BB,
936  SmallPtrSetImpl<const Value *> &EphValues) {
937  for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
938  // FIXME: Currently, the number of instructions in a function regardless of
939  // our ability to simplify them during inline to constants or dead code,
940  // are actually used by the vector bonus heuristic. As long as that's true,
941  // we have to special case debug intrinsics here to prevent differences in
942  // inlining due to debug symbols. Eventually, the number of unsimplified
943  // instructions shouldn't factor into the cost computation, but until then,
944  // hack around it here.
945  if (isa<DbgInfoIntrinsic>(I))
946  continue;
947 
948  // Skip ephemeral values.
949  if (EphValues.count(I))
950  continue;
951 
952  ++NumInstructions;
953  if (isa<ExtractElementInst>(I) || I->getType()->isVectorTy())
954  ++NumVectorInstructions;
955 
956  // If the instruction is floating point, and the target says this operation is
957  // expensive or the function has the "use-soft-float" attribute, this may
958  // eventually become a library call. Treat the cost as such.
959  if (I->getType()->isFloatingPointTy()) {
960  bool hasSoftFloatAttr = false;
961 
962  // If the function has the "use-soft-float" attribute, mark it as expensive.
963  if (F.hasFnAttribute("use-soft-float")) {
964  Attribute Attr = F.getFnAttribute("use-soft-float");
965  StringRef Val = Attr.getValueAsString();
966  if (Val == "true")
967  hasSoftFloatAttr = true;
968  }
969 
970  if (TTI.getFPOpCost(I->getType()) == TargetTransformInfo::TCC_Expensive ||
971  hasSoftFloatAttr)
973  }
974 
975  // If the instruction simplified to a constant, there is no cost to this
976  // instruction. Visit the instructions using our InstVisitor to account for
977  // all of the per-instruction logic. The visit tree returns true if we
978  // consumed the instruction in any way, and false if the instruction's base
979  // cost should count against inlining.
980  if (Base::visit(I))
981  ++NumInstructionsSimplified;
982  else
984 
985  // If the visit this instruction detected an uninlinable pattern, abort.
986  if (IsRecursiveCall || ExposesReturnsTwice || HasDynamicAlloca ||
987  HasIndirectBr || HasFrameEscape)
988  return false;
989 
990  // If the caller is a recursive function then we don't want to inline
991  // functions which allocate a lot of stack space because it would increase
992  // the caller stack usage dramatically.
993  if (IsCallerRecursive &&
995  return false;
996 
997  // Check if we've past the maximum possible threshold so we don't spin in
998  // huge basic blocks that will never inline.
999  if (Cost > Threshold)
1000  return false;
1001  }
1002 
1003  return true;
1004 }
1005 
1006 /// \brief Compute the base pointer and cumulative constant offsets for V.
1007 ///
1008 /// This strips all constant offsets off of V, leaving it the base pointer, and
1009 /// accumulates the total constant offset applied in the returned constant. It
1010 /// returns 0 if V is not a pointer, and returns the constant '0' if there are
1011 /// no constant offsets applied.
1012 ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) {
1013  if (!V->getType()->isPointerTy())
1014  return nullptr;
1015 
1016  const DataLayout &DL = F.getParent()->getDataLayout();
1017  unsigned IntPtrWidth = DL.getPointerSizeInBits();
1018  APInt Offset = APInt::getNullValue(IntPtrWidth);
1019 
1020  // Even though we don't look through PHI nodes, we could be called on an
1021  // instruction in an unreachable block, which may be on a cycle.
1022  SmallPtrSet<Value *, 4> Visited;
1023  Visited.insert(V);
1024  do {
1025  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
1026  if (!GEP->isInBounds() || !accumulateGEPOffset(*GEP, Offset))
1027  return nullptr;
1028  V = GEP->getPointerOperand();
1029  } else if (Operator::getOpcode(V) == Instruction::BitCast) {
1030  V = cast<Operator>(V)->getOperand(0);
1031  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
1032  if (GA->mayBeOverridden())
1033  break;
1034  V = GA->getAliasee();
1035  } else {
1036  break;
1037  }
1038  assert(V->getType()->isPointerTy() && "Unexpected operand type!");
1039  } while (Visited.insert(V).second);
1040 
1041  Type *IntPtrTy = DL.getIntPtrType(V->getContext());
1042  return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
1043 }
1044 
1045 /// \brief Analyze a call site for potential inlining.
1046 ///
1047 /// Returns true if inlining this call is viable, and false if it is not
1048 /// viable. It computes the cost and adjusts the threshold based on numerous
1049 /// factors and heuristics. If this method returns false but the computed cost
1050 /// is below the computed threshold, then inlining was forcibly disabled by
1051 /// some artifact of the routine.
1052 bool CallAnalyzer::analyzeCall(CallSite CS) {
1053  ++NumCallsAnalyzed;
1054 
1055  // Perform some tweaks to the cost and threshold based on the direct
1056  // callsite information.
1057 
1058  // We want to more aggressively inline vector-dense kernels, so up the
1059  // threshold, and we'll lower it if the % of vector instructions gets too
1060  // low. Note that these bonuses are some what arbitrary and evolved over time
1061  // by accident as much as because they are principled bonuses.
1062  //
1063  // FIXME: It would be nice to remove all such bonuses. At least it would be
1064  // nice to base the bonus values on something more scientific.
1065  assert(NumInstructions == 0);
1066  assert(NumVectorInstructions == 0);
1067  FiftyPercentVectorBonus = 3 * Threshold / 2;
1068  TenPercentVectorBonus = 3 * Threshold / 4;
1069  const DataLayout &DL = F.getParent()->getDataLayout();
1070 
1071  // Track whether the post-inlining function would have more than one basic
1072  // block. A single basic block is often intended for inlining. Balloon the
1073  // threshold by 50% until we pass the single-BB phase.
1074  bool SingleBB = true;
1075  int SingleBBBonus = Threshold / 2;
1076 
1077  // Speculatively apply all possible bonuses to Threshold. If cost exceeds
1078  // this Threshold any time, and cost cannot decrease, we can stop processing
1079  // the rest of the function body.
1080  Threshold += (SingleBBBonus + FiftyPercentVectorBonus);
1081 
1082  // Give out bonuses per argument, as the instructions setting them up will
1083  // be gone after inlining.
1084  for (unsigned I = 0, E = CS.arg_size(); I != E; ++I) {
1085  if (CS.isByValArgument(I)) {
1086  // We approximate the number of loads and stores needed by dividing the
1087  // size of the byval type by the target's pointer size.
1088  PointerType *PTy = cast<PointerType>(CS.getArgument(I)->getType());
1089  unsigned TypeSize = DL.getTypeSizeInBits(PTy->getElementType());
1090  unsigned PointerSize = DL.getPointerSizeInBits();
1091  // Ceiling division.
1092  unsigned NumStores = (TypeSize + PointerSize - 1) / PointerSize;
1093 
1094  // If it generates more than 8 stores it is likely to be expanded as an
1095  // inline memcpy so we take that as an upper bound. Otherwise we assume
1096  // one load and one store per word copied.
1097  // FIXME: The maxStoresPerMemcpy setting from the target should be used
1098  // here instead of a magic number of 8, but it's not available via
1099  // DataLayout.
1100  NumStores = std::min(NumStores, 8U);
1101 
1102  Cost -= 2 * NumStores * InlineConstants::InstrCost;
1103  } else {
1104  // For non-byval arguments subtract off one instruction per call
1105  // argument.
1107  }
1108  }
1109 
1110  // If there is only one call of the function, and it has internal linkage,
1111  // the cost of inlining it drops dramatically.
1112  bool OnlyOneCallAndLocalLinkage = F.hasLocalLinkage() && F.hasOneUse() &&
1113  &F == CS.getCalledFunction();
1114  if (OnlyOneCallAndLocalLinkage)
1116 
1117  // If the instruction after the call, or if the normal destination of the
1118  // invoke is an unreachable instruction, the function is noreturn. As such,
1119  // there is little point in inlining this unless there is literally zero
1120  // cost.
1121  Instruction *Instr = CS.getInstruction();
1122  if (InvokeInst *II = dyn_cast<InvokeInst>(Instr)) {
1123  if (isa<UnreachableInst>(II->getNormalDest()->begin()))
1124  Threshold = 0;
1125  } else if (isa<UnreachableInst>(++BasicBlock::iterator(Instr)))
1126  Threshold = 0;
1127 
1128  // If this function uses the coldcc calling convention, prefer not to inline
1129  // it.
1130  if (F.getCallingConv() == CallingConv::Cold)
1132 
1133  // Check if we're done. This can happen due to bonuses and penalties.
1134  if (Cost > Threshold)
1135  return false;
1136 
1137  if (F.empty())
1138  return true;
1139 
1140  Function *Caller = CS.getInstruction()->getParent()->getParent();
1141  // Check if the caller function is recursive itself.
1142  for (User *U : Caller->users()) {
1143  CallSite Site(U);
1144  if (!Site)
1145  continue;
1146  Instruction *I = Site.getInstruction();
1147  if (I->getParent()->getParent() == Caller) {
1148  IsCallerRecursive = true;
1149  break;
1150  }
1151  }
1152 
1153  // Populate our simplified values by mapping from function arguments to call
1154  // arguments with known important simplifications.
1155  CallSite::arg_iterator CAI = CS.arg_begin();
1156  for (Function::arg_iterator FAI = F.arg_begin(), FAE = F.arg_end();
1157  FAI != FAE; ++FAI, ++CAI) {
1158  assert(CAI != CS.arg_end());
1159  if (Constant *C = dyn_cast<Constant>(CAI))
1160  SimplifiedValues[FAI] = C;
1161 
1162  Value *PtrArg = *CAI;
1163  if (ConstantInt *C = stripAndComputeInBoundsConstantOffsets(PtrArg)) {
1164  ConstantOffsetPtrs[FAI] = std::make_pair(PtrArg, C->getValue());
1165 
1166  // We can SROA any pointer arguments derived from alloca instructions.
1167  if (isa<AllocaInst>(PtrArg)) {
1168  SROAArgValues[FAI] = PtrArg;
1169  SROAArgCosts[PtrArg] = 0;
1170  }
1171  }
1172  }
1173  NumConstantArgs = SimplifiedValues.size();
1174  NumConstantOffsetPtrArgs = ConstantOffsetPtrs.size();
1175  NumAllocaArgs = SROAArgValues.size();
1176 
1177  // FIXME: If a caller has multiple calls to a callee, we end up recomputing
1178  // the ephemeral values multiple times (and they're completely determined by
1179  // the callee, so this is purely duplicate work).
1181  CodeMetrics::collectEphemeralValues(&F, &ACT->getAssumptionCache(F), EphValues);
1182 
1183  // The worklist of live basic blocks in the callee *after* inlining. We avoid
1184  // adding basic blocks of the callee which can be proven to be dead for this
1185  // particular call site in order to get more accurate cost estimates. This
1186  // requires a somewhat heavyweight iteration pattern: we need to walk the
1187  // basic blocks in a breadth-first order as we insert live successors. To
1188  // accomplish this, prioritizing for small iterations because we exit after
1189  // crossing our threshold, we use a small-size optimized SetVector.
1191  SmallPtrSet<BasicBlock *, 16> > BBSetVector;
1192  BBSetVector BBWorklist;
1193  BBWorklist.insert(&F.getEntryBlock());
1194  // Note that we *must not* cache the size, this loop grows the worklist.
1195  for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
1196  // Bail out the moment we cross the threshold. This means we'll under-count
1197  // the cost, but only when undercounting doesn't matter.
1198  if (Cost > Threshold)
1199  break;
1200 
1201  BasicBlock *BB = BBWorklist[Idx];
1202  if (BB->empty())
1203  continue;
1204 
1205  // Disallow inlining a blockaddress. A blockaddress only has defined
1206  // behavior for an indirect branch in the same function, and we do not
1207  // currently support inlining indirect branches. But, the inliner may not
1208  // see an indirect branch that ends up being dead code at a particular call
1209  // site. If the blockaddress escapes the function, e.g., via a global
1210  // variable, inlining may lead to an invalid cross-function reference.
1211  if (BB->hasAddressTaken())
1212  return false;
1213 
1214  // Analyze the cost of this block. If we blow through the threshold, this
1215  // returns false, and we can bail on out.
1216  if (!analyzeBlock(BB, EphValues)) {
1217  if (IsRecursiveCall || ExposesReturnsTwice || HasDynamicAlloca ||
1218  HasIndirectBr || HasFrameEscape)
1219  return false;
1220 
1221  // If the caller is a recursive function then we don't want to inline
1222  // functions which allocate a lot of stack space because it would increase
1223  // the caller stack usage dramatically.
1224  if (IsCallerRecursive &&
1226  return false;
1227 
1228  break;
1229  }
1230 
1231  TerminatorInst *TI = BB->getTerminator();
1232 
1233  // Add in the live successors by first checking whether we have terminator
1234  // that may be simplified based on the values simplified by this call.
1235  if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
1236  if (BI->isConditional()) {
1237  Value *Cond = BI->getCondition();
1238  if (ConstantInt *SimpleCond
1239  = dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
1240  BBWorklist.insert(BI->getSuccessor(SimpleCond->isZero() ? 1 : 0));
1241  continue;
1242  }
1243  }
1244  } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
1245  Value *Cond = SI->getCondition();
1246  if (ConstantInt *SimpleCond
1247  = dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
1248  BBWorklist.insert(SI->findCaseValue(SimpleCond).getCaseSuccessor());
1249  continue;
1250  }
1251  }
1252 
1253  // If we're unable to select a particular successor, just count all of
1254  // them.
1255  for (unsigned TIdx = 0, TSize = TI->getNumSuccessors(); TIdx != TSize;
1256  ++TIdx)
1257  BBWorklist.insert(TI->getSuccessor(TIdx));
1258 
1259  // If we had any successors at this point, than post-inlining is likely to
1260  // have them as well. Note that we assume any basic blocks which existed
1261  // due to branches or switches which folded above will also fold after
1262  // inlining.
1263  if (SingleBB && TI->getNumSuccessors() > 1) {
1264  // Take off the bonus we applied to the threshold.
1265  Threshold -= SingleBBBonus;
1266  SingleBB = false;
1267  }
1268  }
1269 
1270  // If this is a noduplicate call, we can still inline as long as
1271  // inlining this would cause the removal of the caller (so the instruction
1272  // is not actually duplicated, just moved).
1273  if (!OnlyOneCallAndLocalLinkage && ContainsNoDuplicateCall)
1274  return false;
1275 
1276  // We applied the maximum possible vector bonus at the beginning. Now,
1277  // subtract the excess bonus, if any, from the Threshold before
1278  // comparing against Cost.
1279  if (NumVectorInstructions <= NumInstructions / 10)
1280  Threshold -= FiftyPercentVectorBonus;
1281  else if (NumVectorInstructions <= NumInstructions / 2)
1282  Threshold -= (FiftyPercentVectorBonus - TenPercentVectorBonus);
1283 
1284  return Cost < Threshold;
1285 }
1286 
1287 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1288 /// \brief Dump stats about this call's analysis.
1289 void CallAnalyzer::dump() {
1290 #define DEBUG_PRINT_STAT(x) dbgs() << " " #x ": " << x << "\n"
1291  DEBUG_PRINT_STAT(NumConstantArgs);
1292  DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
1293  DEBUG_PRINT_STAT(NumAllocaArgs);
1294  DEBUG_PRINT_STAT(NumConstantPtrCmps);
1295  DEBUG_PRINT_STAT(NumConstantPtrDiffs);
1296  DEBUG_PRINT_STAT(NumInstructionsSimplified);
1297  DEBUG_PRINT_STAT(NumInstructions);
1298  DEBUG_PRINT_STAT(SROACostSavings);
1299  DEBUG_PRINT_STAT(SROACostSavingsLost);
1300  DEBUG_PRINT_STAT(ContainsNoDuplicateCall);
1301  DEBUG_PRINT_STAT(Cost);
1303 #undef DEBUG_PRINT_STAT
1304 }
1305 #endif
1306 
1307 INITIALIZE_PASS_BEGIN(InlineCostAnalysis, "inline-cost", "Inline Cost Analysis",
1308  true, true)
1312  true, true)
1313 
1314 char InlineCostAnalysis::ID = 0;
1315 
1316 InlineCostAnalysis::InlineCostAnalysis() : CallGraphSCCPass(ID) {}
1317 
1319 
1321  AU.setPreservesAll();
1325 }
1326 
1328  TTIWP = &getAnalysis<TargetTransformInfoWrapperPass>();
1329  ACT = &getAnalysis<AssumptionCacheTracker>();
1330  return false;
1331 }
1332 
1334  return getInlineCost(CS, CS.getCalledFunction(), Threshold);
1335 }
1336 
1337 /// \brief Test that two functions either have or have not the given attribute
1338 /// at the same time.
1339 template<typename AttrKind>
1340 static bool attributeMatches(Function *F1, Function *F2, AttrKind Attr) {
1341  return F1->getFnAttribute(Attr) == F2->getFnAttribute(Attr);
1342 }
1343 
1344 /// \brief Test that there are no attribute conflicts between Caller and Callee
1345 /// that prevent inlining.
1347  Function *Callee,
1348  TargetTransformInfo &TTI) {
1349  return TTI.hasCompatibleFunctionAttributes(Caller, Callee) &&
1350  attributeMatches(Caller, Callee, Attribute::SanitizeAddress) &&
1351  attributeMatches(Caller, Callee, Attribute::SanitizeMemory) &&
1353 }
1354 
1356  int Threshold) {
1357  // Cannot inline indirect calls.
1358  if (!Callee)
1359  return llvm::InlineCost::getNever();
1360 
1361  // Calls to functions with always-inline attributes should be inlined
1362  // whenever possible.
1364  if (isInlineViable(*Callee))
1365  return llvm::InlineCost::getAlways();
1366  return llvm::InlineCost::getNever();
1367  }
1368 
1369  // Never inline functions with conflicting attributes (unless callee has
1370  // always-inline attribute).
1371  if (!functionsHaveCompatibleAttributes(CS.getCaller(), Callee,
1372  TTIWP->getTTI(*Callee)))
1373  return llvm::InlineCost::getNever();
1374 
1375  // Don't inline this call if the caller has the optnone attribute.
1377  return llvm::InlineCost::getNever();
1378 
1379  // Don't inline functions which can be redefined at link-time to mean
1380  // something else. Don't inline functions marked noinline or call sites
1381  // marked noinline.
1382  if (Callee->mayBeOverridden() ||
1384  return llvm::InlineCost::getNever();
1385 
1386  DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName()
1387  << "...\n");
1388 
1389  CallAnalyzer CA(TTIWP->getTTI(*Callee), ACT, *Callee, Threshold, CS);
1390  bool ShouldInline = CA.analyzeCall(CS);
1391 
1392  DEBUG(CA.dump());
1393 
1394  // Check if there was a reason to force inlining or no inlining.
1395  if (!ShouldInline && CA.getCost() < CA.getThreshold())
1396  return InlineCost::getNever();
1397  if (ShouldInline && CA.getCost() >= CA.getThreshold())
1398  return InlineCost::getAlways();
1399 
1400  return llvm::InlineCost::get(CA.getCost(), CA.getThreshold());
1401 }
1402 
1404  bool ReturnsTwice = F.hasFnAttribute(Attribute::ReturnsTwice);
1405  for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
1406  // Disallow inlining of functions which contain indirect branches or
1407  // blockaddresses.
1408  if (isa<IndirectBrInst>(BI->getTerminator()) || BI->hasAddressTaken())
1409  return false;
1410 
1411  for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
1412  ++II) {
1413  CallSite CS(II);
1414  if (!CS)
1415  continue;
1416 
1417  // Disallow recursive calls.
1418  if (&F == CS.getCalledFunction())
1419  return false;
1420 
1421  // Disallow calls which expose returns-twice to a function not previously
1422  // attributed as such.
1423  if (!ReturnsTwice && CS.isCall() &&
1424  cast<CallInst>(CS.getInstruction())->canReturnTwice())
1425  return false;
1426 
1427  // Disallow inlining functions that call @llvm.localescape. Doing this
1428  // correctly would require major changes to the inliner.
1429  if (CS.getCalledFunction() &&
1431  llvm::Intrinsic::localescape)
1432  return false;
1433  }
1434  }
1435 
1436  return true;
1437 }
ReturnInst - Return a value (possibly void), from a function.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:537
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:649
CaseIt case_end()
Returns a read/write iterator that points one past the last in the SwitchInst.
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
LLVM Argument representation.
Definition: Argument.h:35
Base class for instruction visitors.
Definition: InstVisitor.h:81
Value * getAggregateOperand()
STATISTIC(NumFunctions,"Total number of functions")
ArrayRef< unsigned > getIndices() const
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:119
bool canConstantFoldCallTo(const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
iterator end()
Definition: Function.h:459
InstrTy * getInstruction() const
Definition: CallSite.h:82
bool isSimple() const
Definition: Instructions.h:401
const int ColdccPenalty
Definition: InlineCost.h:34
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:276
An immutable pass that tracks lazily created AssumptionCache objects.
gep_type_iterator gep_type_end(const User *GEP)
CaseIt case_begin()
Returns a read/write iterator that points to the first case in SwitchInst.
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1822
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
arg_iterator arg_end()
Definition: Function.h:480
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:225
F(f)
FunTy * getCaller() const
getCaller - Return the caller function for this call site
Definition: CallSite.h:170
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
TargetTransformInfo & getTTI(Function &F)
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:1990
Hexagon Common GEP
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2269
User::op_iterator arg_iterator
arg_iterator - The type of iterator to use when looping over actual arguments at this call site...
Definition: CallSite.h:147
void reserve(size_type N)
Definition: SmallVector.h:401
bool isSimple() const
Definition: Instructions.h:279
void getAnalysisUsage(AnalysisUsage &Info) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
op_iterator op_begin()
Definition: User.h:183
Represents the cost of inlining a function.
Definition: InlineCost.h:51
bool isEquality() const
This is just a convenience that dispatches to the subclasses.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:172
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:242
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
bool isArrayAllocation() const
isArrayAllocation - Return true if there is an allocation size parameter to the allocation instructio...
ArrayRef< unsigned > getIndices() const
IterTy arg_end() const
Definition: CallSite.h:157
AnalysisUsage & addRequired()
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:475
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
bool isUnconditional() const
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - For this class, we declare that we require and preserve the call graph...
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:551
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:306
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
bool hasFnAttr(Attribute::AttrKind A) const
Return true if this function has the given attribute.
Definition: CallSite.h:237
#define DEBUG_PRINT_STAT(x)
#define false
Definition: ConvertUTF.c:65
This class represents a cast from a pointer to an integer.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
ValTy * getCalledValue() const
getCalledValue - Return the pointer to function that is being called.
Definition: CallSite.h:91
bool empty() const
Definition: BasicBlock.h:242
BasicBlock * getSuccessor(unsigned i) const
This class represents a no-op cast from one type to another.
op_iterator idx_begin()
Definition: Instructions.h:954
Value * getInsertedValueOperand()
bool isFloatingPointTy() const
isFloatingPointTy - Return true if this is one of the six floating point types
Definition: Type.h:159
const int LastCallToStaticBonus
Definition: InlineCost.h:33
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
iterator begin()
Definition: Function.h:457
const int CallPenalty
Definition: InlineCost.h:32
Type * getElementType() const
Definition: DerivedTypes.h:323
bool isInBounds() const
isInBounds - Determine whether the GEP has the inbounds flag.
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:491
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1835
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2191
always inline
bool isInlineViable(Function &Callee)
Minimal filter to detect invalid constructs for inlining.
inline Inline Cost true
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
Wrapper pass for TargetTransformInfo.
const int IndirectCallThreshold
Definition: InlineCost.h:31
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
size_type size() const
Definition: SmallPtrSet.h:79
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:62
static bool mayBeOverridden(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time...
Definition: GlobalValue.h:245
BranchInst - Conditional or Unconditional Branch instruction.
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:99
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
UnreachableInst - This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:41
ResumeInst - Resume the propagation of an exception.
Cost analyzer used by inliner.
Definition: InlineCost.h:102
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
Definition: CallSite.h:327
IndirectBrInst - Indirect Branch Instruction.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
Expected to fold away in lowering.
Represent the analysis usage information of a pass.
op_iterator op_end()
Definition: User.h:185
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
static InlineCost getNever()
Definition: InlineCost.h:75
Value * getPointerOperand()
Definition: Operator.h:388
Value * getOperand(unsigned i) const
Definition: User.h:118
bool runOnSCC(CallGraphSCC &SCC) override
runOnSCC - This method should be implemented by the subclass to perform whatever action is necessary ...
Value * getPointerOperand()
Definition: Instructions.h:284
Value * SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, const FastMathFlags &FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyFPBinOp - Given operands for a BinaryOperator, see if we can fold the result.
arg_iterator arg_begin()
Definition: Function.h:472
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2074
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
inline Inline Cost Analysis
This class represents a cast from an integer to a pointer.
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
Pointer is known to be not null.
Definition: Attributes.h:91
static bool functionsHaveCompatibleAttributes(Function *Caller, Function *Callee, TargetTransformInfo &TTI)
Test that there are no attribute conflicts between Caller and Callee that prevent inlining...
bool isConditional() const
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:694
static bool attributeMatches(Function *F1, Function *F2, AttrKind Attr)
Test that two functions either have or have not the given attribute at the same time.
BinaryOps getOpcode() const
Definition: InstrTypes.h:323
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
iterator end()
Definition: BasicBlock.h:233
unsigned getScalarSizeInBits() const LLVM_READONLY
getScalarSizeInBits - If this is a vector type, return the getPrimitiveSizeInBits value for the eleme...
Definition: Type.cpp:139
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Constant * ConstantFoldInstOperands(unsigned Opcode, Type *DestTy, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands...
bool isStaticAlloca() const
isStaticAlloca - Return true if this alloca is in the entry block of the function and is a constant s...
bool hasCompatibleFunctionAttributes(const Function *Caller, const Function *Callee) const
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
BasicBlockTy * getCaseSuccessor()
Resolves successor for current case.
unsigned arg_size() const
Definition: CallSite.h:162
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:161
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
CaseIt findCaseValue(const ConstantInt *C)
findCaseValue - Search all of the case values for the specified constant.
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:530
bool isNoInline() const
Return true if the call should not be inlined.
Definition: CallSite.h:270
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
INITIALIZE_PASS_BEGIN(InlineCostAnalysis,"inline-cost","Inline Cost Analysis", true, true) INITIALIZE_PASS_END(InlineCostAnalysis
Class for arbitrary precision integers.
Definition: APInt.h:73
Function must not be optimized.
Definition: Attributes.h:98
void setPreservesAll()
Set by analyses that do not transform their input at all.
iterator_range< user_iterator > users()
Definition: Value.h:300
Value * SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyBinOp - Given operands for a BinaryOperator, see if we can fold the result.
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1591
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
bool empty() const
Definition: Function.h:463
Value * getCondition() const
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:48
ThreadSanitizer is on.
Definition: Attributes.h:116
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
Value * getCondition() const
BasicBlock * getDefaultDest() const
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:217
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
Definition: Operator.h:379
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1809
AddressSanitizer is on.
Definition: Attributes.h:115
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:311
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:329
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
InlineCost getInlineCost(CallSite CS, int Threshold)
Get an InlineCost object representing the cost of inlining this callsite.
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
OtherOps getOpcode() const
Get the opcode casted to the right type.
Definition: InstrTypes.h:755
static int const Threshold
TODO: Write a new FunctionPass AliasAnalysis so that it can keep a cache.
SwitchInst - Multiway switch.
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:140
const unsigned TotalAllocaSizeRecursiveCaller
Do not inline functions which allocate this many bytes on the stack when the caller is recursive...
Definition: InlineCost.h:38
Function can return twice.
Definition: Attributes.h:104
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
APInt LLVM_ATTRIBUTE_UNUSED_RESULT sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
Definition: APInt.cpp:1023
CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
A vector that has set insertion semantics.
Definition: SetVector.h:37
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Function.cpp:62
const Value * getArraySize() const
getArraySize - Get the number of elements allocated.
Definition: Instructions.h:110
uint64_t getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:507
InvokeInst - Invoke instruction.
#define DEBUG(X)
Definition: Debug.h:92
IterTy arg_begin() const
arg_begin/arg_end - Return iterators corresponding to the actual argument list for a call site...
Definition: CallSite.h:151
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
inline cost
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2215
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
This pass exposes codegen information to IR-level passes.
static APInt getNullValue(unsigned numBits)
Get the '0' value.
Definition: APInt.h:460
static void collectEphemeralValues(const Loop *L, AssumptionCache *AC, SmallPtrSetImpl< const Value * > &EphValues)
Collect a loop's ephemeral values (those used only by an assume or similar intrinsics in the loop)...
Definition: CodeMetrics.cpp:70
Type * getAllocatedType() const
getAllocatedType - Return the type that is being allocated by the instruction.
Definition: Instructions.h:122
bool isCall() const
isCall - true if a CallInst is enclosed.
Definition: CallSite.h:76
static InlineCost getAlways()
Definition: InlineCost.h:72
Value * getPointerOperand()
Definition: Instructions.h:409
The cost of a 'div' instruction on x86.
MemorySanitizer is on.
Definition: Attributes.h:117
const BasicBlock * getParent() const
Definition: Instruction.h:72
static InlineCost get(int Cost, int Threshold)
Definition: InlineCost.h:67
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
Constant * ConstantFoldCall(Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:64
gep_type_iterator gep_type_begin(const User *GEP)