lib/Transforms/Scalar/SimplifyLibCalls.cpp

   1 //===- SimplifyLibCalls.cpp - Optimize specific well-known library calls --===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements a simple pass that applies a variety of small
  11 // optimizations for calls to specific well-known function calls (e.g. runtime
  12 // library functions).   Any optimization that takes the very simple form
  13 // "replace call to library function with simpler code that provides the same
  14 // result" belongs in this file.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #define DEBUG_TYPE "simplify-libcalls"
  19 #include "llvm/Transforms/Scalar.h"
  20 #include "llvm/Transforms/Utils/BuildLibCalls.h"
  21 #include "llvm/IRBuilder.h"
  22 #include "llvm/Intrinsics.h"
  23 #include "llvm/LLVMContext.h"
  24 #include "llvm/Module.h"
  25 #include "llvm/Pass.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/ADT/SmallPtrSet.h"
  28 #include "llvm/ADT/Statistic.h"
  29 #include "llvm/ADT/StringMap.h"
  30 #include "llvm/Analysis/ValueTracking.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Support/Debug.h"
  33 #include "llvm/Support/raw_ostream.h"
  34 #include "llvm/DataLayout.h"
  35 #include "llvm/Target/TargetLibraryInfo.h"
  36 #include "llvm/Config/config.h"            // FIXME: Shouldn't depend on host!
  37 using namespace llvm;
  38
  39 STATISTIC(NumSimplified, "Number of library calls simplified");
  40 STATISTIC(NumAnnotated, "Number of attributes added to library functions");
  41
  42 static cl::opt<bool> UnsafeFPShrink("enable-double-float-shrink", cl::Hidden,
  43                                    cl::init(false),
  44                                    cl::desc("Enable unsafe double to float "
  45                                             "shrinking for math lib calls"));
  46 //===----------------------------------------------------------------------===//
  47 // Optimizer Base Class
  48 //===----------------------------------------------------------------------===//
  49
  50 /// This class is the abstract base class for the set of optimizations that
  51 /// corresponds to one library call.
  52 namespace {
  53 class LibCallOptimization {
  54 protected:
  55   Function *Caller;
  56   const DataLayout *TD;
  57   const TargetLibraryInfo *TLI;
  58   LLVMContext* Context;
  59 public:
  60   LibCallOptimization() { }
  61   virtual ~LibCallOptimization() {}
  62
  63   /// CallOptimizer - This pure virtual method is implemented by base classes to
  64   /// do various optimizations.  If this returns null then no transformation was
  65   /// performed.  If it returns CI, then it transformed the call and CI is to be
  66   /// deleted.  If it returns something else, replace CI with the new value and
  67   /// delete CI.
  68   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B)
  69     =0;
  70
  71   Value *OptimizeCall(CallInst *CI, const DataLayout *TD,
  72                       const TargetLibraryInfo *TLI, IRBuilder<> &B) {
  73     Caller = CI->getParent()->getParent();
  74     this->TD = TD;
  75     this->TLI = TLI;
  76     if (CI->getCalledFunction())
  77       Context = &CI->getCalledFunction()->getContext();
  78
  79     // We never change the calling convention.
  80     if (CI->getCallingConv() != llvm::CallingConv::C)
  81       return NULL;
  82
  83     return CallOptimizer(CI->getCalledFunction(), CI, B);
  84   }
  85 };
  86 } // End anonymous namespace.
  87
  88
  89 //===----------------------------------------------------------------------===//
  90 // Helper Functions
  91 //===----------------------------------------------------------------------===//
  92
  93 /// IsOnlyUsedInZeroEqualityComparison - Return true if it only matters that the
  94 /// value is equal or not-equal to zero.
  95 static bool IsOnlyUsedInZeroEqualityComparison(Value *V) {
  96   for (Value::use_iterator UI = V->use_begin(), E = V->use_end();
  97        UI != E; ++UI) {
  98     if (ICmpInst *IC = dyn_cast<ICmpInst>(*UI))
  99       if (IC->isEquality())
 100         if (Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
 101           if (C->isNullValue())
 102             continue;
 103     // Unknown instruction.
 104     return false;
 105   }
 106   return true;
 107 }
 108
 109 static bool CallHasFloatingPointArgument(const CallInst *CI) {
 110   for (CallInst::const_op_iterator it = CI->op_begin(), e = CI->op_end();
 111        it != e; ++it) {
 112     if ((*it)->getType()->isFloatingPointTy())
 113       return true;
 114   }
 115   return false;
 116 }
 117
 118 /// IsOnlyUsedInEqualityComparison - Return true if it is only used in equality
 119 /// comparisons with With.
 120 static bool IsOnlyUsedInEqualityComparison(Value *V, Value *With) {
 121   for (Value::use_iterator UI = V->use_begin(), E = V->use_end();
 122        UI != E; ++UI) {
 123     if (ICmpInst *IC = dyn_cast<ICmpInst>(*UI))
 124       if (IC->isEquality() && IC->getOperand(1) == With)
 125         continue;
 126     // Unknown instruction.
 127     return false;
 128   }
 129   return true;
 130 }
 131
 132 //===----------------------------------------------------------------------===//
 133 // String and Memory LibCall Optimizations
 134 //===----------------------------------------------------------------------===//
 135
 136 namespace {
 137 //===---------------------------------------===//
 138 // 'strcpy' Optimizations
 139
 140 struct StrCpyOpt : public LibCallOptimization {
 141   bool OptChkCall;  // True if it's optimizing a __strcpy_chk libcall.
 142
 143   StrCpyOpt(bool c) : OptChkCall(c) {}
 144
 145   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 146     // Verify the "strcpy" function prototype.
 147     unsigned NumParams = OptChkCall ? 3 : 2;
 148     FunctionType *FT = Callee->getFunctionType();
 149     if (FT->getNumParams() != NumParams ||
 150         FT->getReturnType() != FT->getParamType(0) ||
 151         FT->getParamType(0) != FT->getParamType(1) ||
 152         FT->getParamType(0) != B.getInt8PtrTy())
 153       return 0;
 154
 155     Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
 156     if (Dst == Src)      // strcpy(x,x)  -> x
 157       return Src;
 158
 159     // These optimizations require DataLayout.
 160     if (!TD) return 0;
 161
 162     // See if we can get the length of the input string.
 163     uint64_t Len = GetStringLength(Src);
 164     if (Len == 0) return 0;
 165
 166     // We have enough information to now generate the memcpy call to do the
 167     // concatenation for us.  Make a memcpy to copy the nul byte with align = 1.
 168     if (!OptChkCall ||
 169         !EmitMemCpyChk(Dst, Src,
 170                        ConstantInt::get(TD->getIntPtrType(*Context), Len),
 171                        CI->getArgOperand(2), B, TD, TLI))
 172       B.CreateMemCpy(Dst, Src,
 173                      ConstantInt::get(TD->getIntPtrType(*Context), Len), 1);
 174     return Dst;
 175   }
 176 };
 177
 178 //===---------------------------------------===//
 179 // 'stpcpy' Optimizations
 180
 181 struct StpCpyOpt: public LibCallOptimization {
 182   bool OptChkCall;  // True if it's optimizing a __stpcpy_chk libcall.
 183
 184   StpCpyOpt(bool c) : OptChkCall(c) {}
 185
 186   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 187     // Verify the "stpcpy" function prototype.
 188     unsigned NumParams = OptChkCall ? 3 : 2;
 189     FunctionType *FT = Callee->getFunctionType();
 190     if (FT->getNumParams() != NumParams ||
 191         FT->getReturnType() != FT->getParamType(0) ||
 192         FT->getParamType(0) != FT->getParamType(1) ||
 193         FT->getParamType(0) != B.getInt8PtrTy())
 194       return 0;
 195
 196     // These optimizations require DataLayout.
 197     if (!TD) return 0;
 198
 199     Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
 200     if (Dst == Src) {  // stpcpy(x,x)  -> x+strlen(x)
 201       Value *StrLen = EmitStrLen(Src, B, TD, TLI);
 202       return StrLen ? B.CreateInBoundsGEP(Dst, StrLen) : 0;
 203     }
 204
 205     // See if we can get the length of the input string.
 206     uint64_t Len = GetStringLength(Src);
 207     if (Len == 0) return 0;
 208
 209     Value *LenV = ConstantInt::get(TD->getIntPtrType(*Context), Len);
 210     Value *DstEnd = B.CreateGEP(Dst,
 211                                 ConstantInt::get(TD->getIntPtrType(*Context),
 212                                                  Len - 1));
 213
 214     // We have enough information to now generate the memcpy call to do the
 215     // copy for us.  Make a memcpy to copy the nul byte with align = 1.
 216     if (!OptChkCall || !EmitMemCpyChk(Dst, Src, LenV, CI->getArgOperand(2), B,
 217                                       TD, TLI))
 218       B.CreateMemCpy(Dst, Src, LenV, 1);
 219     return DstEnd;
 220   }
 221 };
 222
 223 //===---------------------------------------===//
 224 // 'strncpy' Optimizations
 225
 226 struct StrNCpyOpt : public LibCallOptimization {
 227   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 228     FunctionType *FT = Callee->getFunctionType();
 229     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
 230         FT->getParamType(0) != FT->getParamType(1) ||
 231         FT->getParamType(0) != B.getInt8PtrTy() ||
 232         !FT->getParamType(2)->isIntegerTy())
 233       return 0;
 234
 235     Value *Dst = CI->getArgOperand(0);
 236     Value *Src = CI->getArgOperand(1);
 237     Value *LenOp = CI->getArgOperand(2);
 238
 239     // See if we can get the length of the input string.
 240     uint64_t SrcLen = GetStringLength(Src);
 241     if (SrcLen == 0) return 0;
 242     --SrcLen;
 243
 244     if (SrcLen == 0) {
 245       // strncpy(x, "", y) -> memset(x, '\0', y, 1)
 246       B.CreateMemSet(Dst, B.getInt8('\0'), LenOp, 1);
 247       return Dst;
 248     }
 249
 250     uint64_t Len;
 251     if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(LenOp))
 252       Len = LengthArg->getZExtValue();
 253     else
 254       return 0;
 255
 256     if (Len == 0) return Dst; // strncpy(x, y, 0) -> x
 257
 258     // These optimizations require DataLayout.
 259     if (!TD) return 0;
 260
 261     // Let strncpy handle the zero padding
 262     if (Len > SrcLen+1) return 0;
 263
 264     // strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
 265     B.CreateMemCpy(Dst, Src,
 266                    ConstantInt::get(TD->getIntPtrType(*Context), Len), 1);
 267
 268     return Dst;
 269   }
 270 };
 271
 272 //===---------------------------------------===//
 273 // 'strlen' Optimizations
 274
 275 struct StrLenOpt : public LibCallOptimization {
 276   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 277     FunctionType *FT = Callee->getFunctionType();
 278     if (FT->getNumParams() != 1 ||
 279         FT->getParamType(0) != B.getInt8PtrTy() ||
 280         !FT->getReturnType()->isIntegerTy())
 281       return 0;
 282
 283     Value *Src = CI->getArgOperand(0);
 284
 285     // Constant folding: strlen("xyz") -> 3
 286     if (uint64_t Len = GetStringLength(Src))
 287       return ConstantInt::get(CI->getType(), Len-1);
 288
 289     // strlen(x) != 0 --> *x != 0
 290     // strlen(x) == 0 --> *x == 0
 291     if (IsOnlyUsedInZeroEqualityComparison(CI))
 292       return B.CreateZExt(B.CreateLoad(Src, "strlenfirst"), CI->getType());
 293     return 0;
 294   }
 295 };
 296
 297
 298 //===---------------------------------------===//
 299 // 'strpbrk' Optimizations
 300
 301 struct StrPBrkOpt : public LibCallOptimization {
 302   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 303     FunctionType *FT = Callee->getFunctionType();
 304     if (FT->getNumParams() != 2 ||
 305         FT->getParamType(0) != B.getInt8PtrTy() ||
 306         FT->getParamType(1) != FT->getParamType(0) ||
 307         FT->getReturnType() != FT->getParamType(0))
 308       return 0;
 309
 310     StringRef S1, S2;
 311     bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
 312     bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
 313
 314     // strpbrk(s, "") -> NULL
 315     // strpbrk("", s) -> NULL
 316     if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
 317       return Constant::getNullValue(CI->getType());
 318
 319     // Constant folding.
 320     if (HasS1 && HasS2) {
 321       size_t I = S1.find_first_of(S2);
 322       if (I == std::string::npos) // No match.
 323         return Constant::getNullValue(CI->getType());
 324
 325       return B.CreateGEP(CI->getArgOperand(0), B.getInt64(I), "strpbrk");
 326     }
 327
 328     // strpbrk(s, "a") -> strchr(s, 'a')
 329     if (TD && HasS2 && S2.size() == 1)
 330       return EmitStrChr(CI->getArgOperand(0), S2[0], B, TD, TLI);
 331
 332     return 0;
 333   }
 334 };
 335
 336 //===---------------------------------------===//
 337 // 'strto*' Optimizations.  This handles strtol, strtod, strtof, strtoul, etc.
 338
 339 struct StrToOpt : public LibCallOptimization {
 340   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 341     FunctionType *FT = Callee->getFunctionType();
 342     if ((FT->getNumParams() != 2 && FT->getNumParams() != 3) ||
 343         !FT->getParamType(0)->isPointerTy() ||
 344         !FT->getParamType(1)->isPointerTy())
 345       return 0;
 346
 347     Value *EndPtr = CI->getArgOperand(1);
 348     if (isa<ConstantPointerNull>(EndPtr)) {
 349       // With a null EndPtr, this function won't capture the main argument.
 350       // It would be readonly too, except that it still may write to errno.
 351       CI->addAttribute(1, Attributes::get(Callee->getContext(),
 352                                           Attributes::NoCapture));
 353     }
 354
 355     return 0;
 356   }
 357 };
 358
 359 //===---------------------------------------===//
 360 // 'strspn' Optimizations
 361
 362 struct StrSpnOpt : public LibCallOptimization {
 363   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 364     FunctionType *FT = Callee->getFunctionType();
 365     if (FT->getNumParams() != 2 ||
 366         FT->getParamType(0) != B.getInt8PtrTy() ||
 367         FT->getParamType(1) != FT->getParamType(0) ||
 368         !FT->getReturnType()->isIntegerTy())
 369       return 0;
 370
 371     StringRef S1, S2;
 372     bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
 373     bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
 374
 375     // strspn(s, "") -> 0
 376     // strspn("", s) -> 0
 377     if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
 378       return Constant::getNullValue(CI->getType());
 379
 380     // Constant folding.
 381     if (HasS1 && HasS2) {
 382       size_t Pos = S1.find_first_not_of(S2);
 383       if (Pos == StringRef::npos) Pos = S1.size();
 384       return ConstantInt::get(CI->getType(), Pos);
 385     }
 386
 387     return 0;
 388   }
 389 };
 390
 391 //===---------------------------------------===//
 392 // 'strcspn' Optimizations
 393
 394 struct StrCSpnOpt : public LibCallOptimization {
 395   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 396     FunctionType *FT = Callee->getFunctionType();
 397     if (FT->getNumParams() != 2 ||
 398         FT->getParamType(0) != B.getInt8PtrTy() ||
 399         FT->getParamType(1) != FT->getParamType(0) ||
 400         !FT->getReturnType()->isIntegerTy())
 401       return 0;
 402
 403     StringRef S1, S2;
 404     bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
 405     bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
 406
 407     // strcspn("", s) -> 0
 408     if (HasS1 && S1.empty())
 409       return Constant::getNullValue(CI->getType());
 410
 411     // Constant folding.
 412     if (HasS1 && HasS2) {
 413       size_t Pos = S1.find_first_of(S2);
 414       if (Pos == StringRef::npos) Pos = S1.size();
 415       return ConstantInt::get(CI->getType(), Pos);
 416     }
 417
 418     // strcspn(s, "") -> strlen(s)
 419     if (TD && HasS2 && S2.empty())
 420       return EmitStrLen(CI->getArgOperand(0), B, TD, TLI);
 421
 422     return 0;
 423   }
 424 };
 425
 426 //===---------------------------------------===//
 427 // 'strstr' Optimizations
 428
 429 struct StrStrOpt : public LibCallOptimization {
 430   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 431     FunctionType *FT = Callee->getFunctionType();
 432     if (FT->getNumParams() != 2 ||
 433         !FT->getParamType(0)->isPointerTy() ||
 434         !FT->getParamType(1)->isPointerTy() ||
 435         !FT->getReturnType()->isPointerTy())
 436       return 0;
 437
 438     // fold strstr(x, x) -> x.
 439     if (CI->getArgOperand(0) == CI->getArgOperand(1))
 440       return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
 441
 442     // fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
 443     if (TD && IsOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) {
 444       Value *StrLen = EmitStrLen(CI->getArgOperand(1), B, TD, TLI);
 445       if (!StrLen)
 446         return 0;
 447       Value *StrNCmp = EmitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
 448                                    StrLen, B, TD, TLI);
 449       if (!StrNCmp)
 450         return 0;
 451       for (Value::use_iterator UI = CI->use_begin(), UE = CI->use_end();
 452            UI != UE; ) {
 453         ICmpInst *Old = cast<ICmpInst>(*UI++);
 454         Value *Cmp = B.CreateICmp(Old->getPredicate(), StrNCmp,
 455                                   ConstantInt::getNullValue(StrNCmp->getType()),
 456                                   "cmp");
 457         Old->replaceAllUsesWith(Cmp);
 458         Old->eraseFromParent();
 459       }
 460       return CI;
 461     }
 462
 463     // See if either input string is a constant string.
 464     StringRef SearchStr, ToFindStr;
 465     bool HasStr1 = getConstantStringInfo(CI->getArgOperand(0), SearchStr);
 466     bool HasStr2 = getConstantStringInfo(CI->getArgOperand(1), ToFindStr);
 467
 468     // fold strstr(x, "") -> x.
 469     if (HasStr2 && ToFindStr.empty())
 470       return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
 471
 472     // If both strings are known, constant fold it.
 473     if (HasStr1 && HasStr2) {
 474       std::string::size_type Offset = SearchStr.find(ToFindStr);
 475
 476       if (Offset == StringRef::npos) // strstr("foo", "bar") -> null
 477         return Constant::getNullValue(CI->getType());
 478
 479       // strstr("abcd", "bc") -> gep((char*)"abcd", 1)
 480       Value *Result = CastToCStr(CI->getArgOperand(0), B);
 481       Result = B.CreateConstInBoundsGEP1_64(Result, Offset, "strstr");
 482       return B.CreateBitCast(Result, CI->getType());
 483     }
 484
 485     // fold strstr(x, "y") -> strchr(x, 'y').
 486     if (HasStr2 && ToFindStr.size() == 1) {
 487       Value *StrChr= EmitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TD, TLI);
 488       return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : 0;
 489     }
 490     return 0;
 491   }
 492 };
 493
 494
 495 //===---------------------------------------===//
 496 // 'memcmp' Optimizations
 497
 498 struct MemCmpOpt : public LibCallOptimization {
 499   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 500     FunctionType *FT = Callee->getFunctionType();
 501     if (FT->getNumParams() != 3 || !FT->getParamType(0)->isPointerTy() ||
 502         !FT->getParamType(1)->isPointerTy() ||
 503         !FT->getReturnType()->isIntegerTy(32))
 504       return 0;
 505
 506     Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
 507
 508     if (LHS == RHS)  // memcmp(s,s,x) -> 0
 509       return Constant::getNullValue(CI->getType());
 510
 511     // Make sure we have a constant length.
 512     ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
 513     if (!LenC) return 0;
 514     uint64_t Len = LenC->getZExtValue();
 515
 516     if (Len == 0) // memcmp(s1,s2,0) -> 0
 517       return Constant::getNullValue(CI->getType());
 518
 519     // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
 520     if (Len == 1) {
 521       Value *LHSV = B.CreateZExt(B.CreateLoad(CastToCStr(LHS, B), "lhsc"),
 522                                  CI->getType(), "lhsv");
 523       Value *RHSV = B.CreateZExt(B.CreateLoad(CastToCStr(RHS, B), "rhsc"),
 524                                  CI->getType(), "rhsv");
 525       return B.CreateSub(LHSV, RHSV, "chardiff");
 526     }
 527
 528     // Constant folding: memcmp(x, y, l) -> cnst (all arguments are constant)
 529     StringRef LHSStr, RHSStr;
 530     if (getConstantStringInfo(LHS, LHSStr) &&
 531         getConstantStringInfo(RHS, RHSStr)) {
 532       // Make sure we're not reading out-of-bounds memory.
 533       if (Len > LHSStr.size() || Len > RHSStr.size())
 534         return 0;
 535       uint64_t Ret = memcmp(LHSStr.data(), RHSStr.data(), Len);
 536       return ConstantInt::get(CI->getType(), Ret);
 537     }
 538
 539     return 0;
 540   }
 541 };
 542
 543 //===---------------------------------------===//
 544 // 'memcpy' Optimizations
 545
 546 struct MemCpyOpt : public LibCallOptimization {
 547   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 548     // These optimizations require DataLayout.
 549     if (!TD) return 0;
 550
 551     FunctionType *FT = Callee->getFunctionType();
 552     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
 553         !FT->getParamType(0)->isPointerTy() ||
 554         !FT->getParamType(1)->isPointerTy() ||
 555         FT->getParamType(2) != TD->getIntPtrType(*Context))
 556       return 0;
 557
 558     // memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
 559     B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
 560                    CI->getArgOperand(2), 1);
 561     return CI->getArgOperand(0);
 562   }
 563 };
 564
 565 //===---------------------------------------===//
 566 // 'memmove' Optimizations
 567
 568 struct MemMoveOpt : public LibCallOptimization {
 569   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 570     // These optimizations require DataLayout.
 571     if (!TD) return 0;
 572
 573     FunctionType *FT = Callee->getFunctionType();
 574     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
 575         !FT->getParamType(0)->isPointerTy() ||
 576         !FT->getParamType(1)->isPointerTy() ||
 577         FT->getParamType(2) != TD->getIntPtrType(*Context))
 578       return 0;
 579
 580     // memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
 581     B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
 582                     CI->getArgOperand(2), 1);
 583     return CI->getArgOperand(0);
 584   }
 585 };
 586
 587 //===---------------------------------------===//
 588 // 'memset' Optimizations
 589
 590 struct MemSetOpt : public LibCallOptimization {
 591   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 592     // These optimizations require DataLayout.
 593     if (!TD) return 0;
 594
 595     FunctionType *FT = Callee->getFunctionType();
 596     if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
 597         !FT->getParamType(0)->isPointerTy() ||
 598         !FT->getParamType(1)->isIntegerTy() ||
 599         FT->getParamType(2) != TD->getIntPtrType(*Context))
 600       return 0;
 601
 602     // memset(p, v, n) -> llvm.memset(p, v, n, 1)
 603     Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
 604     B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
 605     return CI->getArgOperand(0);
 606   }
 607 };
 608
 609 //===----------------------------------------------------------------------===//
 610 // Math Library Optimizations
 611 //===----------------------------------------------------------------------===//
 612
 613 //===---------------------------------------===//
 614 // Double -> Float Shrinking Optimizations for Unary Functions like 'floor'
 615
 616 struct UnaryDoubleFPOpt : public LibCallOptimization {
 617   bool CheckRetType;
 618   UnaryDoubleFPOpt(bool CheckReturnType): CheckRetType(CheckReturnType) {}
 619   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 620     FunctionType *FT = Callee->getFunctionType();
 621     if (FT->getNumParams() != 1 || !FT->getReturnType()->isDoubleTy() ||
 622         !FT->getParamType(0)->isDoubleTy())
 623       return 0;
 624
 625     if (CheckRetType) {
 626       // Check if all the uses for function like 'sin' are converted to float.
 627       for (Value::use_iterator UseI = CI->use_begin(); UseI != CI->use_end();
 628           ++UseI) {
 629         FPTruncInst *Cast = dyn_cast<FPTruncInst>(*UseI);
 630         if (Cast == 0 || !Cast->getType()->isFloatTy())
 631           return 0;
 632       }
 633     }
 634
 635     // If this is something like 'floor((double)floatval)', convert to floorf.
 636     FPExtInst *Cast = dyn_cast<FPExtInst>(CI->getArgOperand(0));
 637     if (Cast == 0 || !Cast->getOperand(0)->getType()->isFloatTy())
 638       return 0;
 639
 640     // floor((double)floatval) -> (double)floorf(floatval)
 641     Value *V = Cast->getOperand(0);
 642     V = EmitUnaryFloatFnCall(V, Callee->getName(), B, Callee->getAttributes());
 643     return B.CreateFPExt(V, B.getDoubleTy());
 644   }
 645 };
 646
 647 //===---------------------------------------===//
 648 // 'cos*' Optimizations
 649 struct CosOpt : public LibCallOptimization {
 650   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 651     Value *Ret = NULL;
 652     if (UnsafeFPShrink && Callee->getName() == "cos" &&
 653         TLI->has(LibFunc::cosf)) {
 654       UnaryDoubleFPOpt UnsafeUnaryDoubleFP(true);
 655       Ret = UnsafeUnaryDoubleFP.CallOptimizer(Callee, CI, B);
 656     }
 657
 658     FunctionType *FT = Callee->getFunctionType();
 659     // Just make sure this has 1 argument of FP type, which matches the
 660     // result type.
 661     if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
 662         !FT->getParamType(0)->isFloatingPointTy())
 663       return Ret;
 664
 665     // cos(-x) -> cos(x)
 666     Value *Op1 = CI->getArgOperand(0);
 667     if (BinaryOperator::isFNeg(Op1)) {
 668       BinaryOperator *BinExpr = cast<BinaryOperator>(Op1);
 669       return B.CreateCall(Callee, BinExpr->getOperand(1), "cos");
 670     }
 671     return Ret;
 672   }
 673 };
 674
 675 //===---------------------------------------===//
 676 // 'pow*' Optimizations
 677
 678 struct PowOpt : public LibCallOptimization {
 679   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 680     Value *Ret = NULL;
 681     if (UnsafeFPShrink && Callee->getName() == "pow" &&
 682         TLI->has(LibFunc::powf)) {
 683       UnaryDoubleFPOpt UnsafeUnaryDoubleFP(true);
 684       Ret = UnsafeUnaryDoubleFP.CallOptimizer(Callee, CI, B);
 685     }
 686
 687     FunctionType *FT = Callee->getFunctionType();
 688     // Just make sure this has 2 arguments of the same FP type, which match the
 689     // result type.
 690     if (FT->getNumParams() != 2 || FT->getReturnType() != FT->getParamType(0) ||
 691         FT->getParamType(0) != FT->getParamType(1) ||
 692         !FT->getParamType(0)->isFloatingPointTy())
 693       return Ret;
 694
 695     Value *Op1 = CI->getArgOperand(0), *Op2 = CI->getArgOperand(1);
 696     if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
 697       if (Op1C->isExactlyValue(1.0))  // pow(1.0, x) -> 1.0
 698         return Op1C;
 699       if (Op1C->isExactlyValue(2.0))  // pow(2.0, x) -> exp2(x)
 700         return EmitUnaryFloatFnCall(Op2, "exp2", B, Callee->getAttributes());
 701     }
 702
 703     ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2);
 704     if (Op2C == 0) return Ret;
 705
 706     if (Op2C->getValueAPF().isZero())  // pow(x, 0.0) -> 1.0
 707       return ConstantFP::get(CI->getType(), 1.0);
 708
 709     if (Op2C->isExactlyValue(0.5)) {
 710       // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
 711       // This is faster than calling pow, and still handles negative zero
 712       // and negative infinity correctly.
 713       // TODO: In fast-math mode, this could be just sqrt(x).
 714       // TODO: In finite-only mode, this could be just fabs(sqrt(x)).
 715       Value *Inf = ConstantFP::getInfinity(CI->getType());
 716       Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
 717       Value *Sqrt = EmitUnaryFloatFnCall(Op1, "sqrt", B,
 718                                          Callee->getAttributes());
 719       Value *FAbs = EmitUnaryFloatFnCall(Sqrt, "fabs", B,
 720                                          Callee->getAttributes());
 721       Value *FCmp = B.CreateFCmpOEQ(Op1, NegInf);
 722       Value *Sel = B.CreateSelect(FCmp, Inf, FAbs);
 723       return Sel;
 724     }
 725
 726     if (Op2C->isExactlyValue(1.0))  // pow(x, 1.0) -> x
 727       return Op1;
 728     if (Op2C->isExactlyValue(2.0))  // pow(x, 2.0) -> x*x
 729       return B.CreateFMul(Op1, Op1, "pow2");
 730     if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x
 731       return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0),
 732                           Op1, "powrecip");
 733     return 0;
 734   }
 735 };
 736
 737 //===---------------------------------------===//
 738 // 'exp2' Optimizations
 739
 740 struct Exp2Opt : public LibCallOptimization {
 741   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 742     Value *Ret = NULL;
 743     if (UnsafeFPShrink && Callee->getName() == "exp2" &&
 744         TLI->has(LibFunc::exp2)) {
 745       UnaryDoubleFPOpt UnsafeUnaryDoubleFP(true);
 746       Ret = UnsafeUnaryDoubleFP.CallOptimizer(Callee, CI, B);
 747     }
 748
 749     FunctionType *FT = Callee->getFunctionType();
 750     // Just make sure this has 1 argument of FP type, which matches the
 751     // result type.
 752     if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
 753         !FT->getParamType(0)->isFloatingPointTy())
 754       return Ret;
 755
 756     Value *Op = CI->getArgOperand(0);
 757     // Turn exp2(sitofp(x)) -> ldexp(1.0, sext(x))  if sizeof(x) <= 32
 758     // Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x))  if sizeof(x) < 32
 759     Value *LdExpArg = 0;
 760     if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) {
 761       if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32)
 762         LdExpArg = B.CreateSExt(OpC->getOperand(0), B.getInt32Ty());
 763     } else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) {
 764       if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32)
 765         LdExpArg = B.CreateZExt(OpC->getOperand(0), B.getInt32Ty());
 766     }
 767
 768     if (LdExpArg) {
 769       const char *Name;
 770       if (Op->getType()->isFloatTy())
 771         Name = "ldexpf";
 772       else if (Op->getType()->isDoubleTy())
 773         Name = "ldexp";
 774       else
 775         Name = "ldexpl";
 776
 777       Constant *One = ConstantFP::get(*Context, APFloat(1.0f));
 778       if (!Op->getType()->isFloatTy())
 779         One = ConstantExpr::getFPExtend(One, Op->getType());
 780
 781       Module *M = Caller->getParent();
 782       Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
 783                                              Op->getType(),
 784                                              B.getInt32Ty(), NULL);
 785       CallInst *CI = B.CreateCall2(Callee, One, LdExpArg);
 786       if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
 787         CI->setCallingConv(F->getCallingConv());
 788
 789       return CI;
 790     }
 791     return Ret;
 792   }
 793 };
 794
 795 //===----------------------------------------------------------------------===//
 796 // Integer Optimizations
 797 //===----------------------------------------------------------------------===//
 798
 799 //===---------------------------------------===//
 800 // 'ffs*' Optimizations
 801
 802 struct FFSOpt : public LibCallOptimization {
 803   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 804     FunctionType *FT = Callee->getFunctionType();
 805     // Just make sure this has 2 arguments of the same FP type, which match the
 806     // result type.
 807     if (FT->getNumParams() != 1 ||
 808         !FT->getReturnType()->isIntegerTy(32) ||
 809         !FT->getParamType(0)->isIntegerTy())
 810       return 0;
 811
 812     Value *Op = CI->getArgOperand(0);
 813
 814     // Constant fold.
 815     if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
 816       if (CI->getValue() == 0)  // ffs(0) -> 0.
 817         return Constant::getNullValue(CI->getType());
 818       // ffs(c) -> cttz(c)+1
 819       return B.getInt32(CI->getValue().countTrailingZeros() + 1);
 820     }
 821
 822     // ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
 823     Type *ArgType = Op->getType();
 824     Value *F = Intrinsic::getDeclaration(Callee->getParent(),
 825                                          Intrinsic::cttz, ArgType);
 826     Value *V = B.CreateCall2(F, Op, B.getFalse(), "cttz");
 827     V = B.CreateAdd(V, ConstantInt::get(V->getType(), 1));
 828     V = B.CreateIntCast(V, B.getInt32Ty(), false);
 829
 830     Value *Cond = B.CreateICmpNE(Op, Constant::getNullValue(ArgType));
 831     return B.CreateSelect(Cond, V, B.getInt32(0));
 832   }
 833 };
 834
 835 //===---------------------------------------===//
 836 // 'isdigit' Optimizations
 837
 838 struct IsDigitOpt : public LibCallOptimization {
 839   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 840     FunctionType *FT = Callee->getFunctionType();
 841     // We require integer(i32)
 842     if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
 843         !FT->getParamType(0)->isIntegerTy(32))
 844       return 0;
 845
 846     // isdigit(c) -> (c-'0') <u 10
 847     Value *Op = CI->getArgOperand(0);
 848     Op = B.CreateSub(Op, B.getInt32('0'), "isdigittmp");
 849     Op = B.CreateICmpULT(Op, B.getInt32(10), "isdigit");
 850     return B.CreateZExt(Op, CI->getType());
 851   }
 852 };
 853
 854 //===---------------------------------------===//
 855 // 'isascii' Optimizations
 856
 857 struct IsAsciiOpt : public LibCallOptimization {
 858   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 859     FunctionType *FT = Callee->getFunctionType();
 860     // We require integer(i32)
 861     if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
 862         !FT->getParamType(0)->isIntegerTy(32))
 863       return 0;
 864
 865     // isascii(c) -> c <u 128
 866     Value *Op = CI->getArgOperand(0);
 867     Op = B.CreateICmpULT(Op, B.getInt32(128), "isascii");
 868     return B.CreateZExt(Op, CI->getType());
 869   }
 870 };
 871
 872 //===---------------------------------------===//
 873 // 'abs', 'labs', 'llabs' Optimizations
 874
 875 struct AbsOpt : public LibCallOptimization {
 876   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 877     FunctionType *FT = Callee->getFunctionType();
 878     // We require integer(integer) where the types agree.
 879     if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
 880         FT->getParamType(0) != FT->getReturnType())
 881       return 0;
 882
 883     // abs(x) -> x >s -1 ? x : -x
 884     Value *Op = CI->getArgOperand(0);
 885     Value *Pos = B.CreateICmpSGT(Op, Constant::getAllOnesValue(Op->getType()),
 886                                  "ispos");
 887     Value *Neg = B.CreateNeg(Op, "neg");
 888     return B.CreateSelect(Pos, Op, Neg);
 889   }
 890 };
 891
 892
 893 //===---------------------------------------===//
 894 // 'toascii' Optimizations
 895
 896 struct ToAsciiOpt : public LibCallOptimization {
 897   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 898     FunctionType *FT = Callee->getFunctionType();
 899     // We require i32(i32)
 900     if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
 901         !FT->getParamType(0)->isIntegerTy(32))
 902       return 0;
 903
 904     // isascii(c) -> c & 0x7f
 905     return B.CreateAnd(CI->getArgOperand(0),
 906                        ConstantInt::get(CI->getType(),0x7F));
 907   }
 908 };
 909
 910 //===----------------------------------------------------------------------===//
 911 // Formatting and IO Optimizations
 912 //===----------------------------------------------------------------------===//
 913
 914 //===---------------------------------------===//
 915 // 'printf' Optimizations
 916
 917 struct PrintFOpt : public LibCallOptimization {
 918   Value *OptimizeFixedFormatString(Function *Callee, CallInst *CI,
 919                                    IRBuilder<> &B) {
 920     // Check for a fixed format string.
 921     StringRef FormatStr;
 922     if (!getConstantStringInfo(CI->getArgOperand(0), FormatStr))
 923       return 0;
 924
 925     // Empty format string -> noop.
 926     if (FormatStr.empty())  // Tolerate printf's declared void.
 927       return CI->use_empty() ? (Value*)CI :
 928                                ConstantInt::get(CI->getType(), 0);
 929
 930     // Do not do any of the following transformations if the printf return value
 931     // is used, in general the printf return value is not compatible with either
 932     // putchar() or puts().
 933     if (!CI->use_empty())
 934       return 0;
 935
 936     // printf("x") -> putchar('x'), even for '%'.
 937     if (FormatStr.size() == 1) {
 938       Value *Res = EmitPutChar(B.getInt32(FormatStr[0]), B, TD, TLI);
 939       if (CI->use_empty() || !Res) return Res;
 940       return B.CreateIntCast(Res, CI->getType(), true);
 941     }
 942
 943     // printf("foo\n") --> puts("foo")
 944     if (FormatStr[FormatStr.size()-1] == '\n' &&
 945         FormatStr.find('%') == std::string::npos) {  // no format characters.
 946       // Create a string literal with no \n on it.  We expect the constant merge
 947       // pass to be run after this pass, to merge duplicate strings.
 948       FormatStr = FormatStr.drop_back();
 949       Value *GV = B.CreateGlobalString(FormatStr, "str");
 950       Value *NewCI = EmitPutS(GV, B, TD, TLI);
 951       return (CI->use_empty() || !NewCI) ?
 952               NewCI :
 953               ConstantInt::get(CI->getType(), FormatStr.size()+1);
 954     }
 955
 956     // Optimize specific format strings.
 957     // printf("%c", chr) --> putchar(chr)
 958     if (FormatStr == "%c" && CI->getNumArgOperands() > 1 &&
 959         CI->getArgOperand(1)->getType()->isIntegerTy()) {
 960       Value *Res = EmitPutChar(CI->getArgOperand(1), B, TD, TLI);
 961
 962       if (CI->use_empty() || !Res) return Res;
 963       return B.CreateIntCast(Res, CI->getType(), true);
 964     }
 965
 966     // printf("%s\n", str) --> puts(str)
 967     if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 &&
 968         CI->getArgOperand(1)->getType()->isPointerTy()) {
 969       return EmitPutS(CI->getArgOperand(1), B, TD, TLI);
 970     }
 971     return 0;
 972   }
 973
 974   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
 975     // Require one fixed pointer argument and an integer/void result.
 976     FunctionType *FT = Callee->getFunctionType();
 977     if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
 978         !(FT->getReturnType()->isIntegerTy() ||
 979           FT->getReturnType()->isVoidTy()))
 980       return 0;
 981
 982     if (Value *V = OptimizeFixedFormatString(Callee, CI, B)) {
 983       return V;
 984     }
 985
 986     // printf(format, ...) -> iprintf(format, ...) if no floating point
 987     // arguments.
 988     if (TLI->has(LibFunc::iprintf) && !CallHasFloatingPointArgument(CI)) {
 989       Module *M = B.GetInsertBlock()->getParent()->getParent();
 990       Constant *IPrintFFn =
 991         M->getOrInsertFunction("iprintf", FT, Callee->getAttributes());
 992       CallInst *New = cast<CallInst>(CI->clone());
 993       New->setCalledFunction(IPrintFFn);
 994       B.Insert(New);
 995       return New;
 996     }
 997     return 0;
 998   }
 999 };
1000
1001 //===---------------------------------------===//
1002 // 'sprintf' Optimizations
1003
1004 struct SPrintFOpt : public LibCallOptimization {
1005   Value *OptimizeFixedFormatString(Function *Callee, CallInst *CI,
1006                                    IRBuilder<> &B) {
1007     // Check for a fixed format string.
1008     StringRef FormatStr;
1009     if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
1010       return 0;
1011
1012     // If we just have a format string (nothing else crazy) transform it.
1013     if (CI->getNumArgOperands() == 2) {
1014       // Make sure there's no % in the constant array.  We could try to handle
1015       // %% -> % in the future if we cared.
1016       for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
1017         if (FormatStr[i] == '%')
1018           return 0; // we found a format specifier, bail out.
1019
1020       // These optimizations require DataLayout.
1021       if (!TD) return 0;
1022
1023       // sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
1024       B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
1025                      ConstantInt::get(TD->getIntPtrType(*Context), // Copy the
1026                                       FormatStr.size() + 1), 1);   // nul byte.
1027       return ConstantInt::get(CI->getType(), FormatStr.size());
1028     }
1029
1030     // The remaining optimizations require the format string to be "%s" or "%c"
1031     // and have an extra operand.
1032     if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
1033         CI->getNumArgOperands() < 3)
1034       return 0;
1035
1036     // Decode the second character of the format string.
1037     if (FormatStr[1] == 'c') {
1038       // sprintf(dst, "%c", chr) --> *(i8*)dst = chr; *((i8*)dst+1) = 0
1039       if (!CI->getArgOperand(2)->getType()->isIntegerTy()) return 0;
1040       Value *V = B.CreateTrunc(CI->getArgOperand(2), B.getInt8Ty(), "char");
1041       Value *Ptr = CastToCStr(CI->getArgOperand(0), B);
1042       B.CreateStore(V, Ptr);
1043       Ptr = B.CreateGEP(Ptr, B.getInt32(1), "nul");
1044       B.CreateStore(B.getInt8(0), Ptr);
1045
1046       return ConstantInt::get(CI->getType(), 1);
1047     }
1048
1049     if (FormatStr[1] == 's') {
1050       // These optimizations require DataLayout.
1051       if (!TD) return 0;
1052
1053       // sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
1054       if (!CI->getArgOperand(2)->getType()->isPointerTy()) return 0;
1055
1056       Value *Len = EmitStrLen(CI->getArgOperand(2), B, TD, TLI);
1057       if (!Len)
1058         return 0;
1059       Value *IncLen = B.CreateAdd(Len,
1060                                   ConstantInt::get(Len->getType(), 1),
1061                                   "leninc");
1062       B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(2), IncLen, 1);
1063
1064       // The sprintf result is the unincremented number of bytes in the string.
1065       return B.CreateIntCast(Len, CI->getType(), false);
1066     }
1067     return 0;
1068   }
1069
1070   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
1071     // Require two fixed pointer arguments and an integer result.
1072     FunctionType *FT = Callee->getFunctionType();
1073     if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
1074         !FT->getParamType(1)->isPointerTy() ||
1075         !FT->getReturnType()->isIntegerTy())
1076       return 0;
1077
1078     if (Value *V = OptimizeFixedFormatString(Callee, CI, B)) {
1079       return V;
1080     }
1081
1082     // sprintf(str, format, ...) -> siprintf(str, format, ...) if no floating
1083     // point arguments.
1084     if (TLI->has(LibFunc::siprintf) && !CallHasFloatingPointArgument(CI)) {
1085       Module *M = B.GetInsertBlock()->getParent()->getParent();
1086       Constant *SIPrintFFn =
1087         M->getOrInsertFunction("siprintf", FT, Callee->getAttributes());
1088       CallInst *New = cast<CallInst>(CI->clone());
1089       New->setCalledFunction(SIPrintFFn);
1090       B.Insert(New);
1091       return New;
1092     }
1093     return 0;
1094   }
1095 };
1096
1097 //===---------------------------------------===//
1098 // 'fwrite' Optimizations
1099
1100 struct FWriteOpt : public LibCallOptimization {
1101   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
1102     // Require a pointer, an integer, an integer, a pointer, returning integer.
1103     FunctionType *FT = Callee->getFunctionType();
1104     if (FT->getNumParams() != 4 || !FT->getParamType(0)->isPointerTy() ||
1105         !FT->getParamType(1)->isIntegerTy() ||
1106         !FT->getParamType(2)->isIntegerTy() ||
1107         !FT->getParamType(3)->isPointerTy() ||
1108         !FT->getReturnType()->isIntegerTy())
1109       return 0;
1110
1111     // Get the element size and count.
1112     ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
1113     ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
1114     if (!SizeC || !CountC) return 0;
1115     uint64_t Bytes = SizeC->getZExtValue()*CountC->getZExtValue();
1116
1117     // If this is writing zero records, remove the call (it's a noop).
1118     if (Bytes == 0)
1119       return ConstantInt::get(CI->getType(), 0);
1120
1121     // If this is writing one byte, turn it into fputc.
1122     // This optimisation is only valid, if the return value is unused.
1123     if (Bytes == 1 && CI->use_empty()) {  // fwrite(S,1,1,F) -> fputc(S[0],F)
1124       Value *Char = B.CreateLoad(CastToCStr(CI->getArgOperand(0), B), "char");
1125       Value *NewCI = EmitFPutC(Char, CI->getArgOperand(3), B, TD, TLI);
1126       return NewCI ? ConstantInt::get(CI->getType(), 1) : 0;
1127     }
1128
1129     return 0;
1130   }
1131 };
1132
1133 //===---------------------------------------===//
1134 // 'fputs' Optimizations
1135
1136 struct FPutsOpt : public LibCallOptimization {
1137   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
1138     // These optimizations require DataLayout.
1139     if (!TD) return 0;
1140
1141     // Require two pointers.  Also, we can't optimize if return value is used.
1142     FunctionType *FT = Callee->getFunctionType();
1143     if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
1144         !FT->getParamType(1)->isPointerTy() ||
1145         !CI->use_empty())
1146       return 0;
1147
1148     // fputs(s,F) --> fwrite(s,1,strlen(s),F)
1149     uint64_t Len = GetStringLength(CI->getArgOperand(0));
1150     if (!Len) return 0;
1151     // Known to have no uses (see above).
1152     return EmitFWrite(CI->getArgOperand(0),
1153                       ConstantInt::get(TD->getIntPtrType(*Context), Len-1),
1154                       CI->getArgOperand(1), B, TD, TLI);
1155   }
1156 };
1157
1158 //===---------------------------------------===//
1159 // 'fprintf' Optimizations
1160
1161 struct FPrintFOpt : public LibCallOptimization {
1162   Value *OptimizeFixedFormatString(Function *Callee, CallInst *CI,
1163                                    IRBuilder<> &B) {
1164     // All the optimizations depend on the format string.
1165     StringRef FormatStr;
1166     if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
1167       return 0;
1168
1169     // fprintf(F, "foo") --> fwrite("foo", 3, 1, F)
1170     if (CI->getNumArgOperands() == 2) {
1171       for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
1172         if (FormatStr[i] == '%')  // Could handle %% -> % if we cared.
1173           return 0; // We found a format specifier.
1174
1175       // These optimizations require DataLayout.
1176       if (!TD) return 0;
1177
1178       Value *NewCI = EmitFWrite(CI->getArgOperand(1),
1179                                 ConstantInt::get(TD->getIntPtrType(*Context),
1180                                                  FormatStr.size()),
1181                                 CI->getArgOperand(0), B, TD, TLI);
1182       return NewCI ? ConstantInt::get(CI->getType(), FormatStr.size()) : 0;
1183     }
1184
1185     // The remaining optimizations require the format string to be "%s" or "%c"
1186     // and have an extra operand.
1187     if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
1188         CI->getNumArgOperands() < 3)
1189       return 0;
1190
1191     // Decode the second character of the format string.
1192     if (FormatStr[1] == 'c') {
1193       // fprintf(F, "%c", chr) --> fputc(chr, F)
1194       if (!CI->getArgOperand(2)->getType()->isIntegerTy()) return 0;
1195       Value *NewCI = EmitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B,
1196                                TD, TLI);
1197       return NewCI ? ConstantInt::get(CI->getType(), 1) : 0;
1198     }
1199
1200     if (FormatStr[1] == 's') {
1201       // fprintf(F, "%s", str) --> fputs(str, F)
1202       if (!CI->getArgOperand(2)->getType()->isPointerTy() || !CI->use_empty())
1203         return 0;
1204       return EmitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, TD, TLI);
1205     }
1206     return 0;
1207   }
1208
1209   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
1210     // Require two fixed paramters as pointers and integer result.
1211     FunctionType *FT = Callee->getFunctionType();
1212     if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
1213         !FT->getParamType(1)->isPointerTy() ||
1214         !FT->getReturnType()->isIntegerTy())
1215       return 0;
1216
1217     if (Value *V = OptimizeFixedFormatString(Callee, CI, B)) {
1218       return V;
1219     }
1220
1221     // fprintf(stream, format, ...) -> fiprintf(stream, format, ...) if no
1222     // floating point arguments.
1223     if (TLI->has(LibFunc::fiprintf) && !CallHasFloatingPointArgument(CI)) {
1224       Module *M = B.GetInsertBlock()->getParent()->getParent();
1225       Constant *FIPrintFFn =
1226         M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes());
1227       CallInst *New = cast<CallInst>(CI->clone());
1228       New->setCalledFunction(FIPrintFFn);
1229       B.Insert(New);
1230       return New;
1231     }
1232     return 0;
1233   }
1234 };
1235
1236 //===---------------------------------------===//
1237 // 'puts' Optimizations
1238
1239 struct PutsOpt : public LibCallOptimization {
1240   virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
1241     // Require one fixed pointer argument and an integer/void result.
1242     FunctionType *FT = Callee->getFunctionType();
1243     if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
1244         !(FT->getReturnType()->isIntegerTy() ||
1245           FT->getReturnType()->isVoidTy()))
1246       return 0;
1247
1248     // Check for a constant string.
1249     StringRef Str;
1250     if (!getConstantStringInfo(CI->getArgOperand(0), Str))
1251       return 0;
1252
1253     if (Str.empty() && CI->use_empty()) {
1254       // puts("") -> putchar('\n')
1255       Value *Res = EmitPutChar(B.getInt32('\n'), B, TD, TLI);
1256       if (CI->use_empty() || !Res) return Res;
1257       return B.CreateIntCast(Res, CI->getType(), true);
1258     }
1259
1260     return 0;
1261   }
1262 };
1263
1264 } // end anonymous namespace.
1265
1266 //===----------------------------------------------------------------------===//
1267 // SimplifyLibCalls Pass Implementation
1268 //===----------------------------------------------------------------------===//
1269
1270 namespace {
1271   /// This pass optimizes well known library functions from libc and libm.
1272   ///
1273   class SimplifyLibCalls : public FunctionPass {
1274     TargetLibraryInfo *TLI;
1275
1276     StringMap<LibCallOptimization*> Optimizations;
1277     // String and Memory LibCall Optimizations
1278     StrCpyOpt StrCpy; StrCpyOpt StrCpyChk;
1279     StpCpyOpt StpCpy; StpCpyOpt StpCpyChk;
1280     StrNCpyOpt StrNCpy;
1281     StrLenOpt StrLen; StrPBrkOpt StrPBrk;
1282     StrToOpt StrTo; StrSpnOpt StrSpn; StrCSpnOpt StrCSpn; StrStrOpt StrStr;
1283     MemCmpOpt MemCmp; MemCpyOpt MemCpy; MemMoveOpt MemMove; MemSetOpt MemSet;
1284     // Math Library Optimizations
1285     CosOpt Cos; PowOpt Pow; Exp2Opt Exp2;
1286     UnaryDoubleFPOpt UnaryDoubleFP, UnsafeUnaryDoubleFP;
1287     // Integer Optimizations
1288     FFSOpt FFS; AbsOpt Abs; IsDigitOpt IsDigit; IsAsciiOpt IsAscii;
1289     ToAsciiOpt ToAscii;
1290     // Formatting and IO Optimizations
1291     SPrintFOpt SPrintF; PrintFOpt PrintF;
1292     FWriteOpt FWrite; FPutsOpt FPuts; FPrintFOpt FPrintF;
1293     PutsOpt Puts;
1294
1295     bool Modified;  // This is only used by doInitialization.
1296   public:
1297     static char ID; // Pass identification
1298     SimplifyLibCalls() : FunctionPass(ID), StrCpy(false), StrCpyChk(true),
1299                          StpCpy(false), StpCpyChk(true),
1300                          UnaryDoubleFP(false), UnsafeUnaryDoubleFP(true) {
1301       initializeSimplifyLibCallsPass(*PassRegistry::getPassRegistry());
1302     }
1303     void AddOpt(LibFunc::Func F, LibCallOptimization* Opt);
1304     void AddOpt(LibFunc::Func F1, LibFunc::Func F2, LibCallOptimization* Opt);
1305
1306     void InitOptimizations();
1307     bool runOnFunction(Function &F);
1308
1309     void setDoesNotAccessMemory(Function &F);
1310     void setOnlyReadsMemory(Function &F);
1311     void setDoesNotThrow(Function &F);
1312     void setDoesNotCapture(Function &F, unsigned n);
1313     void setDoesNotAlias(Function &F, unsigned n);
1314     bool doInitialization(Module &M);
1315
1316     void inferPrototypeAttributes(Function &F);
1317     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
1318       AU.addRequired<TargetLibraryInfo>();
1319     }
1320   };
1321 } // end anonymous namespace.
1322
1323 char SimplifyLibCalls::ID = 0;
1324
1325 INITIALIZE_PASS_BEGIN(SimplifyLibCalls, "simplify-libcalls",
1326                       "Simplify well-known library calls", false, false)
1327 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
1328 INITIALIZE_PASS_END(SimplifyLibCalls, "simplify-libcalls",
1329                     "Simplify well-known library calls", false, false)
1330
1331 // Public interface to the Simplify LibCalls pass.
1332 FunctionPass *llvm::createSimplifyLibCallsPass() {
1333   return new SimplifyLibCalls();
1334 }
1335
1336 void SimplifyLibCalls::AddOpt(LibFunc::Func F, LibCallOptimization* Opt) {
1337   if (TLI->has(F))
1338     Optimizations[TLI->getName(F)] = Opt;
1339 }
1340
1341 void SimplifyLibCalls::AddOpt(LibFunc::Func F1, LibFunc::Func F2,
1342                               LibCallOptimization* Opt) {
1343   if (TLI->has(F1) && TLI->has(F2))
1344     Optimizations[TLI->getName(F1)] = Opt;
1345 }
1346
1347 /// Optimizations - Populate the Optimizations map with all the optimizations
1348 /// we know.
1349 void SimplifyLibCalls::InitOptimizations() {
1350   // String and Memory LibCall Optimizations
1351   Optimizations["strcpy"] = &StrCpy;
1352   Optimizations["strncpy"] = &StrNCpy;
1353   Optimizations["stpcpy"] = &StpCpy;
1354   Optimizations["strlen"] = &StrLen;
1355   Optimizations["strpbrk"] = &StrPBrk;
1356   Optimizations["strtol"] = &StrTo;
1357   Optimizations["strtod"] = &StrTo;
1358   Optimizations["strtof"] = &StrTo;
1359   Optimizations["strtoul"] = &StrTo;
1360   Optimizations["strtoll"] = &StrTo;
1361   Optimizations["strtold"] = &StrTo;
1362   Optimizations["strtoull"] = &StrTo;
1363   Optimizations["strspn"] = &StrSpn;
1364   Optimizations["strcspn"] = &StrCSpn;
1365   Optimizations["strstr"] = &StrStr;
1366   Optimizations["memcmp"] = &MemCmp;
1367   AddOpt(LibFunc::memcpy, &MemCpy);
1368   Optimizations["memmove"] = &MemMove;
1369   AddOpt(LibFunc::memset, &MemSet);
1370
1371   // _chk variants of String and Memory LibCall Optimizations.
1372   Optimizations["__strcpy_chk"] = &StrCpyChk;
1373   Optimizations["__stpcpy_chk"] = &StpCpyChk;
1374
1375   // Math Library Optimizations
1376   Optimizations["cosf"] = &Cos;
1377   Optimizations["cos"] = &Cos;
1378   Optimizations["cosl"] = &Cos;
1379   Optimizations["powf"] = &Pow;
1380   Optimizations["pow"] = &Pow;
1381   Optimizations["powl"] = &Pow;
1382   Optimizations["llvm.pow.f32"] = &Pow;
1383   Optimizations["llvm.pow.f64"] = &Pow;
1384   Optimizations["llvm.pow.f80"] = &Pow;
1385   Optimizations["llvm.pow.f128"] = &Pow;
1386   Optimizations["llvm.pow.ppcf128"] = &Pow;
1387   Optimizations["exp2l"] = &Exp2;
1388   Optimizations["exp2"] = &Exp2;
1389   Optimizations["exp2f"] = &Exp2;
1390   Optimizations["llvm.exp2.ppcf128"] = &Exp2;
1391   Optimizations["llvm.exp2.f128"] = &Exp2;
1392   Optimizations["llvm.exp2.f80"] = &Exp2;
1393   Optimizations["llvm.exp2.f64"] = &Exp2;
1394   Optimizations["llvm.exp2.f32"] = &Exp2;
1395
1396   AddOpt(LibFunc::ceil, LibFunc::ceilf, &UnaryDoubleFP);
1397   AddOpt(LibFunc::fabs, LibFunc::fabsf, &UnaryDoubleFP);
1398   AddOpt(LibFunc::floor, LibFunc::floorf, &UnaryDoubleFP);
1399   AddOpt(LibFunc::rint, LibFunc::rintf, &UnaryDoubleFP);
1400   AddOpt(LibFunc::round, LibFunc::roundf, &UnaryDoubleFP);
1401   AddOpt(LibFunc::nearbyint, LibFunc::nearbyintf, &UnaryDoubleFP);
1402   AddOpt(LibFunc::trunc, LibFunc::truncf, &UnaryDoubleFP);
1403
1404   if(UnsafeFPShrink) {
1405     AddOpt(LibFunc::acos, LibFunc::acosf, &UnsafeUnaryDoubleFP);
1406     AddOpt(LibFunc::acosh, LibFunc::acoshf, &UnsafeUnaryDoubleFP);
1407     AddOpt(LibFunc::asin, LibFunc::asinf, &UnsafeUnaryDoubleFP);
1408     AddOpt(LibFunc::asinh, LibFunc::asinhf, &UnsafeUnaryDoubleFP);
1409     AddOpt(LibFunc::atan, LibFunc::atanf, &UnsafeUnaryDoubleFP);
1410     AddOpt(LibFunc::atanh, LibFunc::atanhf, &UnsafeUnaryDoubleFP);
1411     AddOpt(LibFunc::cbrt, LibFunc::cbrtf, &UnsafeUnaryDoubleFP);
1412     AddOpt(LibFunc::cosh, LibFunc::coshf, &UnsafeUnaryDoubleFP);
1413     AddOpt(LibFunc::exp, LibFunc::expf, &UnsafeUnaryDoubleFP);
1414     AddOpt(LibFunc::exp10, LibFunc::exp10f, &UnsafeUnaryDoubleFP);
1415     AddOpt(LibFunc::expm1, LibFunc::expm1f, &UnsafeUnaryDoubleFP);
1416     AddOpt(LibFunc::log, LibFunc::logf, &UnsafeUnaryDoubleFP);
1417     AddOpt(LibFunc::log10, LibFunc::log10f, &UnsafeUnaryDoubleFP);
1418     AddOpt(LibFunc::log1p, LibFunc::log1pf, &UnsafeUnaryDoubleFP);
1419     AddOpt(LibFunc::log2, LibFunc::log2f, &UnsafeUnaryDoubleFP);
1420     AddOpt(LibFunc::logb, LibFunc::logbf, &UnsafeUnaryDoubleFP);
1421     AddOpt(LibFunc::sin, LibFunc::sinf, &UnsafeUnaryDoubleFP);
1422     AddOpt(LibFunc::sinh, LibFunc::sinhf, &UnsafeUnaryDoubleFP);
1423     AddOpt(LibFunc::sqrt, LibFunc::sqrtf, &UnsafeUnaryDoubleFP);
1424     AddOpt(LibFunc::tan, LibFunc::tanf, &UnsafeUnaryDoubleFP);
1425     AddOpt(LibFunc::tanh, LibFunc::tanhf, &UnsafeUnaryDoubleFP);
1426   }
1427
1428   // Integer Optimizations
1429   Optimizations["ffs"] = &FFS;
1430   Optimizations["ffsl"] = &FFS;
1431   Optimizations["ffsll"] = &FFS;
1432   Optimizations["abs"] = &Abs;
1433   Optimizations["labs"] = &Abs;
1434   Optimizations["llabs"] = &Abs;
1435   Optimizations["isdigit"] = &IsDigit;
1436   Optimizations["isascii"] = &IsAscii;
1437   Optimizations["toascii"] = &ToAscii;
1438
1439   // Formatting and IO Optimizations
1440   Optimizations["sprintf"] = &SPrintF;
1441   Optimizations["printf"] = &PrintF;
1442   AddOpt(LibFunc::fwrite, &FWrite);
1443   AddOpt(LibFunc::fputs, &FPuts);
1444   Optimizations["fprintf"] = &FPrintF;
1445   Optimizations["puts"] = &Puts;
1446 }
1447
1448
1449 /// runOnFunction - Top level algorithm.
1450 ///
1451 bool SimplifyLibCalls::runOnFunction(Function &F) {
1452   TLI = &getAnalysis<TargetLibraryInfo>();
1453
1454   if (Optimizations.empty())
1455     InitOptimizations();
1456
1457   const DataLayout *TD = getAnalysisIfAvailable<DataLayout>();
1458
1459   IRBuilder<> Builder(F.getContext());
1460
1461   bool Changed = false;
1462   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
1463     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
1464       // Ignore non-calls.
1465       CallInst *CI = dyn_cast<CallInst>(I++);
1466       if (!CI) continue;
1467
1468       // Ignore indirect calls and calls to non-external functions.
1469       Function *Callee = CI->getCalledFunction();
1470       if (Callee == 0 || !Callee->isDeclaration() ||
1471           !(Callee->hasExternalLinkage() || Callee->hasDLLImportLinkage()))
1472         continue;
1473
1474       // Ignore unknown calls.
1475       LibCallOptimization *LCO = Optimizations.lookup(Callee->getName());
1476       if (!LCO) continue;
1477
1478       // Set the builder to the instruction after the call.
1479       Builder.SetInsertPoint(BB, I);
1480
1481       // Use debug location of CI for all new instructions.
1482       Builder.SetCurrentDebugLocation(CI->getDebugLoc());
1483
1484       // Try to optimize this call.
1485       Value *Result = LCO->OptimizeCall(CI, TD, TLI, Builder);
1486       if (Result == 0) continue;
1487
1488       DEBUG(dbgs() << "SimplifyLibCalls simplified: " << *CI;
1489             dbgs() << "  into: " << *Result << "\n");
1490
1491       // Something changed!
1492       Changed = true;
1493       ++NumSimplified;
1494
1495       // Inspect the instruction after the call (which was potentially just
1496       // added) next.
1497       I = CI; ++I;
1498
1499       if (CI != Result && !CI->use_empty()) {
1500         CI->replaceAllUsesWith(Result);
1501         if (!Result->hasName())
1502           Result->takeName(CI);
1503       }
1504       CI->eraseFromParent();
1505     }
1506   }
1507   return Changed;
1508 }
1509
1510 // Utility methods for doInitialization.
1511
1512 void SimplifyLibCalls::setDoesNotAccessMemory(Function &F) {
1513   if (!F.doesNotAccessMemory()) {
1514     F.setDoesNotAccessMemory();
1515     ++NumAnnotated;
1516     Modified = true;
1517   }
1518 }
1519 void SimplifyLibCalls::setOnlyReadsMemory(Function &F) {
1520   if (!F.onlyReadsMemory()) {
1521     F.setOnlyReadsMemory();
1522     ++NumAnnotated;
1523     Modified = true;
1524   }
1525 }
1526 void SimplifyLibCalls::setDoesNotThrow(Function &F) {
1527   if (!F.doesNotThrow()) {
1528     F.setDoesNotThrow();
1529     ++NumAnnotated;
1530     Modified = true;
1531   }
1532 }
1533 void SimplifyLibCalls::setDoesNotCapture(Function &F, unsigned n) {
1534   if (!F.doesNotCapture(n)) {
1535     F.setDoesNotCapture(n);
1536     ++NumAnnotated;
1537     Modified = true;
1538   }
1539 }
1540 void SimplifyLibCalls::setDoesNotAlias(Function &F, unsigned n) {
1541   if (!F.doesNotAlias(n)) {
1542     F.setDoesNotAlias(n);
1543     ++NumAnnotated;
1544     Modified = true;
1545   }
1546 }
1547
1548
1549 void SimplifyLibCalls::inferPrototypeAttributes(Function &F) {
1550   FunctionType *FTy = F.getFunctionType();
1551
1552   StringRef Name = F.getName();
1553   switch (Name[0]) {
1554   case 's':
1555     if (Name == "strlen") {
1556       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1557         return;
1558       setOnlyReadsMemory(F);
1559       setDoesNotThrow(F);
1560       setDoesNotCapture(F, 1);
1561     } else if (Name == "strchr" ||
1562                Name == "strrchr") {
1563       if (FTy->getNumParams() != 2 ||
1564           !FTy->getParamType(0)->isPointerTy() ||
1565           !FTy->getParamType(1)->isIntegerTy())
1566         return;
1567       setOnlyReadsMemory(F);
1568       setDoesNotThrow(F);
1569     } else if (Name == "strcpy" ||
1570                Name == "stpcpy" ||
1571                Name == "strcat" ||
1572                Name == "strtol" ||
1573                Name == "strtod" ||
1574                Name == "strtof" ||
1575                Name == "strtoul" ||
1576                Name == "strtoll" ||
1577                Name == "strtold" ||
1578                Name == "strncat" ||
1579                Name == "strncpy" ||
1580                Name == "stpncpy" ||
1581                Name == "strtoull") {
1582       if (FTy->getNumParams() < 2 ||
1583           !FTy->getParamType(1)->isPointerTy())
1584         return;
1585       setDoesNotThrow(F);
1586       setDoesNotCapture(F, 2);
1587     } else if (Name == "strxfrm") {
1588       if (FTy->getNumParams() != 3 ||
1589           !FTy->getParamType(0)->isPointerTy() ||
1590           !FTy->getParamType(1)->isPointerTy())
1591         return;
1592       setDoesNotThrow(F);
1593       setDoesNotCapture(F, 1);
1594       setDoesNotCapture(F, 2);
1595     } else if (Name == "strcmp" ||
1596                Name == "strspn" ||
1597                Name == "strncmp" ||
1598                Name == "strcspn" ||
1599                Name == "strcoll" ||
1600                Name == "strcasecmp" ||
1601                Name == "strncasecmp") {
1602       if (FTy->getNumParams() < 2 ||
1603           !FTy->getParamType(0)->isPointerTy() ||
1604           !FTy->getParamType(1)->isPointerTy())
1605         return;
1606       setOnlyReadsMemory(F);
1607       setDoesNotThrow(F);
1608       setDoesNotCapture(F, 1);
1609       setDoesNotCapture(F, 2);
1610     } else if (Name == "strstr" ||
1611                Name == "strpbrk") {
1612       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1613         return;
1614       setOnlyReadsMemory(F);
1615       setDoesNotThrow(F);
1616       setDoesNotCapture(F, 2);
1617     } else if (Name == "strtok" ||
1618                Name == "strtok_r") {
1619       if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1620         return;
1621       setDoesNotThrow(F);
1622       setDoesNotCapture(F, 2);
1623     } else if (Name == "scanf" ||
1624                Name == "setbuf" ||
1625                Name == "setvbuf") {
1626       if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1627         return;
1628       setDoesNotThrow(F);
1629       setDoesNotCapture(F, 1);
1630     } else if (Name == "strdup" ||
1631                Name == "strndup") {
1632       if (FTy->getNumParams() < 1 || !FTy->getReturnType()->isPointerTy() ||
1633           !FTy->getParamType(0)->isPointerTy())
1634         return;
1635       setDoesNotThrow(F);
1636       setDoesNotAlias(F, 0);
1637       setDoesNotCapture(F, 1);
1638     } else if (Name == "stat" ||
1639                Name == "sscanf" ||
1640                Name == "sprintf" ||
1641                Name == "statvfs") {
1642       if (FTy->getNumParams() < 2 ||
1643           !FTy->getParamType(0)->isPointerTy() ||
1644           !FTy->getParamType(1)->isPointerTy())
1645         return;
1646       setDoesNotThrow(F);
1647       setDoesNotCapture(F, 1);
1648       setDoesNotCapture(F, 2);
1649     } else if (Name == "snprintf") {
1650       if (FTy->getNumParams() != 3 ||
1651           !FTy->getParamType(0)->isPointerTy() ||
1652           !FTy->getParamType(2)->isPointerTy())
1653         return;
1654       setDoesNotThrow(F);
1655       setDoesNotCapture(F, 1);
1656       setDoesNotCapture(F, 3);
1657     } else if (Name == "setitimer") {
1658       if (FTy->getNumParams() != 3 ||
1659           !FTy->getParamType(1)->isPointerTy() ||
1660           !FTy->getParamType(2)->isPointerTy())
1661         return;
1662       setDoesNotThrow(F);
1663       setDoesNotCapture(F, 2);
1664       setDoesNotCapture(F, 3);
1665     } else if (Name == "system") {
1666       if (FTy->getNumParams() != 1 ||
1667           !FTy->getParamType(0)->isPointerTy())
1668         return;
1669       // May throw; "system" is a valid pthread cancellation point.
1670       setDoesNotCapture(F, 1);
1671     }
1672     break;
1673   case 'm':
1674     if (Name == "malloc") {
1675       if (FTy->getNumParams() != 1 ||
1676           !FTy->getReturnType()->isPointerTy())
1677         return;
1678       setDoesNotThrow(F);
1679       setDoesNotAlias(F, 0);
1680     } else if (Name == "memcmp") {
1681       if (FTy->getNumParams() != 3 ||
1682           !FTy->getParamType(0)->isPointerTy() ||
1683           !FTy->getParamType(1)->isPointerTy())
1684         return;
1685       setOnlyReadsMemory(F);
1686       setDoesNotThrow(F);
1687       setDoesNotCapture(F, 1);
1688       setDoesNotCapture(F, 2);
1689     } else if (Name == "memchr" ||
1690                Name == "memrchr") {
1691       if (FTy->getNumParams() != 3)
1692         return;
1693       setOnlyReadsMemory(F);
1694       setDoesNotThrow(F);
1695     } else if (Name == "modf" ||
1696                Name == "modff" ||
1697                Name == "modfl" ||
1698                Name == "memcpy" ||
1699                Name == "memccpy" ||
1700                Name == "memmove") {
1701       if (FTy->getNumParams() < 2 ||
1702           !FTy->getParamType(1)->isPointerTy())
1703         return;
1704       setDoesNotThrow(F);
1705       setDoesNotCapture(F, 2);
1706     } else if (Name == "memalign") {
1707       if (!FTy->getReturnType()->isPointerTy())
1708         return;
1709       setDoesNotAlias(F, 0);
1710     } else if (Name == "mkdir" ||
1711                Name == "mktime") {
1712       if (FTy->getNumParams() == 0 ||
1713           !FTy->getParamType(0)->isPointerTy())
1714         return;
1715       setDoesNotThrow(F);
1716       setDoesNotCapture(F, 1);
1717     }
1718     break;
1719   case 'r':
1720     if (Name == "realloc") {
1721       if (FTy->getNumParams() != 2 ||
1722           !FTy->getParamType(0)->isPointerTy() ||
1723           !FTy->getReturnType()->isPointerTy())
1724         return;
1725       setDoesNotThrow(F);
1726       setDoesNotAlias(F, 0);
1727       setDoesNotCapture(F, 1);
1728     } else if (Name == "read") {
1729       if (FTy->getNumParams() != 3 ||
1730           !FTy->getParamType(1)->isPointerTy())
1731         return;
1732       // May throw; "read" is a valid pthread cancellation point.
1733       setDoesNotCapture(F, 2);
1734     } else if (Name == "rmdir" ||
1735                Name == "rewind" ||
1736                Name == "remove" ||
1737                Name == "realpath") {
1738       if (FTy->getNumParams() < 1 ||
1739           !FTy->getParamType(0)->isPointerTy())
1740         return;
1741       setDoesNotThrow(F);
1742       setDoesNotCapture(F, 1);
1743     } else if (Name == "rename" ||
1744                Name == "readlink") {
1745       if (FTy->getNumParams() < 2 ||
1746           !FTy->getParamType(0)->isPointerTy() ||
1747           !FTy->getParamType(1)->isPointerTy())
1748         return;
1749       setDoesNotThrow(F);
1750       setDoesNotCapture(F, 1);
1751       setDoesNotCapture(F, 2);
1752     }
1753     break;
1754   case 'w':
1755     if (Name == "write") {
1756       if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy())
1757         return;
1758       // May throw; "write" is a valid pthread cancellation point.
1759       setDoesNotCapture(F, 2);
1760     }
1761     break;
1762   case 'b':
1763     if (Name == "bcopy") {
1764       if (FTy->getNumParams() != 3 ||
1765           !FTy->getParamType(0)->isPointerTy() ||
1766           !FTy->getParamType(1)->isPointerTy())
1767         return;
1768       setDoesNotThrow(F);
1769       setDoesNotCapture(F, 1);
1770       setDoesNotCapture(F, 2);
1771     } else if (Name == "bcmp") {
1772       if (FTy->getNumParams() != 3 ||
1773           !FTy->getParamType(0)->isPointerTy() ||
1774           !FTy->getParamType(1)->isPointerTy())
1775         return;
1776       setDoesNotThrow(F);
1777       setOnlyReadsMemory(F);
1778       setDoesNotCapture(F, 1);
1779       setDoesNotCapture(F, 2);
1780     } else if (Name == "bzero") {
1781       if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
1782         return;
1783       setDoesNotThrow(F);
1784       setDoesNotCapture(F, 1);
1785     }
1786     break;
1787   case 'c':
1788     if (Name == "calloc") {
1789       if (FTy->getNumParams() != 2 ||
1790           !FTy->getReturnType()->isPointerTy())
1791         return;
1792       setDoesNotThrow(F);
1793       setDoesNotAlias(F, 0);
1794     } else if (Name == "chmod" ||
1795                Name == "chown" ||
1796                Name == "ctermid" ||
1797                Name == "clearerr" ||
1798                Name == "closedir") {
1799       if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1800         return;
1801       setDoesNotThrow(F);
1802       setDoesNotCapture(F, 1);
1803     }
1804     break;
1805   case 'a':
1806     if (Name == "atoi" ||
1807         Name == "atol" ||
1808         Name == "atof" ||
1809         Name == "atoll") {
1810       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1811         return;
1812       setDoesNotThrow(F);
1813       setOnlyReadsMemory(F);
1814       setDoesNotCapture(F, 1);
1815     } else if (Name == "access") {
1816       if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
1817         return;
1818       setDoesNotThrow(F);
1819       setDoesNotCapture(F, 1);
1820     }
1821     break;
1822   case 'f':
1823     if (Name == "fopen") {
1824       if (FTy->getNumParams() != 2 ||
1825           !FTy->getReturnType()->isPointerTy() ||
1826           !FTy->getParamType(0)->isPointerTy() ||
1827           !FTy->getParamType(1)->isPointerTy())
1828         return;
1829       setDoesNotThrow(F);
1830       setDoesNotAlias(F, 0);
1831       setDoesNotCapture(F, 1);
1832       setDoesNotCapture(F, 2);
1833     } else if (Name == "fdopen") {
1834       if (FTy->getNumParams() != 2 ||
1835           !FTy->getReturnType()->isPointerTy() ||
1836           !FTy->getParamType(1)->isPointerTy())
1837         return;
1838       setDoesNotThrow(F);
1839       setDoesNotAlias(F, 0);
1840       setDoesNotCapture(F, 2);
1841     } else if (Name == "feof" ||
1842                Name == "free" ||
1843                Name == "fseek" ||
1844                Name == "ftell" ||
1845                Name == "fgetc" ||
1846                Name == "fseeko" ||
1847                Name == "ftello" ||
1848                Name == "fileno" ||
1849                Name == "fflush" ||
1850                Name == "fclose" ||
1851                Name == "fsetpos" ||
1852                Name == "flockfile" ||
1853                Name == "funlockfile" ||
1854                Name == "ftrylockfile") {
1855       if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1856         return;
1857       setDoesNotThrow(F);
1858       setDoesNotCapture(F, 1);
1859     } else if (Name == "ferror") {
1860       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1861         return;
1862       setDoesNotThrow(F);
1863       setDoesNotCapture(F, 1);
1864       setOnlyReadsMemory(F);
1865     } else if (Name == "fputc" ||
1866                Name == "fstat" ||
1867                Name == "frexp" ||
1868                Name == "frexpf" ||
1869                Name == "frexpl" ||
1870                Name == "fstatvfs") {
1871       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1872         return;
1873       setDoesNotThrow(F);
1874       setDoesNotCapture(F, 2);
1875     } else if (Name == "fgets") {
1876       if (FTy->getNumParams() != 3 ||
1877           !FTy->getParamType(0)->isPointerTy() ||
1878           !FTy->getParamType(2)->isPointerTy())
1879         return;
1880       setDoesNotThrow(F);
1881       setDoesNotCapture(F, 3);
1882     } else if (Name == "fread" ||
1883                Name == "fwrite") {
1884       if (FTy->getNumParams() != 4 ||
1885           !FTy->getParamType(0)->isPointerTy() ||
1886           !FTy->getParamType(3)->isPointerTy())
1887         return;
1888       setDoesNotThrow(F);
1889       setDoesNotCapture(F, 1);
1890       setDoesNotCapture(F, 4);
1891     } else if (Name == "fputs" ||
1892                Name == "fscanf" ||
1893                Name == "fprintf" ||
1894                Name == "fgetpos") {
1895       if (FTy->getNumParams() < 2 ||
1896           !FTy->getParamType(0)->isPointerTy() ||
1897           !FTy->getParamType(1)->isPointerTy())
1898         return;
1899       setDoesNotThrow(F);
1900       setDoesNotCapture(F, 1);
1901       setDoesNotCapture(F, 2);
1902     }
1903     break;
1904   case 'g':
1905     if (Name == "getc" ||
1906         Name == "getlogin_r" ||
1907         Name == "getc_unlocked") {
1908       if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1909         return;
1910       setDoesNotThrow(F);
1911       setDoesNotCapture(F, 1);
1912     } else if (Name == "getenv") {
1913       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1914         return;
1915       setDoesNotThrow(F);
1916       setOnlyReadsMemory(F);
1917       setDoesNotCapture(F, 1);
1918     } else if (Name == "gets" ||
1919                Name == "getchar") {
1920       setDoesNotThrow(F);
1921     } else if (Name == "getitimer") {
1922       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1923         return;
1924       setDoesNotThrow(F);
1925       setDoesNotCapture(F, 2);
1926     } else if (Name == "getpwnam") {
1927       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1928         return;
1929       setDoesNotThrow(F);
1930       setDoesNotCapture(F, 1);
1931     }
1932     break;
1933   case 'u':
1934     if (Name == "ungetc") {
1935       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1936         return;
1937       setDoesNotThrow(F);
1938       setDoesNotCapture(F, 2);
1939     } else if (Name == "uname" ||
1940                Name == "unlink" ||
1941                Name == "unsetenv") {
1942       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1943         return;
1944       setDoesNotThrow(F);
1945       setDoesNotCapture(F, 1);
1946     } else if (Name == "utime" ||
1947                Name == "utimes") {
1948       if (FTy->getNumParams() != 2 ||
1949           !FTy->getParamType(0)->isPointerTy() ||
1950           !FTy->getParamType(1)->isPointerTy())
1951         return;
1952       setDoesNotThrow(F);
1953       setDoesNotCapture(F, 1);
1954       setDoesNotCapture(F, 2);
1955     }
1956     break;
1957   case 'p':
1958     if (Name == "putc") {
1959       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1960         return;
1961       setDoesNotThrow(F);
1962       setDoesNotCapture(F, 2);
1963     } else if (Name == "puts" ||
1964                Name == "printf" ||
1965                Name == "perror") {
1966       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1967         return;
1968       setDoesNotThrow(F);
1969       setDoesNotCapture(F, 1);
1970     } else if (Name == "pread" ||
1971                Name == "pwrite") {
1972       if (FTy->getNumParams() != 4 || !FTy->getParamType(1)->isPointerTy())
1973         return;
1974       // May throw; these are valid pthread cancellation points.
1975       setDoesNotCapture(F, 2);
1976     } else if (Name == "putchar") {
1977       setDoesNotThrow(F);
1978     } else if (Name == "popen") {
1979       if (FTy->getNumParams() != 2 ||
1980           !FTy->getReturnType()->isPointerTy() ||
1981           !FTy->getParamType(0)->isPointerTy() ||
1982           !FTy->getParamType(1)->isPointerTy())
1983         return;
1984       setDoesNotThrow(F);
1985       setDoesNotAlias(F, 0);
1986       setDoesNotCapture(F, 1);
1987       setDoesNotCapture(F, 2);
1988     } else if (Name == "pclose") {
1989       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1990         return;
1991       setDoesNotThrow(F);
1992       setDoesNotCapture(F, 1);
1993     }
1994     break;
1995   case 'v':
1996     if (Name == "vscanf") {
1997       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1998         return;
1999       setDoesNotThrow(F);
2000       setDoesNotCapture(F, 1);
2001     } else if (Name == "vsscanf" ||
2002                Name == "vfscanf") {
2003       if (FTy->getNumParams() != 3 ||
2004           !FTy->getParamType(1)->isPointerTy() ||
2005           !FTy->getParamType(2)->isPointerTy())
2006         return;
2007       setDoesNotThrow(F);
2008       setDoesNotCapture(F, 1);
2009       setDoesNotCapture(F, 2);
2010     } else if (Name == "valloc") {
2011       if (!FTy->getReturnType()->isPointerTy())
2012         return;
2013       setDoesNotThrow(F);
2014       setDoesNotAlias(F, 0);
2015     } else if (Name == "vprintf") {
2016       if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
2017         return;
2018       setDoesNotThrow(F);
2019       setDoesNotCapture(F, 1);
2020     } else if (Name == "vfprintf" ||
2021                Name == "vsprintf") {
2022       if (FTy->getNumParams() != 3 ||
2023           !FTy->getParamType(0)->isPointerTy() ||
2024           !FTy->getParamType(1)->isPointerTy())
2025         return;
2026       setDoesNotThrow(F);
2027       setDoesNotCapture(F, 1);
2028       setDoesNotCapture(F, 2);
2029     } else if (Name == "vsnprintf") {
2030       if (FTy->getNumParams() != 4 ||
2031           !FTy->getParamType(0)->isPointerTy() ||
2032           !FTy->getParamType(2)->isPointerTy())
2033         return;
2034       setDoesNotThrow(F);
2035       setDoesNotCapture(F, 1);
2036       setDoesNotCapture(F, 3);
2037     }
2038     break;
2039   case 'o':
2040     if (Name == "open") {
2041       if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy())
2042         return;
2043       // May throw; "open" is a valid pthread cancellation point.
2044       setDoesNotCapture(F, 1);
2045     } else if (Name == "opendir") {
2046       if (FTy->getNumParams() != 1 ||
2047           !FTy->getReturnType()->isPointerTy() ||
2048           !FTy->getParamType(0)->isPointerTy())
2049         return;
2050       setDoesNotThrow(F);
2051       setDoesNotAlias(F, 0);
2052       setDoesNotCapture(F, 1);
2053     }
2054     break;
2055   case 't':
2056     if (Name == "tmpfile") {
2057       if (!FTy->getReturnType()->isPointerTy())
2058         return;
2059       setDoesNotThrow(F);
2060       setDoesNotAlias(F, 0);
2061     } else if (Name == "times") {
2062       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
2063         return;
2064       setDoesNotThrow(F);
2065       setDoesNotCapture(F, 1);
2066     }
2067     break;
2068   case 'h':
2069     if (Name == "htonl" ||
2070         Name == "htons") {
2071       setDoesNotThrow(F);
2072       setDoesNotAccessMemory(F);
2073     }
2074     break;
2075   case 'n':
2076     if (Name == "ntohl" ||
2077         Name == "ntohs") {
2078       setDoesNotThrow(F);
2079       setDoesNotAccessMemory(F);
2080     }
2081     break;
2082   case 'l':
2083     if (Name == "lstat") {
2084       if (FTy->getNumParams() != 2 ||
2085           !FTy->getParamType(0)->isPointerTy() ||
2086           !FTy->getParamType(1)->isPointerTy())
2087         return;
2088       setDoesNotThrow(F);
2089       setDoesNotCapture(F, 1);
2090       setDoesNotCapture(F, 2);
2091     } else if (Name == "lchown") {
2092       if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy())
2093         return;
2094       setDoesNotThrow(F);
2095       setDoesNotCapture(F, 1);
2096     }
2097     break;
2098   case 'q':
2099     if (Name == "qsort") {
2100       if (FTy->getNumParams() != 4 || !FTy->getParamType(3)->isPointerTy())
2101         return;
2102       // May throw; places call through function pointer.
2103       setDoesNotCapture(F, 4);
2104     }
2105     break;
2106   case '_':
2107     if (Name == "__strdup" ||
2108         Name == "__strndup") {
2109       if (FTy->getNumParams() < 1 ||
2110           !FTy->getReturnType()->isPointerTy() ||
2111           !FTy->getParamType(0)->isPointerTy())
2112         return;
2113       setDoesNotThrow(F);
2114       setDoesNotAlias(F, 0);
2115       setDoesNotCapture(F, 1);
2116     } else if (Name == "__strtok_r") {
2117       if (FTy->getNumParams() != 3 ||
2118           !FTy->getParamType(1)->isPointerTy())
2119         return;
2120       setDoesNotThrow(F);
2121       setDoesNotCapture(F, 2);
2122     } else if (Name == "_IO_getc") {
2123       if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
2124         return;
2125       setDoesNotThrow(F);
2126       setDoesNotCapture(F, 1);
2127     } else if (Name == "_IO_putc") {
2128       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
2129         return;
2130       setDoesNotThrow(F);
2131       setDoesNotCapture(F, 2);
2132     }
2133     break;
2134   case 1:
2135     if (Name == "\1__isoc99_scanf") {
2136       if (FTy->getNumParams() < 1 ||
2137           !FTy->getParamType(0)->isPointerTy())
2138         return;
2139       setDoesNotThrow(F);
2140       setDoesNotCapture(F, 1);
2141     } else if (Name == "\1stat64" ||
2142                Name == "\1lstat64" ||
2143                Name == "\1statvfs64" ||
2144                Name == "\1__isoc99_sscanf") {
2145       if (FTy->getNumParams() < 1 ||
2146           !FTy->getParamType(0)->isPointerTy() ||
2147           !FTy->getParamType(1)->isPointerTy())
2148         return;
2149       setDoesNotThrow(F);
2150       setDoesNotCapture(F, 1);
2151       setDoesNotCapture(F, 2);
2152     } else if (Name == "\1fopen64") {
2153       if (FTy->getNumParams() != 2 ||
2154           !FTy->getReturnType()->isPointerTy() ||
2155           !FTy->getParamType(0)->isPointerTy() ||
2156           !FTy->getParamType(1)->isPointerTy())
2157         return;
2158       setDoesNotThrow(F);
2159       setDoesNotAlias(F, 0);
2160       setDoesNotCapture(F, 1);
2161       setDoesNotCapture(F, 2);
2162     } else if (Name == "\1fseeko64" ||
2163                Name == "\1ftello64") {
2164       if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
2165         return;
2166       setDoesNotThrow(F);
2167       setDoesNotCapture(F, 1);
2168     } else if (Name == "\1tmpfile64") {
2169       if (!FTy->getReturnType()->isPointerTy())
2170         return;
2171       setDoesNotThrow(F);
2172       setDoesNotAlias(F, 0);
2173     } else if (Name == "\1fstat64" ||
2174                Name == "\1fstatvfs64") {
2175       if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
2176         return;
2177       setDoesNotThrow(F);
2178       setDoesNotCapture(F, 2);
2179     } else if (Name == "\1open64") {
2180       if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy())
2181         return;
2182       // May throw; "open" is a valid pthread cancellation point.
2183       setDoesNotCapture(F, 1);
2184     }
2185     break;
2186   }
2187 }
2188
2189 /// doInitialization - Add attributes to well-known functions.
2190 ///
2191 bool SimplifyLibCalls::doInitialization(Module &M) {
2192   Modified = false;
2193   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
2194     Function &F = *I;
2195     if (F.isDeclaration() && F.hasName())
2196       inferPrototypeAttributes(F);
2197   }
2198   return Modified;
2199 }
2200
2201 // TODO:
2202 //   Additional cases that we need to add to this file:
2203 //
2204 // cbrt:
2205 //   * cbrt(expN(X))  -> expN(x/3)
2206 //   * cbrt(sqrt(x))  -> pow(x,1/6)
2207 //   * cbrt(sqrt(x))  -> pow(x,1/9)
2208 //
2209 // exp, expf, expl:
2210 //   * exp(log(x))  -> x
2211 //
2212 // log, logf, logl:
2213 //   * log(exp(x))   -> x
2214 //   * log(x**y)     -> y*log(x)
2215 //   * log(exp(y))   -> y*log(e)
2216 //   * log(exp2(y))  -> y*log(2)
2217 //   * log(exp10(y)) -> y*log(10)
2218 //   * log(sqrt(x))  -> 0.5*log(x)
2219 //   * log(pow(x,y)) -> y*log(x)
2220 //
2221 // lround, lroundf, lroundl:
2222 //   * lround(cnst) -> cnst'
2223 //
2224 // pow, powf, powl:
2225 //   * pow(exp(x),y)  -> exp(x*y)
2226 //   * pow(sqrt(x),y) -> pow(x,y*0.5)
2227 //   * pow(pow(x,y),z)-> pow(x,y*z)
2228 //
2229 // round, roundf, roundl:
2230 //   * round(cnst) -> cnst'
2231 //
2232 // signbit:
2233 //   * signbit(cnst) -> cnst'
2234 //   * signbit(nncst) -> 0 (if pstv is a non-negative constant)
2235 //
2236 // sqrt, sqrtf, sqrtl:
2237 //   * sqrt(expN(x))  -> expN(x*0.5)
2238 //   * sqrt(Nroot(x)) -> pow(x,1/(2*N))
2239 //   * sqrt(pow(x,y)) -> pow(|x|,y*0.5)
2240 //
2241 // strchr:
2242 //   * strchr(p, 0) -> strlen(p)
2243 // tan, tanf, tanl:
2244 //   * tan(atan(x)) -> x
2245 //
2246 // trunc, truncf, truncl:
2247 //   * trunc(cnst) -> cnst'
2248 //
2249 //