llvm/lib/Transforms/Utils/BuildLibCalls.cpp

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