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