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