contrib/llvm/lib/Transforms/Utils/BuildLibCalls.cpp

   1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
   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 some functions that will create standard C libcalls.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Transforms/Utils/BuildLibCalls.h"
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/ADT/Statistic.h"
  17 #include "llvm/Analysis/TargetLibraryInfo.h"
  18 #include "llvm/IR/Constants.h"
  19 #include "llvm/IR/DataLayout.h"
  20 #include "llvm/IR/Function.h"
  21 #include "llvm/IR/IRBuilder.h"
  22 #include "llvm/IR/Intrinsics.h"
  23 #include "llvm/IR/LLVMContext.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/IR/Type.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(NumReadOnly, "Number of functions inferred as readonly");
  35 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
  36 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
  37 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
  38 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
  39 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
  40 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
  41 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
  42
  43 static bool setDoesNotAccessMemory(Function &F) {
  44   if (F.doesNotAccessMemory())
  45     return false;
  46   F.setDoesNotAccessMemory();
  47   ++NumReadNone;
  48   return true;
  49 }
  50
  51 static bool setOnlyReadsMemory(Function &F) {
  52   if (F.onlyReadsMemory())
  53     return false;
  54   F.setOnlyReadsMemory();
  55   ++NumReadOnly;
  56   return true;
  57 }
  58
  59 static bool setOnlyAccessesArgMemory(Function &F) {
  60   if (F.onlyAccessesArgMemory())
  61     return false;
  62   F.setOnlyAccessesArgMemory();
  63   ++NumArgMemOnly;
  64   return true;
  65 }
  66
  67 static bool setDoesNotThrow(Function &F) {
  68   if (F.doesNotThrow())
  69     return false;
  70   F.setDoesNotThrow();
  71   ++NumNoUnwind;
  72   return true;
  73 }
  74
  75 static bool setRetDoesNotAlias(Function &F) {
  76   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
  77     return false;
  78   F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
  79   ++NumNoAlias;
  80   return true;
  81 }
  82
  83 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
  84   if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
  85     return false;
  86   F.addParamAttr(ArgNo, Attribute::NoCapture);
  87   ++NumNoCapture;
  88   return true;
  89 }
  90
  91 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
  92   if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
  93     return false;
  94   F.addParamAttr(ArgNo, Attribute::ReadOnly);
  95   ++NumReadOnlyArg;
  96   return true;
  97 }
  98
  99 static bool setRetNonNull(Function &F) {
 100   assert(F.getReturnType()->isPointerTy() &&
 101          "nonnull applies only to pointers");
 102   if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
 103     return false;
 104   F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
 105   ++NumNonNull;
 106   return true;
 107 }
 108
 109 static bool setReturnedArg(Function &F, unsigned ArgNo) {
 110   if (F.hasParamAttribute(ArgNo, Attribute::Returned))
 111     return false;
 112   F.addParamAttr(ArgNo, Attribute::Returned);
 113   ++NumReturnedArg;
 114   return true;
 115 }
 116
 117 static bool setNonLazyBind(Function &F) {
 118   if (F.hasFnAttribute(Attribute::NonLazyBind))
 119     return false;
 120   F.addFnAttr(Attribute::NonLazyBind);
 121   return true;
 122 }
 123
 124 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
 125                                   const TargetLibraryInfo &TLI) {
 126   Function *F = M->getFunction(Name);
 127   if (!F)
 128     return false;
 129   return inferLibFuncAttributes(*F, TLI);
 130 }
 131
 132 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
 133   LibFunc TheLibFunc;
 134   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
 135     return false;
 136
 137   bool Changed = false;
 138
 139   if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
 140     Changed |= setNonLazyBind(F);
 141
 142   switch (TheLibFunc) {
 143   case LibFunc_strlen:
 144   case LibFunc_wcslen:
 145     Changed |= setOnlyReadsMemory(F);
 146     Changed |= setDoesNotThrow(F);
 147     Changed |= setOnlyAccessesArgMemory(F);
 148     Changed |= setDoesNotCapture(F, 0);
 149     return Changed;
 150   case LibFunc_strchr:
 151   case LibFunc_strrchr:
 152     Changed |= setOnlyReadsMemory(F);
 153     Changed |= setDoesNotThrow(F);
 154     return Changed;
 155   case LibFunc_strtol:
 156   case LibFunc_strtod:
 157   case LibFunc_strtof:
 158   case LibFunc_strtoul:
 159   case LibFunc_strtoll:
 160   case LibFunc_strtold:
 161   case LibFunc_strtoull:
 162     Changed |= setDoesNotThrow(F);
 163     Changed |= setDoesNotCapture(F, 1);
 164     Changed |= setOnlyReadsMemory(F, 0);
 165     return Changed;
 166   case LibFunc_strcpy:
 167   case LibFunc_strncpy:
 168   case LibFunc_strcat:
 169   case LibFunc_strncat:
 170     Changed |= setReturnedArg(F, 0);
 171     LLVM_FALLTHROUGH;
 172   case LibFunc_stpcpy:
 173   case LibFunc_stpncpy:
 174     Changed |= setDoesNotThrow(F);
 175     Changed |= setDoesNotCapture(F, 1);
 176     Changed |= setOnlyReadsMemory(F, 1);
 177     return Changed;
 178   case LibFunc_strxfrm:
 179     Changed |= setDoesNotThrow(F);
 180     Changed |= setDoesNotCapture(F, 0);
 181     Changed |= setDoesNotCapture(F, 1);
 182     Changed |= setOnlyReadsMemory(F, 1);
 183     return Changed;
 184   case LibFunc_strcmp:      // 0,1
 185   case LibFunc_strspn:      // 0,1
 186   case LibFunc_strncmp:     // 0,1
 187   case LibFunc_strcspn:     // 0,1
 188   case LibFunc_strcoll:     // 0,1
 189   case LibFunc_strcasecmp:  // 0,1
 190   case LibFunc_strncasecmp: //
 191     Changed |= setOnlyReadsMemory(F);
 192     Changed |= setDoesNotThrow(F);
 193     Changed |= setDoesNotCapture(F, 0);
 194     Changed |= setDoesNotCapture(F, 1);
 195     return Changed;
 196   case LibFunc_strstr:
 197   case LibFunc_strpbrk:
 198     Changed |= setOnlyReadsMemory(F);
 199     Changed |= setDoesNotThrow(F);
 200     Changed |= setDoesNotCapture(F, 1);
 201     return Changed;
 202   case LibFunc_strtok:
 203   case LibFunc_strtok_r:
 204     Changed |= setDoesNotThrow(F);
 205     Changed |= setDoesNotCapture(F, 1);
 206     Changed |= setOnlyReadsMemory(F, 1);
 207     return Changed;
 208   case LibFunc_scanf:
 209     Changed |= setDoesNotThrow(F);
 210     Changed |= setDoesNotCapture(F, 0);
 211     Changed |= setOnlyReadsMemory(F, 0);
 212     return Changed;
 213   case LibFunc_setbuf:
 214   case LibFunc_setvbuf:
 215     Changed |= setDoesNotThrow(F);
 216     Changed |= setDoesNotCapture(F, 0);
 217     return Changed;
 218   case LibFunc_strdup:
 219   case LibFunc_strndup:
 220     Changed |= setDoesNotThrow(F);
 221     Changed |= setRetDoesNotAlias(F);
 222     Changed |= setDoesNotCapture(F, 0);
 223     Changed |= setOnlyReadsMemory(F, 0);
 224     return Changed;
 225   case LibFunc_stat:
 226   case LibFunc_statvfs:
 227     Changed |= setDoesNotThrow(F);
 228     Changed |= setDoesNotCapture(F, 0);
 229     Changed |= setDoesNotCapture(F, 1);
 230     Changed |= setOnlyReadsMemory(F, 0);
 231     return Changed;
 232   case LibFunc_sscanf:
 233     Changed |= setDoesNotThrow(F);
 234     Changed |= setDoesNotCapture(F, 0);
 235     Changed |= setDoesNotCapture(F, 1);
 236     Changed |= setOnlyReadsMemory(F, 0);
 237     Changed |= setOnlyReadsMemory(F, 1);
 238     return Changed;
 239   case LibFunc_sprintf:
 240     Changed |= setDoesNotThrow(F);
 241     Changed |= setDoesNotCapture(F, 0);
 242     Changed |= setDoesNotCapture(F, 1);
 243     Changed |= setOnlyReadsMemory(F, 1);
 244     return Changed;
 245   case LibFunc_snprintf:
 246     Changed |= setDoesNotThrow(F);
 247     Changed |= setDoesNotCapture(F, 0);
 248     Changed |= setDoesNotCapture(F, 2);
 249     Changed |= setOnlyReadsMemory(F, 2);
 250     return Changed;
 251   case LibFunc_setitimer:
 252     Changed |= setDoesNotThrow(F);
 253     Changed |= setDoesNotCapture(F, 1);
 254     Changed |= setDoesNotCapture(F, 2);
 255     Changed |= setOnlyReadsMemory(F, 1);
 256     return Changed;
 257   case LibFunc_system:
 258     // May throw; "system" is a valid pthread cancellation point.
 259     Changed |= setDoesNotCapture(F, 0);
 260     Changed |= setOnlyReadsMemory(F, 0);
 261     return Changed;
 262   case LibFunc_malloc:
 263     Changed |= setDoesNotThrow(F);
 264     Changed |= setRetDoesNotAlias(F);
 265     return Changed;
 266   case LibFunc_memcmp:
 267     Changed |= setOnlyReadsMemory(F);
 268     Changed |= setDoesNotThrow(F);
 269     Changed |= setDoesNotCapture(F, 0);
 270     Changed |= setDoesNotCapture(F, 1);
 271     return Changed;
 272   case LibFunc_memchr:
 273   case LibFunc_memrchr:
 274     Changed |= setOnlyReadsMemory(F);
 275     Changed |= setDoesNotThrow(F);
 276     return Changed;
 277   case LibFunc_modf:
 278   case LibFunc_modff:
 279   case LibFunc_modfl:
 280     Changed |= setDoesNotThrow(F);
 281     Changed |= setDoesNotCapture(F, 1);
 282     return Changed;
 283   case LibFunc_memcpy:
 284   case LibFunc_memmove:
 285     Changed |= setReturnedArg(F, 0);
 286     LLVM_FALLTHROUGH;
 287   case LibFunc_mempcpy:
 288   case LibFunc_memccpy:
 289     Changed |= setDoesNotThrow(F);
 290     Changed |= setDoesNotCapture(F, 1);
 291     Changed |= setOnlyReadsMemory(F, 1);
 292     return Changed;
 293   case LibFunc_memcpy_chk:
 294     Changed |= setDoesNotThrow(F);
 295     return Changed;
 296   case LibFunc_memalign:
 297     Changed |= setRetDoesNotAlias(F);
 298     return Changed;
 299   case LibFunc_mkdir:
 300     Changed |= setDoesNotThrow(F);
 301     Changed |= setDoesNotCapture(F, 0);
 302     Changed |= setOnlyReadsMemory(F, 0);
 303     return Changed;
 304   case LibFunc_mktime:
 305     Changed |= setDoesNotThrow(F);
 306     Changed |= setDoesNotCapture(F, 0);
 307     return Changed;
 308   case LibFunc_realloc:
 309     Changed |= setDoesNotThrow(F);
 310     Changed |= setRetDoesNotAlias(F);
 311     Changed |= setDoesNotCapture(F, 0);
 312     return Changed;
 313   case LibFunc_read:
 314     // May throw; "read" is a valid pthread cancellation point.
 315     Changed |= setDoesNotCapture(F, 1);
 316     return Changed;
 317   case LibFunc_rewind:
 318     Changed |= setDoesNotThrow(F);
 319     Changed |= setDoesNotCapture(F, 0);
 320     return Changed;
 321   case LibFunc_rmdir:
 322   case LibFunc_remove:
 323   case LibFunc_realpath:
 324     Changed |= setDoesNotThrow(F);
 325     Changed |= setDoesNotCapture(F, 0);
 326     Changed |= setOnlyReadsMemory(F, 0);
 327     return Changed;
 328   case LibFunc_rename:
 329     Changed |= setDoesNotThrow(F);
 330     Changed |= setDoesNotCapture(F, 0);
 331     Changed |= setDoesNotCapture(F, 1);
 332     Changed |= setOnlyReadsMemory(F, 0);
 333     Changed |= setOnlyReadsMemory(F, 1);
 334     return Changed;
 335   case LibFunc_readlink:
 336     Changed |= setDoesNotThrow(F);
 337     Changed |= setDoesNotCapture(F, 0);
 338     Changed |= setDoesNotCapture(F, 1);
 339     Changed |= setOnlyReadsMemory(F, 0);
 340     return Changed;
 341   case LibFunc_write:
 342     // May throw; "write" is a valid pthread cancellation point.
 343     Changed |= setDoesNotCapture(F, 1);
 344     Changed |= setOnlyReadsMemory(F, 1);
 345     return Changed;
 346   case LibFunc_bcopy:
 347     Changed |= setDoesNotThrow(F);
 348     Changed |= setDoesNotCapture(F, 0);
 349     Changed |= setDoesNotCapture(F, 1);
 350     Changed |= setOnlyReadsMemory(F, 0);
 351     return Changed;
 352   case LibFunc_bcmp:
 353     Changed |= setDoesNotThrow(F);
 354     Changed |= setOnlyReadsMemory(F);
 355     Changed |= setDoesNotCapture(F, 0);
 356     Changed |= setDoesNotCapture(F, 1);
 357     return Changed;
 358   case LibFunc_bzero:
 359     Changed |= setDoesNotThrow(F);
 360     Changed |= setDoesNotCapture(F, 0);
 361     return Changed;
 362   case LibFunc_calloc:
 363     Changed |= setDoesNotThrow(F);
 364     Changed |= setRetDoesNotAlias(F);
 365     return Changed;
 366   case LibFunc_chmod:
 367   case LibFunc_chown:
 368     Changed |= setDoesNotThrow(F);
 369     Changed |= setDoesNotCapture(F, 0);
 370     Changed |= setOnlyReadsMemory(F, 0);
 371     return Changed;
 372   case LibFunc_ctermid:
 373   case LibFunc_clearerr:
 374   case LibFunc_closedir:
 375     Changed |= setDoesNotThrow(F);
 376     Changed |= setDoesNotCapture(F, 0);
 377     return Changed;
 378   case LibFunc_atoi:
 379   case LibFunc_atol:
 380   case LibFunc_atof:
 381   case LibFunc_atoll:
 382     Changed |= setDoesNotThrow(F);
 383     Changed |= setOnlyReadsMemory(F);
 384     Changed |= setDoesNotCapture(F, 0);
 385     return Changed;
 386   case LibFunc_access:
 387     Changed |= setDoesNotThrow(F);
 388     Changed |= setDoesNotCapture(F, 0);
 389     Changed |= setOnlyReadsMemory(F, 0);
 390     return Changed;
 391   case LibFunc_fopen:
 392     Changed |= setDoesNotThrow(F);
 393     Changed |= setRetDoesNotAlias(F);
 394     Changed |= setDoesNotCapture(F, 0);
 395     Changed |= setDoesNotCapture(F, 1);
 396     Changed |= setOnlyReadsMemory(F, 0);
 397     Changed |= setOnlyReadsMemory(F, 1);
 398     return Changed;
 399   case LibFunc_fdopen:
 400     Changed |= setDoesNotThrow(F);
 401     Changed |= setRetDoesNotAlias(F);
 402     Changed |= setDoesNotCapture(F, 1);
 403     Changed |= setOnlyReadsMemory(F, 1);
 404     return Changed;
 405   case LibFunc_feof:
 406   case LibFunc_free:
 407   case LibFunc_fseek:
 408   case LibFunc_ftell:
 409   case LibFunc_fgetc:
 410   case LibFunc_fgetc_unlocked:
 411   case LibFunc_fseeko:
 412   case LibFunc_ftello:
 413   case LibFunc_fileno:
 414   case LibFunc_fflush:
 415   case LibFunc_fclose:
 416   case LibFunc_fsetpos:
 417   case LibFunc_flockfile:
 418   case LibFunc_funlockfile:
 419   case LibFunc_ftrylockfile:
 420     Changed |= setDoesNotThrow(F);
 421     Changed |= setDoesNotCapture(F, 0);
 422     return Changed;
 423   case LibFunc_ferror:
 424     Changed |= setDoesNotThrow(F);
 425     Changed |= setDoesNotCapture(F, 0);
 426     Changed |= setOnlyReadsMemory(F);
 427     return Changed;
 428   case LibFunc_fputc:
 429   case LibFunc_fputc_unlocked:
 430   case LibFunc_fstat:
 431   case LibFunc_frexp:
 432   case LibFunc_frexpf:
 433   case LibFunc_frexpl:
 434   case LibFunc_fstatvfs:
 435     Changed |= setDoesNotThrow(F);
 436     Changed |= setDoesNotCapture(F, 1);
 437     return Changed;
 438   case LibFunc_fgets:
 439   case LibFunc_fgets_unlocked:
 440     Changed |= setDoesNotThrow(F);
 441     Changed |= setDoesNotCapture(F, 2);
 442     return Changed;
 443   case LibFunc_fread:
 444   case LibFunc_fread_unlocked:
 445     Changed |= setDoesNotThrow(F);
 446     Changed |= setDoesNotCapture(F, 0);
 447     Changed |= setDoesNotCapture(F, 3);
 448     return Changed;
 449   case LibFunc_fwrite:
 450   case LibFunc_fwrite_unlocked:
 451     Changed |= setDoesNotThrow(F);
 452     Changed |= setDoesNotCapture(F, 0);
 453     Changed |= setDoesNotCapture(F, 3);
 454     // FIXME: readonly #1?
 455     return Changed;
 456   case LibFunc_fputs:
 457   case LibFunc_fputs_unlocked:
 458     Changed |= setDoesNotThrow(F);
 459     Changed |= setDoesNotCapture(F, 0);
 460     Changed |= setDoesNotCapture(F, 1);
 461     Changed |= setOnlyReadsMemory(F, 0);
 462     return Changed;
 463   case LibFunc_fscanf:
 464   case LibFunc_fprintf:
 465     Changed |= setDoesNotThrow(F);
 466     Changed |= setDoesNotCapture(F, 0);
 467     Changed |= setDoesNotCapture(F, 1);
 468     Changed |= setOnlyReadsMemory(F, 1);
 469     return Changed;
 470   case LibFunc_fgetpos:
 471     Changed |= setDoesNotThrow(F);
 472     Changed |= setDoesNotCapture(F, 0);
 473     Changed |= setDoesNotCapture(F, 1);
 474     return Changed;
 475   case LibFunc_getc:
 476   case LibFunc_getlogin_r:
 477   case LibFunc_getc_unlocked:
 478     Changed |= setDoesNotThrow(F);
 479     Changed |= setDoesNotCapture(F, 0);
 480     return Changed;
 481   case LibFunc_getenv:
 482     Changed |= setDoesNotThrow(F);
 483     Changed |= setOnlyReadsMemory(F);
 484     Changed |= setDoesNotCapture(F, 0);
 485     return Changed;
 486   case LibFunc_gets:
 487   case LibFunc_getchar:
 488   case LibFunc_getchar_unlocked:
 489     Changed |= setDoesNotThrow(F);
 490     return Changed;
 491   case LibFunc_getitimer:
 492     Changed |= setDoesNotThrow(F);
 493     Changed |= setDoesNotCapture(F, 1);
 494     return Changed;
 495   case LibFunc_getpwnam:
 496     Changed |= setDoesNotThrow(F);
 497     Changed |= setDoesNotCapture(F, 0);
 498     Changed |= setOnlyReadsMemory(F, 0);
 499     return Changed;
 500   case LibFunc_ungetc:
 501     Changed |= setDoesNotThrow(F);
 502     Changed |= setDoesNotCapture(F, 1);
 503     return Changed;
 504   case LibFunc_uname:
 505     Changed |= setDoesNotThrow(F);
 506     Changed |= setDoesNotCapture(F, 0);
 507     return Changed;
 508   case LibFunc_unlink:
 509     Changed |= setDoesNotThrow(F);
 510     Changed |= setDoesNotCapture(F, 0);
 511     Changed |= setOnlyReadsMemory(F, 0);
 512     return Changed;
 513   case LibFunc_unsetenv:
 514     Changed |= setDoesNotThrow(F);
 515     Changed |= setDoesNotCapture(F, 0);
 516     Changed |= setOnlyReadsMemory(F, 0);
 517     return Changed;
 518   case LibFunc_utime:
 519   case LibFunc_utimes:
 520     Changed |= setDoesNotThrow(F);
 521     Changed |= setDoesNotCapture(F, 0);
 522     Changed |= setDoesNotCapture(F, 1);
 523     Changed |= setOnlyReadsMemory(F, 0);
 524     Changed |= setOnlyReadsMemory(F, 1);
 525     return Changed;
 526   case LibFunc_putc:
 527   case LibFunc_putc_unlocked:
 528     Changed |= setDoesNotThrow(F);
 529     Changed |= setDoesNotCapture(F, 1);
 530     return Changed;
 531   case LibFunc_puts:
 532   case LibFunc_printf:
 533   case LibFunc_perror:
 534     Changed |= setDoesNotThrow(F);
 535     Changed |= setDoesNotCapture(F, 0);
 536     Changed |= setOnlyReadsMemory(F, 0);
 537     return Changed;
 538   case LibFunc_pread:
 539     // May throw; "pread" is a valid pthread cancellation point.
 540     Changed |= setDoesNotCapture(F, 1);
 541     return Changed;
 542   case LibFunc_pwrite:
 543     // May throw; "pwrite" is a valid pthread cancellation point.
 544     Changed |= setDoesNotCapture(F, 1);
 545     Changed |= setOnlyReadsMemory(F, 1);
 546     return Changed;
 547   case LibFunc_putchar:
 548   case LibFunc_putchar_unlocked:
 549     Changed |= setDoesNotThrow(F);
 550     return Changed;
 551   case LibFunc_popen:
 552     Changed |= setDoesNotThrow(F);
 553     Changed |= setRetDoesNotAlias(F);
 554     Changed |= setDoesNotCapture(F, 0);
 555     Changed |= setDoesNotCapture(F, 1);
 556     Changed |= setOnlyReadsMemory(F, 0);
 557     Changed |= setOnlyReadsMemory(F, 1);
 558     return Changed;
 559   case LibFunc_pclose:
 560     Changed |= setDoesNotThrow(F);
 561     Changed |= setDoesNotCapture(F, 0);
 562     return Changed;
 563   case LibFunc_vscanf:
 564     Changed |= setDoesNotThrow(F);
 565     Changed |= setDoesNotCapture(F, 0);
 566     Changed |= setOnlyReadsMemory(F, 0);
 567     return Changed;
 568   case LibFunc_vsscanf:
 569     Changed |= setDoesNotThrow(F);
 570     Changed |= setDoesNotCapture(F, 0);
 571     Changed |= setDoesNotCapture(F, 1);
 572     Changed |= setOnlyReadsMemory(F, 0);
 573     Changed |= setOnlyReadsMemory(F, 1);
 574     return Changed;
 575   case LibFunc_vfscanf:
 576     Changed |= setDoesNotThrow(F);
 577     Changed |= setDoesNotCapture(F, 0);
 578     Changed |= setDoesNotCapture(F, 1);
 579     Changed |= setOnlyReadsMemory(F, 1);
 580     return Changed;
 581   case LibFunc_valloc:
 582     Changed |= setDoesNotThrow(F);
 583     Changed |= setRetDoesNotAlias(F);
 584     return Changed;
 585   case LibFunc_vprintf:
 586     Changed |= setDoesNotThrow(F);
 587     Changed |= setDoesNotCapture(F, 0);
 588     Changed |= setOnlyReadsMemory(F, 0);
 589     return Changed;
 590   case LibFunc_vfprintf:
 591   case LibFunc_vsprintf:
 592     Changed |= setDoesNotThrow(F);
 593     Changed |= setDoesNotCapture(F, 0);
 594     Changed |= setDoesNotCapture(F, 1);
 595     Changed |= setOnlyReadsMemory(F, 1);
 596     return Changed;
 597   case LibFunc_vsnprintf:
 598     Changed |= setDoesNotThrow(F);
 599     Changed |= setDoesNotCapture(F, 0);
 600     Changed |= setDoesNotCapture(F, 2);
 601     Changed |= setOnlyReadsMemory(F, 2);
 602     return Changed;
 603   case LibFunc_open:
 604     // May throw; "open" is a valid pthread cancellation point.
 605     Changed |= setDoesNotCapture(F, 0);
 606     Changed |= setOnlyReadsMemory(F, 0);
 607     return Changed;
 608   case LibFunc_opendir:
 609     Changed |= setDoesNotThrow(F);
 610     Changed |= setRetDoesNotAlias(F);
 611     Changed |= setDoesNotCapture(F, 0);
 612     Changed |= setOnlyReadsMemory(F, 0);
 613     return Changed;
 614   case LibFunc_tmpfile:
 615     Changed |= setDoesNotThrow(F);
 616     Changed |= setRetDoesNotAlias(F);
 617     return Changed;
 618   case LibFunc_times:
 619     Changed |= setDoesNotThrow(F);
 620     Changed |= setDoesNotCapture(F, 0);
 621     return Changed;
 622   case LibFunc_htonl:
 623   case LibFunc_htons:
 624   case LibFunc_ntohl:
 625   case LibFunc_ntohs:
 626     Changed |= setDoesNotThrow(F);
 627     Changed |= setDoesNotAccessMemory(F);
 628     return Changed;
 629   case LibFunc_lstat:
 630     Changed |= setDoesNotThrow(F);
 631     Changed |= setDoesNotCapture(F, 0);
 632     Changed |= setDoesNotCapture(F, 1);
 633     Changed |= setOnlyReadsMemory(F, 0);
 634     return Changed;
 635   case LibFunc_lchown:
 636     Changed |= setDoesNotThrow(F);
 637     Changed |= setDoesNotCapture(F, 0);
 638     Changed |= setOnlyReadsMemory(F, 0);
 639     return Changed;
 640   case LibFunc_qsort:
 641     // May throw; places call through function pointer.
 642     Changed |= setDoesNotCapture(F, 3);
 643     return Changed;
 644   case LibFunc_dunder_strdup:
 645   case LibFunc_dunder_strndup:
 646     Changed |= setDoesNotThrow(F);
 647     Changed |= setRetDoesNotAlias(F);
 648     Changed |= setDoesNotCapture(F, 0);
 649     Changed |= setOnlyReadsMemory(F, 0);
 650     return Changed;
 651   case LibFunc_dunder_strtok_r:
 652     Changed |= setDoesNotThrow(F);
 653     Changed |= setDoesNotCapture(F, 1);
 654     Changed |= setOnlyReadsMemory(F, 1);
 655     return Changed;
 656   case LibFunc_under_IO_getc:
 657     Changed |= setDoesNotThrow(F);
 658     Changed |= setDoesNotCapture(F, 0);
 659     return Changed;
 660   case LibFunc_under_IO_putc:
 661     Changed |= setDoesNotThrow(F);
 662     Changed |= setDoesNotCapture(F, 1);
 663     return Changed;
 664   case LibFunc_dunder_isoc99_scanf:
 665     Changed |= setDoesNotThrow(F);
 666     Changed |= setDoesNotCapture(F, 0);
 667     Changed |= setOnlyReadsMemory(F, 0);
 668     return Changed;
 669   case LibFunc_stat64:
 670   case LibFunc_lstat64:
 671   case LibFunc_statvfs64:
 672     Changed |= setDoesNotThrow(F);
 673     Changed |= setDoesNotCapture(F, 0);
 674     Changed |= setDoesNotCapture(F, 1);
 675     Changed |= setOnlyReadsMemory(F, 0);
 676     return Changed;
 677   case LibFunc_dunder_isoc99_sscanf:
 678     Changed |= setDoesNotThrow(F);
 679     Changed |= setDoesNotCapture(F, 0);
 680     Changed |= setDoesNotCapture(F, 1);
 681     Changed |= setOnlyReadsMemory(F, 0);
 682     Changed |= setOnlyReadsMemory(F, 1);
 683     return Changed;
 684   case LibFunc_fopen64:
 685     Changed |= setDoesNotThrow(F);
 686     Changed |= setRetDoesNotAlias(F);
 687     Changed |= setDoesNotCapture(F, 0);
 688     Changed |= setDoesNotCapture(F, 1);
 689     Changed |= setOnlyReadsMemory(F, 0);
 690     Changed |= setOnlyReadsMemory(F, 1);
 691     return Changed;
 692   case LibFunc_fseeko64:
 693   case LibFunc_ftello64:
 694     Changed |= setDoesNotThrow(F);
 695     Changed |= setDoesNotCapture(F, 0);
 696     return Changed;
 697   case LibFunc_tmpfile64:
 698     Changed |= setDoesNotThrow(F);
 699     Changed |= setRetDoesNotAlias(F);
 700     return Changed;
 701   case LibFunc_fstat64:
 702   case LibFunc_fstatvfs64:
 703     Changed |= setDoesNotThrow(F);
 704     Changed |= setDoesNotCapture(F, 1);
 705     return Changed;
 706   case LibFunc_open64:
 707     // May throw; "open" is a valid pthread cancellation point.
 708     Changed |= setDoesNotCapture(F, 0);
 709     Changed |= setOnlyReadsMemory(F, 0);
 710     return Changed;
 711   case LibFunc_gettimeofday:
 712     // Currently some platforms have the restrict keyword on the arguments to
 713     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
 714     // arguments.
 715     Changed |= setDoesNotThrow(F);
 716     Changed |= setDoesNotCapture(F, 0);
 717     Changed |= setDoesNotCapture(F, 1);
 718     return Changed;
 719   case LibFunc_Znwj: // new(unsigned int)
 720   case LibFunc_Znwm: // new(unsigned long)
 721   case LibFunc_Znaj: // new[](unsigned int)
 722   case LibFunc_Znam: // new[](unsigned long)
 723   case LibFunc_msvc_new_int: // new(unsigned int)
 724   case LibFunc_msvc_new_longlong: // new(unsigned long long)
 725   case LibFunc_msvc_new_array_int: // new[](unsigned int)
 726   case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
 727     // Operator new always returns a nonnull noalias pointer
 728     Changed |= setRetNonNull(F);
 729     Changed |= setRetDoesNotAlias(F);
 730     return Changed;
 731   // TODO: add LibFunc entries for:
 732   // case LibFunc_memset_pattern4:
 733   // case LibFunc_memset_pattern8:
 734   case LibFunc_memset_pattern16:
 735     Changed |= setOnlyAccessesArgMemory(F);
 736     Changed |= setDoesNotCapture(F, 0);
 737     Changed |= setDoesNotCapture(F, 1);
 738     Changed |= setOnlyReadsMemory(F, 1);
 739     return Changed;
 740   // int __nvvm_reflect(const char *)
 741   case LibFunc_nvvm_reflect:
 742     Changed |= setDoesNotAccessMemory(F);
 743     Changed |= setDoesNotThrow(F);
 744     return Changed;
 745
 746   default:
 747     // FIXME: It'd be really nice to cover all the library functions we're
 748     // aware of here.
 749     return false;
 750   }
 751 }
 752
 753 bool llvm::hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
 754                            LibFunc DoubleFn, LibFunc FloatFn,
 755                            LibFunc LongDoubleFn) {
 756   switch (Ty->getTypeID()) {
 757   case Type::HalfTyID:
 758     return false;
 759   case Type::FloatTyID:
 760     return TLI->has(FloatFn);
 761   case Type::DoubleTyID:
 762     return TLI->has(DoubleFn);
 763   default:
 764     return TLI->has(LongDoubleFn);
 765   }
 766 }
 767
 768 StringRef llvm::getUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
 769                                 LibFunc DoubleFn, LibFunc FloatFn,
 770                                 LibFunc LongDoubleFn) {
 771   assert(hasUnaryFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
 772          "Cannot get name for unavailable function!");
 773
 774   switch (Ty->getTypeID()) {
 775   case Type::HalfTyID:
 776     llvm_unreachable("No name for HalfTy!");
 777   case Type::FloatTyID:
 778     return TLI->getName(FloatFn);
 779   case Type::DoubleTyID:
 780     return TLI->getName(DoubleFn);
 781   default:
 782     return TLI->getName(LongDoubleFn);
 783   }
 784 }
 785
 786 //- Emit LibCalls ------------------------------------------------------------//
 787
 788 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
 789   unsigned AS = V->getType()->getPointerAddressSpace();
 790   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
 791 }
 792
 793 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
 794                         const TargetLibraryInfo *TLI) {
 795   if (!TLI->has(LibFunc_strlen))
 796     return nullptr;
 797
 798   Module *M = B.GetInsertBlock()->getModule();
 799   StringRef StrlenName = TLI->getName(LibFunc_strlen);
 800   LLVMContext &Context = B.GetInsertBlock()->getContext();
 801   Constant *StrLen = M->getOrInsertFunction(StrlenName, DL.getIntPtrType(Context),
 802                                             B.getInt8PtrTy());
 803   inferLibFuncAttributes(M, StrlenName, *TLI);
 804   CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), StrlenName);
 805   if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
 806     CI->setCallingConv(F->getCallingConv());
 807
 808   return CI;
 809 }
 810
 811 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
 812                         const TargetLibraryInfo *TLI) {
 813   if (!TLI->has(LibFunc_strchr))
 814     return nullptr;
 815
 816   Module *M = B.GetInsertBlock()->getModule();
 817   StringRef StrChrName = TLI->getName(LibFunc_strchr);
 818   Type *I8Ptr = B.getInt8PtrTy();
 819   Type *I32Ty = B.getInt32Ty();
 820   Constant *StrChr =
 821       M->getOrInsertFunction(StrChrName, I8Ptr, I8Ptr, I32Ty);
 822   inferLibFuncAttributes(M, StrChrName, *TLI);
 823   CallInst *CI = B.CreateCall(
 824       StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, StrChrName);
 825   if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
 826     CI->setCallingConv(F->getCallingConv());
 827   return CI;
 828 }
 829
 830 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
 831                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
 832   if (!TLI->has(LibFunc_strncmp))
 833     return nullptr;
 834
 835   Module *M = B.GetInsertBlock()->getModule();
 836   StringRef StrNCmpName = TLI->getName(LibFunc_strncmp);
 837   LLVMContext &Context = B.GetInsertBlock()->getContext();
 838   Value *StrNCmp = M->getOrInsertFunction(StrNCmpName, B.getInt32Ty(),
 839                                           B.getInt8PtrTy(), B.getInt8PtrTy(),
 840                                           DL.getIntPtrType(Context));
 841   inferLibFuncAttributes(M, StrNCmpName, *TLI);
 842   CallInst *CI = B.CreateCall(
 843       StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, StrNCmpName);
 844
 845   if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
 846     CI->setCallingConv(F->getCallingConv());
 847
 848   return CI;
 849 }
 850
 851 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
 852                         const TargetLibraryInfo *TLI, StringRef Name) {
 853   if (!TLI->has(LibFunc_strcpy))
 854     return nullptr;
 855
 856   Module *M = B.GetInsertBlock()->getModule();
 857   Type *I8Ptr = B.getInt8PtrTy();
 858   Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);
 859   inferLibFuncAttributes(M, Name, *TLI);
 860   CallInst *CI =
 861       B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
 862   if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
 863     CI->setCallingConv(F->getCallingConv());
 864   return CI;
 865 }
 866
 867 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
 868                          const TargetLibraryInfo *TLI, StringRef Name) {
 869   if (!TLI->has(LibFunc_strncpy))
 870     return nullptr;
 871
 872   Module *M = B.GetInsertBlock()->getModule();
 873   Type *I8Ptr = B.getInt8PtrTy();
 874   Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
 875                                           Len->getType());
 876   inferLibFuncAttributes(M, Name, *TLI);
 877   CallInst *CI = B.CreateCall(
 878       StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, Name);
 879   if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
 880     CI->setCallingConv(F->getCallingConv());
 881   return CI;
 882 }
 883
 884 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
 885                            IRBuilder<> &B, const DataLayout &DL,
 886                            const TargetLibraryInfo *TLI) {
 887   if (!TLI->has(LibFunc_memcpy_chk))
 888     return nullptr;
 889
 890   Module *M = B.GetInsertBlock()->getModule();
 891   AttributeList AS;
 892   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
 893                           Attribute::NoUnwind);
 894   LLVMContext &Context = B.GetInsertBlock()->getContext();
 895   Value *MemCpy = M->getOrInsertFunction(
 896       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
 897       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
 898       DL.getIntPtrType(Context));
 899   Dst = castToCStr(Dst, B);
 900   Src = castToCStr(Src, B);
 901   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
 902   if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
 903     CI->setCallingConv(F->getCallingConv());
 904   return CI;
 905 }
 906
 907 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
 908                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
 909   if (!TLI->has(LibFunc_memchr))
 910     return nullptr;
 911
 912   Module *M = B.GetInsertBlock()->getModule();
 913   StringRef MemChrName = TLI->getName(LibFunc_memchr);
 914   LLVMContext &Context = B.GetInsertBlock()->getContext();
 915   Value *MemChr = M->getOrInsertFunction(MemChrName, B.getInt8PtrTy(),
 916                                          B.getInt8PtrTy(), B.getInt32Ty(),
 917                                          DL.getIntPtrType(Context));
 918   inferLibFuncAttributes(M, MemChrName, *TLI);
 919   CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, MemChrName);
 920
 921   if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
 922     CI->setCallingConv(F->getCallingConv());
 923
 924   return CI;
 925 }
 926
 927 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
 928                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
 929   if (!TLI->has(LibFunc_memcmp))
 930     return nullptr;
 931
 932   Module *M = B.GetInsertBlock()->getModule();
 933   StringRef MemCmpName = TLI->getName(LibFunc_memcmp);
 934   LLVMContext &Context = B.GetInsertBlock()->getContext();
 935   Value *MemCmp = M->getOrInsertFunction(MemCmpName, B.getInt32Ty(),
 936                                          B.getInt8PtrTy(), B.getInt8PtrTy(),
 937                                          DL.getIntPtrType(Context));
 938   inferLibFuncAttributes(M, MemCmpName, *TLI);
 939   CallInst *CI = B.CreateCall(
 940       MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, MemCmpName);
 941
 942   if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
 943     CI->setCallingConv(F->getCallingConv());
 944
 945   return CI;
 946 }
 947
 948 /// Append a suffix to the function name according to the type of 'Op'.
 949 static void appendTypeSuffix(Value *Op, StringRef &Name,
 950                              SmallString<20> &NameBuffer) {
 951   if (!Op->getType()->isDoubleTy()) {
 952       NameBuffer += Name;
 953
 954     if (Op->getType()->isFloatTy())
 955       NameBuffer += 'f';
 956     else
 957       NameBuffer += 'l';
 958
 959     Name = NameBuffer;
 960   }
 961 }
 962
 963 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
 964                                          IRBuilder<> &B,
 965                                          const AttributeList &Attrs) {
 966   assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
 967
 968   Module *M = B.GetInsertBlock()->getModule();
 969   Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
 970                                          Op->getType());
 971   CallInst *CI = B.CreateCall(Callee, Op, Name);
 972
 973   // The incoming attribute set may have come from a speculatable intrinsic, but
 974   // is being replaced with a library call which is not allowed to be
 975   // speculatable.
 976   CI->setAttributes(Attrs.removeAttribute(B.getContext(),
 977                                           AttributeList::FunctionIndex,
 978                                           Attribute::Speculatable));
 979   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
 980     CI->setCallingConv(F->getCallingConv());
 981
 982   return CI;
 983 }
 984
 985 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
 986                                   const AttributeList &Attrs) {
 987   SmallString<20> NameBuffer;
 988   appendTypeSuffix(Op, Name, NameBuffer);
 989
 990   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
 991 }
 992
 993 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
 994                                   LibFunc DoubleFn, LibFunc FloatFn,
 995                                   LibFunc LongDoubleFn, IRBuilder<> &B,
 996                                   const AttributeList &Attrs) {
 997   // Get the name of the function according to TLI.
 998   StringRef Name = getUnaryFloatFn(TLI, Op->getType(),
 999                                    DoubleFn, FloatFn, LongDoubleFn);
1000
1001   return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1002 }
1003
1004 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1005                                    IRBuilder<> &B, const AttributeList &Attrs) {
1006   assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1007
1008   SmallString<20> NameBuffer;
1009   appendTypeSuffix(Op1, Name, NameBuffer);
1010
1011   Module *M = B.GetInsertBlock()->getModule();
1012   Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
1013                                          Op2->getType());
1014   CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
1015   CI->setAttributes(Attrs);
1016   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
1017     CI->setCallingConv(F->getCallingConv());
1018
1019   return CI;
1020 }
1021
1022 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
1023                          const TargetLibraryInfo *TLI) {
1024   if (!TLI->has(LibFunc_putchar))
1025     return nullptr;
1026
1027   Module *M = B.GetInsertBlock()->getModule();
1028   StringRef PutCharName = TLI->getName(LibFunc_putchar);
1029   Value *PutChar = M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1030   inferLibFuncAttributes(M, PutCharName, *TLI);
1031   CallInst *CI = B.CreateCall(PutChar,
1032                               B.CreateIntCast(Char,
1033                               B.getInt32Ty(),
1034                               /*isSigned*/true,
1035                               "chari"),
1036                               PutCharName);
1037
1038   if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
1039     CI->setCallingConv(F->getCallingConv());
1040   return CI;
1041 }
1042
1043 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
1044                       const TargetLibraryInfo *TLI) {
1045   if (!TLI->has(LibFunc_puts))
1046     return nullptr;
1047
1048   Module *M = B.GetInsertBlock()->getModule();
1049   StringRef PutsName = TLI->getName(LibFunc_puts);
1050   Value *PutS =
1051       M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1052   inferLibFuncAttributes(M, PutsName, *TLI);
1053   CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1054   if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
1055     CI->setCallingConv(F->getCallingConv());
1056   return CI;
1057 }
1058
1059 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
1060                        const TargetLibraryInfo *TLI) {
1061   if (!TLI->has(LibFunc_fputc))
1062     return nullptr;
1063
1064   Module *M = B.GetInsertBlock()->getModule();
1065   StringRef FPutcName = TLI->getName(LibFunc_fputc);
1066   Constant *F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(), B.getInt32Ty(),
1067                                        File->getType());
1068   if (File->getType()->isPointerTy())
1069     inferLibFuncAttributes(M, FPutcName, *TLI);
1070   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1071                          "chari");
1072   CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1073
1074   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1075     CI->setCallingConv(Fn->getCallingConv());
1076   return CI;
1077 }
1078
1079 Value *llvm::emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
1080                                const TargetLibraryInfo *TLI) {
1081   if (!TLI->has(LibFunc_fputc_unlocked))
1082     return nullptr;
1083
1084   Module *M = B.GetInsertBlock()->getModule();
1085   StringRef FPutcUnlockedName = TLI->getName(LibFunc_fputc_unlocked);
1086   Constant *F = M->getOrInsertFunction(FPutcUnlockedName, B.getInt32Ty(),
1087                                        B.getInt32Ty(), File->getType());
1088   if (File->getType()->isPointerTy())
1089     inferLibFuncAttributes(M, FPutcUnlockedName, *TLI);
1090   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/ true, "chari");
1091   CallInst *CI = B.CreateCall(F, {Char, File}, FPutcUnlockedName);
1092
1093   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1094     CI->setCallingConv(Fn->getCallingConv());
1095   return CI;
1096 }
1097
1098 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
1099                        const TargetLibraryInfo *TLI) {
1100   if (!TLI->has(LibFunc_fputs))
1101     return nullptr;
1102
1103   Module *M = B.GetInsertBlock()->getModule();
1104   StringRef FPutsName = TLI->getName(LibFunc_fputs);
1105   Constant *F = M->getOrInsertFunction(
1106       FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
1107   if (File->getType()->isPointerTy())
1108     inferLibFuncAttributes(M, FPutsName, *TLI);
1109   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1110
1111   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1112     CI->setCallingConv(Fn->getCallingConv());
1113   return CI;
1114 }
1115
1116 Value *llvm::emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
1117                                const TargetLibraryInfo *TLI) {
1118   if (!TLI->has(LibFunc_fputs_unlocked))
1119     return nullptr;
1120
1121   Module *M = B.GetInsertBlock()->getModule();
1122   StringRef FPutsUnlockedName = TLI->getName(LibFunc_fputs_unlocked);
1123   Constant *F = M->getOrInsertFunction(FPutsUnlockedName, B.getInt32Ty(),
1124                                        B.getInt8PtrTy(), File->getType());
1125   if (File->getType()->isPointerTy())
1126     inferLibFuncAttributes(M, FPutsUnlockedName, *TLI);
1127   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsUnlockedName);
1128
1129   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1130     CI->setCallingConv(Fn->getCallingConv());
1131   return CI;
1132 }
1133
1134 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
1135                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
1136   if (!TLI->has(LibFunc_fwrite))
1137     return nullptr;
1138
1139   Module *M = B.GetInsertBlock()->getModule();
1140   LLVMContext &Context = B.GetInsertBlock()->getContext();
1141   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1142   Constant *F = M->getOrInsertFunction(
1143       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1144       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1145
1146   if (File->getType()->isPointerTy())
1147     inferLibFuncAttributes(M, FWriteName, *TLI);
1148   CallInst *CI =
1149       B.CreateCall(F, {castToCStr(Ptr, B), Size,
1150                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1151
1152   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1153     CI->setCallingConv(Fn->getCallingConv());
1154   return CI;
1155 }
1156
1157 Value *llvm::emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL,
1158                         const TargetLibraryInfo *TLI) {
1159   if (!TLI->has(LibFunc_malloc))
1160     return nullptr;
1161
1162   Module *M = B.GetInsertBlock()->getModule();
1163   StringRef MallocName = TLI->getName(LibFunc_malloc);
1164   LLVMContext &Context = B.GetInsertBlock()->getContext();
1165   Value *Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1166                                          DL.getIntPtrType(Context));
1167   inferLibFuncAttributes(M, MallocName, *TLI);
1168   CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1169
1170   if (const Function *F = dyn_cast<Function>(Malloc->stripPointerCasts()))
1171     CI->setCallingConv(F->getCallingConv());
1172
1173   return CI;
1174 }
1175
1176 Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
1177                         IRBuilder<> &B, const TargetLibraryInfo &TLI) {
1178   if (!TLI.has(LibFunc_calloc))
1179     return nullptr;
1180
1181   Module *M = B.GetInsertBlock()->getModule();
1182   StringRef CallocName = TLI.getName(LibFunc_calloc);
1183   const DataLayout &DL = M->getDataLayout();
1184   IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1185   Value *Calloc = M->getOrInsertFunction(CallocName, Attrs, B.getInt8PtrTy(),
1186                                          PtrType, PtrType);
1187   inferLibFuncAttributes(M, CallocName, TLI);
1188   CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1189
1190   if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))
1191     CI->setCallingConv(F->getCallingConv());
1192
1193   return CI;
1194 }
1195
1196 Value *llvm::emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
1197                                 IRBuilder<> &B, const DataLayout &DL,
1198                                 const TargetLibraryInfo *TLI) {
1199   if (!TLI->has(LibFunc_fwrite_unlocked))
1200     return nullptr;
1201
1202   Module *M = B.GetInsertBlock()->getModule();
1203   LLVMContext &Context = B.GetInsertBlock()->getContext();
1204   StringRef FWriteUnlockedName = TLI->getName(LibFunc_fwrite_unlocked);
1205   Constant *F = M->getOrInsertFunction(
1206       FWriteUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1207       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1208
1209   if (File->getType()->isPointerTy())
1210     inferLibFuncAttributes(M, FWriteUnlockedName, *TLI);
1211   CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1212
1213   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1214     CI->setCallingConv(Fn->getCallingConv());
1215   return CI;
1216 }
1217
1218 Value *llvm::emitFGetCUnlocked(Value *File, IRBuilder<> &B,
1219                                const TargetLibraryInfo *TLI) {
1220   if (!TLI->has(LibFunc_fgetc_unlocked))
1221     return nullptr;
1222
1223   Module *M = B.GetInsertBlock()->getModule();
1224   StringRef FGetCUnlockedName = TLI->getName(LibFunc_fgetc_unlocked);
1225   Constant *F =
1226       M->getOrInsertFunction(FGetCUnlockedName, B.getInt32Ty(), File->getType());
1227   if (File->getType()->isPointerTy())
1228     inferLibFuncAttributes(M, FGetCUnlockedName, *TLI);
1229   CallInst *CI = B.CreateCall(F, File, FGetCUnlockedName);
1230
1231   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1232     CI->setCallingConv(Fn->getCallingConv());
1233   return CI;
1234 }
1235
1236 Value *llvm::emitFGetSUnlocked(Value *Str, Value *Size, Value *File,
1237                                IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1238   if (!TLI->has(LibFunc_fgets_unlocked))
1239     return nullptr;
1240
1241   Module *M = B.GetInsertBlock()->getModule();
1242   StringRef FGetSUnlockedName = TLI->getName(LibFunc_fgets_unlocked);
1243   Constant *F =
1244       M->getOrInsertFunction(FGetSUnlockedName, B.getInt8PtrTy(),
1245                              B.getInt8PtrTy(), B.getInt32Ty(), File->getType());
1246   inferLibFuncAttributes(M, FGetSUnlockedName, *TLI);
1247   CallInst *CI =
1248       B.CreateCall(F, {castToCStr(Str, B), Size, File}, FGetSUnlockedName);
1249
1250   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1251     CI->setCallingConv(Fn->getCallingConv());
1252   return CI;
1253 }
1254
1255 Value *llvm::emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
1256                                IRBuilder<> &B, const DataLayout &DL,
1257                                const TargetLibraryInfo *TLI) {
1258   if (!TLI->has(LibFunc_fread_unlocked))
1259     return nullptr;
1260
1261   Module *M = B.GetInsertBlock()->getModule();
1262   LLVMContext &Context = B.GetInsertBlock()->getContext();
1263   StringRef FReadUnlockedName = TLI->getName(LibFunc_fread_unlocked);
1264   Constant *F = M->getOrInsertFunction(
1265       FReadUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1266       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1267
1268   if (File->getType()->isPointerTy())
1269     inferLibFuncAttributes(M, FReadUnlockedName, *TLI);
1270   CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1271
1272   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1273     CI->setCallingConv(Fn->getCallingConv());
1274   return CI;
1275 }