llvm/lib/Transforms/Utils/BuildLibCalls.cpp

   1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements some functions that will create standard C libcalls.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Transforms/Utils/BuildLibCalls.h"
  14 #include "llvm/ADT/SmallString.h"
  15 #include "llvm/ADT/Statistic.h"
  16 #include "llvm/Analysis/TargetLibraryInfo.h"
  17 #include "llvm/IR/Constants.h"
  18 #include "llvm/IR/DataLayout.h"
  19 #include "llvm/IR/Function.h"
  20 #include "llvm/IR/IRBuilder.h"
  21 #include "llvm/IR/Intrinsics.h"
  22 #include "llvm/IR/LLVMContext.h"
  23 #include "llvm/IR/Module.h"
  24 #include "llvm/IR/Type.h"
  25 #include "llvm/Analysis/MemoryBuiltins.h"
  26
  27 using namespace llvm;
  28
  29 #define DEBUG_TYPE "build-libcalls"
  30
  31 //- Infer Attributes ---------------------------------------------------------//
  32
  33 STATISTIC(NumReadNone, "Number of functions inferred as readnone");
  34 STATISTIC(NumInaccessibleMemOnly,
  35           "Number of functions inferred as inaccessiblememonly");
  36 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
  37 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
  38 STATISTIC(NumInaccessibleMemOrArgMemOnly,
  39           "Number of functions inferred as inaccessiblemem_or_argmemonly");
  40 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
  41 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
  42 STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
  43 STATISTIC(NumSExtArg, "Number of arguments inferred as signext");
  44 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
  45 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
  46 STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
  47 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
  48 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
  49 STATISTIC(NumWillReturn, "Number of functions inferred as willreturn");
  50
  51 static bool setDoesNotAccessMemory(Function &F) {
  52   if (F.doesNotAccessMemory())
  53     return false;
  54   F.setDoesNotAccessMemory();
  55   ++NumReadNone;
  56   return true;
  57 }
  58
  59 static bool setOnlyAccessesInaccessibleMemory(Function &F) {
  60   if (F.onlyAccessesInaccessibleMemory())
  61     return false;
  62   F.setOnlyAccessesInaccessibleMemory();
  63   ++NumInaccessibleMemOnly;
  64   return true;
  65 }
  66
  67 static bool setOnlyReadsMemory(Function &F) {
  68   if (F.onlyReadsMemory())
  69     return false;
  70   F.setOnlyReadsMemory();
  71   ++NumReadOnly;
  72   return true;
  73 }
  74
  75 static bool setOnlyAccessesArgMemory(Function &F) {
  76   if (F.onlyAccessesArgMemory())
  77     return false;
  78   F.setOnlyAccessesArgMemory();
  79   ++NumArgMemOnly;
  80   return true;
  81 }
  82
  83 static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F) {
  84   if (F.onlyAccessesInaccessibleMemOrArgMem())
  85     return false;
  86   F.setOnlyAccessesInaccessibleMemOrArgMem();
  87   ++NumInaccessibleMemOrArgMemOnly;
  88   return true;
  89 }
  90
  91 static bool setDoesNotThrow(Function &F) {
  92   if (F.doesNotThrow())
  93     return false;
  94   F.setDoesNotThrow();
  95   ++NumNoUnwind;
  96   return true;
  97 }
  98
  99 static bool setRetDoesNotAlias(Function &F) {
 100   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
 101     return false;
 102   F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
 103   ++NumNoAlias;
 104   return true;
 105 }
 106
 107 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
 108   if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
 109     return false;
 110   F.addParamAttr(ArgNo, Attribute::NoCapture);
 111   ++NumNoCapture;
 112   return true;
 113 }
 114
 115 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
 116   if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
 117     return false;
 118   F.addParamAttr(ArgNo, Attribute::NoAlias);
 119   ++NumNoAlias;
 120   return true;
 121 }
 122
 123 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
 124   if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
 125     return false;
 126   F.addParamAttr(ArgNo, Attribute::ReadOnly);
 127   ++NumReadOnlyArg;
 128   return true;
 129 }
 130
 131 static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
 132   if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
 133     return false;
 134   F.addParamAttr(ArgNo, Attribute::WriteOnly);
 135   ++NumWriteOnlyArg;
 136   return true;
 137 }
 138
 139 static bool setSignExtendedArg(Function &F, unsigned ArgNo) {
 140  if (F.hasParamAttribute(ArgNo, Attribute::SExt))
 141     return false;
 142   F.addParamAttr(ArgNo, Attribute::SExt);
 143   ++NumSExtArg;
 144   return true;
 145 }
 146
 147 static bool setRetNoUndef(Function &F) {
 148   if (!F.getReturnType()->isVoidTy() &&
 149       !F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) {
 150     F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
 151     ++NumNoUndef;
 152     return true;
 153   }
 154   return false;
 155 }
 156
 157 static bool setArgsNoUndef(Function &F) {
 158   bool Changed = false;
 159   for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
 160     if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
 161       F.addParamAttr(ArgNo, Attribute::NoUndef);
 162       ++NumNoUndef;
 163       Changed = true;
 164     }
 165   }
 166   return Changed;
 167 }
 168
 169 static bool setRetAndArgsNoUndef(Function &F) {
 170   return setRetNoUndef(F) | setArgsNoUndef(F);
 171 }
 172
 173 static bool setRetNonNull(Function &F) {
 174   assert(F.getReturnType()->isPointerTy() &&
 175          "nonnull applies only to pointers");
 176   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
 177     return false;
 178   F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
 179   ++NumNonNull;
 180   return true;
 181 }
 182
 183 static bool setReturnedArg(Function &F, unsigned ArgNo) {
 184   if (F.hasParamAttribute(ArgNo, Attribute::Returned))
 185     return false;
 186   F.addParamAttr(ArgNo, Attribute::Returned);
 187   ++NumReturnedArg;
 188   return true;
 189 }
 190
 191 static bool setNonLazyBind(Function &F) {
 192   if (F.hasFnAttribute(Attribute::NonLazyBind))
 193     return false;
 194   F.addFnAttr(Attribute::NonLazyBind);
 195   return true;
 196 }
 197
 198 static bool setDoesNotFreeMemory(Function &F) {
 199   if (F.hasFnAttribute(Attribute::NoFree))
 200     return false;
 201   F.addFnAttr(Attribute::NoFree);
 202   return true;
 203 }
 204
 205 static bool setWillReturn(Function &F) {
 206   if (F.hasFnAttribute(Attribute::WillReturn))
 207     return false;
 208   F.addFnAttr(Attribute::WillReturn);
 209   ++NumWillReturn;
 210   return true;
 211 }
 212
 213 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
 214                                   const TargetLibraryInfo &TLI) {
 215   Function *F = M->getFunction(Name);
 216   if (!F)
 217     return false;
 218   return inferLibFuncAttributes(*F, TLI);
 219 }
 220
 221 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
 222   LibFunc TheLibFunc;
 223   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
 224     return false;
 225
 226   bool Changed = false;
 227
 228   if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F,  &TLI))
 229     Changed |= setDoesNotFreeMemory(F);
 230
 231   if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
 232     Changed |= setNonLazyBind(F);
 233
 234   switch (TheLibFunc) {
 235   case LibFunc_strlen:
 236   case LibFunc_wcslen:
 237     Changed |= setOnlyReadsMemory(F);
 238     Changed |= setDoesNotThrow(F);
 239     Changed |= setOnlyAccessesArgMemory(F);
 240     Changed |= setWillReturn(F);
 241     Changed |= setDoesNotCapture(F, 0);
 242     return Changed;
 243   case LibFunc_strchr:
 244   case LibFunc_strrchr:
 245     Changed |= setOnlyAccessesArgMemory(F);
 246     Changed |= setOnlyReadsMemory(F);
 247     Changed |= setDoesNotThrow(F);
 248     Changed |= setWillReturn(F);
 249     return Changed;
 250   case LibFunc_strtol:
 251   case LibFunc_strtod:
 252   case LibFunc_strtof:
 253   case LibFunc_strtoul:
 254   case LibFunc_strtoll:
 255   case LibFunc_strtold:
 256   case LibFunc_strtoull:
 257     Changed |= setDoesNotThrow(F);
 258     Changed |= setWillReturn(F);
 259     Changed |= setDoesNotCapture(F, 1);
 260     Changed |= setOnlyReadsMemory(F, 0);
 261     return Changed;
 262   case LibFunc_strcpy:
 263   case LibFunc_strncpy:
 264   case LibFunc_strcat:
 265   case LibFunc_strncat:
 266     Changed |= setWillReturn(F);
 267     Changed |= setReturnedArg(F, 0);
 268     LLVM_FALLTHROUGH;
 269   case LibFunc_stpcpy:
 270   case LibFunc_stpncpy:
 271     Changed |= setOnlyAccessesArgMemory(F);
 272     Changed |= setDoesNotThrow(F);
 273     Changed |= setWillReturn(F);
 274     Changed |= setDoesNotCapture(F, 1);
 275     Changed |= setOnlyWritesMemory(F, 0);
 276     Changed |= setOnlyReadsMemory(F, 1);
 277     Changed |= setDoesNotAlias(F, 0);
 278     Changed |= setDoesNotAlias(F, 1);
 279     return Changed;
 280   case LibFunc_strxfrm:
 281     Changed |= setDoesNotThrow(F);
 282     Changed |= setWillReturn(F);
 283     Changed |= setDoesNotCapture(F, 0);
 284     Changed |= setDoesNotCapture(F, 1);
 285     Changed |= setOnlyReadsMemory(F, 1);
 286     return Changed;
 287   case LibFunc_strcmp:      // 0,1
 288   case LibFunc_strspn:      // 0,1
 289   case LibFunc_strncmp:     // 0,1
 290   case LibFunc_strcspn:     // 0,1
 291     Changed |= setDoesNotThrow(F);
 292     Changed |= setOnlyAccessesArgMemory(F);
 293     Changed |= setWillReturn(F);
 294     Changed |= setOnlyReadsMemory(F);
 295     Changed |= setDoesNotCapture(F, 0);
 296     Changed |= setDoesNotCapture(F, 1);
 297     return Changed;
 298   case LibFunc_strcoll:
 299   case LibFunc_strcasecmp:  // 0,1
 300   case LibFunc_strncasecmp: //
 301     // Those functions may depend on the locale, which may be accessed through
 302     // global memory.
 303     Changed |= setOnlyReadsMemory(F);
 304     Changed |= setDoesNotThrow(F);
 305     Changed |= setWillReturn(F);
 306     Changed |= setDoesNotCapture(F, 0);
 307     Changed |= setDoesNotCapture(F, 1);
 308     return Changed;
 309   case LibFunc_strstr:
 310   case LibFunc_strpbrk:
 311     Changed |= setOnlyAccessesArgMemory(F);
 312     Changed |= setOnlyReadsMemory(F);
 313     Changed |= setDoesNotThrow(F);
 314     Changed |= setWillReturn(F);
 315     Changed |= setDoesNotCapture(F, 1);
 316     return Changed;
 317   case LibFunc_strtok:
 318   case LibFunc_strtok_r:
 319     Changed |= setDoesNotThrow(F);
 320     Changed |= setWillReturn(F);
 321     Changed |= setDoesNotCapture(F, 1);
 322     Changed |= setOnlyReadsMemory(F, 1);
 323     return Changed;
 324   case LibFunc_scanf:
 325     Changed |= setRetAndArgsNoUndef(F);
 326     Changed |= setDoesNotThrow(F);
 327     Changed |= setDoesNotCapture(F, 0);
 328     Changed |= setOnlyReadsMemory(F, 0);
 329     return Changed;
 330   case LibFunc_setbuf:
 331   case LibFunc_setvbuf:
 332     Changed |= setRetAndArgsNoUndef(F);
 333     Changed |= setDoesNotThrow(F);
 334     Changed |= setDoesNotCapture(F, 0);
 335     return Changed;
 336   case LibFunc_strdup:
 337   case LibFunc_strndup:
 338     Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
 339     Changed |= setDoesNotThrow(F);
 340     Changed |= setRetDoesNotAlias(F);
 341     Changed |= setWillReturn(F);
 342     Changed |= setDoesNotCapture(F, 0);
 343     Changed |= setOnlyReadsMemory(F, 0);
 344     return Changed;
 345   case LibFunc_stat:
 346   case LibFunc_statvfs:
 347     Changed |= setRetAndArgsNoUndef(F);
 348     Changed |= setDoesNotThrow(F);
 349     Changed |= setDoesNotCapture(F, 0);
 350     Changed |= setDoesNotCapture(F, 1);
 351     Changed |= setOnlyReadsMemory(F, 0);
 352     return Changed;
 353   case LibFunc_sscanf:
 354     Changed |= setRetAndArgsNoUndef(F);
 355     Changed |= setDoesNotThrow(F);
 356     Changed |= setDoesNotCapture(F, 0);
 357     Changed |= setDoesNotCapture(F, 1);
 358     Changed |= setOnlyReadsMemory(F, 0);
 359     Changed |= setOnlyReadsMemory(F, 1);
 360     return Changed;
 361   case LibFunc_sprintf:
 362     Changed |= setRetAndArgsNoUndef(F);
 363     Changed |= setDoesNotThrow(F);
 364     Changed |= setDoesNotCapture(F, 0);
 365     Changed |= setDoesNotAlias(F, 0);
 366     Changed |= setOnlyWritesMemory(F, 0);
 367     Changed |= setDoesNotCapture(F, 1);
 368     Changed |= setOnlyReadsMemory(F, 1);
 369     return Changed;
 370   case LibFunc_snprintf:
 371     Changed |= setRetAndArgsNoUndef(F);
 372     Changed |= setDoesNotThrow(F);
 373     Changed |= setDoesNotCapture(F, 0);
 374     Changed |= setDoesNotAlias(F, 0);
 375     Changed |= setOnlyWritesMemory(F, 0);
 376     Changed |= setDoesNotCapture(F, 2);
 377     Changed |= setOnlyReadsMemory(F, 2);
 378     return Changed;
 379   case LibFunc_setitimer:
 380     Changed |= setRetAndArgsNoUndef(F);
 381     Changed |= setDoesNotThrow(F);
 382     Changed |= setWillReturn(F);
 383     Changed |= setDoesNotCapture(F, 1);
 384     Changed |= setDoesNotCapture(F, 2);
 385     Changed |= setOnlyReadsMemory(F, 1);
 386     return Changed;
 387   case LibFunc_system:
 388     // May throw; "system" is a valid pthread cancellation point.
 389     Changed |= setRetAndArgsNoUndef(F);
 390     Changed |= setDoesNotCapture(F, 0);
 391     Changed |= setOnlyReadsMemory(F, 0);
 392     return Changed;
 393   case LibFunc_malloc:
 394     Changed |= setOnlyAccessesInaccessibleMemory(F);
 395     Changed |= setRetNoUndef(F);
 396     Changed |= setDoesNotThrow(F);
 397     Changed |= setRetDoesNotAlias(F);
 398     Changed |= setWillReturn(F);
 399     return Changed;
 400   case LibFunc_memcmp:
 401     Changed |= setOnlyAccessesArgMemory(F);
 402     Changed |= setOnlyReadsMemory(F);
 403     Changed |= setDoesNotThrow(F);
 404     Changed |= setWillReturn(F);
 405     Changed |= setDoesNotCapture(F, 0);
 406     Changed |= setDoesNotCapture(F, 1);
 407     return Changed;
 408   case LibFunc_memchr:
 409   case LibFunc_memrchr:
 410     Changed |= setDoesNotThrow(F);
 411     Changed |= setOnlyAccessesArgMemory(F);
 412     Changed |= setOnlyReadsMemory(F);
 413     Changed |= setWillReturn(F);
 414     return Changed;
 415   case LibFunc_modf:
 416   case LibFunc_modff:
 417   case LibFunc_modfl:
 418     Changed |= setDoesNotThrow(F);
 419     Changed |= setWillReturn(F);
 420     Changed |= setDoesNotCapture(F, 1);
 421     return Changed;
 422   case LibFunc_memcpy:
 423     Changed |= setDoesNotThrow(F);
 424     Changed |= setOnlyAccessesArgMemory(F);
 425     Changed |= setWillReturn(F);
 426     Changed |= setDoesNotAlias(F, 0);
 427     Changed |= setReturnedArg(F, 0);
 428     Changed |= setOnlyWritesMemory(F, 0);
 429     Changed |= setDoesNotAlias(F, 1);
 430     Changed |= setDoesNotCapture(F, 1);
 431     Changed |= setOnlyReadsMemory(F, 1);
 432     return Changed;
 433   case LibFunc_memmove:
 434     Changed |= setDoesNotThrow(F);
 435     Changed |= setOnlyAccessesArgMemory(F);
 436     Changed |= setWillReturn(F);
 437     Changed |= setReturnedArg(F, 0);
 438     Changed |= setOnlyWritesMemory(F, 0);
 439     Changed |= setDoesNotCapture(F, 1);
 440     Changed |= setOnlyReadsMemory(F, 1);
 441     return Changed;
 442   case LibFunc_mempcpy:
 443   case LibFunc_memccpy:
 444     Changed |= setDoesNotThrow(F);
 445     Changed |= setOnlyAccessesArgMemory(F);
 446     Changed |= setWillReturn(F);
 447     Changed |= setDoesNotAlias(F, 0);
 448     Changed |= setOnlyWritesMemory(F, 0);
 449     Changed |= setDoesNotAlias(F, 1);
 450     Changed |= setDoesNotCapture(F, 1);
 451     Changed |= setOnlyReadsMemory(F, 1);
 452     return Changed;
 453   case LibFunc_memcpy_chk:
 454     Changed |= setDoesNotThrow(F);
 455     return Changed;
 456   case LibFunc_memalign:
 457     Changed |= setOnlyAccessesInaccessibleMemory(F);
 458     Changed |= setRetNoUndef(F);
 459     Changed |= setDoesNotThrow(F);
 460     Changed |= setRetDoesNotAlias(F);
 461     Changed |= setWillReturn(F);
 462     return Changed;
 463   case LibFunc_mkdir:
 464     Changed |= setRetAndArgsNoUndef(F);
 465     Changed |= setDoesNotThrow(F);
 466     Changed |= setDoesNotCapture(F, 0);
 467     Changed |= setOnlyReadsMemory(F, 0);
 468     return Changed;
 469   case LibFunc_mktime:
 470     Changed |= setRetAndArgsNoUndef(F);
 471     Changed |= setDoesNotThrow(F);
 472     Changed |= setWillReturn(F);
 473     Changed |= setDoesNotCapture(F, 0);
 474     return Changed;
 475   case LibFunc_realloc:
 476     Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
 477     Changed |= setRetNoUndef(F);
 478     Changed |= setDoesNotThrow(F);
 479     Changed |= setRetDoesNotAlias(F);
 480     Changed |= setWillReturn(F);
 481     Changed |= setDoesNotCapture(F, 0);
 482     return Changed;
 483   case LibFunc_reallocf:
 484     Changed |= setRetNoUndef(F);
 485     Changed |= setWillReturn(F);
 486     return Changed;
 487   case LibFunc_read:
 488     // May throw; "read" is a valid pthread cancellation point.
 489     Changed |= setRetAndArgsNoUndef(F);
 490     Changed |= setDoesNotCapture(F, 1);
 491     return Changed;
 492   case LibFunc_rewind:
 493     Changed |= setRetAndArgsNoUndef(F);
 494     Changed |= setDoesNotThrow(F);
 495     Changed |= setDoesNotCapture(F, 0);
 496     return Changed;
 497   case LibFunc_rmdir:
 498   case LibFunc_remove:
 499   case LibFunc_realpath:
 500     Changed |= setRetAndArgsNoUndef(F);
 501     Changed |= setDoesNotThrow(F);
 502     Changed |= setDoesNotCapture(F, 0);
 503     Changed |= setOnlyReadsMemory(F, 0);
 504     return Changed;
 505   case LibFunc_rename:
 506     Changed |= setRetAndArgsNoUndef(F);
 507     Changed |= setDoesNotThrow(F);
 508     Changed |= setDoesNotCapture(F, 0);
 509     Changed |= setDoesNotCapture(F, 1);
 510     Changed |= setOnlyReadsMemory(F, 0);
 511     Changed |= setOnlyReadsMemory(F, 1);
 512     return Changed;
 513   case LibFunc_readlink:
 514     Changed |= setRetAndArgsNoUndef(F);
 515     Changed |= setDoesNotThrow(F);
 516     Changed |= setDoesNotCapture(F, 0);
 517     Changed |= setDoesNotCapture(F, 1);
 518     Changed |= setOnlyReadsMemory(F, 0);
 519     return Changed;
 520   case LibFunc_write:
 521     // May throw; "write" is a valid pthread cancellation point.
 522     Changed |= setRetAndArgsNoUndef(F);
 523     Changed |= setDoesNotCapture(F, 1);
 524     Changed |= setOnlyReadsMemory(F, 1);
 525     return Changed;
 526   case LibFunc_aligned_alloc:
 527     Changed |= setOnlyAccessesInaccessibleMemory(F);
 528     Changed |= setRetNoUndef(F);
 529     Changed |= setDoesNotThrow(F);
 530     Changed |= setRetDoesNotAlias(F);
 531     Changed |= setWillReturn(F);
 532     return Changed;
 533   case LibFunc_bcopy:
 534     Changed |= setDoesNotThrow(F);
 535     Changed |= setOnlyAccessesArgMemory(F);
 536     Changed |= setWillReturn(F);
 537     Changed |= setDoesNotCapture(F, 0);
 538     Changed |= setOnlyReadsMemory(F, 0);
 539     Changed |= setOnlyWritesMemory(F, 1);
 540     Changed |= setDoesNotCapture(F, 1);
 541     return Changed;
 542   case LibFunc_bcmp:
 543     Changed |= setDoesNotThrow(F);
 544     Changed |= setOnlyAccessesArgMemory(F);
 545     Changed |= setOnlyReadsMemory(F);
 546     Changed |= setWillReturn(F);
 547     Changed |= setDoesNotCapture(F, 0);
 548     Changed |= setDoesNotCapture(F, 1);
 549     return Changed;
 550   case LibFunc_bzero:
 551     Changed |= setDoesNotThrow(F);
 552     Changed |= setOnlyAccessesArgMemory(F);
 553     Changed |= setWillReturn(F);
 554     Changed |= setDoesNotCapture(F, 0);
 555     Changed |= setOnlyWritesMemory(F, 0);
 556     return Changed;
 557   case LibFunc_calloc:
 558     Changed |= setOnlyAccessesInaccessibleMemory(F);
 559     Changed |= setRetNoUndef(F);
 560     Changed |= setDoesNotThrow(F);
 561     Changed |= setRetDoesNotAlias(F);
 562     Changed |= setWillReturn(F);
 563     return Changed;
 564   case LibFunc_chmod:
 565   case LibFunc_chown:
 566     Changed |= setRetAndArgsNoUndef(F);
 567     Changed |= setDoesNotThrow(F);
 568     Changed |= setDoesNotCapture(F, 0);
 569     Changed |= setOnlyReadsMemory(F, 0);
 570     return Changed;
 571   case LibFunc_ctermid:
 572   case LibFunc_clearerr:
 573   case LibFunc_closedir:
 574     Changed |= setRetAndArgsNoUndef(F);
 575     Changed |= setDoesNotThrow(F);
 576     Changed |= setDoesNotCapture(F, 0);
 577     return Changed;
 578   case LibFunc_atoi:
 579   case LibFunc_atol:
 580   case LibFunc_atof:
 581   case LibFunc_atoll:
 582     Changed |= setDoesNotThrow(F);
 583     Changed |= setOnlyReadsMemory(F);
 584     Changed |= setWillReturn(F);
 585     Changed |= setDoesNotCapture(F, 0);
 586     return Changed;
 587   case LibFunc_access:
 588     Changed |= setRetAndArgsNoUndef(F);
 589     Changed |= setDoesNotThrow(F);
 590     Changed |= setDoesNotCapture(F, 0);
 591     Changed |= setOnlyReadsMemory(F, 0);
 592     return Changed;
 593   case LibFunc_fopen:
 594     Changed |= setRetAndArgsNoUndef(F);
 595     Changed |= setDoesNotThrow(F);
 596     Changed |= setRetDoesNotAlias(F);
 597     Changed |= setDoesNotCapture(F, 0);
 598     Changed |= setDoesNotCapture(F, 1);
 599     Changed |= setOnlyReadsMemory(F, 0);
 600     Changed |= setOnlyReadsMemory(F, 1);
 601     return Changed;
 602   case LibFunc_fdopen:
 603     Changed |= setRetAndArgsNoUndef(F);
 604     Changed |= setDoesNotThrow(F);
 605     Changed |= setRetDoesNotAlias(F);
 606     Changed |= setDoesNotCapture(F, 1);
 607     Changed |= setOnlyReadsMemory(F, 1);
 608     return Changed;
 609   case LibFunc_feof:
 610     Changed |= setRetAndArgsNoUndef(F);
 611     Changed |= setDoesNotThrow(F);
 612     Changed |= setDoesNotCapture(F, 0);
 613     return Changed;
 614   case LibFunc_free:
 615     Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
 616     Changed |= setArgsNoUndef(F);
 617     Changed |= setDoesNotThrow(F);
 618     Changed |= setWillReturn(F);
 619     Changed |= setDoesNotCapture(F, 0);
 620     return Changed;
 621   case LibFunc_fseek:
 622   case LibFunc_ftell:
 623   case LibFunc_fgetc:
 624   case LibFunc_fgetc_unlocked:
 625   case LibFunc_fseeko:
 626   case LibFunc_ftello:
 627   case LibFunc_fileno:
 628   case LibFunc_fflush:
 629   case LibFunc_fclose:
 630   case LibFunc_fsetpos:
 631   case LibFunc_flockfile:
 632   case LibFunc_funlockfile:
 633   case LibFunc_ftrylockfile:
 634     Changed |= setRetAndArgsNoUndef(F);
 635     Changed |= setDoesNotThrow(F);
 636     Changed |= setDoesNotCapture(F, 0);
 637     return Changed;
 638   case LibFunc_ferror:
 639     Changed |= setRetAndArgsNoUndef(F);
 640     Changed |= setDoesNotThrow(F);
 641     Changed |= setDoesNotCapture(F, 0);
 642     Changed |= setOnlyReadsMemory(F);
 643     return Changed;
 644   case LibFunc_fputc:
 645   case LibFunc_fputc_unlocked:
 646   case LibFunc_fstat:
 647     Changed |= setRetAndArgsNoUndef(F);
 648     Changed |= setDoesNotThrow(F);
 649     Changed |= setDoesNotCapture(F, 1);
 650     return Changed;
 651   case LibFunc_frexp:
 652   case LibFunc_frexpf:
 653   case LibFunc_frexpl:
 654     Changed |= setDoesNotThrow(F);
 655     Changed |= setWillReturn(F);
 656     Changed |= setDoesNotCapture(F, 1);
 657     return Changed;
 658   case LibFunc_fstatvfs:
 659     Changed |= setRetAndArgsNoUndef(F);
 660     Changed |= setDoesNotThrow(F);
 661     Changed |= setDoesNotCapture(F, 1);
 662     return Changed;
 663   case LibFunc_fgets:
 664   case LibFunc_fgets_unlocked:
 665     Changed |= setRetAndArgsNoUndef(F);
 666     Changed |= setDoesNotThrow(F);
 667     Changed |= setDoesNotCapture(F, 2);
 668     return Changed;
 669   case LibFunc_fread:
 670   case LibFunc_fread_unlocked:
 671     Changed |= setRetAndArgsNoUndef(F);
 672     Changed |= setDoesNotThrow(F);
 673     Changed |= setDoesNotCapture(F, 0);
 674     Changed |= setDoesNotCapture(F, 3);
 675     return Changed;
 676   case LibFunc_fwrite:
 677   case LibFunc_fwrite_unlocked:
 678     Changed |= setRetAndArgsNoUndef(F);
 679     Changed |= setDoesNotThrow(F);
 680     Changed |= setDoesNotCapture(F, 0);
 681     Changed |= setDoesNotCapture(F, 3);
 682     // FIXME: readonly #1?
 683     return Changed;
 684   case LibFunc_fputs:
 685   case LibFunc_fputs_unlocked:
 686     Changed |= setRetAndArgsNoUndef(F);
 687     Changed |= setDoesNotThrow(F);
 688     Changed |= setDoesNotCapture(F, 0);
 689     Changed |= setDoesNotCapture(F, 1);
 690     Changed |= setOnlyReadsMemory(F, 0);
 691     return Changed;
 692   case LibFunc_fscanf:
 693   case LibFunc_fprintf:
 694     Changed |= setRetAndArgsNoUndef(F);
 695     Changed |= setDoesNotThrow(F);
 696     Changed |= setDoesNotCapture(F, 0);
 697     Changed |= setDoesNotCapture(F, 1);
 698     Changed |= setOnlyReadsMemory(F, 1);
 699     return Changed;
 700   case LibFunc_fgetpos:
 701     Changed |= setRetAndArgsNoUndef(F);
 702     Changed |= setDoesNotThrow(F);
 703     Changed |= setDoesNotCapture(F, 0);
 704     Changed |= setDoesNotCapture(F, 1);
 705     return Changed;
 706   case LibFunc_getc:
 707     Changed |= setRetAndArgsNoUndef(F);
 708     Changed |= setDoesNotThrow(F);
 709     Changed |= setDoesNotCapture(F, 0);
 710     return Changed;
 711   case LibFunc_getlogin_r:
 712     Changed |= setRetAndArgsNoUndef(F);
 713     Changed |= setDoesNotThrow(F);
 714     Changed |= setDoesNotCapture(F, 0);
 715     return Changed;
 716   case LibFunc_getc_unlocked:
 717     Changed |= setRetAndArgsNoUndef(F);
 718     Changed |= setDoesNotThrow(F);
 719     Changed |= setDoesNotCapture(F, 0);
 720     return Changed;
 721   case LibFunc_getenv:
 722     Changed |= setRetAndArgsNoUndef(F);
 723     Changed |= setDoesNotThrow(F);
 724     Changed |= setOnlyReadsMemory(F);
 725     Changed |= setDoesNotCapture(F, 0);
 726     return Changed;
 727   case LibFunc_gets:
 728   case LibFunc_getchar:
 729   case LibFunc_getchar_unlocked:
 730     Changed |= setRetAndArgsNoUndef(F);
 731     Changed |= setDoesNotThrow(F);
 732     return Changed;
 733   case LibFunc_getitimer:
 734     Changed |= setRetAndArgsNoUndef(F);
 735     Changed |= setDoesNotThrow(F);
 736     Changed |= setDoesNotCapture(F, 1);
 737     return Changed;
 738   case LibFunc_getpwnam:
 739     Changed |= setRetAndArgsNoUndef(F);
 740     Changed |= setDoesNotThrow(F);
 741     Changed |= setDoesNotCapture(F, 0);
 742     Changed |= setOnlyReadsMemory(F, 0);
 743     return Changed;
 744   case LibFunc_ungetc:
 745     Changed |= setRetAndArgsNoUndef(F);
 746     Changed |= setDoesNotThrow(F);
 747     Changed |= setDoesNotCapture(F, 1);
 748     return Changed;
 749   case LibFunc_uname:
 750     Changed |= setRetAndArgsNoUndef(F);
 751     Changed |= setDoesNotThrow(F);
 752     Changed |= setDoesNotCapture(F, 0);
 753     return Changed;
 754   case LibFunc_unlink:
 755     Changed |= setRetAndArgsNoUndef(F);
 756     Changed |= setDoesNotThrow(F);
 757     Changed |= setDoesNotCapture(F, 0);
 758     Changed |= setOnlyReadsMemory(F, 0);
 759     return Changed;
 760   case LibFunc_unsetenv:
 761     Changed |= setRetAndArgsNoUndef(F);
 762     Changed |= setDoesNotThrow(F);
 763     Changed |= setDoesNotCapture(F, 0);
 764     Changed |= setOnlyReadsMemory(F, 0);
 765     return Changed;
 766   case LibFunc_utime:
 767   case LibFunc_utimes:
 768     Changed |= setRetAndArgsNoUndef(F);
 769     Changed |= setDoesNotThrow(F);
 770     Changed |= setDoesNotCapture(F, 0);
 771     Changed |= setDoesNotCapture(F, 1);
 772     Changed |= setOnlyReadsMemory(F, 0);
 773     Changed |= setOnlyReadsMemory(F, 1);
 774     return Changed;
 775   case LibFunc_putc:
 776   case LibFunc_putc_unlocked:
 777     Changed |= setRetAndArgsNoUndef(F);
 778     Changed |= setDoesNotThrow(F);
 779     Changed |= setDoesNotCapture(F, 1);
 780     return Changed;
 781   case LibFunc_puts:
 782   case LibFunc_printf:
 783   case LibFunc_perror:
 784     Changed |= setRetAndArgsNoUndef(F);
 785     Changed |= setDoesNotThrow(F);
 786     Changed |= setDoesNotCapture(F, 0);
 787     Changed |= setOnlyReadsMemory(F, 0);
 788     return Changed;
 789   case LibFunc_pread:
 790     // May throw; "pread" is a valid pthread cancellation point.
 791     Changed |= setRetAndArgsNoUndef(F);
 792     Changed |= setDoesNotCapture(F, 1);
 793     return Changed;
 794   case LibFunc_pwrite:
 795     // May throw; "pwrite" is a valid pthread cancellation point.
 796     Changed |= setRetAndArgsNoUndef(F);
 797     Changed |= setDoesNotCapture(F, 1);
 798     Changed |= setOnlyReadsMemory(F, 1);
 799     return Changed;
 800   case LibFunc_putchar:
 801   case LibFunc_putchar_unlocked:
 802     Changed |= setRetAndArgsNoUndef(F);
 803     Changed |= setDoesNotThrow(F);
 804     return Changed;
 805   case LibFunc_popen:
 806     Changed |= setRetAndArgsNoUndef(F);
 807     Changed |= setDoesNotThrow(F);
 808     Changed |= setRetDoesNotAlias(F);
 809     Changed |= setDoesNotCapture(F, 0);
 810     Changed |= setDoesNotCapture(F, 1);
 811     Changed |= setOnlyReadsMemory(F, 0);
 812     Changed |= setOnlyReadsMemory(F, 1);
 813     return Changed;
 814   case LibFunc_pclose:
 815     Changed |= setRetAndArgsNoUndef(F);
 816     Changed |= setDoesNotThrow(F);
 817     Changed |= setDoesNotCapture(F, 0);
 818     return Changed;
 819   case LibFunc_vscanf:
 820     Changed |= setRetAndArgsNoUndef(F);
 821     Changed |= setDoesNotThrow(F);
 822     Changed |= setDoesNotCapture(F, 0);
 823     Changed |= setOnlyReadsMemory(F, 0);
 824     return Changed;
 825   case LibFunc_vsscanf:
 826     Changed |= setRetAndArgsNoUndef(F);
 827     Changed |= setDoesNotThrow(F);
 828     Changed |= setDoesNotCapture(F, 0);
 829     Changed |= setDoesNotCapture(F, 1);
 830     Changed |= setOnlyReadsMemory(F, 0);
 831     Changed |= setOnlyReadsMemory(F, 1);
 832     return Changed;
 833   case LibFunc_vfscanf:
 834     Changed |= setRetAndArgsNoUndef(F);
 835     Changed |= setDoesNotThrow(F);
 836     Changed |= setDoesNotCapture(F, 0);
 837     Changed |= setDoesNotCapture(F, 1);
 838     Changed |= setOnlyReadsMemory(F, 1);
 839     return Changed;
 840   case LibFunc_valloc:
 841     Changed |= setOnlyAccessesInaccessibleMemory(F);
 842     Changed |= setRetNoUndef(F);
 843     Changed |= setDoesNotThrow(F);
 844     Changed |= setRetDoesNotAlias(F);
 845     Changed |= setWillReturn(F);
 846     return Changed;
 847   case LibFunc_vprintf:
 848     Changed |= setRetAndArgsNoUndef(F);
 849     Changed |= setDoesNotThrow(F);
 850     Changed |= setDoesNotCapture(F, 0);
 851     Changed |= setOnlyReadsMemory(F, 0);
 852     return Changed;
 853   case LibFunc_vfprintf:
 854   case LibFunc_vsprintf:
 855     Changed |= setRetAndArgsNoUndef(F);
 856     Changed |= setDoesNotThrow(F);
 857     Changed |= setDoesNotCapture(F, 0);
 858     Changed |= setDoesNotCapture(F, 1);
 859     Changed |= setOnlyReadsMemory(F, 1);
 860     return Changed;
 861   case LibFunc_vsnprintf:
 862     Changed |= setRetAndArgsNoUndef(F);
 863     Changed |= setDoesNotThrow(F);
 864     Changed |= setDoesNotCapture(F, 0);
 865     Changed |= setDoesNotCapture(F, 2);
 866     Changed |= setOnlyReadsMemory(F, 2);
 867     return Changed;
 868   case LibFunc_open:
 869     // May throw; "open" is a valid pthread cancellation point.
 870     Changed |= setRetAndArgsNoUndef(F);
 871     Changed |= setDoesNotCapture(F, 0);
 872     Changed |= setOnlyReadsMemory(F, 0);
 873     return Changed;
 874   case LibFunc_opendir:
 875     Changed |= setRetAndArgsNoUndef(F);
 876     Changed |= setDoesNotThrow(F);
 877     Changed |= setRetDoesNotAlias(F);
 878     Changed |= setDoesNotCapture(F, 0);
 879     Changed |= setOnlyReadsMemory(F, 0);
 880     return Changed;
 881   case LibFunc_tmpfile:
 882     Changed |= setRetAndArgsNoUndef(F);
 883     Changed |= setDoesNotThrow(F);
 884     Changed |= setRetDoesNotAlias(F);
 885     return Changed;
 886   case LibFunc_times:
 887     Changed |= setRetAndArgsNoUndef(F);
 888     Changed |= setDoesNotThrow(F);
 889     Changed |= setDoesNotCapture(F, 0);
 890     return Changed;
 891   case LibFunc_htonl:
 892   case LibFunc_htons:
 893   case LibFunc_ntohl:
 894   case LibFunc_ntohs:
 895     Changed |= setDoesNotThrow(F);
 896     Changed |= setDoesNotAccessMemory(F);
 897     return Changed;
 898   case LibFunc_lstat:
 899     Changed |= setRetAndArgsNoUndef(F);
 900     Changed |= setDoesNotThrow(F);
 901     Changed |= setDoesNotCapture(F, 0);
 902     Changed |= setDoesNotCapture(F, 1);
 903     Changed |= setOnlyReadsMemory(F, 0);
 904     return Changed;
 905   case LibFunc_lchown:
 906     Changed |= setRetAndArgsNoUndef(F);
 907     Changed |= setDoesNotThrow(F);
 908     Changed |= setDoesNotCapture(F, 0);
 909     Changed |= setOnlyReadsMemory(F, 0);
 910     return Changed;
 911   case LibFunc_qsort:
 912     // May throw; places call through function pointer.
 913     // Cannot give undef pointer/size
 914     Changed |= setRetAndArgsNoUndef(F);
 915     Changed |= setDoesNotCapture(F, 3);
 916     return Changed;
 917   case LibFunc_dunder_strdup:
 918   case LibFunc_dunder_strndup:
 919     Changed |= setDoesNotThrow(F);
 920     Changed |= setRetDoesNotAlias(F);
 921     Changed |= setWillReturn(F);
 922     Changed |= setDoesNotCapture(F, 0);
 923     Changed |= setOnlyReadsMemory(F, 0);
 924     return Changed;
 925   case LibFunc_dunder_strtok_r:
 926     Changed |= setDoesNotThrow(F);
 927     Changed |= setDoesNotCapture(F, 1);
 928     Changed |= setOnlyReadsMemory(F, 1);
 929     return Changed;
 930   case LibFunc_under_IO_getc:
 931     Changed |= setRetAndArgsNoUndef(F);
 932     Changed |= setDoesNotThrow(F);
 933     Changed |= setDoesNotCapture(F, 0);
 934     return Changed;
 935   case LibFunc_under_IO_putc:
 936     Changed |= setRetAndArgsNoUndef(F);
 937     Changed |= setDoesNotThrow(F);
 938     Changed |= setDoesNotCapture(F, 1);
 939     return Changed;
 940   case LibFunc_dunder_isoc99_scanf:
 941     Changed |= setRetAndArgsNoUndef(F);
 942     Changed |= setDoesNotThrow(F);
 943     Changed |= setDoesNotCapture(F, 0);
 944     Changed |= setOnlyReadsMemory(F, 0);
 945     return Changed;
 946   case LibFunc_stat64:
 947   case LibFunc_lstat64:
 948   case LibFunc_statvfs64:
 949     Changed |= setRetAndArgsNoUndef(F);
 950     Changed |= setDoesNotThrow(F);
 951     Changed |= setDoesNotCapture(F, 0);
 952     Changed |= setDoesNotCapture(F, 1);
 953     Changed |= setOnlyReadsMemory(F, 0);
 954     return Changed;
 955   case LibFunc_dunder_isoc99_sscanf:
 956     Changed |= setRetAndArgsNoUndef(F);
 957     Changed |= setDoesNotThrow(F);
 958     Changed |= setDoesNotCapture(F, 0);
 959     Changed |= setDoesNotCapture(F, 1);
 960     Changed |= setOnlyReadsMemory(F, 0);
 961     Changed |= setOnlyReadsMemory(F, 1);
 962     return Changed;
 963   case LibFunc_fopen64:
 964     Changed |= setRetAndArgsNoUndef(F);
 965     Changed |= setDoesNotThrow(F);
 966     Changed |= setRetDoesNotAlias(F);
 967     Changed |= setDoesNotCapture(F, 0);
 968     Changed |= setDoesNotCapture(F, 1);
 969     Changed |= setOnlyReadsMemory(F, 0);
 970     Changed |= setOnlyReadsMemory(F, 1);
 971     return Changed;
 972   case LibFunc_fseeko64:
 973   case LibFunc_ftello64:
 974     Changed |= setRetAndArgsNoUndef(F);
 975     Changed |= setDoesNotThrow(F);
 976     Changed |= setDoesNotCapture(F, 0);
 977     return Changed;
 978   case LibFunc_tmpfile64:
 979     Changed |= setRetAndArgsNoUndef(F);
 980     Changed |= setDoesNotThrow(F);
 981     Changed |= setRetDoesNotAlias(F);
 982     return Changed;
 983   case LibFunc_fstat64:
 984   case LibFunc_fstatvfs64:
 985     Changed |= setRetAndArgsNoUndef(F);
 986     Changed |= setDoesNotThrow(F);
 987     Changed |= setDoesNotCapture(F, 1);
 988     return Changed;
 989   case LibFunc_open64:
 990     // May throw; "open" is a valid pthread cancellation point.
 991     Changed |= setRetAndArgsNoUndef(F);
 992     Changed |= setDoesNotCapture(F, 0);
 993     Changed |= setOnlyReadsMemory(F, 0);
 994     return Changed;
 995   case LibFunc_gettimeofday:
 996     // Currently some platforms have the restrict keyword on the arguments to
 997     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
 998     // arguments.
 999     Changed |= setRetAndArgsNoUndef(F);
1000     Changed |= setDoesNotThrow(F);
1001     Changed |= setDoesNotCapture(F, 0);
1002     Changed |= setDoesNotCapture(F, 1);
1003     return Changed;
1004   case LibFunc_Znwj: // new(unsigned int)
1005   case LibFunc_Znwm: // new(unsigned long)
1006   case LibFunc_Znaj: // new[](unsigned int)
1007   case LibFunc_Znam: // new[](unsigned long)
1008   case LibFunc_msvc_new_int: // new(unsigned int)
1009   case LibFunc_msvc_new_longlong: // new(unsigned long long)
1010   case LibFunc_msvc_new_array_int: // new[](unsigned int)
1011   case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
1012     Changed |= setOnlyAccessesInaccessibleMemory(F);
1013     // Operator new always returns a nonnull noalias pointer
1014     Changed |= setRetNoUndef(F);
1015     Changed |= setRetNonNull(F);
1016     Changed |= setRetDoesNotAlias(F);
1017     Changed |= setWillReturn(F);
1018     return Changed;
1019   // TODO: add LibFunc entries for:
1020   // case LibFunc_memset_pattern4:
1021   // case LibFunc_memset_pattern8:
1022   case LibFunc_memset_pattern16:
1023     Changed |= setOnlyAccessesArgMemory(F);
1024     Changed |= setDoesNotCapture(F, 0);
1025     Changed |= setOnlyWritesMemory(F, 0);
1026     Changed |= setDoesNotCapture(F, 1);
1027     Changed |= setOnlyReadsMemory(F, 1);
1028     return Changed;
1029   case LibFunc_memset:
1030     Changed |= setOnlyAccessesArgMemory(F);
1031     Changed |= setWillReturn(F);
1032     Changed |= setDoesNotThrow(F);
1033     Changed |= setOnlyWritesMemory(F, 0);
1034     return Changed;
1035   // int __nvvm_reflect(const char *)
1036   case LibFunc_nvvm_reflect:
1037     Changed |= setRetAndArgsNoUndef(F);
1038     Changed |= setDoesNotAccessMemory(F);
1039     Changed |= setDoesNotThrow(F);
1040     return Changed;
1041   case LibFunc_ldexp:
1042   case LibFunc_ldexpf:
1043   case LibFunc_ldexpl:
1044     Changed |= setSignExtendedArg(F, 1);
1045     Changed |= setWillReturn(F);
1046     return Changed;
1047   case LibFunc_abs:
1048   case LibFunc_acos:
1049   case LibFunc_acosf:
1050   case LibFunc_acosh:
1051   case LibFunc_acoshf:
1052   case LibFunc_acoshl:
1053   case LibFunc_acosl:
1054   case LibFunc_asin:
1055   case LibFunc_asinf:
1056   case LibFunc_asinh:
1057   case LibFunc_asinhf:
1058   case LibFunc_asinhl:
1059   case LibFunc_asinl:
1060   case LibFunc_atan:
1061   case LibFunc_atan2:
1062   case LibFunc_atan2f:
1063   case LibFunc_atan2l:
1064   case LibFunc_atanf:
1065   case LibFunc_atanh:
1066   case LibFunc_atanhf:
1067   case LibFunc_atanhl:
1068   case LibFunc_atanl:
1069   case LibFunc_cbrt:
1070   case LibFunc_cbrtf:
1071   case LibFunc_cbrtl:
1072   case LibFunc_ceil:
1073   case LibFunc_ceilf:
1074   case LibFunc_ceill:
1075   case LibFunc_copysign:
1076   case LibFunc_copysignf:
1077   case LibFunc_copysignl:
1078   case LibFunc_cos:
1079   case LibFunc_cosh:
1080   case LibFunc_coshf:
1081   case LibFunc_coshl:
1082   case LibFunc_cosf:
1083   case LibFunc_cosl:
1084   case LibFunc_cospi:
1085   case LibFunc_cospif:
1086   case LibFunc_exp:
1087   case LibFunc_expf:
1088   case LibFunc_expl:
1089   case LibFunc_exp2:
1090   case LibFunc_exp2f:
1091   case LibFunc_exp2l:
1092   case LibFunc_expm1:
1093   case LibFunc_expm1f:
1094   case LibFunc_expm1l:
1095   case LibFunc_fabs:
1096   case LibFunc_fabsf:
1097   case LibFunc_fabsl:
1098   case LibFunc_ffs:
1099   case LibFunc_ffsl:
1100   case LibFunc_ffsll:
1101   case LibFunc_floor:
1102   case LibFunc_floorf:
1103   case LibFunc_floorl:
1104   case LibFunc_fls:
1105   case LibFunc_flsl:
1106   case LibFunc_flsll:
1107   case LibFunc_fmax:
1108   case LibFunc_fmaxf:
1109   case LibFunc_fmaxl:
1110   case LibFunc_fmin:
1111   case LibFunc_fminf:
1112   case LibFunc_fminl:
1113   case LibFunc_fmod:
1114   case LibFunc_fmodf:
1115   case LibFunc_fmodl:
1116   case LibFunc_isascii:
1117   case LibFunc_isdigit:
1118   case LibFunc_labs:
1119   case LibFunc_llabs:
1120   case LibFunc_log:
1121   case LibFunc_log10:
1122   case LibFunc_log10f:
1123   case LibFunc_log10l:
1124   case LibFunc_log1p:
1125   case LibFunc_log1pf:
1126   case LibFunc_log1pl:
1127   case LibFunc_log2:
1128   case LibFunc_log2f:
1129   case LibFunc_log2l:
1130   case LibFunc_logb:
1131   case LibFunc_logbf:
1132   case LibFunc_logbl:
1133   case LibFunc_logf:
1134   case LibFunc_logl:
1135   case LibFunc_nearbyint:
1136   case LibFunc_nearbyintf:
1137   case LibFunc_nearbyintl:
1138   case LibFunc_pow:
1139   case LibFunc_powf:
1140   case LibFunc_powl:
1141   case LibFunc_rint:
1142   case LibFunc_rintf:
1143   case LibFunc_rintl:
1144   case LibFunc_round:
1145   case LibFunc_roundf:
1146   case LibFunc_roundl:
1147   case LibFunc_sin:
1148   case LibFunc_sincospif_stret:
1149   case LibFunc_sinf:
1150   case LibFunc_sinh:
1151   case LibFunc_sinhf:
1152   case LibFunc_sinhl:
1153   case LibFunc_sinl:
1154   case LibFunc_sinpi:
1155   case LibFunc_sinpif:
1156   case LibFunc_sqrt:
1157   case LibFunc_sqrtf:
1158   case LibFunc_sqrtl:
1159   case LibFunc_strnlen:
1160   case LibFunc_tan:
1161   case LibFunc_tanf:
1162   case LibFunc_tanh:
1163   case LibFunc_tanhf:
1164   case LibFunc_tanhl:
1165   case LibFunc_tanl:
1166   case LibFunc_toascii:
1167   case LibFunc_trunc:
1168   case LibFunc_truncf:
1169   case LibFunc_truncl:
1170     Changed |= setDoesNotThrow(F);
1171     Changed |= setDoesNotFreeMemory(F);
1172     Changed |= setWillReturn(F);
1173     return Changed;
1174   default:
1175     // FIXME: It'd be really nice to cover all the library functions we're
1176     // aware of here.
1177     return false;
1178   }
1179 }
1180
1181 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
1182                       LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
1183   switch (Ty->getTypeID()) {
1184   case Type::HalfTyID:
1185     return false;
1186   case Type::FloatTyID:
1187     return TLI->has(FloatFn);
1188   case Type::DoubleTyID:
1189     return TLI->has(DoubleFn);
1190   default:
1191     return TLI->has(LongDoubleFn);
1192   }
1193 }
1194
1195 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
1196                                LibFunc DoubleFn, LibFunc FloatFn,
1197                                LibFunc LongDoubleFn) {
1198   assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
1199          "Cannot get name for unavailable function!");
1200
1201   switch (Ty->getTypeID()) {
1202   case Type::HalfTyID:
1203     llvm_unreachable("No name for HalfTy!");
1204   case Type::FloatTyID:
1205     return TLI->getName(FloatFn);
1206   case Type::DoubleTyID:
1207     return TLI->getName(DoubleFn);
1208   default:
1209     return TLI->getName(LongDoubleFn);
1210   }
1211 }
1212
1213 //- Emit LibCalls ------------------------------------------------------------//
1214
1215 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
1216   unsigned AS = V->getType()->getPointerAddressSpace();
1217   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
1218 }
1219
1220 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
1221                           ArrayRef<Type *> ParamTypes,
1222                           ArrayRef<Value *> Operands, IRBuilderBase &B,
1223                           const TargetLibraryInfo *TLI,
1224                           bool IsVaArgs = false) {
1225   if (!TLI->has(TheLibFunc))
1226     return nullptr;
1227
1228   Module *M = B.GetInsertBlock()->getModule();
1229   StringRef FuncName = TLI->getName(TheLibFunc);
1230   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
1231   FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
1232   inferLibFuncAttributes(M, FuncName, *TLI);
1233   CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
1234   if (const Function *F =
1235           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1236     CI->setCallingConv(F->getCallingConv());
1237   return CI;
1238 }
1239
1240 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
1241                         const TargetLibraryInfo *TLI) {
1242   LLVMContext &Context = B.GetInsertBlock()->getContext();
1243   return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
1244                      B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
1245 }
1246
1247 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
1248                         const TargetLibraryInfo *TLI) {
1249   return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
1250                      castToCStr(Ptr, B), B, TLI);
1251 }
1252
1253 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
1254                         const TargetLibraryInfo *TLI) {
1255   Type *I8Ptr = B.getInt8PtrTy();
1256   Type *I32Ty = B.getInt32Ty();
1257   return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
1258                      {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
1259 }
1260
1261 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1262                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
1263   LLVMContext &Context = B.GetInsertBlock()->getContext();
1264   return emitLibCall(
1265       LibFunc_strncmp, B.getInt32Ty(),
1266       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1267       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1268 }
1269
1270 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1271                         const TargetLibraryInfo *TLI) {
1272   Type *I8Ptr = B.getInt8PtrTy();
1273   return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1274                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1275 }
1276
1277 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1278                         const TargetLibraryInfo *TLI) {
1279   Type *I8Ptr = B.getInt8PtrTy();
1280   return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1281                      {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1282 }
1283
1284 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1285                          const TargetLibraryInfo *TLI) {
1286   Type *I8Ptr = B.getInt8PtrTy();
1287   return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1288                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1289 }
1290
1291 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1292                          const TargetLibraryInfo *TLI) {
1293   Type *I8Ptr = B.getInt8PtrTy();
1294   return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1295                      {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1296 }
1297
1298 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1299                            IRBuilderBase &B, const DataLayout &DL,
1300                            const TargetLibraryInfo *TLI) {
1301   if (!TLI->has(LibFunc_memcpy_chk))
1302     return nullptr;
1303
1304   Module *M = B.GetInsertBlock()->getModule();
1305   AttributeList AS;
1306   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1307                           Attribute::NoUnwind);
1308   LLVMContext &Context = B.GetInsertBlock()->getContext();
1309   FunctionCallee MemCpy = M->getOrInsertFunction(
1310       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
1311       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
1312       DL.getIntPtrType(Context));
1313   Dst = castToCStr(Dst, B);
1314   Src = castToCStr(Src, B);
1315   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1316   if (const Function *F =
1317           dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1318     CI->setCallingConv(F->getCallingConv());
1319   return CI;
1320 }
1321
1322 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1323                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
1324   LLVMContext &Context = B.GetInsertBlock()->getContext();
1325   return emitLibCall(
1326       LibFunc_mempcpy, B.getInt8PtrTy(),
1327       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1328       {Dst, Src, Len}, B, TLI);
1329 }
1330
1331 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1332                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1333   LLVMContext &Context = B.GetInsertBlock()->getContext();
1334   return emitLibCall(
1335       LibFunc_memchr, B.getInt8PtrTy(),
1336       {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
1337       {castToCStr(Ptr, B), Val, Len}, B, TLI);
1338 }
1339
1340 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1341                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1342   LLVMContext &Context = B.GetInsertBlock()->getContext();
1343   return emitLibCall(
1344       LibFunc_memcmp, B.getInt32Ty(),
1345       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1346       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1347 }
1348
1349 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1350                       const DataLayout &DL, const TargetLibraryInfo *TLI) {
1351   LLVMContext &Context = B.GetInsertBlock()->getContext();
1352   return emitLibCall(
1353       LibFunc_bcmp, B.getInt32Ty(),
1354       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1355       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1356 }
1357
1358 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1359                          IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1360   return emitLibCall(
1361       LibFunc_memccpy, B.getInt8PtrTy(),
1362       {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
1363       {Ptr1, Ptr2, Val, Len}, B, TLI);
1364 }
1365
1366 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1367                           ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1368                           const TargetLibraryInfo *TLI) {
1369   SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1370   llvm::append_range(Args, VariadicArgs);
1371   return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
1372                      {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
1373                      Args, B, TLI, /*IsVaArgs=*/true);
1374 }
1375
1376 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1377                          ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1378                          const TargetLibraryInfo *TLI) {
1379   SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1380   llvm::append_range(Args, VariadicArgs);
1381   return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
1382                      {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
1383                      /*IsVaArgs=*/true);
1384 }
1385
1386 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1387                         const TargetLibraryInfo *TLI) {
1388   return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1389                      {B.getInt8PtrTy(), B.getInt8PtrTy()},
1390                      {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1391 }
1392
1393 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1394                          const TargetLibraryInfo *TLI) {
1395   return emitLibCall(LibFunc_strlcpy, Size->getType(),
1396                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1397                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1398 }
1399
1400 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1401                          const TargetLibraryInfo *TLI) {
1402   return emitLibCall(LibFunc_strlcat, Size->getType(),
1403                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1404                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1405 }
1406
1407 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1408                          const TargetLibraryInfo *TLI) {
1409   return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1410                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1411                      {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1412 }
1413
1414 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1415                            IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1416   return emitLibCall(
1417       LibFunc_vsnprintf, B.getInt32Ty(),
1418       {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1419       {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1420 }
1421
1422 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1423                           IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1424   return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1425                      {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1426                      {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1427 }
1428
1429 /// Append a suffix to the function name according to the type of 'Op'.
1430 static void appendTypeSuffix(Value *Op, StringRef &Name,
1431                              SmallString<20> &NameBuffer) {
1432   if (!Op->getType()->isDoubleTy()) {
1433       NameBuffer += Name;
1434
1435     if (Op->getType()->isFloatTy())
1436       NameBuffer += 'f';
1437     else
1438       NameBuffer += 'l';
1439
1440     Name = NameBuffer;
1441   }
1442 }
1443
1444 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1445                                          IRBuilderBase &B,
1446                                          const AttributeList &Attrs) {
1447   assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1448
1449   Module *M = B.GetInsertBlock()->getModule();
1450   FunctionCallee Callee =
1451       M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1452   CallInst *CI = B.CreateCall(Callee, Op, Name);
1453
1454   // The incoming attribute set may have come from a speculatable intrinsic, but
1455   // is being replaced with a library call which is not allowed to be
1456   // speculatable.
1457   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1458                                           AttributeList::FunctionIndex,
1459                                           Attribute::Speculatable));
1460   if (const Function *F =
1461           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1462     CI->setCallingConv(F->getCallingConv());
1463
1464   return CI;
1465 }
1466
1467 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
1468                                   const AttributeList &Attrs) {
1469   SmallString<20> NameBuffer;
1470   appendTypeSuffix(Op, Name, NameBuffer);
1471
1472   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1473 }
1474
1475 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1476                                   LibFunc DoubleFn, LibFunc FloatFn,
1477                                   LibFunc LongDoubleFn, IRBuilderBase &B,
1478                                   const AttributeList &Attrs) {
1479   // Get the name of the function according to TLI.
1480   StringRef Name = getFloatFnName(TLI, Op->getType(),
1481                                   DoubleFn, FloatFn, LongDoubleFn);
1482
1483   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1484 }
1485
1486 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1487                                           StringRef Name, IRBuilderBase &B,
1488                                           const AttributeList &Attrs,
1489                                           const TargetLibraryInfo *TLI = nullptr) {
1490   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1491
1492   Module *M = B.GetInsertBlock()->getModule();
1493   FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1494                                                  Op1->getType(), Op2->getType());
1495   if (TLI != nullptr)
1496     inferLibFuncAttributes(M, Name, *TLI);
1497   CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1498
1499   // The incoming attribute set may have come from a speculatable intrinsic, but
1500   // is being replaced with a library call which is not allowed to be
1501   // speculatable.
1502   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1503                                           AttributeList::FunctionIndex,
1504                                           Attribute::Speculatable));
1505   if (const Function *F =
1506           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1507     CI->setCallingConv(F->getCallingConv());
1508
1509   return CI;
1510 }
1511
1512 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1513                                    IRBuilderBase &B,
1514                                    const AttributeList &Attrs) {
1515   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1516
1517   SmallString<20> NameBuffer;
1518   appendTypeSuffix(Op1, Name, NameBuffer);
1519
1520   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1521 }
1522
1523 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1524                                    const TargetLibraryInfo *TLI,
1525                                    LibFunc DoubleFn, LibFunc FloatFn,
1526                                    LibFunc LongDoubleFn, IRBuilderBase &B,
1527                                    const AttributeList &Attrs) {
1528   // Get the name of the function according to TLI.
1529   StringRef Name = getFloatFnName(TLI, Op1->getType(),
1530                                   DoubleFn, FloatFn, LongDoubleFn);
1531
1532   return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs, TLI);
1533 }
1534
1535 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1536                          const TargetLibraryInfo *TLI) {
1537   if (!TLI->has(LibFunc_putchar))
1538     return nullptr;
1539
1540   Module *M = B.GetInsertBlock()->getModule();
1541   StringRef PutCharName = TLI->getName(LibFunc_putchar);
1542   FunctionCallee PutChar =
1543       M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1544   inferLibFuncAttributes(M, PutCharName, *TLI);
1545   CallInst *CI = B.CreateCall(PutChar,
1546                               B.CreateIntCast(Char,
1547                               B.getInt32Ty(),
1548                               /*isSigned*/true,
1549                               "chari"),
1550                               PutCharName);
1551
1552   if (const Function *F =
1553           dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1554     CI->setCallingConv(F->getCallingConv());
1555   return CI;
1556 }
1557
1558 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1559                       const TargetLibraryInfo *TLI) {
1560   if (!TLI->has(LibFunc_puts))
1561     return nullptr;
1562
1563   Module *M = B.GetInsertBlock()->getModule();
1564   StringRef PutsName = TLI->getName(LibFunc_puts);
1565   FunctionCallee PutS =
1566       M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1567   inferLibFuncAttributes(M, PutsName, *TLI);
1568   CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1569   if (const Function *F =
1570           dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1571     CI->setCallingConv(F->getCallingConv());
1572   return CI;
1573 }
1574
1575 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1576                        const TargetLibraryInfo *TLI) {
1577   if (!TLI->has(LibFunc_fputc))
1578     return nullptr;
1579
1580   Module *M = B.GetInsertBlock()->getModule();
1581   StringRef FPutcName = TLI->getName(LibFunc_fputc);
1582   FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1583                                             B.getInt32Ty(), File->getType());
1584   if (File->getType()->isPointerTy())
1585     inferLibFuncAttributes(M, FPutcName, *TLI);
1586   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1587                          "chari");
1588   CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1589
1590   if (const Function *Fn =
1591           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1592     CI->setCallingConv(Fn->getCallingConv());
1593   return CI;
1594 }
1595
1596 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1597                        const TargetLibraryInfo *TLI) {
1598   if (!TLI->has(LibFunc_fputs))
1599     return nullptr;
1600
1601   Module *M = B.GetInsertBlock()->getModule();
1602   StringRef FPutsName = TLI->getName(LibFunc_fputs);
1603   FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1604                                             B.getInt8PtrTy(), File->getType());
1605   if (File->getType()->isPointerTy())
1606     inferLibFuncAttributes(M, FPutsName, *TLI);
1607   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1608
1609   if (const Function *Fn =
1610           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1611     CI->setCallingConv(Fn->getCallingConv());
1612   return CI;
1613 }
1614
1615 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1616                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1617   if (!TLI->has(LibFunc_fwrite))
1618     return nullptr;
1619
1620   Module *M = B.GetInsertBlock()->getModule();
1621   LLVMContext &Context = B.GetInsertBlock()->getContext();
1622   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1623   FunctionCallee F = M->getOrInsertFunction(
1624       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1625       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1626
1627   if (File->getType()->isPointerTy())
1628     inferLibFuncAttributes(M, FWriteName, *TLI);
1629   CallInst *CI =
1630       B.CreateCall(F, {castToCStr(Ptr, B), Size,
1631                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1632
1633   if (const Function *Fn =
1634           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1635     CI->setCallingConv(Fn->getCallingConv());
1636   return CI;
1637 }
1638
1639 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1640                         const TargetLibraryInfo *TLI) {
1641   if (!TLI->has(LibFunc_malloc))
1642     return nullptr;
1643
1644   Module *M = B.GetInsertBlock()->getModule();
1645   StringRef MallocName = TLI->getName(LibFunc_malloc);
1646   LLVMContext &Context = B.GetInsertBlock()->getContext();
1647   FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1648                                                  DL.getIntPtrType(Context));
1649   inferLibFuncAttributes(M, MallocName, *TLI);
1650   CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1651
1652   if (const Function *F =
1653           dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1654     CI->setCallingConv(F->getCallingConv());
1655
1656   return CI;
1657 }
1658
1659 Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
1660                         IRBuilderBase &B, const TargetLibraryInfo &TLI) {
1661   if (!TLI.has(LibFunc_calloc))
1662     return nullptr;
1663
1664   Module *M = B.GetInsertBlock()->getModule();
1665   StringRef CallocName = TLI.getName(LibFunc_calloc);
1666   const DataLayout &DL = M->getDataLayout();
1667   IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1668   FunctionCallee Calloc = M->getOrInsertFunction(
1669       CallocName, Attrs, B.getInt8PtrTy(), PtrType, PtrType);
1670   inferLibFuncAttributes(M, CallocName, TLI);
1671   CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1672
1673   if (const auto *F =
1674           dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1675     CI->setCallingConv(F->getCallingConv());
1676
1677   return CI;
1678 }