LLVM  14.0.0git
LibCallsShrinkWrap.cpp
Go to the documentation of this file.
1 //===-- LibCallsShrinkWrap.cpp ----------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass shrink-wraps a call to function if the result is not used.
10 // The call can set errno but is otherwise side effect free. For example:
11 // sqrt(val);
12 // is transformed to
13 // if (val < 0)
14 // sqrt(val);
15 // Even if the result of library call is not being used, the compiler cannot
16 // safely delete the call because the function can set errno on error
17 // conditions.
18 // Note in many functions, the error condition solely depends on the incoming
19 // parameter. In this optimization, we can generate the condition can lead to
20 // the errno to shrink-wrap the call. Since the chances of hitting the error
21 // condition is low, the runtime call is effectively eliminated.
22 //
23 // These partially dead calls are usually results of C++ abstraction penalty
24 // exposed by inlining.
25 //
26 //===----------------------------------------------------------------------===//
27 
29 #include "llvm/ADT/SmallVector.h"
30 #include "llvm/ADT/Statistic.h"
33 #include "llvm/IR/CFG.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/Dominators.h"
36 #include "llvm/IR/Function.h"
37 #include "llvm/IR/IRBuilder.h"
38 #include "llvm/IR/InstVisitor.h"
39 #include "llvm/IR/Instructions.h"
40 #include "llvm/IR/LLVMContext.h"
41 #include "llvm/IR/MDBuilder.h"
42 #include "llvm/InitializePasses.h"
43 #include "llvm/Pass.h"
45 using namespace llvm;
46 
47 #define DEBUG_TYPE "libcalls-shrinkwrap"
48 
49 STATISTIC(NumWrappedOneCond, "Number of One-Condition Wrappers Inserted");
50 STATISTIC(NumWrappedTwoCond, "Number of Two-Condition Wrappers Inserted");
51 
52 namespace {
53 class LibCallsShrinkWrapLegacyPass : public FunctionPass {
54 public:
55  static char ID; // Pass identification, replacement for typeid
56  explicit LibCallsShrinkWrapLegacyPass() : FunctionPass(ID) {
59  }
60  void getAnalysisUsage(AnalysisUsage &AU) const override;
61  bool runOnFunction(Function &F) override;
62 };
63 }
64 
66 INITIALIZE_PASS_BEGIN(LibCallsShrinkWrapLegacyPass, "libcalls-shrinkwrap",
67  "Conditionally eliminate dead library calls", false,
68  false)
70 INITIALIZE_PASS_END(LibCallsShrinkWrapLegacyPass, "libcalls-shrinkwrap",
71  "Conditionally eliminate dead library calls", false, false)
72 
73 namespace {
74 class LibCallsShrinkWrap : public InstVisitor<LibCallsShrinkWrap> {
75 public:
77  : TLI(TLI), DT(DT){};
78  void visitCallInst(CallInst &CI) { checkCandidate(CI); }
79  bool perform() {
80  bool Changed = false;
81  for (auto &CI : WorkList) {
82  LLVM_DEBUG(dbgs() << "CDCE calls: " << CI->getCalledFunction()->getName()
83  << "\n");
84  if (perform(CI)) {
85  Changed = true;
86  LLVM_DEBUG(dbgs() << "Transformed\n");
87  }
88  }
89  return Changed;
90  }
91 
92 private:
93  bool perform(CallInst *CI);
94  void checkCandidate(CallInst &CI);
95  void shrinkWrapCI(CallInst *CI, Value *Cond);
96  bool performCallDomainErrorOnly(CallInst *CI, const LibFunc &Func);
97  bool performCallErrors(CallInst *CI, const LibFunc &Func);
98  bool performCallRangeErrorOnly(CallInst *CI, const LibFunc &Func);
99  Value *generateOneRangeCond(CallInst *CI, const LibFunc &Func);
100  Value *generateTwoRangeCond(CallInst *CI, const LibFunc &Func);
101  Value *generateCondForPow(CallInst *CI, const LibFunc &Func);
102 
103  // Create an OR of two conditions.
104  Value *createOrCond(CallInst *CI, CmpInst::Predicate Cmp, float Val,
105  CmpInst::Predicate Cmp2, float Val2) {
106  IRBuilder<> BBBuilder(CI);
107  Value *Arg = CI->getArgOperand(0);
108  auto Cond2 = createCond(BBBuilder, Arg, Cmp2, Val2);
109  auto Cond1 = createCond(BBBuilder, Arg, Cmp, Val);
110  return BBBuilder.CreateOr(Cond1, Cond2);
111  }
112 
113  // Create a single condition using IRBuilder.
114  Value *createCond(IRBuilder<> &BBBuilder, Value *Arg, CmpInst::Predicate Cmp,
115  float Val) {
116  Constant *V = ConstantFP::get(BBBuilder.getContext(), APFloat(Val));
117  if (!Arg->getType()->isFloatTy())
118  V = ConstantExpr::getFPExtend(V, Arg->getType());
119  return BBBuilder.CreateFCmp(Cmp, Arg, V);
120  }
121 
122  // Create a single condition.
123  Value *createCond(CallInst *CI, CmpInst::Predicate Cmp, float Val) {
124  IRBuilder<> BBBuilder(CI);
125  Value *Arg = CI->getArgOperand(0);
126  return createCond(BBBuilder, Arg, Cmp, Val);
127  }
128 
129  const TargetLibraryInfo &TLI;
130  DominatorTree *DT;
132 };
133 } // end anonymous namespace
134 
135 // Perform the transformation to calls with errno set by domain error.
136 bool LibCallsShrinkWrap::performCallDomainErrorOnly(CallInst *CI,
137  const LibFunc &Func) {
138  Value *Cond = nullptr;
139 
140  switch (Func) {
141  case LibFunc_acos: // DomainError: (x < -1 || x > 1)
142  case LibFunc_acosf: // Same as acos
143  case LibFunc_acosl: // Same as acos
144  case LibFunc_asin: // DomainError: (x < -1 || x > 1)
145  case LibFunc_asinf: // Same as asin
146  case LibFunc_asinl: // Same as asin
147  {
148  ++NumWrappedTwoCond;
149  Cond = createOrCond(CI, CmpInst::FCMP_OLT, -1.0f, CmpInst::FCMP_OGT, 1.0f);
150  break;
151  }
152  case LibFunc_cos: // DomainError: (x == +inf || x == -inf)
153  case LibFunc_cosf: // Same as cos
154  case LibFunc_cosl: // Same as cos
155  case LibFunc_sin: // DomainError: (x == +inf || x == -inf)
156  case LibFunc_sinf: // Same as sin
157  case LibFunc_sinl: // Same as sin
158  {
159  ++NumWrappedTwoCond;
160  Cond = createOrCond(CI, CmpInst::FCMP_OEQ, INFINITY, CmpInst::FCMP_OEQ,
161  -INFINITY);
162  break;
163  }
164  case LibFunc_acosh: // DomainError: (x < 1)
165  case LibFunc_acoshf: // Same as acosh
166  case LibFunc_acoshl: // Same as acosh
167  {
168  ++NumWrappedOneCond;
169  Cond = createCond(CI, CmpInst::FCMP_OLT, 1.0f);
170  break;
171  }
172  case LibFunc_sqrt: // DomainError: (x < 0)
173  case LibFunc_sqrtf: // Same as sqrt
174  case LibFunc_sqrtl: // Same as sqrt
175  {
176  ++NumWrappedOneCond;
177  Cond = createCond(CI, CmpInst::FCMP_OLT, 0.0f);
178  break;
179  }
180  default:
181  return false;
182  }
183  shrinkWrapCI(CI, Cond);
184  return true;
185 }
186 
187 // Perform the transformation to calls with errno set by range error.
188 bool LibCallsShrinkWrap::performCallRangeErrorOnly(CallInst *CI,
189  const LibFunc &Func) {
190  Value *Cond = nullptr;
191 
192  switch (Func) {
193  case LibFunc_cosh:
194  case LibFunc_coshf:
195  case LibFunc_coshl:
196  case LibFunc_exp:
197  case LibFunc_expf:
198  case LibFunc_expl:
199  case LibFunc_exp10:
200  case LibFunc_exp10f:
201  case LibFunc_exp10l:
202  case LibFunc_exp2:
203  case LibFunc_exp2f:
204  case LibFunc_exp2l:
205  case LibFunc_sinh:
206  case LibFunc_sinhf:
207  case LibFunc_sinhl: {
208  Cond = generateTwoRangeCond(CI, Func);
209  break;
210  }
211  case LibFunc_expm1: // RangeError: (709, inf)
212  case LibFunc_expm1f: // RangeError: (88, inf)
213  case LibFunc_expm1l: // RangeError: (11356, inf)
214  {
215  Cond = generateOneRangeCond(CI, Func);
216  break;
217  }
218  default:
219  return false;
220  }
221  shrinkWrapCI(CI, Cond);
222  return true;
223 }
224 
225 // Perform the transformation to calls with errno set by combination of errors.
226 bool LibCallsShrinkWrap::performCallErrors(CallInst *CI,
227  const LibFunc &Func) {
228  Value *Cond = nullptr;
229 
230  switch (Func) {
231  case LibFunc_atanh: // DomainError: (x < -1 || x > 1)
232  // PoleError: (x == -1 || x == 1)
233  // Overall Cond: (x <= -1 || x >= 1)
234  case LibFunc_atanhf: // Same as atanh
235  case LibFunc_atanhl: // Same as atanh
236  {
237  ++NumWrappedTwoCond;
238  Cond = createOrCond(CI, CmpInst::FCMP_OLE, -1.0f, CmpInst::FCMP_OGE, 1.0f);
239  break;
240  }
241  case LibFunc_log: // DomainError: (x < 0)
242  // PoleError: (x == 0)
243  // Overall Cond: (x <= 0)
244  case LibFunc_logf: // Same as log
245  case LibFunc_logl: // Same as log
246  case LibFunc_log10: // Same as log
247  case LibFunc_log10f: // Same as log
248  case LibFunc_log10l: // Same as log
249  case LibFunc_log2: // Same as log
250  case LibFunc_log2f: // Same as log
251  case LibFunc_log2l: // Same as log
252  case LibFunc_logb: // Same as log
253  case LibFunc_logbf: // Same as log
254  case LibFunc_logbl: // Same as log
255  {
256  ++NumWrappedOneCond;
257  Cond = createCond(CI, CmpInst::FCMP_OLE, 0.0f);
258  break;
259  }
260  case LibFunc_log1p: // DomainError: (x < -1)
261  // PoleError: (x == -1)
262  // Overall Cond: (x <= -1)
263  case LibFunc_log1pf: // Same as log1p
264  case LibFunc_log1pl: // Same as log1p
265  {
266  ++NumWrappedOneCond;
267  Cond = createCond(CI, CmpInst::FCMP_OLE, -1.0f);
268  break;
269  }
270  case LibFunc_pow: // DomainError: x < 0 and y is noninteger
271  // PoleError: x == 0 and y < 0
272  // RangeError: overflow or underflow
273  case LibFunc_powf:
274  case LibFunc_powl: {
275  Cond = generateCondForPow(CI, Func);
276  if (Cond == nullptr)
277  return false;
278  break;
279  }
280  default:
281  return false;
282  }
283  assert(Cond && "performCallErrors should not see an empty condition");
284  shrinkWrapCI(CI, Cond);
285  return true;
286 }
287 
288 // Checks if CI is a candidate for shrinkwrapping and put it into work list if
289 // true.
290 void LibCallsShrinkWrap::checkCandidate(CallInst &CI) {
291  if (CI.isNoBuiltin())
292  return;
293  // A possible improvement is to handle the calls with the return value being
294  // used. If there is API for fast libcall implementation without setting
295  // errno, we can use the same framework to direct/wrap the call to the fast
296  // API in the error free path, and leave the original call in the slow path.
297  if (!CI.use_empty())
298  return;
299 
300  LibFunc Func;
302  if (!Callee)
303  return;
304  if (!TLI.getLibFunc(*Callee, Func) || !TLI.has(Func))
305  return;
306 
307  if (CI.arg_empty())
308  return;
309  // TODO: Handle long double in other formats.
310  Type *ArgType = CI.getArgOperand(0)->getType();
311  if (!(ArgType->isFloatTy() || ArgType->isDoubleTy() ||
312  ArgType->isX86_FP80Ty()))
313  return;
314 
315  WorkList.push_back(&CI);
316 }
317 
318 // Generate the upper bound condition for RangeError.
319 Value *LibCallsShrinkWrap::generateOneRangeCond(CallInst *CI,
320  const LibFunc &Func) {
321  float UpperBound;
322  switch (Func) {
323  case LibFunc_expm1: // RangeError: (709, inf)
324  UpperBound = 709.0f;
325  break;
326  case LibFunc_expm1f: // RangeError: (88, inf)
327  UpperBound = 88.0f;
328  break;
329  case LibFunc_expm1l: // RangeError: (11356, inf)
330  UpperBound = 11356.0f;
331  break;
332  default:
333  llvm_unreachable("Unhandled library call!");
334  }
335 
336  ++NumWrappedOneCond;
337  return createCond(CI, CmpInst::FCMP_OGT, UpperBound);
338 }
339 
340 // Generate the lower and upper bound condition for RangeError.
341 Value *LibCallsShrinkWrap::generateTwoRangeCond(CallInst *CI,
342  const LibFunc &Func) {
343  float UpperBound, LowerBound;
344  switch (Func) {
345  case LibFunc_cosh: // RangeError: (x < -710 || x > 710)
346  case LibFunc_sinh: // Same as cosh
347  LowerBound = -710.0f;
348  UpperBound = 710.0f;
349  break;
350  case LibFunc_coshf: // RangeError: (x < -89 || x > 89)
351  case LibFunc_sinhf: // Same as coshf
352  LowerBound = -89.0f;
353  UpperBound = 89.0f;
354  break;
355  case LibFunc_coshl: // RangeError: (x < -11357 || x > 11357)
356  case LibFunc_sinhl: // Same as coshl
357  LowerBound = -11357.0f;
358  UpperBound = 11357.0f;
359  break;
360  case LibFunc_exp: // RangeError: (x < -745 || x > 709)
361  LowerBound = -745.0f;
362  UpperBound = 709.0f;
363  break;
364  case LibFunc_expf: // RangeError: (x < -103 || x > 88)
365  LowerBound = -103.0f;
366  UpperBound = 88.0f;
367  break;
368  case LibFunc_expl: // RangeError: (x < -11399 || x > 11356)
369  LowerBound = -11399.0f;
370  UpperBound = 11356.0f;
371  break;
372  case LibFunc_exp10: // RangeError: (x < -323 || x > 308)
373  LowerBound = -323.0f;
374  UpperBound = 308.0f;
375  break;
376  case LibFunc_exp10f: // RangeError: (x < -45 || x > 38)
377  LowerBound = -45.0f;
378  UpperBound = 38.0f;
379  break;
380  case LibFunc_exp10l: // RangeError: (x < -4950 || x > 4932)
381  LowerBound = -4950.0f;
382  UpperBound = 4932.0f;
383  break;
384  case LibFunc_exp2: // RangeError: (x < -1074 || x > 1023)
385  LowerBound = -1074.0f;
386  UpperBound = 1023.0f;
387  break;
388  case LibFunc_exp2f: // RangeError: (x < -149 || x > 127)
389  LowerBound = -149.0f;
390  UpperBound = 127.0f;
391  break;
392  case LibFunc_exp2l: // RangeError: (x < -16445 || x > 11383)
393  LowerBound = -16445.0f;
394  UpperBound = 11383.0f;
395  break;
396  default:
397  llvm_unreachable("Unhandled library call!");
398  }
399 
400  ++NumWrappedTwoCond;
401  return createOrCond(CI, CmpInst::FCMP_OGT, UpperBound, CmpInst::FCMP_OLT,
402  LowerBound);
403 }
404 
405 // For pow(x,y), We only handle the following cases:
406 // (1) x is a constant && (x >= 1) && (x < MaxUInt8)
407 // Cond is: (y > 127)
408 // (2) x is a value coming from an integer type.
409 // (2.1) if x's bit_size == 8
410 // Cond: (x <= 0 || y > 128)
411 // (2.2) if x's bit_size is 16
412 // Cond: (x <= 0 || y > 64)
413 // (2.3) if x's bit_size is 32
414 // Cond: (x <= 0 || y > 32)
415 // Support for powl(x,y) and powf(x,y) are TBD.
416 //
417 // Note that condition can be more conservative than the actual condition
418 // (i.e. we might invoke the calls that will not set the errno.).
419 //
420 Value *LibCallsShrinkWrap::generateCondForPow(CallInst *CI,
421  const LibFunc &Func) {
422  // FIXME: LibFunc_powf and powl TBD.
423  if (Func != LibFunc_pow) {
424  LLVM_DEBUG(dbgs() << "Not handled powf() and powl()\n");
425  return nullptr;
426  }
427 
428  Value *Base = CI->getArgOperand(0);
429  Value *Exp = CI->getArgOperand(1);
430  IRBuilder<> BBBuilder(CI);
431 
432  // Constant Base case.
433  if (ConstantFP *CF = dyn_cast<ConstantFP>(Base)) {
434  double D = CF->getValueAPF().convertToDouble();
435  if (D < 1.0f || D > APInt::getMaxValue(8).getZExtValue()) {
436  LLVM_DEBUG(dbgs() << "Not handled pow(): constant base out of range\n");
437  return nullptr;
438  }
439 
440  ++NumWrappedOneCond;
441  Constant *V = ConstantFP::get(CI->getContext(), APFloat(127.0f));
442  if (!Exp->getType()->isFloatTy())
443  V = ConstantExpr::getFPExtend(V, Exp->getType());
444  return BBBuilder.CreateFCmp(CmpInst::FCMP_OGT, Exp, V);
445  }
446 
447  // If the Base value coming from an integer type.
448  Instruction *I = dyn_cast<Instruction>(Base);
449  if (!I) {
450  LLVM_DEBUG(dbgs() << "Not handled pow(): FP type base\n");
451  return nullptr;
452  }
453  unsigned Opcode = I->getOpcode();
454  if (Opcode == Instruction::UIToFP || Opcode == Instruction::SIToFP) {
455  unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits();
456  float UpperV = 0.0f;
457  if (BW == 8)
458  UpperV = 128.0f;
459  else if (BW == 16)
460  UpperV = 64.0f;
461  else if (BW == 32)
462  UpperV = 32.0f;
463  else {
464  LLVM_DEBUG(dbgs() << "Not handled pow(): type too wide\n");
465  return nullptr;
466  }
467 
468  ++NumWrappedTwoCond;
469  Constant *V = ConstantFP::get(CI->getContext(), APFloat(UpperV));
470  Constant *V0 = ConstantFP::get(CI->getContext(), APFloat(0.0f));
471  if (!Exp->getType()->isFloatTy())
472  V = ConstantExpr::getFPExtend(V, Exp->getType());
473  if (!Base->getType()->isFloatTy())
474  V0 = ConstantExpr::getFPExtend(V0, Exp->getType());
475 
476  Value *Cond = BBBuilder.CreateFCmp(CmpInst::FCMP_OGT, Exp, V);
477  Value *Cond0 = BBBuilder.CreateFCmp(CmpInst::FCMP_OLE, Base, V0);
478  return BBBuilder.CreateOr(Cond0, Cond);
479  }
480  LLVM_DEBUG(dbgs() << "Not handled pow(): base not from integer convert\n");
481  return nullptr;
482 }
483 
484 // Wrap conditions that can potentially generate errno to the library call.
485 void LibCallsShrinkWrap::shrinkWrapCI(CallInst *CI, Value *Cond) {
486  assert(Cond != nullptr && "ShrinkWrapCI is not expecting an empty call inst");
487  MDNode *BranchWeights =
488  MDBuilder(CI->getContext()).createBranchWeights(1, 2000);
489 
490  Instruction *NewInst =
491  SplitBlockAndInsertIfThen(Cond, CI, false, BranchWeights, DT);
492  BasicBlock *CallBB = NewInst->getParent();
493  CallBB->setName("cdce.call");
494  BasicBlock *SuccBB = CallBB->getSingleSuccessor();
495  assert(SuccBB && "The split block should have a single successor");
496  SuccBB->setName("cdce.end");
497  CI->removeFromParent();
498  CallBB->getInstList().insert(CallBB->getFirstInsertionPt(), CI);
499  LLVM_DEBUG(dbgs() << "== Basic Block After ==");
500  LLVM_DEBUG(dbgs() << *CallBB->getSinglePredecessor() << *CallBB
501  << *CallBB->getSingleSuccessor() << "\n");
502 }
503 
504 // Perform the transformation to a single candidate.
505 bool LibCallsShrinkWrap::perform(CallInst *CI) {
506  LibFunc Func;
508  assert(Callee && "perform() should apply to a non-empty callee");
509  TLI.getLibFunc(*Callee, Func);
510  assert(Func && "perform() is not expecting an empty function");
511 
512  if (performCallDomainErrorOnly(CI, Func) || performCallRangeErrorOnly(CI, Func))
513  return true;
514  return performCallErrors(CI, Func);
515 }
516 
517 void LibCallsShrinkWrapLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
521 }
522 
523 static bool runImpl(Function &F, const TargetLibraryInfo &TLI,
524  DominatorTree *DT) {
525  if (F.hasFnAttribute(Attribute::OptimizeForSize))
526  return false;
527  LibCallsShrinkWrap CCDCE(TLI, DT);
528  CCDCE.visit(F);
529  bool Changed = CCDCE.perform();
530 
531 // Verify the dominator after we've updated it locally.
533  return Changed;
534 }
535 
537  auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
538  auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
539  auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
540  return runImpl(F, TLI, DT);
541 }
542 
543 namespace llvm {
545 
546 // Public interface to LibCallsShrinkWrap pass.
548  return new LibCallsShrinkWrapLegacyPass();
549 }
550 
553  auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);
555  if (!runImpl(F, TLI, DT))
556  return PreservedAnalyses::all();
557  auto PA = PreservedAnalyses();
558  PA.preserve<DominatorTreeAnalysis>();
559  return PA;
560 }
561 }
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
libcalls
partially inline libcalls
Definition: PartiallyInlineLibCalls.cpp:208
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::CallBase::isNoBuiltin
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Definition: InstrTypes.h:1789
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:783
llvm::Function
Definition: Function.h:62
Pass.h
llvm::SmallVector< CallInst *, 16 >
Statistic.h
false::LibCallsShrinkWrap::LibCallsShrinkWrap
LibCallsShrinkWrap(const TargetLibraryInfo &TLI, DominatorTree *DT)
Definition: LibCallsShrinkWrap.cpp:76
llvm::APInt::getMaxValue
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
Definition: APInt.h:186
llvm::IRBuilder<>
llvm::IRBuilderBase::CreateOr
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1388
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:151
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
GlobalsModRef.h
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::BasicBlock::getSingleSuccessor
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
Definition: BasicBlock.cpp:298
llvm::Type::isX86_FP80Ty
bool isX86_FP80Ty() const
Return true if this is x86 long double.
Definition: Type.h:153
llvm::BasicBlock::getSinglePredecessor
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:268
llvm::Sched::Fast
@ Fast
Definition: TargetLowering.h:105
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:724
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
shrinkwrap
libcalls shrinkwrap
Definition: LibCallsShrinkWrap.cpp:70
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
Constants.h
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::LibFunc
LibFunc
Definition: TargetLibraryInfo.h:34
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1383
llvm::MDBuilder::createBranchWeights
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
Definition: MDBuilder.cpp:37
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
TargetLibraryInfo.h
llvm::BasicBlock::getFirstInsertionPt
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:253
false
Definition: StackSlotColoring.cpp:142
llvm::createLibCallsShrinkWrapPass
FunctionPass * createLibCallsShrinkWrapPass()
Definition: LibCallsShrinkWrap.cpp:547
llvm::Instruction
Definition: Instruction.h:45
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:287
MDBuilder.h
llvm::IRBuilderBase::getContext
LLVMContext & getContext() const
Definition: IRBuilder.h:180
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
false::LibCallsShrinkWrap::perform
bool perform()
Definition: LibCallsShrinkWrap.cpp:79
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:376
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(LibCallsShrinkWrapLegacyPass, "libcalls-shrinkwrap", "Conditionally eliminate dead library calls", false, false) INITIALIZE_PASS_END(LibCallsShrinkWrapLegacyPass
llvm::IRBuilderBase::CreateFCmp
Value * CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2352
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:723
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:726
llvm::Instruction::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing basic block, but does not delete it.
Definition: Instruction.cpp:74
false::LibCallsShrinkWrap
Definition: LibCallsShrinkWrap.cpp:74
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
CFG.h
INFINITY
#define INFINITY
Definition: regcomp.c:281
llvm::APFloat
Definition: APFloat.h:701
false::LibCallsShrinkWrap::visitCallInst
void visitCallInst(CallInst &CI)
Definition: LibCallsShrinkWrap.cpp:78
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:465
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
I
#define I(x, y, z)
Definition: MD5.cpp:59
IRBuilder.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:725
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
calls
libcalls Conditionally eliminate dead library calls
Definition: LibCallsShrinkWrap.cpp:71
LibCallsShrinkWrap.h
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:179
InstVisitor.h
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
library
Itanium Name Demangler i e convert the string _Z1fv into but neither can depend on each other libcxxabi needs the demangler to implement which is part of the itanium ABI spec LLVM needs a copy for a bunch of but doesn t want to use the system s __cxa_demangle because it a might not be and b probably isn t that up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic library
Definition: README.txt:30
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:990
llvm::InstVisitor
Base class for instruction visitors.
Definition: InstVisitor.h:79
runImpl
static bool runImpl(Function &F, const TargetLibraryInfo &TLI, DominatorTree *DT)
Definition: LibCallsShrinkWrap.cpp:523
llvm::ifs::IFSSymbolType::Func
@ Func
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:206
llvm::initializeLibCallsShrinkWrapLegacyPassPass
void initializeLibCallsShrinkWrapLegacyPassPass(PassRegistry &)
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:69
llvm::Type::isFloatTy
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:147
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:972
llvm::AnalysisManager::getCachedResult
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
Definition: PassManager.h:802
Function.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:221
llvm::Type::isDoubleTy
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:150
llvm::CallBase::arg_empty
bool arg_empty() const
Definition: InstrTypes.h:1325
llvm::MDBuilder
Definition: MDBuilder.h:35
llvm::DominatorTreeAnalysis
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:252
llvm::BasicBlock::getInstList
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:363
Instructions.h
SmallVector.h
llvm::ConstantExpr::getFPExtend
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2149
Dominators.h
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1328
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
llvm::GlobalsAAWrapperPass
Legacy wrapper pass to provide the GlobalsAAResult object.
Definition: GlobalsModRef.h:143
llvm::DominatorTreeBase::verify
bool verify(VerificationLevel VL=VerificationLevel::Full) const
verify - checks if the tree is correct.
Definition: GenericDomTree.h:802
llvm::codeview::CompileSym3Flags::Exp
@ Exp
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:727
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
llvm::LibCallsShrinkWrapPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
Definition: LibCallsShrinkWrap.cpp:551
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
LLVMContext.h
llvm::SplitBlockAndInsertIfThen
Instruction * SplitBlockAndInsertIfThen(Value *Cond, Instruction *SplitBefore, bool Unreachable, MDNode *BranchWeights, DominatorTree *DT, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)
Split the containing block at the specified instruction - everything before SplitBefore stays in the ...
Definition: BasicBlockUtils.cpp:1418
BasicBlockUtils.h
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:440
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::LibCallsShrinkWrapPassID
char & LibCallsShrinkWrapPassID
Definition: LibCallsShrinkWrap.cpp:544
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37