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