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