LLVM  4.0.0
SimplifyLibCalls.cpp
Go to the documentation of this file.
1 //===------ SimplifyLibCalls.cpp - Library calls simplifier ---------------===//
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 is a utility pass used for testing the InstructionSimplify analysis.
11 // The analysis is applied to every instruction, and if it simplifies then the
12 // instruction is replaced by the simplification. If you are looking for a pass
13 // that performs serious instruction folding, use the instcombine pass instead.
14 //
15 //===----------------------------------------------------------------------===//
16 
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/StringMap.h"
20 #include "llvm/ADT/Triple.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/DiagnosticInfo.h"
25 #include "llvm/IR/Function.h"
26 #include "llvm/IR/IRBuilder.h"
27 #include "llvm/IR/IntrinsicInst.h"
28 #include "llvm/IR/Intrinsics.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/PatternMatch.h"
35 
36 using namespace llvm;
37 using namespace PatternMatch;
38 
39 static cl::opt<bool>
40  ColdErrorCalls("error-reporting-is-cold", cl::init(true), cl::Hidden,
41  cl::desc("Treat error-reporting calls as cold"));
42 
43 static cl::opt<bool>
44  EnableUnsafeFPShrink("enable-double-float-shrink", cl::Hidden,
45  cl::init(false),
46  cl::desc("Enable unsafe double to float "
47  "shrinking for math lib calls"));
48 
49 
50 //===----------------------------------------------------------------------===//
51 // Helper Functions
52 //===----------------------------------------------------------------------===//
53 
55  return Func == LibFunc::abs || Func == LibFunc::labs ||
56  Func == LibFunc::llabs || Func == LibFunc::strlen;
57 }
58 
60  switch(CI->getCallingConv()) {
61  default:
62  return false;
64  return true;
68 
69  // The iOS ABI diverges from the standard in some cases, so for now don't
70  // try to simplify those calls.
71  if (Triple(CI->getModule()->getTargetTriple()).isiOS())
72  return false;
73 
74  auto *FuncTy = CI->getFunctionType();
75 
76  if (!FuncTy->getReturnType()->isPointerTy() &&
77  !FuncTy->getReturnType()->isIntegerTy() &&
78  !FuncTy->getReturnType()->isVoidTy())
79  return false;
80 
81  for (auto Param : FuncTy->params()) {
82  if (!Param->isPointerTy() && !Param->isIntegerTy())
83  return false;
84  }
85  return true;
86  }
87  }
88  return false;
89 }
90 
91 /// Return true if it only matters that the value is equal or not-equal to zero.
93  for (User *U : V->users()) {
94  if (ICmpInst *IC = dyn_cast<ICmpInst>(U))
95  if (IC->isEquality())
96  if (Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
97  if (C->isNullValue())
98  continue;
99  // Unknown instruction.
100  return false;
101  }
102  return true;
103 }
104 
105 /// Return true if it is only used in equality comparisons with With.
107  for (User *U : V->users()) {
108  if (ICmpInst *IC = dyn_cast<ICmpInst>(U))
109  if (IC->isEquality() && IC->getOperand(1) == With)
110  continue;
111  // Unknown instruction.
112  return false;
113  }
114  return true;
115 }
116 
117 static bool callHasFloatingPointArgument(const CallInst *CI) {
118  return any_of(CI->operands(), [](const Use &OI) {
119  return OI->getType()->isFloatingPointTy();
120  });
121 }
122 
123 /// \brief Check whether the overloaded unary floating point function
124 /// corresponding to \a Ty is available.
125 static bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
126  LibFunc::Func DoubleFn, LibFunc::Func FloatFn,
127  LibFunc::Func LongDoubleFn) {
128  switch (Ty->getTypeID()) {
129  case Type::FloatTyID:
130  return TLI->has(FloatFn);
131  case Type::DoubleTyID:
132  return TLI->has(DoubleFn);
133  default:
134  return TLI->has(LongDoubleFn);
135  }
136 }
137 
138 //===----------------------------------------------------------------------===//
139 // String and Memory Library Call Optimizations
140 //===----------------------------------------------------------------------===//
141 
142 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
143  // Extract some information from the instruction
144  Value *Dst = CI->getArgOperand(0);
145  Value *Src = CI->getArgOperand(1);
146 
147  // See if we can get the length of the input string.
148  uint64_t Len = GetStringLength(Src);
149  if (Len == 0)
150  return nullptr;
151  --Len; // Unbias length.
152 
153  // Handle the simple, do-nothing case: strcat(x, "") -> x
154  if (Len == 0)
155  return Dst;
156 
157  return emitStrLenMemCpy(Src, Dst, Len, B);
158 }
159 
160 Value *LibCallSimplifier::emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
161  IRBuilder<> &B) {
162  // We need to find the end of the destination string. That's where the
163  // memory is to be moved to. We just generate a call to strlen.
164  Value *DstLen = emitStrLen(Dst, B, DL, TLI);
165  if (!DstLen)
166  return nullptr;
167 
168  // Now that we have the destination's length, we must index into the
169  // destination's pointer to get the actual memcpy destination (end of
170  // the string .. we're concatenating).
171  Value *CpyDst = B.CreateGEP(B.getInt8Ty(), Dst, DstLen, "endptr");
172 
173  // We have enough information to now generate the memcpy call to do the
174  // concatenation for us. Make a memcpy to copy the nul byte with align = 1.
175  B.CreateMemCpy(CpyDst, Src,
176  ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1),
177  1);
178  return Dst;
179 }
180 
181 Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilder<> &B) {
182  // Extract some information from the instruction.
183  Value *Dst = CI->getArgOperand(0);
184  Value *Src = CI->getArgOperand(1);
185  uint64_t Len;
186 
187  // We don't do anything if length is not constant.
188  if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
189  Len = LengthArg->getZExtValue();
190  else
191  return nullptr;
192 
193  // See if we can get the length of the input string.
194  uint64_t SrcLen = GetStringLength(Src);
195  if (SrcLen == 0)
196  return nullptr;
197  --SrcLen; // Unbias length.
198 
199  // Handle the simple, do-nothing cases:
200  // strncat(x, "", c) -> x
201  // strncat(x, c, 0) -> x
202  if (SrcLen == 0 || Len == 0)
203  return Dst;
204 
205  // We don't optimize this case.
206  if (Len < SrcLen)
207  return nullptr;
208 
209  // strncat(x, s, c) -> strcat(x, s)
210  // s is constant so the strcat can be optimized further.
211  return emitStrLenMemCpy(Src, Dst, SrcLen, B);
212 }
213 
214 Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilder<> &B) {
215  Function *Callee = CI->getCalledFunction();
216  FunctionType *FT = Callee->getFunctionType();
217  Value *SrcStr = CI->getArgOperand(0);
218 
219  // If the second operand is non-constant, see if we can compute the length
220  // of the input string and turn this into memchr.
221  ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
222  if (!CharC) {
223  uint64_t Len = GetStringLength(SrcStr);
224  if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32.
225  return nullptr;
226 
227  return emitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
228  ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
229  B, DL, TLI);
230  }
231 
232  // Otherwise, the character is a constant, see if the first argument is
233  // a string literal. If so, we can constant fold.
234  StringRef Str;
235  if (!getConstantStringInfo(SrcStr, Str)) {
236  if (CharC->isZero()) // strchr(p, 0) -> p + strlen(p)
237  return B.CreateGEP(B.getInt8Ty(), SrcStr, emitStrLen(SrcStr, B, DL, TLI),
238  "strchr");
239  return nullptr;
240  }
241 
242  // Compute the offset, make sure to handle the case when we're searching for
243  // zero (a weird way to spell strlen).
244  size_t I = (0xFF & CharC->getSExtValue()) == 0
245  ? Str.size()
246  : Str.find(CharC->getSExtValue());
247  if (I == StringRef::npos) // Didn't find the char. strchr returns null.
248  return Constant::getNullValue(CI->getType());
249 
250  // strchr(s+n,c) -> gep(s+n+i,c)
251  return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "strchr");
252 }
253 
254 Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilder<> &B) {
255  Value *SrcStr = CI->getArgOperand(0);
256  ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
257 
258  // Cannot fold anything if we're not looking for a constant.
259  if (!CharC)
260  return nullptr;
261 
262  StringRef Str;
263  if (!getConstantStringInfo(SrcStr, Str)) {
264  // strrchr(s, 0) -> strchr(s, 0)
265  if (CharC->isZero())
266  return emitStrChr(SrcStr, '\0', B, TLI);
267  return nullptr;
268  }
269 
270  // Compute the offset.
271  size_t I = (0xFF & CharC->getSExtValue()) == 0
272  ? Str.size()
273  : Str.rfind(CharC->getSExtValue());
274  if (I == StringRef::npos) // Didn't find the char. Return null.
275  return Constant::getNullValue(CI->getType());
276 
277  // strrchr(s+n,c) -> gep(s+n+i,c)
278  return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "strrchr");
279 }
280 
281 Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilder<> &B) {
282  Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
283  if (Str1P == Str2P) // strcmp(x,x) -> 0
284  return ConstantInt::get(CI->getType(), 0);
285 
286  StringRef Str1, Str2;
287  bool HasStr1 = getConstantStringInfo(Str1P, Str1);
288  bool HasStr2 = getConstantStringInfo(Str2P, Str2);
289 
290  // strcmp(x, y) -> cnst (if both x and y are constant strings)
291  if (HasStr1 && HasStr2)
292  return ConstantInt::get(CI->getType(), Str1.compare(Str2));
293 
294  if (HasStr1 && Str1.empty()) // strcmp("", x) -> -*x
295  return B.CreateNeg(
296  B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType()));
297 
298  if (HasStr2 && Str2.empty()) // strcmp(x,"") -> *x
299  return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
300 
301  // strcmp(P, "x") -> memcmp(P, "x", 2)
302  uint64_t Len1 = GetStringLength(Str1P);
303  uint64_t Len2 = GetStringLength(Str2P);
304  if (Len1 && Len2) {
305  return emitMemCmp(Str1P, Str2P,
306  ConstantInt::get(DL.getIntPtrType(CI->getContext()),
307  std::min(Len1, Len2)),
308  B, DL, TLI);
309  }
310 
311  return nullptr;
312 }
313 
314 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
315  Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
316  if (Str1P == Str2P) // strncmp(x,x,n) -> 0
317  return ConstantInt::get(CI->getType(), 0);
318 
319  // Get the length argument if it is constant.
320  uint64_t Length;
321  if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
322  Length = LengthArg->getZExtValue();
323  else
324  return nullptr;
325 
326  if (Length == 0) // strncmp(x,y,0) -> 0
327  return ConstantInt::get(CI->getType(), 0);
328 
329  if (Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
330  return emitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, DL, TLI);
331 
332  StringRef Str1, Str2;
333  bool HasStr1 = getConstantStringInfo(Str1P, Str1);
334  bool HasStr2 = getConstantStringInfo(Str2P, Str2);
335 
336  // strncmp(x, y) -> cnst (if both x and y are constant strings)
337  if (HasStr1 && HasStr2) {
338  StringRef SubStr1 = Str1.substr(0, Length);
339  StringRef SubStr2 = Str2.substr(0, Length);
340  return ConstantInt::get(CI->getType(), SubStr1.compare(SubStr2));
341  }
342 
343  if (HasStr1 && Str1.empty()) // strncmp("", x, n) -> -*x
344  return B.CreateNeg(
345  B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType()));
346 
347  if (HasStr2 && Str2.empty()) // strncmp(x, "", n) -> *x
348  return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
349 
350  return nullptr;
351 }
352 
353 Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
354  Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
355  if (Dst == Src) // strcpy(x,x) -> x
356  return Src;
357 
358  // See if we can get the length of the input string.
359  uint64_t Len = GetStringLength(Src);
360  if (Len == 0)
361  return nullptr;
362 
363  // We have enough information to now generate the memcpy call to do the
364  // copy for us. Make a memcpy to copy the nul byte with align = 1.
365  B.CreateMemCpy(Dst, Src,
366  ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len), 1);
367  return Dst;
368 }
369 
370 Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilder<> &B) {
371  Function *Callee = CI->getCalledFunction();
372  Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
373  if (Dst == Src) { // stpcpy(x,x) -> x+strlen(x)
374  Value *StrLen = emitStrLen(Src, B, DL, TLI);
375  return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
376  }
377 
378  // See if we can get the length of the input string.
379  uint64_t Len = GetStringLength(Src);
380  if (Len == 0)
381  return nullptr;
382 
383  Type *PT = Callee->getFunctionType()->getParamType(0);
384  Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
385  Value *DstEnd = B.CreateGEP(B.getInt8Ty(), Dst,
386  ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
387 
388  // We have enough information to now generate the memcpy call to do the
389  // copy for us. Make a memcpy to copy the nul byte with align = 1.
390  B.CreateMemCpy(Dst, Src, LenV, 1);
391  return DstEnd;
392 }
393 
394 Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) {
395  Function *Callee = CI->getCalledFunction();
396  Value *Dst = CI->getArgOperand(0);
397  Value *Src = CI->getArgOperand(1);
398  Value *LenOp = CI->getArgOperand(2);
399 
400  // See if we can get the length of the input string.
401  uint64_t SrcLen = GetStringLength(Src);
402  if (SrcLen == 0)
403  return nullptr;
404  --SrcLen;
405 
406  if (SrcLen == 0) {
407  // strncpy(x, "", y) -> memset(x, '\0', y, 1)
408  B.CreateMemSet(Dst, B.getInt8('\0'), LenOp, 1);
409  return Dst;
410  }
411 
412  uint64_t Len;
413  if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(LenOp))
414  Len = LengthArg->getZExtValue();
415  else
416  return nullptr;
417 
418  if (Len == 0)
419  return Dst; // strncpy(x, y, 0) -> x
420 
421  // Let strncpy handle the zero padding
422  if (Len > SrcLen + 1)
423  return nullptr;
424 
425  Type *PT = Callee->getFunctionType()->getParamType(0);
426  // strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
427  B.CreateMemCpy(Dst, Src, ConstantInt::get(DL.getIntPtrType(PT), Len), 1);
428 
429  return Dst;
430 }
431 
432 Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilder<> &B) {
433  Value *Src = CI->getArgOperand(0);
434 
435  // Constant folding: strlen("xyz") -> 3
436  if (uint64_t Len = GetStringLength(Src))
437  return ConstantInt::get(CI->getType(), Len - 1);
438 
439  // If s is a constant pointer pointing to a string literal, we can fold
440  // strlen(s + x) to strlen(s) - x, when x is known to be in the range
441  // [0, strlen(s)] or the string has a single null terminator '\0' at the end.
442  // We only try to simplify strlen when the pointer s points to an array
443  // of i8. Otherwise, we would need to scale the offset x before doing the
444  // subtraction. This will make the optimization more complex, and it's not
445  // very useful because calling strlen for a pointer of other types is
446  // very uncommon.
447  if (GEPOperator *GEP = dyn_cast<GEPOperator>(Src)) {
449  return nullptr;
450 
451  StringRef Str;
452  if (getConstantStringInfo(GEP->getOperand(0), Str, 0, false)) {
453  size_t NullTermIdx = Str.find('\0');
454 
455  // If the string does not have '\0', leave it to strlen to compute
456  // its length.
457  if (NullTermIdx == StringRef::npos)
458  return nullptr;
459 
460  Value *Offset = GEP->getOperand(2);
461  unsigned BitWidth = Offset->getType()->getIntegerBitWidth();
462  APInt KnownZero(BitWidth, 0);
463  APInt KnownOne(BitWidth, 0);
464  computeKnownBits(Offset, KnownZero, KnownOne, DL, 0, nullptr, CI,
465  nullptr);
466  KnownZero.flipAllBits();
467  size_t ArrSize =
468  cast<ArrayType>(GEP->getSourceElementType())->getNumElements();
469 
470  // KnownZero's bits are flipped, so zeros in KnownZero now represent
471  // bits known to be zeros in Offset, and ones in KnowZero represent
472  // bits unknown in Offset. Therefore, Offset is known to be in range
473  // [0, NullTermIdx] when the flipped KnownZero is non-negative and
474  // unsigned-less-than NullTermIdx.
475  //
476  // If Offset is not provably in the range [0, NullTermIdx], we can still
477  // optimize if we can prove that the program has undefined behavior when
478  // Offset is outside that range. That is the case when GEP->getOperand(0)
479  // is a pointer to an object whose memory extent is NullTermIdx+1.
480  if ((KnownZero.isNonNegative() && KnownZero.ule(NullTermIdx)) ||
481  (GEP->isInBounds() && isa<GlobalVariable>(GEP->getOperand(0)) &&
482  NullTermIdx == ArrSize - 1))
483  return B.CreateSub(ConstantInt::get(CI->getType(), NullTermIdx),
484  Offset);
485  }
486 
487  return nullptr;
488  }
489 
490  // strlen(x?"foo":"bars") --> x ? 3 : 4
491  if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {
492  uint64_t LenTrue = GetStringLength(SI->getTrueValue());
493  uint64_t LenFalse = GetStringLength(SI->getFalseValue());
494  if (LenTrue && LenFalse) {
495  Function *Caller = CI->getParent()->getParent();
496  emitOptimizationRemark(CI->getContext(), "simplify-libcalls", *Caller,
497  SI->getDebugLoc(),
498  "folded strlen(select) to select of constants");
499  return B.CreateSelect(SI->getCondition(),
500  ConstantInt::get(CI->getType(), LenTrue - 1),
501  ConstantInt::get(CI->getType(), LenFalse - 1));
502  }
503  }
504 
505  // strlen(x) != 0 --> *x != 0
506  // strlen(x) == 0 --> *x == 0
508  return B.CreateZExt(B.CreateLoad(Src, "strlenfirst"), CI->getType());
509 
510  return nullptr;
511 }
512 
513 Value *LibCallSimplifier::optimizeStrPBrk(CallInst *CI, IRBuilder<> &B) {
514  StringRef S1, S2;
515  bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
516  bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
517 
518  // strpbrk(s, "") -> nullptr
519  // strpbrk("", s) -> nullptr
520  if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
521  return Constant::getNullValue(CI->getType());
522 
523  // Constant folding.
524  if (HasS1 && HasS2) {
525  size_t I = S1.find_first_of(S2);
526  if (I == StringRef::npos) // No match.
527  return Constant::getNullValue(CI->getType());
528 
529  return B.CreateGEP(B.getInt8Ty(), CI->getArgOperand(0), B.getInt64(I),
530  "strpbrk");
531  }
532 
533  // strpbrk(s, "a") -> strchr(s, 'a')
534  if (HasS2 && S2.size() == 1)
535  return emitStrChr(CI->getArgOperand(0), S2[0], B, TLI);
536 
537  return nullptr;
538 }
539 
540 Value *LibCallSimplifier::optimizeStrTo(CallInst *CI, IRBuilder<> &B) {
541  Value *EndPtr = CI->getArgOperand(1);
542  if (isa<ConstantPointerNull>(EndPtr)) {
543  // With a null EndPtr, this function won't capture the main argument.
544  // It would be readonly too, except that it still may write to errno.
545  CI->addAttribute(1, Attribute::NoCapture);
546  }
547 
548  return nullptr;
549 }
550 
551 Value *LibCallSimplifier::optimizeStrSpn(CallInst *CI, IRBuilder<> &B) {
552  StringRef S1, S2;
553  bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
554  bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
555 
556  // strspn(s, "") -> 0
557  // strspn("", s) -> 0
558  if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
559  return Constant::getNullValue(CI->getType());
560 
561  // Constant folding.
562  if (HasS1 && HasS2) {
563  size_t Pos = S1.find_first_not_of(S2);
564  if (Pos == StringRef::npos)
565  Pos = S1.size();
566  return ConstantInt::get(CI->getType(), Pos);
567  }
568 
569  return nullptr;
570 }
571 
572 Value *LibCallSimplifier::optimizeStrCSpn(CallInst *CI, IRBuilder<> &B) {
573  StringRef S1, S2;
574  bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
575  bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
576 
577  // strcspn("", s) -> 0
578  if (HasS1 && S1.empty())
579  return Constant::getNullValue(CI->getType());
580 
581  // Constant folding.
582  if (HasS1 && HasS2) {
583  size_t Pos = S1.find_first_of(S2);
584  if (Pos == StringRef::npos)
585  Pos = S1.size();
586  return ConstantInt::get(CI->getType(), Pos);
587  }
588 
589  // strcspn(s, "") -> strlen(s)
590  if (HasS2 && S2.empty())
591  return emitStrLen(CI->getArgOperand(0), B, DL, TLI);
592 
593  return nullptr;
594 }
595 
596 Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilder<> &B) {
597  // fold strstr(x, x) -> x.
598  if (CI->getArgOperand(0) == CI->getArgOperand(1))
599  return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
600 
601  // fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
603  Value *StrLen = emitStrLen(CI->getArgOperand(1), B, DL, TLI);
604  if (!StrLen)
605  return nullptr;
606  Value *StrNCmp = emitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
607  StrLen, B, DL, TLI);
608  if (!StrNCmp)
609  return nullptr;
610  for (auto UI = CI->user_begin(), UE = CI->user_end(); UI != UE;) {
611  ICmpInst *Old = cast<ICmpInst>(*UI++);
612  Value *Cmp =
613  B.CreateICmp(Old->getPredicate(), StrNCmp,
614  ConstantInt::getNullValue(StrNCmp->getType()), "cmp");
615  replaceAllUsesWith(Old, Cmp);
616  }
617  return CI;
618  }
619 
620  // See if either input string is a constant string.
621  StringRef SearchStr, ToFindStr;
622  bool HasStr1 = getConstantStringInfo(CI->getArgOperand(0), SearchStr);
623  bool HasStr2 = getConstantStringInfo(CI->getArgOperand(1), ToFindStr);
624 
625  // fold strstr(x, "") -> x.
626  if (HasStr2 && ToFindStr.empty())
627  return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
628 
629  // If both strings are known, constant fold it.
630  if (HasStr1 && HasStr2) {
631  size_t Offset = SearchStr.find(ToFindStr);
632 
633  if (Offset == StringRef::npos) // strstr("foo", "bar") -> null
634  return Constant::getNullValue(CI->getType());
635 
636  // strstr("abcd", "bc") -> gep((char*)"abcd", 1)
637  Value *Result = castToCStr(CI->getArgOperand(0), B);
638  Result = B.CreateConstInBoundsGEP1_64(Result, Offset, "strstr");
639  return B.CreateBitCast(Result, CI->getType());
640  }
641 
642  // fold strstr(x, "y") -> strchr(x, 'y').
643  if (HasStr2 && ToFindStr.size() == 1) {
644  Value *StrChr = emitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI);
645  return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
646  }
647  return nullptr;
648 }
649 
650 Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilder<> &B) {
651  Value *SrcStr = CI->getArgOperand(0);
652  ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
654 
655  // memchr(x, y, 0) -> null
656  if (LenC && LenC->isNullValue())
657  return Constant::getNullValue(CI->getType());
658 
659  // From now on we need at least constant length and string.
660  StringRef Str;
661  if (!LenC || !getConstantStringInfo(SrcStr, Str, 0, /*TrimAtNul=*/false))
662  return nullptr;
663 
664  // Truncate the string to LenC. If Str is smaller than LenC we will still only
665  // scan the string, as reading past the end of it is undefined and we can just
666  // return null if we don't find the char.
667  Str = Str.substr(0, LenC->getZExtValue());
668 
669  // If the char is variable but the input str and length are not we can turn
670  // this memchr call into a simple bit field test. Of course this only works
671  // when the return value is only checked against null.
672  //
673  // It would be really nice to reuse switch lowering here but we can't change
674  // the CFG at this point.
675  //
676  // memchr("\r\n", C, 2) != nullptr -> (C & ((1 << '\r') | (1 << '\n'))) != 0
677  // after bounds check.
678  if (!CharC && !Str.empty() && isOnlyUsedInZeroEqualityComparison(CI)) {
679  unsigned char Max =
680  *std::max_element(reinterpret_cast<const unsigned char *>(Str.begin()),
681  reinterpret_cast<const unsigned char *>(Str.end()));
682 
683  // Make sure the bit field we're about to create fits in a register on the
684  // target.
685  // FIXME: On a 64 bit architecture this prevents us from using the
686  // interesting range of alpha ascii chars. We could do better by emitting
687  // two bitfields or shifting the range by 64 if no lower chars are used.
688  if (!DL.fitsInLegalInteger(Max + 1))
689  return nullptr;
690 
691  // For the bit field use a power-of-2 type with at least 8 bits to avoid
692  // creating unnecessary illegal types.
693  unsigned char Width = NextPowerOf2(std::max((unsigned char)7, Max));
694 
695  // Now build the bit field.
696  APInt Bitfield(Width, 0);
697  for (char C : Str)
698  Bitfield.setBit((unsigned char)C);
699  Value *BitfieldC = B.getInt(Bitfield);
700 
701  // First check that the bit field access is within bounds.
702  Value *C = B.CreateZExtOrTrunc(CI->getArgOperand(1), BitfieldC->getType());
703  Value *Bounds = B.CreateICmp(ICmpInst::ICMP_ULT, C, B.getIntN(Width, Width),
704  "memchr.bounds");
705 
706  // Create code that checks if the given bit is set in the field.
707  Value *Shl = B.CreateShl(B.getIntN(Width, 1ULL), C);
708  Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
709 
710  // Finally merge both checks and cast to pointer type. The inttoptr
711  // implicitly zexts the i1 to intptr type.
712  return B.CreateIntToPtr(B.CreateAnd(Bounds, Bits, "memchr"), CI->getType());
713  }
714 
715  // Check if all arguments are constants. If so, we can constant fold.
716  if (!CharC)
717  return nullptr;
718 
719  // Compute the offset.
720  size_t I = Str.find(CharC->getSExtValue() & 0xFF);
721  if (I == StringRef::npos) // Didn't find the char. memchr returns null.
722  return Constant::getNullValue(CI->getType());
723 
724  // memchr(s+n,c,l) -> gep(s+n+i,c)
725  return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "memchr");
726 }
727 
728 Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilder<> &B) {
729  Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
730 
731  if (LHS == RHS) // memcmp(s,s,x) -> 0
732  return Constant::getNullValue(CI->getType());
733 
734  // Make sure we have a constant length.
736  if (!LenC)
737  return nullptr;
738  uint64_t Len = LenC->getZExtValue();
739 
740  if (Len == 0) // memcmp(s1,s2,0) -> 0
741  return Constant::getNullValue(CI->getType());
742 
743  // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
744  if (Len == 1) {
745  Value *LHSV = B.CreateZExt(B.CreateLoad(castToCStr(LHS, B), "lhsc"),
746  CI->getType(), "lhsv");
747  Value *RHSV = B.CreateZExt(B.CreateLoad(castToCStr(RHS, B), "rhsc"),
748  CI->getType(), "rhsv");
749  return B.CreateSub(LHSV, RHSV, "chardiff");
750  }
751 
752  // memcmp(S1,S2,N/8)==0 -> (*(intN_t*)S1 != *(intN_t*)S2)==0
753  if (DL.isLegalInteger(Len * 8) && isOnlyUsedInZeroEqualityComparison(CI)) {
754 
755  IntegerType *IntType = IntegerType::get(CI->getContext(), Len * 8);
756  unsigned PrefAlignment = DL.getPrefTypeAlignment(IntType);
757 
758  if (getKnownAlignment(LHS, DL, CI) >= PrefAlignment &&
759  getKnownAlignment(RHS, DL, CI) >= PrefAlignment) {
760 
761  Type *LHSPtrTy =
762  IntType->getPointerTo(LHS->getType()->getPointerAddressSpace());
763  Type *RHSPtrTy =
764  IntType->getPointerTo(RHS->getType()->getPointerAddressSpace());
765 
766  Value *LHSV =
767  B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy, "lhsc"), "lhsv");
768  Value *RHSV =
769  B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy, "rhsc"), "rhsv");
770 
771  return B.CreateZExt(B.CreateICmpNE(LHSV, RHSV), CI->getType(), "memcmp");
772  }
773  }
774 
775  // Constant folding: memcmp(x, y, l) -> cnst (all arguments are constant)
776  StringRef LHSStr, RHSStr;
777  if (getConstantStringInfo(LHS, LHSStr) &&
778  getConstantStringInfo(RHS, RHSStr)) {
779  // Make sure we're not reading out-of-bounds memory.
780  if (Len > LHSStr.size() || Len > RHSStr.size())
781  return nullptr;
782  // Fold the memcmp and normalize the result. This way we get consistent
783  // results across multiple platforms.
784  uint64_t Ret = 0;
785  int Cmp = memcmp(LHSStr.data(), RHSStr.data(), Len);
786  if (Cmp < 0)
787  Ret = -1;
788  else if (Cmp > 0)
789  Ret = 1;
790  return ConstantInt::get(CI->getType(), Ret);
791  }
792 
793  return nullptr;
794 }
795 
796 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) {
797  // memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
798  B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
799  CI->getArgOperand(2), 1);
800  return CI->getArgOperand(0);
801 }
802 
803 Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
804  // memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
805  B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
806  CI->getArgOperand(2), 1);
807  return CI->getArgOperand(0);
808 }
809 
810 // TODO: Does this belong in BuildLibCalls or should all of those similar
811 // functions be moved here?
812 static Value *emitCalloc(Value *Num, Value *Size, const AttributeSet &Attrs,
813  IRBuilder<> &B, const TargetLibraryInfo &TLI) {
815  if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func))
816  return nullptr;
817 
818  Module *M = B.GetInsertBlock()->getModule();
819  const DataLayout &DL = M->getDataLayout();
820  IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
821  Value *Calloc = M->getOrInsertFunction("calloc", Attrs, B.getInt8PtrTy(),
822  PtrType, PtrType, nullptr);
823  CallInst *CI = B.CreateCall(Calloc, { Num, Size }, "calloc");
824 
825  if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))
826  CI->setCallingConv(F->getCallingConv());
827 
828  return CI;
829 }
830 
831 /// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
833  const TargetLibraryInfo &TLI) {
834  // This has to be a memset of zeros (bzero).
835  auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
836  if (!FillValue || FillValue->getZExtValue() != 0)
837  return nullptr;
838 
839  // TODO: We should handle the case where the malloc has more than one use.
840  // This is necessary to optimize common patterns such as when the result of
841  // the malloc is checked against null or when a memset intrinsic is used in
842  // place of a memset library call.
843  auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
844  if (!Malloc || !Malloc->hasOneUse())
845  return nullptr;
846 
847  // Is the inner call really malloc()?
848  Function *InnerCallee = Malloc->getCalledFunction();
850  if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) ||
851  Func != LibFunc::malloc)
852  return nullptr;
853 
854  // The memset must cover the same number of bytes that are malloc'd.
855  if (Memset->getArgOperand(2) != Malloc->getArgOperand(0))
856  return nullptr;
857 
858  // Replace the malloc with a calloc. We need the data layout to know what the
859  // actual size of a 'size_t' parameter is.
860  B.SetInsertPoint(Malloc->getParent(), ++Malloc->getIterator());
861  const DataLayout &DL = Malloc->getModule()->getDataLayout();
862  IntegerType *SizeType = DL.getIntPtrType(B.GetInsertBlock()->getContext());
863  Value *Calloc = emitCalloc(ConstantInt::get(SizeType, 1),
864  Malloc->getArgOperand(0), Malloc->getAttributes(),
865  B, TLI);
866  if (!Calloc)
867  return nullptr;
868 
869  Malloc->replaceAllUsesWith(Calloc);
870  Malloc->eraseFromParent();
871 
872  return Calloc;
873 }
874 
875 Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
876  if (auto *Calloc = foldMallocMemset(CI, B, *TLI))
877  return Calloc;
878 
879  // memset(p, v, n) -> llvm.memset(p, v, n, 1)
880  Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
881  B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
882  return CI->getArgOperand(0);
883 }
884 
885 //===----------------------------------------------------------------------===//
886 // Math Library Optimizations
887 //===----------------------------------------------------------------------===//
888 
889 /// Return a variant of Val with float type.
890 /// Currently this works in two cases: If Val is an FPExtension of a float
891 /// value to something bigger, simply return the operand.
892 /// If Val is a ConstantFP but can be converted to a float ConstantFP without
893 /// loss of precision do so.
895  if (FPExtInst *Cast = dyn_cast<FPExtInst>(Val)) {
896  Value *Op = Cast->getOperand(0);
897  if (Op->getType()->isFloatTy())
898  return Op;
899  }
900  if (ConstantFP *Const = dyn_cast<ConstantFP>(Val)) {
901  APFloat F = Const->getValueAPF();
902  bool losesInfo;
904  &losesInfo);
905  if (!losesInfo)
906  return ConstantFP::get(Const->getContext(), F);
907  }
908  return nullptr;
909 }
910 
911 /// Shrink double -> float for unary functions like 'floor'.
913  bool CheckRetType) {
914  Function *Callee = CI->getCalledFunction();
915  // We know this libcall has a valid prototype, but we don't know which.
916  if (!CI->getType()->isDoubleTy())
917  return nullptr;
918 
919  if (CheckRetType) {
920  // Check if all the uses for function like 'sin' are converted to float.
921  for (User *U : CI->users()) {
922  FPTruncInst *Cast = dyn_cast<FPTruncInst>(U);
923  if (!Cast || !Cast->getType()->isFloatTy())
924  return nullptr;
925  }
926  }
927 
928  // If this is something like 'floor((double)floatval)', convert to floorf.
930  if (V == nullptr)
931  return nullptr;
932 
933  // Propagate fast-math flags from the existing call to the new call.
936 
937  // floor((double)floatval) -> (double)floorf(floatval)
938  if (Callee->isIntrinsic()) {
939  Module *M = CI->getModule();
940  Intrinsic::ID IID = Callee->getIntrinsicID();
942  V = B.CreateCall(F, V);
943  } else {
944  // The call is a library call rather than an intrinsic.
945  V = emitUnaryFloatFnCall(V, Callee->getName(), B, Callee->getAttributes());
946  }
947 
948  return B.CreateFPExt(V, B.getDoubleTy());
949 }
950 
951 /// Shrink double -> float for binary functions like 'fmin/fmax'.
953  Function *Callee = CI->getCalledFunction();
954  // We know this libcall has a valid prototype, but we don't know which.
955  if (!CI->getType()->isDoubleTy())
956  return nullptr;
957 
958  // If this is something like 'fmin((double)floatval1, (double)floatval2)',
959  // or fmin(1.0, (double)floatval), then we convert it to fminf.
961  if (V1 == nullptr)
962  return nullptr;
964  if (V2 == nullptr)
965  return nullptr;
966 
967  // Propagate fast-math flags from the existing call to the new call.
970 
971  // fmin((double)floatval1, (double)floatval2)
972  // -> (double)fminf(floatval1, floatval2)
973  // TODO: Handle intrinsics in the same way as in optimizeUnaryDoubleFP().
974  Value *V = emitBinaryFloatFnCall(V1, V2, Callee->getName(), B,
975  Callee->getAttributes());
976  return B.CreateFPExt(V, B.getDoubleTy());
977 }
978 
979 Value *LibCallSimplifier::optimizeCos(CallInst *CI, IRBuilder<> &B) {
980  Function *Callee = CI->getCalledFunction();
981  Value *Ret = nullptr;
982  StringRef Name = Callee->getName();
983  if (UnsafeFPShrink && Name == "cos" && hasFloatVersion(Name))
984  Ret = optimizeUnaryDoubleFP(CI, B, true);
985 
986  // cos(-x) -> cos(x)
987  Value *Op1 = CI->getArgOperand(0);
988  if (BinaryOperator::isFNeg(Op1)) {
989  BinaryOperator *BinExpr = cast<BinaryOperator>(Op1);
990  return B.CreateCall(Callee, BinExpr->getOperand(1), "cos");
991  }
992  return Ret;
993 }
994 
995 static Value *getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B) {
996  // Multiplications calculated using Addition Chains.
997  // Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
998 
999  assert(Exp != 0 && "Incorrect exponent 0 not handled");
1000 
1001  if (InnerChain[Exp])
1002  return InnerChain[Exp];
1003 
1004  static const unsigned AddChain[33][2] = {
1005  {0, 0}, // Unused.
1006  {0, 0}, // Unused (base case = pow1).
1007  {1, 1}, // Unused (pre-computed).
1008  {1, 2}, {2, 2}, {2, 3}, {3, 3}, {2, 5}, {4, 4},
1009  {1, 8}, {5, 5}, {1, 10}, {6, 6}, {4, 9}, {7, 7},
1010  {3, 12}, {8, 8}, {8, 9}, {2, 16}, {1, 18}, {10, 10},
1011  {6, 15}, {11, 11}, {3, 20}, {12, 12}, {8, 17}, {13, 13},
1012  {3, 24}, {14, 14}, {4, 25}, {15, 15}, {3, 28}, {16, 16},
1013  };
1014 
1015  InnerChain[Exp] = B.CreateFMul(getPow(InnerChain, AddChain[Exp][0], B),
1016  getPow(InnerChain, AddChain[Exp][1], B));
1017  return InnerChain[Exp];
1018 }
1019 
1020 Value *LibCallSimplifier::optimizePow(CallInst *CI, IRBuilder<> &B) {
1021  Function *Callee = CI->getCalledFunction();
1022  Value *Ret = nullptr;
1023  StringRef Name = Callee->getName();
1024  if (UnsafeFPShrink && Name == "pow" && hasFloatVersion(Name))
1025  Ret = optimizeUnaryDoubleFP(CI, B, true);
1026 
1027  Value *Op1 = CI->getArgOperand(0), *Op2 = CI->getArgOperand(1);
1028 
1029  // pow(1.0, x) -> 1.0
1030  if (match(Op1, m_SpecificFP(1.0)))
1031  return Op1;
1032  // pow(2.0, x) -> llvm.exp2(x)
1033  if (match(Op1, m_SpecificFP(2.0))) {
1034  Value *Exp2 = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::exp2,
1035  CI->getType());
1036  return B.CreateCall(Exp2, Op2, "exp2");
1037  }
1038 
1039  // There's no llvm.exp10 intrinsic yet, but, maybe, some day there will
1040  // be one.
1041  if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
1042  // pow(10.0, x) -> exp10(x)
1043  if (Op1C->isExactlyValue(10.0) &&
1044  hasUnaryFloatFn(TLI, Op1->getType(), LibFunc::exp10, LibFunc::exp10f,
1045  LibFunc::exp10l))
1046  return emitUnaryFloatFnCall(Op2, TLI->getName(LibFunc::exp10), B,
1047  Callee->getAttributes());
1048  }
1049 
1050  // pow(exp(x), y) -> exp(x * y)
1051  // pow(exp2(x), y) -> exp2(x * y)
1052  // We enable these only with fast-math. Besides rounding differences, the
1053  // transformation changes overflow and underflow behavior quite dramatically.
1054  // Example: x = 1000, y = 0.001.
1055  // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1).
1056  auto *OpC = dyn_cast<CallInst>(Op1);
1057  if (OpC && OpC->hasUnsafeAlgebra() && CI->hasUnsafeAlgebra()) {
1059  Function *OpCCallee = OpC->getCalledFunction();
1060  if (OpCCallee && TLI->getLibFunc(OpCCallee->getName(), Func) &&
1061  TLI->has(Func) && (Func == LibFunc::exp || Func == LibFunc::exp2)) {
1064  Value *FMul = B.CreateFMul(OpC->getArgOperand(0), Op2, "mul");
1065  return emitUnaryFloatFnCall(FMul, OpCCallee->getName(), B,
1066  OpCCallee->getAttributes());
1067  }
1068  }
1069 
1070  ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2);
1071  if (!Op2C)
1072  return Ret;
1073 
1074  if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0
1075  return ConstantFP::get(CI->getType(), 1.0);
1076 
1077  if (Op2C->isExactlyValue(-0.5) &&
1078  hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf,
1079  LibFunc::sqrtl)) {
1080  // If -ffast-math:
1081  // pow(x, -0.5) -> 1.0 / sqrt(x)
1082  if (CI->hasUnsafeAlgebra()) {
1085 
1086  // Here we cannot lower to an intrinsic because C99 sqrt() and llvm.sqrt
1087  // are not guaranteed to have the same semantics.
1088  Value *Sqrt = emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc::sqrt), B,
1089  Callee->getAttributes());
1090 
1091  return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Sqrt, "sqrtrecip");
1092  }
1093  }
1094 
1095  if (Op2C->isExactlyValue(0.5) &&
1096  hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf,
1097  LibFunc::sqrtl) &&
1098  hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::fabs, LibFunc::fabsf,
1099  LibFunc::fabsl)) {
1100 
1101  // In -ffast-math, pow(x, 0.5) -> sqrt(x).
1102  if (CI->hasUnsafeAlgebra()) {
1105 
1106  // Unlike other math intrinsics, sqrt has differerent semantics
1107  // from the libc function. See LangRef for details.
1108  return emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc::sqrt), B,
1109  Callee->getAttributes());
1110  }
1111 
1112  // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
1113  // This is faster than calling pow, and still handles negative zero
1114  // and negative infinity correctly.
1115  // TODO: In finite-only mode, this could be just fabs(sqrt(x)).
1116  Value *Inf = ConstantFP::getInfinity(CI->getType());
1117  Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
1118  Value *Sqrt = emitUnaryFloatFnCall(Op1, "sqrt", B, Callee->getAttributes());
1119  Value *FAbs =
1120  emitUnaryFloatFnCall(Sqrt, "fabs", B, Callee->getAttributes());
1121  Value *FCmp = B.CreateFCmpOEQ(Op1, NegInf);
1122  Value *Sel = B.CreateSelect(FCmp, Inf, FAbs);
1123  return Sel;
1124  }
1125 
1126  if (Op2C->isExactlyValue(1.0)) // pow(x, 1.0) -> x
1127  return Op1;
1128  if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x
1129  return B.CreateFMul(Op1, Op1, "pow2");
1130  if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x
1131  return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Op1, "powrecip");
1132 
1133  // In -ffast-math, generate repeated fmul instead of generating pow(x, n).
1134  if (CI->hasUnsafeAlgebra()) {
1135  APFloat V = abs(Op2C->getValueAPF());
1136  // We limit to a max of 7 fmul(s). Thus max exponent is 32.
1137  // This transformation applies to integer exponents only.
1138  if (V.compare(APFloat(V.getSemantics(), 32.0)) == APFloat::cmpGreaterThan ||
1139  !V.isInteger())
1140  return nullptr;
1141 
1142  // Propagate fast math flags.
1145 
1146  // We will memoize intermediate products of the Addition Chain.
1147  Value *InnerChain[33] = {nullptr};
1148  InnerChain[1] = Op1;
1149  InnerChain[2] = B.CreateFMul(Op1, Op1);
1150 
1151  // We cannot readily convert a non-double type (like float) to a double.
1152  // So we first convert V to something which could be converted to double.
1153  bool ignored;
1155 
1156  Value *FMul = getPow(InnerChain, V.convertToDouble(), B);
1157  // For negative exponents simply compute the reciprocal.
1158  if (Op2C->isNegative())
1159  FMul = B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), FMul);
1160  return FMul;
1161  }
1162 
1163  return nullptr;
1164 }
1165 
1166 Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
1167  Function *Callee = CI->getCalledFunction();
1168  Value *Ret = nullptr;
1169  StringRef Name = Callee->getName();
1170  if (UnsafeFPShrink && Name == "exp2" && hasFloatVersion(Name))
1171  Ret = optimizeUnaryDoubleFP(CI, B, true);
1172 
1173  Value *Op = CI->getArgOperand(0);
1174  // Turn exp2(sitofp(x)) -> ldexp(1.0, sext(x)) if sizeof(x) <= 32
1175  // Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x)) if sizeof(x) < 32
1176  LibFunc::Func LdExp = LibFunc::ldexpl;
1177  if (Op->getType()->isFloatTy())
1178  LdExp = LibFunc::ldexpf;
1179  else if (Op->getType()->isDoubleTy())
1180  LdExp = LibFunc::ldexp;
1181 
1182  if (TLI->has(LdExp)) {
1183  Value *LdExpArg = nullptr;
1184  if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) {
1185  if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32)
1186  LdExpArg = B.CreateSExt(OpC->getOperand(0), B.getInt32Ty());
1187  } else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) {
1188  if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32)
1189  LdExpArg = B.CreateZExt(OpC->getOperand(0), B.getInt32Ty());
1190  }
1191 
1192  if (LdExpArg) {
1193  Constant *One = ConstantFP::get(CI->getContext(), APFloat(1.0f));
1194  if (!Op->getType()->isFloatTy())
1195  One = ConstantExpr::getFPExtend(One, Op->getType());
1196 
1197  Module *M = CI->getModule();
1198  Value *NewCallee =
1199  M->getOrInsertFunction(TLI->getName(LdExp), Op->getType(),
1200  Op->getType(), B.getInt32Ty(), nullptr);
1201  CallInst *CI = B.CreateCall(NewCallee, {One, LdExpArg});
1202  if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
1203  CI->setCallingConv(F->getCallingConv());
1204 
1205  return CI;
1206  }
1207  }
1208  return Ret;
1209 }
1210 
1211 Value *LibCallSimplifier::optimizeFabs(CallInst *CI, IRBuilder<> &B) {
1212  Function *Callee = CI->getCalledFunction();
1213  StringRef Name = Callee->getName();
1214  if (Name == "fabs" && hasFloatVersion(Name))
1215  return optimizeUnaryDoubleFP(CI, B, false);
1216 
1217  return nullptr;
1218 }
1219 
1220 Value *LibCallSimplifier::optimizeFMinFMax(CallInst *CI, IRBuilder<> &B) {
1221  Function *Callee = CI->getCalledFunction();
1222  // If we can shrink the call to a float function rather than a double
1223  // function, do that first.
1224  StringRef Name = Callee->getName();
1225  if ((Name == "fmin" || Name == "fmax") && hasFloatVersion(Name))
1226  if (Value *Ret = optimizeBinaryDoubleFP(CI, B))
1227  return Ret;
1228 
1230  FastMathFlags FMF;
1231  if (CI->hasUnsafeAlgebra()) {
1232  // Unsafe algebra sets all fast-math-flags to true.
1233  FMF.setUnsafeAlgebra();
1234  } else {
1235  // At a minimum, no-nans-fp-math must be true.
1236  if (!CI->hasNoNaNs())
1237  return nullptr;
1238  // No-signed-zeros is implied by the definitions of fmax/fmin themselves:
1239  // "Ideally, fmax would be sensitive to the sign of zero, for example
1240  // fmax(-0. 0, +0. 0) would return +0; however, implementation in software
1241  // might be impractical."
1242  FMF.setNoSignedZeros();
1243  FMF.setNoNaNs();
1244  }
1245  B.setFastMathFlags(FMF);
1246 
1247  // We have a relaxed floating-point environment. We can ignore NaN-handling
1248  // and transform to a compare and select. We do not have to consider errno or
1249  // exceptions, because fmin/fmax do not have those.
1250  Value *Op0 = CI->getArgOperand(0);
1251  Value *Op1 = CI->getArgOperand(1);
1252  Value *Cmp = Callee->getName().startswith("fmin") ?
1253  B.CreateFCmpOLT(Op0, Op1) : B.CreateFCmpOGT(Op0, Op1);
1254  return B.CreateSelect(Cmp, Op0, Op1);
1255 }
1256 
1257 Value *LibCallSimplifier::optimizeLog(CallInst *CI, IRBuilder<> &B) {
1258  Function *Callee = CI->getCalledFunction();
1259  Value *Ret = nullptr;
1260  StringRef Name = Callee->getName();
1261  if (UnsafeFPShrink && hasFloatVersion(Name))
1262  Ret = optimizeUnaryDoubleFP(CI, B, true);
1263 
1264  if (!CI->hasUnsafeAlgebra())
1265  return Ret;
1266  Value *Op1 = CI->getArgOperand(0);
1267  auto *OpC = dyn_cast<CallInst>(Op1);
1268 
1269  // The earlier call must also be unsafe in order to do these transforms.
1270  if (!OpC || !OpC->hasUnsafeAlgebra())
1271  return Ret;
1272 
1273  // log(pow(x,y)) -> y*log(x)
1274  // This is only applicable to log, log2, log10.
1275  if (Name != "log" && Name != "log2" && Name != "log10")
1276  return Ret;
1277 
1279  FastMathFlags FMF;
1280  FMF.setUnsafeAlgebra();
1281  B.setFastMathFlags(FMF);
1282 
1284  Function *F = OpC->getCalledFunction();
1285  if (F && ((TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
1286  Func == LibFunc::pow) || F->getIntrinsicID() == Intrinsic::pow))
1287  return B.CreateFMul(OpC->getArgOperand(1),
1288  emitUnaryFloatFnCall(OpC->getOperand(0), Callee->getName(), B,
1289  Callee->getAttributes()), "mul");
1290 
1291  // log(exp2(y)) -> y*log(2)
1292  if (F && Name == "log" && TLI->getLibFunc(F->getName(), Func) &&
1293  TLI->has(Func) && Func == LibFunc::exp2)
1294  return B.CreateFMul(
1295  OpC->getArgOperand(0),
1297  Callee->getName(), B, Callee->getAttributes()),
1298  "logmul");
1299  return Ret;
1300 }
1301 
1302 Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
1303  Function *Callee = CI->getCalledFunction();
1304  Value *Ret = nullptr;
1305  if (TLI->has(LibFunc::sqrtf) && (Callee->getName() == "sqrt" ||
1306  Callee->getIntrinsicID() == Intrinsic::sqrt))
1307  Ret = optimizeUnaryDoubleFP(CI, B, true);
1308 
1309  if (!CI->hasUnsafeAlgebra())
1310  return Ret;
1311 
1313  if (!I || I->getOpcode() != Instruction::FMul || !I->hasUnsafeAlgebra())
1314  return Ret;
1315 
1316  // We're looking for a repeated factor in a multiplication tree,
1317  // so we can do this fold: sqrt(x * x) -> fabs(x);
1318  // or this fold: sqrt((x * x) * y) -> fabs(x) * sqrt(y).
1319  Value *Op0 = I->getOperand(0);
1320  Value *Op1 = I->getOperand(1);
1321  Value *RepeatOp = nullptr;
1322  Value *OtherOp = nullptr;
1323  if (Op0 == Op1) {
1324  // Simple match: the operands of the multiply are identical.
1325  RepeatOp = Op0;
1326  } else {
1327  // Look for a more complicated pattern: one of the operands is itself
1328  // a multiply, so search for a common factor in that multiply.
1329  // Note: We don't bother looking any deeper than this first level or for
1330  // variations of this pattern because instcombine's visitFMUL and/or the
1331  // reassociation pass should give us this form.
1332  Value *OtherMul0, *OtherMul1;
1333  if (match(Op0, m_FMul(m_Value(OtherMul0), m_Value(OtherMul1)))) {
1334  // Pattern: sqrt((x * y) * z)
1335  if (OtherMul0 == OtherMul1 &&
1336  cast<Instruction>(Op0)->hasUnsafeAlgebra()) {
1337  // Matched: sqrt((x * x) * z)
1338  RepeatOp = OtherMul0;
1339  OtherOp = Op1;
1340  }
1341  }
1342  }
1343  if (!RepeatOp)
1344  return Ret;
1345 
1346  // Fast math flags for any created instructions should match the sqrt
1347  // and multiply.
1350 
1351  // If we found a repeated factor, hoist it out of the square root and
1352  // replace it with the fabs of that factor.
1353  Module *M = Callee->getParent();
1354  Type *ArgType = I->getType();
1355  Value *Fabs = Intrinsic::getDeclaration(M, Intrinsic::fabs, ArgType);
1356  Value *FabsCall = B.CreateCall(Fabs, RepeatOp, "fabs");
1357  if (OtherOp) {
1358  // If we found a non-repeated factor, we still need to get its square
1359  // root. We then multiply that by the value that was simplified out
1360  // of the square root calculation.
1361  Value *Sqrt = Intrinsic::getDeclaration(M, Intrinsic::sqrt, ArgType);
1362  Value *SqrtCall = B.CreateCall(Sqrt, OtherOp, "sqrt");
1363  return B.CreateFMul(FabsCall, SqrtCall);
1364  }
1365  return FabsCall;
1366 }
1367 
1368 // TODO: Generalize to handle any trig function and its inverse.
1369 Value *LibCallSimplifier::optimizeTan(CallInst *CI, IRBuilder<> &B) {
1370  Function *Callee = CI->getCalledFunction();
1371  Value *Ret = nullptr;
1372  StringRef Name = Callee->getName();
1373  if (UnsafeFPShrink && Name == "tan" && hasFloatVersion(Name))
1374  Ret = optimizeUnaryDoubleFP(CI, B, true);
1375 
1376  Value *Op1 = CI->getArgOperand(0);
1377  auto *OpC = dyn_cast<CallInst>(Op1);
1378  if (!OpC)
1379  return Ret;
1380 
1381  // Both calls must allow unsafe optimizations in order to remove them.
1382  if (!CI->hasUnsafeAlgebra() || !OpC->hasUnsafeAlgebra())
1383  return Ret;
1384 
1385  // tan(atan(x)) -> x
1386  // tanf(atanf(x)) -> x
1387  // tanl(atanl(x)) -> x
1389  Function *F = OpC->getCalledFunction();
1390  if (F && TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
1391  ((Func == LibFunc::atan && Callee->getName() == "tan") ||
1392  (Func == LibFunc::atanf && Callee->getName() == "tanf") ||
1393  (Func == LibFunc::atanl && Callee->getName() == "tanl")))
1394  Ret = OpC->getArgOperand(0);
1395  return Ret;
1396 }
1397 
1398 static bool isTrigLibCall(CallInst *CI) {
1399  // We can only hope to do anything useful if we can ignore things like errno
1400  // and floating-point exceptions.
1401  // We already checked the prototype.
1402  return CI->hasFnAttr(Attribute::NoUnwind) &&
1403  CI->hasFnAttr(Attribute::ReadNone);
1404 }
1405 
1406 static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
1407  bool UseFloat, Value *&Sin, Value *&Cos,
1408  Value *&SinCos) {
1409  Type *ArgTy = Arg->getType();
1410  Type *ResTy;
1411  StringRef Name;
1412 
1413  Triple T(OrigCallee->getParent()->getTargetTriple());
1414  if (UseFloat) {
1415  Name = "__sincospif_stret";
1416 
1417  assert(T.getArch() != Triple::x86 && "x86 messy and unsupported for now");
1418  // x86_64 can't use {float, float} since that would be returned in both
1419  // xmm0 and xmm1, which isn't what a real struct would do.
1420  ResTy = T.getArch() == Triple::x86_64
1421  ? static_cast<Type *>(VectorType::get(ArgTy, 2))
1422  : static_cast<Type *>(StructType::get(ArgTy, ArgTy, nullptr));
1423  } else {
1424  Name = "__sincospi_stret";
1425  ResTy = StructType::get(ArgTy, ArgTy, nullptr);
1426  }
1427 
1428  Module *M = OrigCallee->getParent();
1429  Value *Callee = M->getOrInsertFunction(Name, OrigCallee->getAttributes(),
1430  ResTy, ArgTy, nullptr);
1431 
1432  if (Instruction *ArgInst = dyn_cast<Instruction>(Arg)) {
1433  // If the argument is an instruction, it must dominate all uses so put our
1434  // sincos call there.
1435  B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());
1436  } else {
1437  // Otherwise (e.g. for a constant) the beginning of the function is as
1438  // good a place as any.
1439  BasicBlock &EntryBB = B.GetInsertBlock()->getParent()->getEntryBlock();
1440  B.SetInsertPoint(&EntryBB, EntryBB.begin());
1441  }
1442 
1443  SinCos = B.CreateCall(Callee, Arg, "sincospi");
1444 
1445  if (SinCos->getType()->isStructTy()) {
1446  Sin = B.CreateExtractValue(SinCos, 0, "sinpi");
1447  Cos = B.CreateExtractValue(SinCos, 1, "cospi");
1448  } else {
1449  Sin = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 0),
1450  "sinpi");
1451  Cos = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 1),
1452  "cospi");
1453  }
1454 }
1455 
1456 Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilder<> &B) {
1457  // Make sure the prototype is as expected, otherwise the rest of the
1458  // function is probably invalid and likely to abort.
1459  if (!isTrigLibCall(CI))
1460  return nullptr;
1461 
1462  Value *Arg = CI->getArgOperand(0);
1463  SmallVector<CallInst *, 1> SinCalls;
1464  SmallVector<CallInst *, 1> CosCalls;
1465  SmallVector<CallInst *, 1> SinCosCalls;
1466 
1467  bool IsFloat = Arg->getType()->isFloatTy();
1468 
1469  // Look for all compatible sinpi, cospi and sincospi calls with the same
1470  // argument. If there are enough (in some sense) we can make the
1471  // substitution.
1472  Function *F = CI->getFunction();
1473  for (User *U : Arg->users())
1474  classifyArgUse(U, F, IsFloat, SinCalls, CosCalls, SinCosCalls);
1475 
1476  // It's only worthwhile if both sinpi and cospi are actually used.
1477  if (SinCosCalls.empty() && (SinCalls.empty() || CosCalls.empty()))
1478  return nullptr;
1479 
1480  Value *Sin, *Cos, *SinCos;
1481  insertSinCosCall(B, CI->getCalledFunction(), Arg, IsFloat, Sin, Cos, SinCos);
1482 
1483  auto replaceTrigInsts = [this](SmallVectorImpl<CallInst *> &Calls,
1484  Value *Res) {
1485  for (CallInst *C : Calls)
1486  replaceAllUsesWith(C, Res);
1487  };
1488 
1489  replaceTrigInsts(SinCalls, Sin);
1490  replaceTrigInsts(CosCalls, Cos);
1491  replaceTrigInsts(SinCosCalls, SinCos);
1492 
1493  return nullptr;
1494 }
1495 
1496 void LibCallSimplifier::classifyArgUse(
1497  Value *Val, Function *F, bool IsFloat,
1498  SmallVectorImpl<CallInst *> &SinCalls,
1499  SmallVectorImpl<CallInst *> &CosCalls,
1500  SmallVectorImpl<CallInst *> &SinCosCalls) {
1501  CallInst *CI = dyn_cast<CallInst>(Val);
1502 
1503  if (!CI)
1504  return;
1505 
1506  // Don't consider calls in other functions.
1507  if (CI->getFunction() != F)
1508  return;
1509 
1510  Function *Callee = CI->getCalledFunction();
1512  if (!Callee || !TLI->getLibFunc(*Callee, Func) || !TLI->has(Func) ||
1513  !isTrigLibCall(CI))
1514  return;
1515 
1516  if (IsFloat) {
1517  if (Func == LibFunc::sinpif)
1518  SinCalls.push_back(CI);
1519  else if (Func == LibFunc::cospif)
1520  CosCalls.push_back(CI);
1521  else if (Func == LibFunc::sincospif_stret)
1522  SinCosCalls.push_back(CI);
1523  } else {
1524  if (Func == LibFunc::sinpi)
1525  SinCalls.push_back(CI);
1526  else if (Func == LibFunc::cospi)
1527  CosCalls.push_back(CI);
1528  else if (Func == LibFunc::sincospi_stret)
1529  SinCosCalls.push_back(CI);
1530  }
1531 }
1532 
1533 //===----------------------------------------------------------------------===//
1534 // Integer Library Call Optimizations
1535 //===----------------------------------------------------------------------===//
1536 
1537 Value *LibCallSimplifier::optimizeFFS(CallInst *CI, IRBuilder<> &B) {
1538  // ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
1539  Value *Op = CI->getArgOperand(0);
1540  Type *ArgType = Op->getType();
1542  Intrinsic::cttz, ArgType);
1543  Value *V = B.CreateCall(F, {Op, B.getTrue()}, "cttz");
1544  V = B.CreateAdd(V, ConstantInt::get(V->getType(), 1));
1545  V = B.CreateIntCast(V, B.getInt32Ty(), false);
1546 
1547  Value *Cond = B.CreateICmpNE(Op, Constant::getNullValue(ArgType));
1548  return B.CreateSelect(Cond, V, B.getInt32(0));
1549 }
1550 
1551 Value *LibCallSimplifier::optimizeFls(CallInst *CI, IRBuilder<> &B) {
1552  // fls(x) -> (i32)(sizeInBits(x) - llvm.ctlz(x, false))
1553  Value *Op = CI->getArgOperand(0);
1554  Type *ArgType = Op->getType();
1556  Intrinsic::ctlz, ArgType);
1557  Value *V = B.CreateCall(F, {Op, B.getFalse()}, "ctlz");
1558  V = B.CreateSub(ConstantInt::get(V->getType(), ArgType->getIntegerBitWidth()),
1559  V);
1560  return B.CreateIntCast(V, CI->getType(), false);
1561 }
1562 
1563 Value *LibCallSimplifier::optimizeAbs(CallInst *CI, IRBuilder<> &B) {
1564  // abs(x) -> x >s -1 ? x : -x
1565  Value *Op = CI->getArgOperand(0);
1566  Value *Pos =
1567  B.CreateICmpSGT(Op, Constant::getAllOnesValue(Op->getType()), "ispos");
1568  Value *Neg = B.CreateNeg(Op, "neg");
1569  return B.CreateSelect(Pos, Op, Neg);
1570 }
1571 
1572 Value *LibCallSimplifier::optimizeIsDigit(CallInst *CI, IRBuilder<> &B) {
1573  // isdigit(c) -> (c-'0') <u 10
1574  Value *Op = CI->getArgOperand(0);
1575  Op = B.CreateSub(Op, B.getInt32('0'), "isdigittmp");
1576  Op = B.CreateICmpULT(Op, B.getInt32(10), "isdigit");
1577  return B.CreateZExt(Op, CI->getType());
1578 }
1579 
1580 Value *LibCallSimplifier::optimizeIsAscii(CallInst *CI, IRBuilder<> &B) {
1581  // isascii(c) -> c <u 128
1582  Value *Op = CI->getArgOperand(0);
1583  Op = B.CreateICmpULT(Op, B.getInt32(128), "isascii");
1584  return B.CreateZExt(Op, CI->getType());
1585 }
1586 
1587 Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilder<> &B) {
1588  // toascii(c) -> c & 0x7f
1589  return B.CreateAnd(CI->getArgOperand(0),
1590  ConstantInt::get(CI->getType(), 0x7F));
1591 }
1592 
1593 //===----------------------------------------------------------------------===//
1594 // Formatting and IO Library Call Optimizations
1595 //===----------------------------------------------------------------------===//
1596 
1597 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg);
1598 
1599 Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
1600  int StreamArg) {
1601  Function *Callee = CI->getCalledFunction();
1602  // Error reporting calls should be cold, mark them as such.
1603  // This applies even to non-builtin calls: it is only a hint and applies to
1604  // functions that the frontend might not understand as builtins.
1605 
1606  // This heuristic was suggested in:
1607  // Improving Static Branch Prediction in a Compiler
1608  // Brian L. Deitrich, Ben-Chung Cheng, Wen-mei W. Hwu
1609  // Proceedings of PACT'98, Oct. 1998, IEEE
1610  if (!CI->hasFnAttr(Attribute::Cold) &&
1611  isReportingError(Callee, CI, StreamArg)) {
1613  }
1614 
1615  return nullptr;
1616 }
1617 
1618 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) {
1619  if (!ColdErrorCalls || !Callee || !Callee->isDeclaration())
1620  return false;
1621 
1622  if (StreamArg < 0)
1623  return true;
1624 
1625  // These functions might be considered cold, but only if their stream
1626  // argument is stderr.
1627 
1628  if (StreamArg >= (int)CI->getNumArgOperands())
1629  return false;
1630  LoadInst *LI = dyn_cast<LoadInst>(CI->getArgOperand(StreamArg));
1631  if (!LI)
1632  return false;
1634  if (!GV || !GV->isDeclaration())
1635  return false;
1636  return GV->getName() == "stderr";
1637 }
1638 
1639 Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilder<> &B) {
1640  // Check for a fixed format string.
1641  StringRef FormatStr;
1642  if (!getConstantStringInfo(CI->getArgOperand(0), FormatStr))
1643  return nullptr;
1644 
1645  // Empty format string -> noop.
1646  if (FormatStr.empty()) // Tolerate printf's declared void.
1647  return CI->use_empty() ? (Value *)CI : ConstantInt::get(CI->getType(), 0);
1648 
1649  // Do not do any of the following transformations if the printf return value
1650  // is used, in general the printf return value is not compatible with either
1651  // putchar() or puts().
1652  if (!CI->use_empty())
1653  return nullptr;
1654 
1655  // printf("x") -> putchar('x'), even for "%" and "%%".
1656  if (FormatStr.size() == 1 || FormatStr == "%%")
1657  return emitPutChar(B.getInt32(FormatStr[0]), B, TLI);
1658 
1659  // printf("%s", "a") --> putchar('a')
1660  if (FormatStr == "%s" && CI->getNumArgOperands() > 1) {
1661  StringRef ChrStr;
1662  if (!getConstantStringInfo(CI->getOperand(1), ChrStr))
1663  return nullptr;
1664  if (ChrStr.size() != 1)
1665  return nullptr;
1666  return emitPutChar(B.getInt32(ChrStr[0]), B, TLI);
1667  }
1668 
1669  // printf("foo\n") --> puts("foo")
1670  if (FormatStr[FormatStr.size() - 1] == '\n' &&
1671  FormatStr.find('%') == StringRef::npos) { // No format characters.
1672  // Create a string literal with no \n on it. We expect the constant merge
1673  // pass to be run after this pass, to merge duplicate strings.
1674  FormatStr = FormatStr.drop_back();
1675  Value *GV = B.CreateGlobalString(FormatStr, "str");
1676  return emitPutS(GV, B, TLI);
1677  }
1678 
1679  // Optimize specific format strings.
1680  // printf("%c", chr) --> putchar(chr)
1681  if (FormatStr == "%c" && CI->getNumArgOperands() > 1 &&
1682  CI->getArgOperand(1)->getType()->isIntegerTy())
1683  return emitPutChar(CI->getArgOperand(1), B, TLI);
1684 
1685  // printf("%s\n", str) --> puts(str)
1686  if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 &&
1687  CI->getArgOperand(1)->getType()->isPointerTy())
1688  return emitPutS(CI->getArgOperand(1), B, TLI);
1689  return nullptr;
1690 }
1691 
1692 Value *LibCallSimplifier::optimizePrintF(CallInst *CI, IRBuilder<> &B) {
1693 
1694  Function *Callee = CI->getCalledFunction();
1695  FunctionType *FT = Callee->getFunctionType();
1696  if (Value *V = optimizePrintFString(CI, B)) {
1697  return V;
1698  }
1699 
1700  // printf(format, ...) -> iprintf(format, ...) if no floating point
1701  // arguments.
1702  if (TLI->has(LibFunc::iprintf) && !callHasFloatingPointArgument(CI)) {
1703  Module *M = B.GetInsertBlock()->getParent()->getParent();
1704  Constant *IPrintFFn =
1705  M->getOrInsertFunction("iprintf", FT, Callee->getAttributes());
1706  CallInst *New = cast<CallInst>(CI->clone());
1707  New->setCalledFunction(IPrintFFn);
1708  B.Insert(New);
1709  return New;
1710  }
1711  return nullptr;
1712 }
1713 
1714 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI, IRBuilder<> &B) {
1715  // Check for a fixed format string.
1716  StringRef FormatStr;
1717  if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
1718  return nullptr;
1719 
1720  // If we just have a format string (nothing else crazy) transform it.
1721  if (CI->getNumArgOperands() == 2) {
1722  // Make sure there's no % in the constant array. We could try to handle
1723  // %% -> % in the future if we cared.
1724  for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
1725  if (FormatStr[i] == '%')
1726  return nullptr; // we found a format specifier, bail out.
1727 
1728  // sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
1729  B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
1730  ConstantInt::get(DL.getIntPtrType(CI->getContext()),
1731  FormatStr.size() + 1),
1732  1); // Copy the null byte.
1733  return ConstantInt::get(CI->getType(), FormatStr.size());
1734  }
1735 
1736  // The remaining optimizations require the format string to be "%s" or "%c"
1737  // and have an extra operand.
1738  if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
1739  CI->getNumArgOperands() < 3)
1740  return nullptr;
1741 
1742  // Decode the second character of the format string.
1743  if (FormatStr[1] == 'c') {
1744  // sprintf(dst, "%c", chr) --> *(i8*)dst = chr; *((i8*)dst+1) = 0
1745  if (!CI->getArgOperand(2)->getType()->isIntegerTy())
1746  return nullptr;
1747  Value *V = B.CreateTrunc(CI->getArgOperand(2), B.getInt8Ty(), "char");
1748  Value *Ptr = castToCStr(CI->getArgOperand(0), B);
1749  B.CreateStore(V, Ptr);
1750  Ptr = B.CreateGEP(B.getInt8Ty(), Ptr, B.getInt32(1), "nul");
1751  B.CreateStore(B.getInt8(0), Ptr);
1752 
1753  return ConstantInt::get(CI->getType(), 1);
1754  }
1755 
1756  if (FormatStr[1] == 's') {
1757  // sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
1758  if (!CI->getArgOperand(2)->getType()->isPointerTy())
1759  return nullptr;
1760 
1761  Value *Len = emitStrLen(CI->getArgOperand(2), B, DL, TLI);
1762  if (!Len)
1763  return nullptr;
1764  Value *IncLen =
1765  B.CreateAdd(Len, ConstantInt::get(Len->getType(), 1), "leninc");
1766  B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(2), IncLen, 1);
1767 
1768  // The sprintf result is the unincremented number of bytes in the string.
1769  return B.CreateIntCast(Len, CI->getType(), false);
1770  }
1771  return nullptr;
1772 }
1773 
1774 Value *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilder<> &B) {
1775  Function *Callee = CI->getCalledFunction();
1776  FunctionType *FT = Callee->getFunctionType();
1777  if (Value *V = optimizeSPrintFString(CI, B)) {
1778  return V;
1779  }
1780 
1781  // sprintf(str, format, ...) -> siprintf(str, format, ...) if no floating
1782  // point arguments.
1783  if (TLI->has(LibFunc::siprintf) && !callHasFloatingPointArgument(CI)) {
1784  Module *M = B.GetInsertBlock()->getParent()->getParent();
1785  Constant *SIPrintFFn =
1786  M->getOrInsertFunction("siprintf", FT, Callee->getAttributes());
1787  CallInst *New = cast<CallInst>(CI->clone());
1788  New->setCalledFunction(SIPrintFFn);
1789  B.Insert(New);
1790  return New;
1791  }
1792  return nullptr;
1793 }
1794 
1795 Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI, IRBuilder<> &B) {
1796  optimizeErrorReporting(CI, B, 0);
1797 
1798  // All the optimizations depend on the format string.
1799  StringRef FormatStr;
1800  if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
1801  return nullptr;
1802 
1803  // Do not do any of the following transformations if the fprintf return
1804  // value is used, in general the fprintf return value is not compatible
1805  // with fwrite(), fputc() or fputs().
1806  if (!CI->use_empty())
1807  return nullptr;
1808 
1809  // fprintf(F, "foo") --> fwrite("foo", 3, 1, F)
1810  if (CI->getNumArgOperands() == 2) {
1811  for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
1812  if (FormatStr[i] == '%') // Could handle %% -> % if we cared.
1813  return nullptr; // We found a format specifier.
1814 
1815  return emitFWrite(
1816  CI->getArgOperand(1),
1817  ConstantInt::get(DL.getIntPtrType(CI->getContext()), FormatStr.size()),
1818  CI->getArgOperand(0), B, DL, TLI);
1819  }
1820 
1821  // The remaining optimizations require the format string to be "%s" or "%c"
1822  // and have an extra operand.
1823  if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
1824  CI->getNumArgOperands() < 3)
1825  return nullptr;
1826 
1827  // Decode the second character of the format string.
1828  if (FormatStr[1] == 'c') {
1829  // fprintf(F, "%c", chr) --> fputc(chr, F)
1830  if (!CI->getArgOperand(2)->getType()->isIntegerTy())
1831  return nullptr;
1832  return emitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
1833  }
1834 
1835  if (FormatStr[1] == 's') {
1836  // fprintf(F, "%s", str) --> fputs(str, F)
1837  if (!CI->getArgOperand(2)->getType()->isPointerTy())
1838  return nullptr;
1839  return emitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
1840  }
1841  return nullptr;
1842 }
1843 
1844 Value *LibCallSimplifier::optimizeFPrintF(CallInst *CI, IRBuilder<> &B) {
1845  Function *Callee = CI->getCalledFunction();
1846  FunctionType *FT = Callee->getFunctionType();
1847  if (Value *V = optimizeFPrintFString(CI, B)) {
1848  return V;
1849  }
1850 
1851  // fprintf(stream, format, ...) -> fiprintf(stream, format, ...) if no
1852  // floating point arguments.
1853  if (TLI->has(LibFunc::fiprintf) && !callHasFloatingPointArgument(CI)) {
1854  Module *M = B.GetInsertBlock()->getParent()->getParent();
1855  Constant *FIPrintFFn =
1856  M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes());
1857  CallInst *New = cast<CallInst>(CI->clone());
1858  New->setCalledFunction(FIPrintFFn);
1859  B.Insert(New);
1860  return New;
1861  }
1862  return nullptr;
1863 }
1864 
1865 Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
1866  optimizeErrorReporting(CI, B, 3);
1867 
1868  // Get the element size and count.
1869  ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
1870  ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
1871  if (!SizeC || !CountC)
1872  return nullptr;
1873  uint64_t Bytes = SizeC->getZExtValue() * CountC->getZExtValue();
1874 
1875  // If this is writing zero records, remove the call (it's a noop).
1876  if (Bytes == 0)
1877  return ConstantInt::get(CI->getType(), 0);
1878 
1879  // If this is writing one byte, turn it into fputc.
1880  // This optimisation is only valid, if the return value is unused.
1881  if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F)
1882  Value *Char = B.CreateLoad(castToCStr(CI->getArgOperand(0), B), "char");
1883  Value *NewCI = emitFPutC(Char, CI->getArgOperand(3), B, TLI);
1884  return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr;
1885  }
1886 
1887  return nullptr;
1888 }
1889 
1890 Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilder<> &B) {
1891  optimizeErrorReporting(CI, B, 1);
1892 
1893  // Don't rewrite fputs to fwrite when optimising for size because fwrite
1894  // requires more arguments and thus extra MOVs are required.
1895  if (CI->getParent()->getParent()->optForSize())
1896  return nullptr;
1897 
1898  // We can't optimize if return value is used.
1899  if (!CI->use_empty())
1900  return nullptr;
1901 
1902  // fputs(s,F) --> fwrite(s,1,strlen(s),F)
1903  uint64_t Len = GetStringLength(CI->getArgOperand(0));
1904  if (!Len)
1905  return nullptr;
1906 
1907  // Known to have no uses (see above).
1908  return emitFWrite(
1909  CI->getArgOperand(0),
1910  ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
1911  CI->getArgOperand(1), B, DL, TLI);
1912 }
1913 
1914 Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilder<> &B) {
1915  // Check for a constant string.
1916  StringRef Str;
1917  if (!getConstantStringInfo(CI->getArgOperand(0), Str))
1918  return nullptr;
1919 
1920  if (Str.empty() && CI->use_empty()) {
1921  // puts("") -> putchar('\n')
1922  Value *Res = emitPutChar(B.getInt32('\n'), B, TLI);
1923  if (CI->use_empty() || !Res)
1924  return Res;
1925  return B.CreateIntCast(Res, CI->getType(), true);
1926  }
1927 
1928  return nullptr;
1929 }
1930 
1931 bool LibCallSimplifier::hasFloatVersion(StringRef FuncName) {
1933  SmallString<20> FloatFuncName = FuncName;
1934  FloatFuncName += 'f';
1935  if (TLI->getLibFunc(FloatFuncName, Func))
1936  return TLI->has(Func);
1937  return false;
1938 }
1939 
1940 Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI,
1941  IRBuilder<> &Builder) {
1943  Function *Callee = CI->getCalledFunction();
1944  // Check for string/memory library functions.
1945  if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
1946  // Make sure we never change the calling convention.
1947  assert((ignoreCallingConv(Func) ||
1948  isCallingConvCCompatible(CI)) &&
1949  "Optimizing string/memory libcall would change the calling convention");
1950  switch (Func) {
1951  case LibFunc::strcat:
1952  return optimizeStrCat(CI, Builder);
1953  case LibFunc::strncat:
1954  return optimizeStrNCat(CI, Builder);
1955  case LibFunc::strchr:
1956  return optimizeStrChr(CI, Builder);
1957  case LibFunc::strrchr:
1958  return optimizeStrRChr(CI, Builder);
1959  case LibFunc::strcmp:
1960  return optimizeStrCmp(CI, Builder);
1961  case LibFunc::strncmp:
1962  return optimizeStrNCmp(CI, Builder);
1963  case LibFunc::strcpy:
1964  return optimizeStrCpy(CI, Builder);
1965  case LibFunc::stpcpy:
1966  return optimizeStpCpy(CI, Builder);
1967  case LibFunc::strncpy:
1968  return optimizeStrNCpy(CI, Builder);
1969  case LibFunc::strlen:
1970  return optimizeStrLen(CI, Builder);
1971  case LibFunc::strpbrk:
1972  return optimizeStrPBrk(CI, Builder);
1973  case LibFunc::strtol:
1974  case LibFunc::strtod:
1975  case LibFunc::strtof:
1976  case LibFunc::strtoul:
1977  case LibFunc::strtoll:
1978  case LibFunc::strtold:
1979  case LibFunc::strtoull:
1980  return optimizeStrTo(CI, Builder);
1981  case LibFunc::strspn:
1982  return optimizeStrSpn(CI, Builder);
1983  case LibFunc::strcspn:
1984  return optimizeStrCSpn(CI, Builder);
1985  case LibFunc::strstr:
1986  return optimizeStrStr(CI, Builder);
1987  case LibFunc::memchr:
1988  return optimizeMemChr(CI, Builder);
1989  case LibFunc::memcmp:
1990  return optimizeMemCmp(CI, Builder);
1991  case LibFunc::memcpy:
1992  return optimizeMemCpy(CI, Builder);
1993  case LibFunc::memmove:
1994  return optimizeMemMove(CI, Builder);
1995  case LibFunc::memset:
1996  return optimizeMemSet(CI, Builder);
1997  default:
1998  break;
1999  }
2000  }
2001  return nullptr;
2002 }
2003 
2005  if (CI->isNoBuiltin())
2006  return nullptr;
2007 
2009  Function *Callee = CI->getCalledFunction();
2010  StringRef FuncName = Callee->getName();
2011 
2013  CI->getOperandBundlesAsDefs(OpBundles);
2014  IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
2015  bool isCallingConvC = isCallingConvCCompatible(CI);
2016 
2017  // Command-line parameter overrides instruction attribute.
2018  if (EnableUnsafeFPShrink.getNumOccurrences() > 0)
2019  UnsafeFPShrink = EnableUnsafeFPShrink;
2020  else if (isa<FPMathOperator>(CI) && CI->hasUnsafeAlgebra())
2021  UnsafeFPShrink = true;
2022 
2023  // First, check for intrinsics.
2024  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
2025  if (!isCallingConvC)
2026  return nullptr;
2027  switch (II->getIntrinsicID()) {
2028  case Intrinsic::pow:
2029  return optimizePow(CI, Builder);
2030  case Intrinsic::exp2:
2031  return optimizeExp2(CI, Builder);
2032  case Intrinsic::fabs:
2033  return optimizeFabs(CI, Builder);
2034  case Intrinsic::log:
2035  return optimizeLog(CI, Builder);
2036  case Intrinsic::sqrt:
2037  return optimizeSqrt(CI, Builder);
2038  // TODO: Use foldMallocMemset() with memset intrinsic.
2039  default:
2040  return nullptr;
2041  }
2042  }
2043 
2044  // Also try to simplify calls to fortified library functions.
2045  if (Value *SimplifiedFortifiedCI = FortifiedSimplifier.optimizeCall(CI)) {
2046  // Try to further simplify the result.
2047  CallInst *SimplifiedCI = dyn_cast<CallInst>(SimplifiedFortifiedCI);
2048  if (SimplifiedCI && SimplifiedCI->getCalledFunction()) {
2049  // Use an IR Builder from SimplifiedCI if available instead of CI
2050  // to guarantee we reach all uses we might replace later on.
2051  IRBuilder<> TmpBuilder(SimplifiedCI);
2052  if (Value *V = optimizeStringMemoryLibCall(SimplifiedCI, TmpBuilder)) {
2053  // If we were able to further simplify, remove the now redundant call.
2054  SimplifiedCI->replaceAllUsesWith(V);
2055  SimplifiedCI->eraseFromParent();
2056  return V;
2057  }
2058  }
2059  return SimplifiedFortifiedCI;
2060  }
2061 
2062  // Then check for known library functions.
2063  if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
2064  // We never change the calling convention.
2065  if (!ignoreCallingConv(Func) && !isCallingConvC)
2066  return nullptr;
2067  if (Value *V = optimizeStringMemoryLibCall(CI, Builder))
2068  return V;
2069  switch (Func) {
2070  case LibFunc::cosf:
2071  case LibFunc::cos:
2072  case LibFunc::cosl:
2073  return optimizeCos(CI, Builder);
2074  case LibFunc::sinpif:
2075  case LibFunc::sinpi:
2076  case LibFunc::cospif:
2077  case LibFunc::cospi:
2078  return optimizeSinCosPi(CI, Builder);
2079  case LibFunc::powf:
2080  case LibFunc::pow:
2081  case LibFunc::powl:
2082  return optimizePow(CI, Builder);
2083  case LibFunc::exp2l:
2084  case LibFunc::exp2:
2085  case LibFunc::exp2f:
2086  return optimizeExp2(CI, Builder);
2087  case LibFunc::fabsf:
2088  case LibFunc::fabs:
2089  case LibFunc::fabsl:
2090  return optimizeFabs(CI, Builder);
2091  case LibFunc::sqrtf:
2092  case LibFunc::sqrt:
2093  case LibFunc::sqrtl:
2094  return optimizeSqrt(CI, Builder);
2095  case LibFunc::ffs:
2096  case LibFunc::ffsl:
2097  case LibFunc::ffsll:
2098  return optimizeFFS(CI, Builder);
2099  case LibFunc::fls:
2100  case LibFunc::flsl:
2101  case LibFunc::flsll:
2102  return optimizeFls(CI, Builder);
2103  case LibFunc::abs:
2104  case LibFunc::labs:
2105  case LibFunc::llabs:
2106  return optimizeAbs(CI, Builder);
2107  case LibFunc::isdigit:
2108  return optimizeIsDigit(CI, Builder);
2109  case LibFunc::isascii:
2110  return optimizeIsAscii(CI, Builder);
2111  case LibFunc::toascii:
2112  return optimizeToAscii(CI, Builder);
2113  case LibFunc::printf:
2114  return optimizePrintF(CI, Builder);
2115  case LibFunc::sprintf:
2116  return optimizeSPrintF(CI, Builder);
2117  case LibFunc::fprintf:
2118  return optimizeFPrintF(CI, Builder);
2119  case LibFunc::fwrite:
2120  return optimizeFWrite(CI, Builder);
2121  case LibFunc::fputs:
2122  return optimizeFPuts(CI, Builder);
2123  case LibFunc::log:
2124  case LibFunc::log10:
2125  case LibFunc::log1p:
2126  case LibFunc::log2:
2127  case LibFunc::logb:
2128  return optimizeLog(CI, Builder);
2129  case LibFunc::puts:
2130  return optimizePuts(CI, Builder);
2131  case LibFunc::tan:
2132  case LibFunc::tanf:
2133  case LibFunc::tanl:
2134  return optimizeTan(CI, Builder);
2135  case LibFunc::perror:
2136  return optimizeErrorReporting(CI, Builder);
2137  case LibFunc::vfprintf:
2138  case LibFunc::fiprintf:
2139  return optimizeErrorReporting(CI, Builder, 0);
2140  case LibFunc::fputc:
2141  return optimizeErrorReporting(CI, Builder, 1);
2142  case LibFunc::ceil:
2143  case LibFunc::floor:
2144  case LibFunc::rint:
2145  case LibFunc::round:
2146  case LibFunc::nearbyint:
2147  case LibFunc::trunc:
2148  if (hasFloatVersion(FuncName))
2149  return optimizeUnaryDoubleFP(CI, Builder, false);
2150  return nullptr;
2151  case LibFunc::acos:
2152  case LibFunc::acosh:
2153  case LibFunc::asin:
2154  case LibFunc::asinh:
2155  case LibFunc::atan:
2156  case LibFunc::atanh:
2157  case LibFunc::cbrt:
2158  case LibFunc::cosh:
2159  case LibFunc::exp:
2160  case LibFunc::exp10:
2161  case LibFunc::expm1:
2162  case LibFunc::sin:
2163  case LibFunc::sinh:
2164  case LibFunc::tanh:
2165  if (UnsafeFPShrink && hasFloatVersion(FuncName))
2166  return optimizeUnaryDoubleFP(CI, Builder, true);
2167  return nullptr;
2168  case LibFunc::copysign:
2169  if (hasFloatVersion(FuncName))
2170  return optimizeBinaryDoubleFP(CI, Builder);
2171  return nullptr;
2172  case LibFunc::fminf:
2173  case LibFunc::fmin:
2174  case LibFunc::fminl:
2175  case LibFunc::fmaxf:
2176  case LibFunc::fmax:
2177  case LibFunc::fmaxl:
2178  return optimizeFMinFMax(CI, Builder);
2179  default:
2180  return nullptr;
2181  }
2182  }
2183  return nullptr;
2184 }
2185 
2187  const DataLayout &DL, const TargetLibraryInfo *TLI,
2188  function_ref<void(Instruction *, Value *)> Replacer)
2189  : FortifiedSimplifier(TLI), DL(DL), TLI(TLI), UnsafeFPShrink(false),
2190  Replacer(Replacer) {}
2191 
2192 void LibCallSimplifier::replaceAllUsesWith(Instruction *I, Value *With) {
2193  // Indirect through the replacer used in this instance.
2194  Replacer(I, With);
2195 }
2196 
2197 // TODO:
2198 // Additional cases that we need to add to this file:
2199 //
2200 // cbrt:
2201 // * cbrt(expN(X)) -> expN(x/3)
2202 // * cbrt(sqrt(x)) -> pow(x,1/6)
2203 // * cbrt(cbrt(x)) -> pow(x,1/9)
2204 //
2205 // exp, expf, expl:
2206 // * exp(log(x)) -> x
2207 //
2208 // log, logf, logl:
2209 // * log(exp(x)) -> x
2210 // * log(exp(y)) -> y*log(e)
2211 // * log(exp10(y)) -> y*log(10)
2212 // * log(sqrt(x)) -> 0.5*log(x)
2213 //
2214 // lround, lroundf, lroundl:
2215 // * lround(cnst) -> cnst'
2216 //
2217 // pow, powf, powl:
2218 // * pow(sqrt(x),y) -> pow(x,y*0.5)
2219 // * pow(pow(x,y),z)-> pow(x,y*z)
2220 //
2221 // round, roundf, roundl:
2222 // * round(cnst) -> cnst'
2223 //
2224 // signbit:
2225 // * signbit(cnst) -> cnst'
2226 // * signbit(nncst) -> 0 (if pstv is a non-negative constant)
2227 //
2228 // sqrt, sqrtf, sqrtl:
2229 // * sqrt(expN(x)) -> expN(x*0.5)
2230 // * sqrt(Nroot(x)) -> pow(x,1/(2*N))
2231 // * sqrt(pow(x,y)) -> pow(|x|,y*0.5)
2232 //
2233 // trunc, truncf, truncl:
2234 // * trunc(cnst) -> cnst'
2235 //
2236 //
2237 
2238 //===----------------------------------------------------------------------===//
2239 // Fortified Library Call Optimizations
2240 //===----------------------------------------------------------------------===//
2241 
2242 bool FortifiedLibCallSimplifier::isFortifiedCallFoldable(CallInst *CI,
2243  unsigned ObjSizeOp,
2244  unsigned SizeOp,
2245  bool isString) {
2246  if (CI->getArgOperand(ObjSizeOp) == CI->getArgOperand(SizeOp))
2247  return true;
2248  if (ConstantInt *ObjSizeCI =
2249  dyn_cast<ConstantInt>(CI->getArgOperand(ObjSizeOp))) {
2250  if (ObjSizeCI->isAllOnesValue())
2251  return true;
2252  // If the object size wasn't -1 (unknown), bail out if we were asked to.
2253  if (OnlyLowerUnknownSize)
2254  return false;
2255  if (isString) {
2256  uint64_t Len = GetStringLength(CI->getArgOperand(SizeOp));
2257  // If the length is 0 we don't know how long it is and so we can't
2258  // remove the check.
2259  if (Len == 0)
2260  return false;
2261  return ObjSizeCI->getZExtValue() >= Len;
2262  }
2263  if (ConstantInt *SizeCI = dyn_cast<ConstantInt>(CI->getArgOperand(SizeOp)))
2264  return ObjSizeCI->getZExtValue() >= SizeCI->getZExtValue();
2265  }
2266  return false;
2267 }
2268 
2269 Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
2270  IRBuilder<> &B) {
2271  if (isFortifiedCallFoldable(CI, 3, 2, false)) {
2272  B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
2273  CI->getArgOperand(2), 1);
2274  return CI->getArgOperand(0);
2275  }
2276  return nullptr;
2277 }
2278 
2279 Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
2280  IRBuilder<> &B) {
2281  if (isFortifiedCallFoldable(CI, 3, 2, false)) {
2282  B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
2283  CI->getArgOperand(2), 1);
2284  return CI->getArgOperand(0);
2285  }
2286  return nullptr;
2287 }
2288 
2289 Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
2290  IRBuilder<> &B) {
2291  // TODO: Try foldMallocMemset() here.
2292 
2293  if (isFortifiedCallFoldable(CI, 3, 2, false)) {
2294  Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
2295  B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
2296  return CI->getArgOperand(0);
2297  }
2298  return nullptr;
2299 }
2300 
2301 Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
2302  IRBuilder<> &B,
2303  LibFunc::Func Func) {
2304  Function *Callee = CI->getCalledFunction();
2305  StringRef Name = Callee->getName();
2306  const DataLayout &DL = CI->getModule()->getDataLayout();
2307  Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
2308  *ObjSize = CI->getArgOperand(2);
2309 
2310  // __stpcpy_chk(x,x,...) -> x+strlen(x)
2311  if (Func == LibFunc::stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
2312  Value *StrLen = emitStrLen(Src, B, DL, TLI);
2313  return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
2314  }
2315 
2316  // If a) we don't have any length information, or b) we know this will
2317  // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
2318  // st[rp]cpy_chk call which may fail at runtime if the size is too long.
2319  // TODO: It might be nice to get a maximum length out of the possible
2320  // string lengths for varying.
2321  if (isFortifiedCallFoldable(CI, 2, 1, true))
2322  return emitStrCpy(Dst, Src, B, TLI, Name.substr(2, 6));
2323 
2324  if (OnlyLowerUnknownSize)
2325  return nullptr;
2326 
2327  // Maybe we can stil fold __st[rp]cpy_chk to __memcpy_chk.
2328  uint64_t Len = GetStringLength(Src);
2329  if (Len == 0)
2330  return nullptr;
2331 
2332  Type *SizeTTy = DL.getIntPtrType(CI->getContext());
2333  Value *LenV = ConstantInt::get(SizeTTy, Len);
2334  Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
2335  // If the function was an __stpcpy_chk, and we were able to fold it into
2336  // a __memcpy_chk, we still need to return the correct end pointer.
2337  if (Ret && Func == LibFunc::stpcpy_chk)
2338  return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1));
2339  return Ret;
2340 }
2341 
2342 Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI,
2343  IRBuilder<> &B,
2344  LibFunc::Func Func) {
2345  Function *Callee = CI->getCalledFunction();
2346  StringRef Name = Callee->getName();
2347  if (isFortifiedCallFoldable(CI, 3, 2, false)) {
2348  Value *Ret = emitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
2349  CI->getArgOperand(2), B, TLI, Name.substr(2, 7));
2350  return Ret;
2351  }
2352  return nullptr;
2353 }
2354 
2356  // FIXME: We shouldn't be changing "nobuiltin" or TLI unavailable calls here.
2357  // Some clang users checked for _chk libcall availability using:
2358  // __has_builtin(__builtin___memcpy_chk)
2359  // When compiling with -fno-builtin, this is always true.
2360  // When passing -ffreestanding/-mkernel, which both imply -fno-builtin, we
2361  // end up with fortified libcalls, which isn't acceptable in a freestanding
2362  // environment which only provides their non-fortified counterparts.
2363  //
2364  // Until we change clang and/or teach external users to check for availability
2365  // differently, disregard the "nobuiltin" attribute and TLI::has.
2366  //
2367  // PR23093.
2368 
2370  Function *Callee = CI->getCalledFunction();
2371 
2373  CI->getOperandBundlesAsDefs(OpBundles);
2374  IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
2375  bool isCallingConvC = isCallingConvCCompatible(CI);
2376 
2377  // First, check that this is a known library functions and that the prototype
2378  // is correct.
2379  if (!TLI->getLibFunc(*Callee, Func))
2380  return nullptr;
2381 
2382  // We never change the calling convention.
2383  if (!ignoreCallingConv(Func) && !isCallingConvC)
2384  return nullptr;
2385 
2386  switch (Func) {
2387  case LibFunc::memcpy_chk:
2388  return optimizeMemCpyChk(CI, Builder);
2389  case LibFunc::memmove_chk:
2390  return optimizeMemMoveChk(CI, Builder);
2391  case LibFunc::memset_chk:
2392  return optimizeMemSetChk(CI, Builder);
2393  case LibFunc::stpcpy_chk:
2394  case LibFunc::strcpy_chk:
2395  return optimizeStrpCpyChk(CI, Builder, Func);
2396  case LibFunc::stpncpy_chk:
2397  case LibFunc::strncpy_chk:
2398  return optimizeStrpNCpyChk(CI, Builder, Func);
2399  default:
2400  break;
2401  }
2402  return nullptr;
2403 }
2404 
2406  const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
2407  : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
static Value * optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B, bool CheckRetType)
Shrink double -> float for unary functions like 'floor'.
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
void push_back(const T &Elt)
Definition: SmallVector.h:211
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1554
static Value * foldMallocMemset(CallInst *Memset, IRBuilder<> &B, const TargetLibraryInfo &TLI)
Fold memset[_chk](malloc(n), 0, n) –> calloc(1, n).
void setNoSignedZeros()
Definition: Operator.h:203
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1469
Value * CreateIsNotNull(Value *Arg, const Twine &Name="")
Return an i1 value testing if Arg is not null.
Definition: IRBuilder.h:1704
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:1309
size_t i
static bool callHasFloatingPointArgument(const CallInst *CI)
Value * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1478
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
Definition: CallingConv.h:95
Value * optimizeCall(CallInst *CI)
Take the given call instruction and return a more optimal value to replace the instruction with or 0 ...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void setNoNaNs()
Flag setters.
Definition: Operator.h:201
static Constant * getInfinity(Type *Ty, bool Negative=false)
Definition: Constants.cpp:713
2: 32-bit floating point type
Definition: Type.h:58
uint64_t GetStringLength(const Value *V)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'...
This class represents a function call, abstracting a target machine's calling convention.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:151
static uint64_t round(uint64_t Acc, uint64_t Input)
Definition: xxhash.cpp:57
unsigned less than
Definition: InstrTypes.h:905
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:148
static bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty, LibFunc::Func DoubleFn, LibFunc::Func FloatFn, LibFunc::Func LongDoubleFn)
Check whether the overloaded unary floating point function corresponding to Ty is available...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
Value * CreateSExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1304
static cl::opt< bool > ColdErrorCalls("error-reporting-is-cold", cl::init(true), cl::Hidden, cl::desc("Treat error-reporting calls as cold"))
CallInst * CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memset to the specified pointer and the specified value.
Definition: IRBuilder.h:404
An instruction for reading from memory.
Definition: Instructions.h:164
Hexagon Common GEP
static bool isTrigLibCall(CallInst *CI)
Value * emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B, const TargetLibraryInfo *TLI, StringRef Name="strncpy")
Emit a call to the strncpy function to the builder, for the specified pointer arguments and length...
Value * emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B, const AttributeSet &Attrs)
Emit a call to the unary function named 'Name' (e.g.
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with strcmp
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:218
void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-applied message.
bool optForSize() const
Optimize this function for size (-Os) or minimum size (-Oz).
Definition: Function.h:464
static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg)
static cl::opt< bool > EnableUnsafeFPShrink("enable-double-float-shrink", cl::Hidden, cl::init(false), cl::desc("Enable unsafe double to float ""shrinking for math lib calls"))
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
void setCallingConv(CallingConv::ID CC)
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:347
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
Definition: PatternMatch.h:343
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
Value * CreateFPExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1351
This class represents the LLVM 'select' instruction.
static bool ignoreCallingConv(LibFunc::Func Func)
bool has(LibFunc::Func F) const
Tests whether a library function is available.
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize=false)
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
Value * emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an integer.
unsigned getNumArgOperands() const
Return the number of call arguments.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:813
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following: ...
Value * CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1484
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
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:154
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1094
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1358
Class to represent function types.
Definition: DerivedTypes.h:102
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1362
#define F(x, y, z)
Definition: MD5.cpp:51
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4139
#define T
Value * emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the __memcpy_chk function to the builder.
Function Alias Analysis false
CallInst * CreateMemMove(Value *Dst, Value *Src, uint64_t Size, unsigned Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memmove between the specified pointers.
Definition: IRBuilder.h:443
bool hasUnsafeAlgebra() const
Determine whether the unsafe-algebra flag is set.
InstTy * Insert(InstTy *I, const Twine &Name="") const
Insert and return the specified instruction.
Definition: IRBuilder.h:639
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:136
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:949
Value * emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, const TargetLibraryInfo *TLI, StringRef Name="strcpy")
Emit a call to the strcpy function to the builder, for the specified pointer arguments.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:835
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:68
bool isGEPBasedOnPointerToString(const GEPOperator *GEP)
Returns true if the GEP is based on a pointer to a string (array of i8), and is indexing into this st...
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
static Value * valueHasFloatPrecision(Value *Val)
Return a variant of Val with float type.
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1301
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
Value * CreateInBoundsGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1158
Value * CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1497
static unsigned getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
Definition: Local.h:183
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block...
Definition: IRBuilder.h:127
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
ConstantInt * getIntN(unsigned N, uint64_t C)
Get a constant N-bit value, zero extended or truncated from a 64-bit value.
Definition: IRBuilder.h:318
iterator begin() const
Definition: StringRef.h:103
static const fltSemantics & IEEEsingle()
Definition: APFloat.cpp:100
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: InstrTypes.h:1441
Value * emitFPutS(Value *Str, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function.
LoadInst * CreateLoad(Value *Ptr, const char *Name)
Definition: IRBuilder.h:1082
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const
Searches for a particular function name.
Type * getDoubleTy()
Fetch the type representing a 64-bit floating point value.
Definition: IRBuilder.h:375
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:133
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
Constant * stripPointerCasts()
Definition: Constant.h:155
static Value * emitCalloc(Value *Num, Value *Size, const AttributeSet &Attrs, IRBuilder<> &B, const TargetLibraryInfo &TLI)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeSet AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:123
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
ConstantInt * getTrue()
Get the constant value for i1 true.
Definition: IRBuilder.h:287
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an important base class in LLVM.
Definition: Constant.h:42
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Definition: IRBuilder.h:1609
bool isInteger() const
Definition: APFloat.h:1050
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:145
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:269
Value * CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1501
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:587
void setUnsafeAlgebra()
Definition: Operator.h:205
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:743
uint32_t Offset
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1044
This instruction compares its operands according to the predicate given to the constructor.
Value * getOperand(unsigned i) const
Definition: User.h:145
op_range operands()
Definition: User.h:213
Value * getPointerOperand()
Definition: Instructions.h:270
static bool isCallingConvCCompatible(CallInst *CI)
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:96
Class to represent integer types.
Definition: DerivedTypes.h:39
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Definition: IRBuilder.h:312
Value * castToCStr(Value *V, IRBuilder<> &B)
Return V if it is an i8*, otherwise cast it to i8*.
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:960
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:1629
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:249
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
uint64_t NextPowerOf2(uint64_t A)
NextPowerOf2 - Returns the next power of two (in 64-bits) that is strictly greater than A...
Definition: MathExtras.h:619
Value * emitStrChr(Value *Ptr, char C, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the strchr function to the builder, for the specified pointer and character.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE int compare(StringRef RHS) const
compare - Compare two strings; the result is -1, 0, or 1 if this string is lexicographically less tha...
Definition: StringRef.h:181
LLVM_NODISCARD size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Definition: StringRef.cpp:264
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:1671
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:385
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1298
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
FunctionType * getFunctionType() const
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:357
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:709
Value * CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1509
Value * emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strlen function to the builder, for the specified pointer.
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:234
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
GlobalVariable * CreateGlobalString(StringRef Str, const Twine &Name="", unsigned AddressSpace=0)
Make a new global variable with initializer type i8*.
Definition: IRBuilder.cpp:27
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:330
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Definition: IRBuilder.h:1425
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
Provides information about what library functions are available for the current target.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:307
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:121
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
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:558
Function * getCalledFunction() const
Return the function called, or null if this is an indirect function invocation.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:198
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
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:623
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:464
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:146
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:176
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
Value * CreateGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1141
Class for arbitrary precision integers.
Definition: APInt.h:77
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
iterator_range< user_iterator > users()
Definition: Value.h:370
IntegerType * getInt8Ty()
Fetch the type representing an 8-bit integer.
Definition: IRBuilder.h:337
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:932
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
double convertToDouble() const
Definition: APFloat.h:1013
static Value * optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B)
Shrink double -> float for binary functions like 'fmin/fmax'.
static const fltSemantics & IEEEdouble()
Definition: APFloat.cpp:103
Value * emitFPutC(Value *Char, Value *File, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
ConstantInt * getFalse()
Get the constant value for i1 false.
Definition: IRBuilder.h:292
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:207
bool isNegative() const
Return true if the sign bit is set.
Definition: Constants.h:306
void setCalledFunction(Value *Fn)
Set the function called.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
CallInst * CreateMemCpy(Value *Dst, Value *Src, uint64_t Size, unsigned Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memcpy between the specified pointers.
Definition: IRBuilder.h:422
static const size_t npos
Definition: StringRef.h:51
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
static bool isOnlyUsedInZeroEqualityComparison(Value *V)
Return true if it only matters that the value is equal or not-equal to zero.
Value * emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strncmp function to the builder.
static bool isFNeg(const Value *V, bool IgnoreZeroSign=false)
#define I(x, y, z)
Definition: MD5.cpp:54
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.cpp:230
APFloat abs(APFloat X)
Returns the absolute value of the argument.
Definition: APFloat.h:1099
This class represents a cast unsigned integer to floating point.
CallInst * CreateCall(Value *Callee, ArrayRef< Value * > Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1579
Value * optimizeCall(CallInst *CI)
optimizeCall - Take the given call instruction and return a more optimal value to replace the instruc...
LLVM_NODISCARD 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:287
static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg, bool UseFloat, Value *&Sin, Value *&Cos, Value *&SinCos)
Type * getFloatTy()
Fetch the type representing a 32-bit floating point value.
Definition: IRBuilder.h:370
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:987
const APFloat & getValueAPF() const
Definition: Constants.h:300
bool getConstantStringInfo(const Value *V, StringRef &Str, uint64_t Offset=0, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
Value * emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite function.
bool isExactlyValue(const APFloat &V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
Definition: Constants.cpp:729
3: 64-bit floating point type
Definition: Type.h:59
Value * emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memcmp function.
bool use_empty() const
Definition: Value.h:299
This class represents a cast from signed integer to floating point.
static bool isOnlyUsedInEqualityComparison(Value *V, Value *With)
Return true if it is only used in equality comparisons with With.
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:392
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
user_iterator user_begin()
Definition: Value.h:346
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:33
This class represents a truncation of floating point types.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
LLVM Value Representation.
Definition: Value.h:71
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
Value * emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function. This assumes that Str is some pointer.
bool isZero() const
Definition: APFloat.h:1031
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:631
Value * emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memchr function.
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Definition: IRBuilder.h:220
iterator end() const
Definition: StringRef.h:105
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:125
cmpResult compare(const APFloat &RHS) const
Definition: APFloat.h:1018
Value * CreateFDiv(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:903
ConstantInt * getInt8(uint8_t C)
Get a constant 8-bit value.
Definition: IRBuilder.h:297
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:678
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:168
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_back(size_t N=1) const
Return a StringRef equal to 'this' but with the last N elements dropped.
Definition: StringRef.h:643
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
int * Ptr
T Max(T a, T b)
Definition: FuzzerDefs.h:57
Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, IRBuilder<> &B, const AttributeSet &Attrs)
Emit a call to the binary function named 'Name' (e.g.
ConstantInt * getInt(const APInt &AI)
Get a constant integer value.
Definition: IRBuilder.h:323
This class represents an extension of floating point types.
LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI, function_ref< void(Instruction *, Value *)> Replacer=&replaceAllUsesWithDefault)
Value * CreateFMul(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:871
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:162
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:479
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1613
ARM_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:99
const fltSemantics & getSemantics() const
Definition: APFloat.h:1043
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:102
static Value * getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B)
const BasicBlock * getParent() const
Definition: Instruction.h:62
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
user_iterator user_end()
Definition: Value.h:354