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