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 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) { 1429 unsigned AS = V->getType()->getPointerAddressSpace(); 1430 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr"); 1431 } 1432 1433 static IntegerType *getIntTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1434 return B.getIntNTy(TLI->getIntSize()); 1435 } 1436 1437 static IntegerType *getSizeTTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1438 const Module *M = B.GetInsertBlock()->getModule(); 1439 return B.getIntNTy(TLI->getSizeTSize(*M)); 1440 } 1441 1442 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType, 1443 ArrayRef<Type *> ParamTypes, 1444 ArrayRef<Value *> Operands, IRBuilderBase &B, 1445 const TargetLibraryInfo *TLI, 1446 bool IsVaArgs = false) { 1447 Module *M = B.GetInsertBlock()->getModule(); 1448 if (!isLibFuncEmittable(M, TLI, TheLibFunc)) 1449 return nullptr; 1450 1451 StringRef FuncName = TLI->getName(TheLibFunc); 1452 FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs); 1453 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, FuncType); 1454 inferNonMandatoryLibFuncAttrs(M, FuncName, *TLI); 1455 CallInst *CI = B.CreateCall(Callee, Operands, FuncName); 1456 if (const Function *F = 1457 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1458 CI->setCallingConv(F->getCallingConv()); 1459 return CI; 1460 } 1461 1462 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL, 1463 const TargetLibraryInfo *TLI) { 1464 Type *SizeTTy = getSizeTTy(B, TLI); 1465 return emitLibCall(LibFunc_strlen, SizeTTy, 1466 B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI); 1467 } 1468 1469 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B, 1470 const TargetLibraryInfo *TLI) { 1471 return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(), 1472 castToCStr(Ptr, B), B, TLI); 1473 } 1474 1475 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B, 1476 const TargetLibraryInfo *TLI) { 1477 Type *I8Ptr = B.getInt8PtrTy(); 1478 Type *IntTy = getIntTy(B, TLI); 1479 return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, IntTy}, 1480 {castToCStr(Ptr, B), ConstantInt::get(IntTy, C)}, B, TLI); 1481 } 1482 1483 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1484 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1485 Type *IntTy = getIntTy(B, TLI); 1486 Type *SizeTTy = getSizeTTy(B, TLI); 1487 return emitLibCall( 1488 LibFunc_strncmp, IntTy, 1489 {B.getInt8PtrTy(), B.getInt8PtrTy(), SizeTTy}, 1490 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1491 } 1492 1493 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, 1494 const TargetLibraryInfo *TLI) { 1495 Type *I8Ptr = Dst->getType(); 1496 return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr}, 1497 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); 1498 } 1499 1500 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, 1501 const TargetLibraryInfo *TLI) { 1502 Type *I8Ptr = B.getInt8PtrTy(); 1503 return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr}, 1504 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); 1505 } 1506 1507 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1508 const TargetLibraryInfo *TLI) { 1509 Type *I8Ptr = B.getInt8PtrTy(); 1510 Type *SizeTTy = getSizeTTy(B, TLI); 1511 return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy}, 1512 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); 1513 } 1514 1515 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1516 const TargetLibraryInfo *TLI) { 1517 Type *I8Ptr = B.getInt8PtrTy(); 1518 Type *SizeTTy = getSizeTTy(B, TLI); 1519 return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy}, 1520 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); 1521 } 1522 1523 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, 1524 IRBuilderBase &B, const DataLayout &DL, 1525 const TargetLibraryInfo *TLI) { 1526 Module *M = B.GetInsertBlock()->getModule(); 1527 if (!isLibFuncEmittable(M, TLI, LibFunc_memcpy_chk)) 1528 return nullptr; 1529 1530 AttributeList AS; 1531 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex, 1532 Attribute::NoUnwind); 1533 Type *I8Ptr = B.getInt8PtrTy(); 1534 Type *SizeTTy = getSizeTTy(B, TLI); 1535 FunctionCallee MemCpy = getOrInsertLibFunc(M, *TLI, LibFunc_memcpy_chk, 1536 AttributeList::get(M->getContext(), AS), I8Ptr, 1537 I8Ptr, I8Ptr, SizeTTy, SizeTTy); 1538 Dst = castToCStr(Dst, B); 1539 Src = castToCStr(Src, B); 1540 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize}); 1541 if (const Function *F = 1542 dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts())) 1543 CI->setCallingConv(F->getCallingConv()); 1544 return CI; 1545 } 1546 1547 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1548 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1549 Type *I8Ptr = B.getInt8PtrTy(); 1550 Type *SizeTTy = getSizeTTy(B, TLI); 1551 return emitLibCall(LibFunc_mempcpy, I8Ptr, 1552 {I8Ptr, I8Ptr, SizeTTy}, 1553 {Dst, Src, Len}, B, TLI); 1554 } 1555 1556 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, 1557 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1558 Type *I8Ptr = B.getInt8PtrTy(); 1559 Type *IntTy = getIntTy(B, TLI); 1560 Type *SizeTTy = getSizeTTy(B, TLI); 1561 return emitLibCall(LibFunc_memchr, I8Ptr, 1562 {I8Ptr, IntTy, SizeTTy}, 1563 {castToCStr(Ptr, B), Val, Len}, B, TLI); 1564 } 1565 1566 Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, 1567 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1568 Type *I8Ptr = B.getInt8PtrTy(); 1569 Type *IntTy = getIntTy(B, TLI); 1570 Type *SizeTTy = getSizeTTy(B, TLI); 1571 return emitLibCall(LibFunc_memrchr, I8Ptr, 1572 {I8Ptr, IntTy, SizeTTy}, 1573 {castToCStr(Ptr, B), Val, Len}, B, TLI); 1574 } 1575 1576 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1577 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1578 Type *I8Ptr = B.getInt8PtrTy(); 1579 Type *IntTy = getIntTy(B, TLI); 1580 Type *SizeTTy = getSizeTTy(B, TLI); 1581 return emitLibCall(LibFunc_memcmp, IntTy, 1582 {I8Ptr, I8Ptr, SizeTTy}, 1583 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1584 } 1585 1586 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1587 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1588 Type *I8Ptr = B.getInt8PtrTy(); 1589 Type *IntTy = getIntTy(B, TLI); 1590 Type *SizeTTy = getSizeTTy(B, TLI); 1591 return emitLibCall(LibFunc_bcmp, IntTy, 1592 {I8Ptr, I8Ptr, SizeTTy}, 1593 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1594 } 1595 1596 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, 1597 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1598 Type *I8Ptr = B.getInt8PtrTy(); 1599 Type *IntTy = getIntTy(B, TLI); 1600 Type *SizeTTy = getSizeTTy(B, TLI); 1601 return emitLibCall(LibFunc_memccpy, I8Ptr, 1602 {I8Ptr, I8Ptr, IntTy, SizeTTy}, 1603 {Ptr1, Ptr2, Val, Len}, B, TLI); 1604 } 1605 1606 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, 1607 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B, 1608 const TargetLibraryInfo *TLI) { 1609 Type *I8Ptr = B.getInt8PtrTy(); 1610 Type *IntTy = getIntTy(B, TLI); 1611 Type *SizeTTy = getSizeTTy(B, TLI); 1612 SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)}; 1613 llvm::append_range(Args, VariadicArgs); 1614 return emitLibCall(LibFunc_snprintf, IntTy, 1615 {I8Ptr, SizeTTy, I8Ptr}, 1616 Args, B, TLI, /*IsVaArgs=*/true); 1617 } 1618 1619 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt, 1620 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B, 1621 const TargetLibraryInfo *TLI) { 1622 Type *I8Ptr = B.getInt8PtrTy(); 1623 Type *IntTy = getIntTy(B, TLI); 1624 SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)}; 1625 llvm::append_range(Args, VariadicArgs); 1626 return emitLibCall(LibFunc_sprintf, IntTy, 1627 {I8Ptr, I8Ptr}, Args, B, TLI, 1628 /*IsVaArgs=*/true); 1629 } 1630 1631 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, 1632 const TargetLibraryInfo *TLI) { 1633 return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(), 1634 {B.getInt8PtrTy(), B.getInt8PtrTy()}, 1635 {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI); 1636 } 1637 1638 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1639 const TargetLibraryInfo *TLI) { 1640 Type *I8Ptr = B.getInt8PtrTy(); 1641 Type *SizeTTy = getSizeTTy(B, TLI); 1642 return emitLibCall(LibFunc_strlcpy, SizeTTy, 1643 {I8Ptr, I8Ptr, SizeTTy}, 1644 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1645 } 1646 1647 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1648 const TargetLibraryInfo *TLI) { 1649 Type *I8Ptr = B.getInt8PtrTy(); 1650 Type *SizeTTy = getSizeTTy(B, TLI); 1651 return emitLibCall(LibFunc_strlcat, SizeTTy, 1652 {I8Ptr, I8Ptr, SizeTTy}, 1653 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1654 } 1655 1656 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1657 const TargetLibraryInfo *TLI) { 1658 Type *I8Ptr = B.getInt8PtrTy(); 1659 Type *SizeTTy = getSizeTTy(B, TLI); 1660 return emitLibCall(LibFunc_strncat, I8Ptr, 1661 {I8Ptr, I8Ptr, SizeTTy}, 1662 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1663 } 1664 1665 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, 1666 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1667 Type *I8Ptr = B.getInt8PtrTy(); 1668 Type *IntTy = getIntTy(B, TLI); 1669 Type *SizeTTy = getSizeTTy(B, TLI); 1670 return emitLibCall( 1671 LibFunc_vsnprintf, IntTy, 1672 {I8Ptr, SizeTTy, I8Ptr, VAList->getType()}, 1673 {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI); 1674 } 1675 1676 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, 1677 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1678 Type *I8Ptr = B.getInt8PtrTy(); 1679 Type *IntTy = getIntTy(B, TLI); 1680 return emitLibCall(LibFunc_vsprintf, IntTy, 1681 {I8Ptr, I8Ptr, VAList->getType()}, 1682 {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI); 1683 } 1684 1685 /// Append a suffix to the function name according to the type of 'Op'. 1686 static void appendTypeSuffix(Value *Op, StringRef &Name, 1687 SmallString<20> &NameBuffer) { 1688 if (!Op->getType()->isDoubleTy()) { 1689 NameBuffer += Name; 1690 1691 if (Op->getType()->isFloatTy()) 1692 NameBuffer += 'f'; 1693 else 1694 NameBuffer += 'l'; 1695 1696 Name = NameBuffer; 1697 } 1698 } 1699 1700 static Value *emitUnaryFloatFnCallHelper(Value *Op, LibFunc TheLibFunc, 1701 StringRef Name, IRBuilderBase &B, 1702 const AttributeList &Attrs, 1703 const TargetLibraryInfo *TLI) { 1704 assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall"); 1705 1706 Module *M = B.GetInsertBlock()->getModule(); 1707 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op->getType(), 1708 Op->getType()); 1709 CallInst *CI = B.CreateCall(Callee, Op, Name); 1710 1711 // The incoming attribute set may have come from a speculatable intrinsic, but 1712 // is being replaced with a library call which is not allowed to be 1713 // speculatable. 1714 CI->setAttributes( 1715 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable)); 1716 if (const Function *F = 1717 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1718 CI->setCallingConv(F->getCallingConv()); 1719 1720 return CI; 1721 } 1722 1723 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, 1724 StringRef Name, IRBuilderBase &B, 1725 const AttributeList &Attrs) { 1726 SmallString<20> NameBuffer; 1727 appendTypeSuffix(Op, Name, NameBuffer); 1728 1729 LibFunc TheLibFunc; 1730 TLI->getLibFunc(Name, TheLibFunc); 1731 1732 return emitUnaryFloatFnCallHelper(Op, TheLibFunc, Name, B, Attrs, TLI); 1733 } 1734 1735 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, 1736 LibFunc DoubleFn, LibFunc FloatFn, 1737 LibFunc LongDoubleFn, IRBuilderBase &B, 1738 const AttributeList &Attrs) { 1739 // Get the name of the function according to TLI. 1740 Module *M = B.GetInsertBlock()->getModule(); 1741 LibFunc TheLibFunc; 1742 StringRef Name = getFloatFn(M, TLI, Op->getType(), DoubleFn, FloatFn, 1743 LongDoubleFn, TheLibFunc); 1744 1745 return emitUnaryFloatFnCallHelper(Op, TheLibFunc, Name, B, Attrs, TLI); 1746 } 1747 1748 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2, 1749 LibFunc TheLibFunc, 1750 StringRef Name, IRBuilderBase &B, 1751 const AttributeList &Attrs, 1752 const TargetLibraryInfo *TLI) { 1753 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall"); 1754 1755 Module *M = B.GetInsertBlock()->getModule(); 1756 FunctionCallee Callee = getOrInsertLibFunc(M, *TLI, TheLibFunc, Op1->getType(), 1757 Op1->getType(), Op2->getType()); 1758 inferNonMandatoryLibFuncAttrs(M, Name, *TLI); 1759 CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name); 1760 1761 // The incoming attribute set may have come from a speculatable intrinsic, but 1762 // is being replaced with a library call which is not allowed to be 1763 // speculatable. 1764 CI->setAttributes( 1765 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable)); 1766 if (const Function *F = 1767 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1768 CI->setCallingConv(F->getCallingConv()); 1769 1770 return CI; 1771 } 1772 1773 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, 1774 const TargetLibraryInfo *TLI, 1775 StringRef Name, IRBuilderBase &B, 1776 const AttributeList &Attrs) { 1777 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall"); 1778 1779 SmallString<20> NameBuffer; 1780 appendTypeSuffix(Op1, Name, NameBuffer); 1781 1782 LibFunc TheLibFunc; 1783 TLI->getLibFunc(Name, TheLibFunc); 1784 1785 return emitBinaryFloatFnCallHelper(Op1, Op2, TheLibFunc, Name, B, Attrs, TLI); 1786 } 1787 1788 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, 1789 const TargetLibraryInfo *TLI, 1790 LibFunc DoubleFn, LibFunc FloatFn, 1791 LibFunc LongDoubleFn, IRBuilderBase &B, 1792 const AttributeList &Attrs) { 1793 // Get the name of the function according to TLI. 1794 Module *M = B.GetInsertBlock()->getModule(); 1795 LibFunc TheLibFunc; 1796 StringRef Name = getFloatFn(M, TLI, Op1->getType(), DoubleFn, FloatFn, 1797 LongDoubleFn, TheLibFunc); 1798 1799 return emitBinaryFloatFnCallHelper(Op1, Op2, TheLibFunc, Name, B, Attrs, TLI); 1800 } 1801 1802 // Emit a call to putchar(int) with Char as the argument. Char must have 1803 // the same precision as int, which need not be 32 bits. 1804 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B, 1805 const TargetLibraryInfo *TLI) { 1806 Module *M = B.GetInsertBlock()->getModule(); 1807 if (!isLibFuncEmittable(M, TLI, LibFunc_putchar)) 1808 return nullptr; 1809 1810 Type *IntTy = getIntTy(B, TLI); 1811 StringRef PutCharName = TLI->getName(LibFunc_putchar); 1812 FunctionCallee PutChar = getOrInsertLibFunc(M, *TLI, LibFunc_putchar, 1813 IntTy, IntTy); 1814 inferNonMandatoryLibFuncAttrs(M, PutCharName, *TLI); 1815 CallInst *CI = B.CreateCall(PutChar, Char, PutCharName); 1816 1817 if (const Function *F = 1818 dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts())) 1819 CI->setCallingConv(F->getCallingConv()); 1820 return CI; 1821 } 1822 1823 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B, 1824 const TargetLibraryInfo *TLI) { 1825 Module *M = B.GetInsertBlock()->getModule(); 1826 if (!isLibFuncEmittable(M, TLI, LibFunc_puts)) 1827 return nullptr; 1828 1829 Type *IntTy = getIntTy(B, TLI); 1830 StringRef PutsName = TLI->getName(LibFunc_puts); 1831 FunctionCallee PutS = getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy, 1832 B.getInt8PtrTy()); 1833 inferNonMandatoryLibFuncAttrs(M, PutsName, *TLI); 1834 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName); 1835 if (const Function *F = 1836 dyn_cast<Function>(PutS.getCallee()->stripPointerCasts())) 1837 CI->setCallingConv(F->getCallingConv()); 1838 return CI; 1839 } 1840 1841 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B, 1842 const TargetLibraryInfo *TLI) { 1843 Module *M = B.GetInsertBlock()->getModule(); 1844 if (!isLibFuncEmittable(M, TLI, LibFunc_fputc)) 1845 return nullptr; 1846 1847 Type *IntTy = getIntTy(B, TLI); 1848 StringRef FPutcName = TLI->getName(LibFunc_fputc); 1849 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputc, IntTy, 1850 IntTy, File->getType()); 1851 if (File->getType()->isPointerTy()) 1852 inferNonMandatoryLibFuncAttrs(M, FPutcName, *TLI); 1853 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName); 1854 1855 if (const Function *Fn = 1856 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1857 CI->setCallingConv(Fn->getCallingConv()); 1858 return CI; 1859 } 1860 1861 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B, 1862 const TargetLibraryInfo *TLI) { 1863 Module *M = B.GetInsertBlock()->getModule(); 1864 if (!isLibFuncEmittable(M, TLI, LibFunc_fputs)) 1865 return nullptr; 1866 1867 Type *IntTy = getIntTy(B, TLI); 1868 StringRef FPutsName = TLI->getName(LibFunc_fputs); 1869 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputs, IntTy, 1870 B.getInt8PtrTy(), File->getType()); 1871 if (File->getType()->isPointerTy()) 1872 inferNonMandatoryLibFuncAttrs(M, FPutsName, *TLI); 1873 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName); 1874 1875 if (const Function *Fn = 1876 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1877 CI->setCallingConv(Fn->getCallingConv()); 1878 return CI; 1879 } 1880 1881 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, 1882 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1883 Module *M = B.GetInsertBlock()->getModule(); 1884 if (!isLibFuncEmittable(M, TLI, LibFunc_fwrite)) 1885 return nullptr; 1886 1887 Type *SizeTTy = getSizeTTy(B, TLI); 1888 StringRef FWriteName = TLI->getName(LibFunc_fwrite); 1889 FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fwrite, 1890 SizeTTy, B.getInt8PtrTy(), SizeTTy, 1891 SizeTTy, File->getType()); 1892 1893 if (File->getType()->isPointerTy()) 1894 inferNonMandatoryLibFuncAttrs(M, FWriteName, *TLI); 1895 CallInst *CI = 1896 B.CreateCall(F, {castToCStr(Ptr, B), Size, 1897 ConstantInt::get(SizeTTy, 1), File}); 1898 1899 if (const Function *Fn = 1900 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1901 CI->setCallingConv(Fn->getCallingConv()); 1902 return CI; 1903 } 1904 1905 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, 1906 const TargetLibraryInfo *TLI) { 1907 Module *M = B.GetInsertBlock()->getModule(); 1908 if (!isLibFuncEmittable(M, TLI, LibFunc_malloc)) 1909 return nullptr; 1910 1911 StringRef MallocName = TLI->getName(LibFunc_malloc); 1912 Type *SizeTTy = getSizeTTy(B, TLI); 1913 FunctionCallee Malloc = getOrInsertLibFunc(M, *TLI, LibFunc_malloc, 1914 B.getInt8PtrTy(), SizeTTy); 1915 inferNonMandatoryLibFuncAttrs(M, MallocName, *TLI); 1916 CallInst *CI = B.CreateCall(Malloc, Num, MallocName); 1917 1918 if (const Function *F = 1919 dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts())) 1920 CI->setCallingConv(F->getCallingConv()); 1921 1922 return CI; 1923 } 1924 1925 Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, 1926 const TargetLibraryInfo &TLI) { 1927 Module *M = B.GetInsertBlock()->getModule(); 1928 if (!isLibFuncEmittable(M, &TLI, LibFunc_calloc)) 1929 return nullptr; 1930 1931 StringRef CallocName = TLI.getName(LibFunc_calloc); 1932 Type *SizeTTy = getSizeTTy(B, &TLI); 1933 FunctionCallee Calloc = getOrInsertLibFunc(M, TLI, LibFunc_calloc, 1934 B.getInt8PtrTy(), SizeTTy, SizeTTy); 1935 inferNonMandatoryLibFuncAttrs(M, CallocName, TLI); 1936 CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName); 1937 1938 if (const auto *F = 1939 dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts())) 1940 CI->setCallingConv(F->getCallingConv()); 1941 1942 return CI; 1943 } 1944 1945 Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B, 1946 const TargetLibraryInfo *TLI, LibFunc NewFunc, 1947 uint8_t HotCold) { 1948 Module *M = B.GetInsertBlock()->getModule(); 1949 if (!isLibFuncEmittable(M, TLI, NewFunc)) 1950 return nullptr; 1951 1952 StringRef Name = TLI->getName(NewFunc); 1953 FunctionCallee Func = M->getOrInsertFunction(Name, B.getInt8PtrTy(), 1954 Num->getType(), B.getInt8Ty()); 1955 inferNonMandatoryLibFuncAttrs(M, Name, *TLI); 1956 CallInst *CI = B.CreateCall(Func, {Num, B.getInt8(HotCold)}, Name); 1957 1958 if (const Function *F = 1959 dyn_cast<Function>(Func.getCallee()->stripPointerCasts())) 1960 CI->setCallingConv(F->getCallingConv()); 1961 1962 return CI; 1963 } 1964 1965 Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, 1966 const TargetLibraryInfo *TLI, 1967 LibFunc NewFunc, uint8_t HotCold) { 1968 Module *M = B.GetInsertBlock()->getModule(); 1969 if (!isLibFuncEmittable(M, TLI, NewFunc)) 1970 return nullptr; 1971 1972 StringRef Name = TLI->getName(NewFunc); 1973 FunctionCallee Func = 1974 M->getOrInsertFunction(Name, B.getInt8PtrTy(), Num->getType(), 1975 NoThrow->getType(), B.getInt8Ty()); 1976 inferNonMandatoryLibFuncAttrs(M, Name, *TLI); 1977 CallInst *CI = B.CreateCall(Func, {Num, NoThrow, B.getInt8(HotCold)}, Name); 1978 1979 if (const Function *F = 1980 dyn_cast<Function>(Func.getCallee()->stripPointerCasts())) 1981 CI->setCallingConv(F->getCallingConv()); 1982 1983 return CI; 1984 } 1985 1986 Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, 1987 const TargetLibraryInfo *TLI, 1988 LibFunc NewFunc, uint8_t HotCold) { 1989 Module *M = B.GetInsertBlock()->getModule(); 1990 if (!isLibFuncEmittable(M, TLI, NewFunc)) 1991 return nullptr; 1992 1993 StringRef Name = TLI->getName(NewFunc); 1994 FunctionCallee Func = M->getOrInsertFunction( 1995 Name, B.getInt8PtrTy(), Num->getType(), Align->getType(), B.getInt8Ty()); 1996 inferNonMandatoryLibFuncAttrs(M, Name, *TLI); 1997 CallInst *CI = B.CreateCall(Func, {Num, Align, B.getInt8(HotCold)}, Name); 1998 1999 if (const Function *F = 2000 dyn_cast<Function>(Func.getCallee()->stripPointerCasts())) 2001 CI->setCallingConv(F->getCallingConv()); 2002 2003 return CI; 2004 } 2005 2006 Value *llvm::emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, 2007 Value *NoThrow, IRBuilderBase &B, 2008 const TargetLibraryInfo *TLI, 2009 LibFunc NewFunc, uint8_t HotCold) { 2010 Module *M = B.GetInsertBlock()->getModule(); 2011 if (!isLibFuncEmittable(M, TLI, NewFunc)) 2012 return nullptr; 2013 2014 StringRef Name = TLI->getName(NewFunc); 2015 FunctionCallee Func = M->getOrInsertFunction( 2016 Name, B.getInt8PtrTy(), Num->getType(), Align->getType(), 2017 NoThrow->getType(), B.getInt8Ty()); 2018 inferNonMandatoryLibFuncAttrs(M, Name, *TLI); 2019 CallInst *CI = 2020 B.CreateCall(Func, {Num, Align, NoThrow, B.getInt8(HotCold)}, Name); 2021 2022 if (const Function *F = 2023 dyn_cast<Function>(Func.getCallee()->stripPointerCasts())) 2024 CI->setCallingConv(F->getCallingConv()); 2025 2026 return CI; 2027 } 2028