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