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 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name, 251 const TargetLibraryInfo &TLI) { 252 Function *F = M->getFunction(Name); 253 if (!F) 254 return false; 255 return inferLibFuncAttributes(*F, TLI); 256 } 257 258 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) { 259 LibFunc TheLibFunc; 260 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc))) 261 return false; 262 263 bool Changed = false; 264 265 if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F, &TLI)) 266 Changed |= setDoesNotFreeMemory(F); 267 268 if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT()) 269 Changed |= setNonLazyBind(F); 270 271 switch (TheLibFunc) { 272 case LibFunc_strlen: 273 case LibFunc_strnlen: 274 case LibFunc_wcslen: 275 Changed |= setOnlyReadsMemory(F); 276 Changed |= setDoesNotThrow(F); 277 Changed |= setOnlyAccessesArgMemory(F); 278 Changed |= setWillReturn(F); 279 Changed |= setDoesNotCapture(F, 0); 280 return Changed; 281 case LibFunc_strchr: 282 case LibFunc_strrchr: 283 Changed |= setOnlyAccessesArgMemory(F); 284 Changed |= setOnlyReadsMemory(F); 285 Changed |= setDoesNotThrow(F); 286 Changed |= setWillReturn(F); 287 return Changed; 288 case LibFunc_strtol: 289 case LibFunc_strtod: 290 case LibFunc_strtof: 291 case LibFunc_strtoul: 292 case LibFunc_strtoll: 293 case LibFunc_strtold: 294 case LibFunc_strtoull: 295 Changed |= setDoesNotThrow(F); 296 Changed |= setWillReturn(F); 297 Changed |= setDoesNotCapture(F, 1); 298 Changed |= setOnlyReadsMemory(F, 0); 299 return Changed; 300 case LibFunc_strcat: 301 case LibFunc_strncat: 302 Changed |= setOnlyAccessesArgMemory(F); 303 Changed |= setDoesNotThrow(F); 304 Changed |= setWillReturn(F); 305 Changed |= setReturnedArg(F, 0); 306 Changed |= setDoesNotCapture(F, 1); 307 Changed |= setOnlyReadsMemory(F, 1); 308 Changed |= setDoesNotAlias(F, 0); 309 Changed |= setDoesNotAlias(F, 1); 310 return Changed; 311 case LibFunc_strcpy: 312 case LibFunc_strncpy: 313 Changed |= setReturnedArg(F, 0); 314 LLVM_FALLTHROUGH; 315 case LibFunc_stpcpy: 316 case LibFunc_stpncpy: 317 Changed |= setOnlyAccessesArgMemory(F); 318 Changed |= setDoesNotThrow(F); 319 Changed |= setWillReturn(F); 320 Changed |= setDoesNotCapture(F, 1); 321 Changed |= setOnlyWritesMemory(F, 0); 322 Changed |= setOnlyReadsMemory(F, 1); 323 Changed |= setDoesNotAlias(F, 0); 324 Changed |= setDoesNotAlias(F, 1); 325 return Changed; 326 case LibFunc_strxfrm: 327 Changed |= setDoesNotThrow(F); 328 Changed |= setWillReturn(F); 329 Changed |= setDoesNotCapture(F, 0); 330 Changed |= setDoesNotCapture(F, 1); 331 Changed |= setOnlyReadsMemory(F, 1); 332 return Changed; 333 case LibFunc_strcmp: // 0,1 334 case LibFunc_strspn: // 0,1 335 case LibFunc_strncmp: // 0,1 336 case LibFunc_strcspn: // 0,1 337 Changed |= setDoesNotThrow(F); 338 Changed |= setOnlyAccessesArgMemory(F); 339 Changed |= setWillReturn(F); 340 Changed |= setOnlyReadsMemory(F); 341 Changed |= setDoesNotCapture(F, 0); 342 Changed |= setDoesNotCapture(F, 1); 343 return Changed; 344 case LibFunc_strcoll: 345 case LibFunc_strcasecmp: // 0,1 346 case LibFunc_strncasecmp: // 347 // Those functions may depend on the locale, which may be accessed through 348 // global memory. 349 Changed |= setOnlyReadsMemory(F); 350 Changed |= setDoesNotThrow(F); 351 Changed |= setWillReturn(F); 352 Changed |= setDoesNotCapture(F, 0); 353 Changed |= setDoesNotCapture(F, 1); 354 return Changed; 355 case LibFunc_strstr: 356 case LibFunc_strpbrk: 357 Changed |= setOnlyAccessesArgMemory(F); 358 Changed |= setOnlyReadsMemory(F); 359 Changed |= setDoesNotThrow(F); 360 Changed |= setWillReturn(F); 361 Changed |= setDoesNotCapture(F, 1); 362 return Changed; 363 case LibFunc_strtok: 364 case LibFunc_strtok_r: 365 Changed |= setDoesNotThrow(F); 366 Changed |= setWillReturn(F); 367 Changed |= setDoesNotCapture(F, 1); 368 Changed |= setOnlyReadsMemory(F, 1); 369 return Changed; 370 case LibFunc_scanf: 371 Changed |= setRetAndArgsNoUndef(F); 372 Changed |= setDoesNotThrow(F); 373 Changed |= setDoesNotCapture(F, 0); 374 Changed |= setOnlyReadsMemory(F, 0); 375 return Changed; 376 case LibFunc_setbuf: 377 case LibFunc_setvbuf: 378 Changed |= setRetAndArgsNoUndef(F); 379 Changed |= setDoesNotThrow(F); 380 Changed |= setDoesNotCapture(F, 0); 381 return Changed; 382 case LibFunc_strndup: 383 Changed |= setArgNoUndef(F, 1); 384 LLVM_FALLTHROUGH; 385 case LibFunc_strdup: 386 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F); 387 Changed |= setDoesNotThrow(F); 388 Changed |= setRetDoesNotAlias(F); 389 Changed |= setWillReturn(F); 390 Changed |= setDoesNotCapture(F, 0); 391 Changed |= setOnlyReadsMemory(F, 0); 392 return Changed; 393 case LibFunc_stat: 394 case LibFunc_statvfs: 395 Changed |= setRetAndArgsNoUndef(F); 396 Changed |= setDoesNotThrow(F); 397 Changed |= setDoesNotCapture(F, 0); 398 Changed |= setDoesNotCapture(F, 1); 399 Changed |= setOnlyReadsMemory(F, 0); 400 return Changed; 401 case LibFunc_sscanf: 402 Changed |= setRetAndArgsNoUndef(F); 403 Changed |= setDoesNotThrow(F); 404 Changed |= setDoesNotCapture(F, 0); 405 Changed |= setDoesNotCapture(F, 1); 406 Changed |= setOnlyReadsMemory(F, 0); 407 Changed |= setOnlyReadsMemory(F, 1); 408 return Changed; 409 case LibFunc_sprintf: 410 Changed |= setRetAndArgsNoUndef(F); 411 Changed |= setDoesNotThrow(F); 412 Changed |= setDoesNotCapture(F, 0); 413 Changed |= setDoesNotAlias(F, 0); 414 Changed |= setOnlyWritesMemory(F, 0); 415 Changed |= setDoesNotCapture(F, 1); 416 Changed |= setOnlyReadsMemory(F, 1); 417 return Changed; 418 case LibFunc_snprintf: 419 Changed |= setRetAndArgsNoUndef(F); 420 Changed |= setDoesNotThrow(F); 421 Changed |= setDoesNotCapture(F, 0); 422 Changed |= setDoesNotAlias(F, 0); 423 Changed |= setOnlyWritesMemory(F, 0); 424 Changed |= setDoesNotCapture(F, 2); 425 Changed |= setOnlyReadsMemory(F, 2); 426 return Changed; 427 case LibFunc_setitimer: 428 Changed |= setRetAndArgsNoUndef(F); 429 Changed |= setDoesNotThrow(F); 430 Changed |= setWillReturn(F); 431 Changed |= setDoesNotCapture(F, 1); 432 Changed |= setDoesNotCapture(F, 2); 433 Changed |= setOnlyReadsMemory(F, 1); 434 return Changed; 435 case LibFunc_system: 436 // May throw; "system" is a valid pthread cancellation point. 437 Changed |= setRetAndArgsNoUndef(F); 438 Changed |= setDoesNotCapture(F, 0); 439 Changed |= setOnlyReadsMemory(F, 0); 440 return Changed; 441 case LibFunc_aligned_alloc: 442 Changed |= setAlignedAllocParam(F, 0); 443 Changed |= setAllocSize(F, 1, None); 444 LLVM_FALLTHROUGH; 445 case LibFunc_valloc: 446 case LibFunc_malloc: 447 case LibFunc_vec_malloc: 448 Changed |= setAllocSize(F, 0, None); 449 Changed |= setOnlyAccessesInaccessibleMemory(F); 450 Changed |= setRetAndArgsNoUndef(F); 451 Changed |= setDoesNotThrow(F); 452 Changed |= setRetDoesNotAlias(F); 453 Changed |= setWillReturn(F); 454 return Changed; 455 case LibFunc_memcmp: 456 Changed |= setOnlyAccessesArgMemory(F); 457 Changed |= setOnlyReadsMemory(F); 458 Changed |= setDoesNotThrow(F); 459 Changed |= setWillReturn(F); 460 Changed |= setDoesNotCapture(F, 0); 461 Changed |= setDoesNotCapture(F, 1); 462 return Changed; 463 case LibFunc_memchr: 464 case LibFunc_memrchr: 465 Changed |= setDoesNotThrow(F); 466 Changed |= setOnlyAccessesArgMemory(F); 467 Changed |= setOnlyReadsMemory(F); 468 Changed |= setWillReturn(F); 469 return Changed; 470 case LibFunc_modf: 471 case LibFunc_modff: 472 case LibFunc_modfl: 473 Changed |= setDoesNotThrow(F); 474 Changed |= setWillReturn(F); 475 Changed |= setDoesNotCapture(F, 1); 476 return Changed; 477 case LibFunc_memcpy: 478 Changed |= setDoesNotThrow(F); 479 Changed |= setOnlyAccessesArgMemory(F); 480 Changed |= setWillReturn(F); 481 Changed |= setDoesNotAlias(F, 0); 482 Changed |= setReturnedArg(F, 0); 483 Changed |= setOnlyWritesMemory(F, 0); 484 Changed |= setDoesNotAlias(F, 1); 485 Changed |= setDoesNotCapture(F, 1); 486 Changed |= setOnlyReadsMemory(F, 1); 487 return Changed; 488 case LibFunc_memmove: 489 Changed |= setDoesNotThrow(F); 490 Changed |= setOnlyAccessesArgMemory(F); 491 Changed |= setWillReturn(F); 492 Changed |= setReturnedArg(F, 0); 493 Changed |= setOnlyWritesMemory(F, 0); 494 Changed |= setDoesNotCapture(F, 1); 495 Changed |= setOnlyReadsMemory(F, 1); 496 return Changed; 497 case LibFunc_mempcpy: 498 case LibFunc_memccpy: 499 Changed |= setWillReturn(F); 500 LLVM_FALLTHROUGH; 501 case LibFunc_memcpy_chk: 502 Changed |= setDoesNotThrow(F); 503 Changed |= setOnlyAccessesArgMemory(F); 504 Changed |= setDoesNotAlias(F, 0); 505 Changed |= setOnlyWritesMemory(F, 0); 506 Changed |= setDoesNotAlias(F, 1); 507 Changed |= setDoesNotCapture(F, 1); 508 Changed |= setOnlyReadsMemory(F, 1); 509 return Changed; 510 case LibFunc_memalign: 511 Changed |= setAllocSize(F, 1, None); 512 Changed |= setAlignedAllocParam(F, 0); 513 Changed |= setOnlyAccessesInaccessibleMemory(F); 514 Changed |= setRetNoUndef(F); 515 Changed |= setDoesNotThrow(F); 516 Changed |= setRetDoesNotAlias(F); 517 Changed |= setWillReturn(F); 518 return Changed; 519 case LibFunc_mkdir: 520 Changed |= setRetAndArgsNoUndef(F); 521 Changed |= setDoesNotThrow(F); 522 Changed |= setDoesNotCapture(F, 0); 523 Changed |= setOnlyReadsMemory(F, 0); 524 return Changed; 525 case LibFunc_mktime: 526 Changed |= setRetAndArgsNoUndef(F); 527 Changed |= setDoesNotThrow(F); 528 Changed |= setWillReturn(F); 529 Changed |= setDoesNotCapture(F, 0); 530 return Changed; 531 case LibFunc_realloc: 532 case LibFunc_vec_realloc: 533 case LibFunc_reallocf: 534 Changed |= setAllocatedPointerParam(F, 0); 535 Changed |= setAllocSize(F, 1, None); 536 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F); 537 Changed |= setRetNoUndef(F); 538 Changed |= setDoesNotThrow(F); 539 Changed |= setRetDoesNotAlias(F); 540 Changed |= setWillReturn(F); 541 Changed |= setDoesNotCapture(F, 0); 542 Changed |= setArgNoUndef(F, 1); 543 return Changed; 544 case LibFunc_read: 545 // May throw; "read" is a valid pthread cancellation point. 546 Changed |= setRetAndArgsNoUndef(F); 547 Changed |= setDoesNotCapture(F, 1); 548 return Changed; 549 case LibFunc_rewind: 550 Changed |= setRetAndArgsNoUndef(F); 551 Changed |= setDoesNotThrow(F); 552 Changed |= setDoesNotCapture(F, 0); 553 return Changed; 554 case LibFunc_rmdir: 555 case LibFunc_remove: 556 case LibFunc_realpath: 557 Changed |= setRetAndArgsNoUndef(F); 558 Changed |= setDoesNotThrow(F); 559 Changed |= setDoesNotCapture(F, 0); 560 Changed |= setOnlyReadsMemory(F, 0); 561 return Changed; 562 case LibFunc_rename: 563 Changed |= setRetAndArgsNoUndef(F); 564 Changed |= setDoesNotThrow(F); 565 Changed |= setDoesNotCapture(F, 0); 566 Changed |= setDoesNotCapture(F, 1); 567 Changed |= setOnlyReadsMemory(F, 0); 568 Changed |= setOnlyReadsMemory(F, 1); 569 return Changed; 570 case LibFunc_readlink: 571 Changed |= setRetAndArgsNoUndef(F); 572 Changed |= setDoesNotThrow(F); 573 Changed |= setDoesNotCapture(F, 0); 574 Changed |= setDoesNotCapture(F, 1); 575 Changed |= setOnlyReadsMemory(F, 0); 576 return Changed; 577 case LibFunc_write: 578 // May throw; "write" is a valid pthread cancellation point. 579 Changed |= setRetAndArgsNoUndef(F); 580 Changed |= setDoesNotCapture(F, 1); 581 Changed |= setOnlyReadsMemory(F, 1); 582 return Changed; 583 case LibFunc_bcopy: 584 Changed |= setDoesNotThrow(F); 585 Changed |= setOnlyAccessesArgMemory(F); 586 Changed |= setWillReturn(F); 587 Changed |= setDoesNotCapture(F, 0); 588 Changed |= setOnlyReadsMemory(F, 0); 589 Changed |= setOnlyWritesMemory(F, 1); 590 Changed |= setDoesNotCapture(F, 1); 591 return Changed; 592 case LibFunc_bcmp: 593 Changed |= setDoesNotThrow(F); 594 Changed |= setOnlyAccessesArgMemory(F); 595 Changed |= setOnlyReadsMemory(F); 596 Changed |= setWillReturn(F); 597 Changed |= setDoesNotCapture(F, 0); 598 Changed |= setDoesNotCapture(F, 1); 599 return Changed; 600 case LibFunc_bzero: 601 Changed |= setDoesNotThrow(F); 602 Changed |= setOnlyAccessesArgMemory(F); 603 Changed |= setWillReturn(F); 604 Changed |= setDoesNotCapture(F, 0); 605 Changed |= setOnlyWritesMemory(F, 0); 606 return Changed; 607 case LibFunc_calloc: 608 case LibFunc_vec_calloc: 609 Changed |= setAllocSize(F, 0, 1); 610 Changed |= setOnlyAccessesInaccessibleMemory(F); 611 Changed |= setRetAndArgsNoUndef(F); 612 Changed |= setDoesNotThrow(F); 613 Changed |= setRetDoesNotAlias(F); 614 Changed |= setWillReturn(F); 615 return Changed; 616 case LibFunc_chmod: 617 case LibFunc_chown: 618 Changed |= setRetAndArgsNoUndef(F); 619 Changed |= setDoesNotThrow(F); 620 Changed |= setDoesNotCapture(F, 0); 621 Changed |= setOnlyReadsMemory(F, 0); 622 return Changed; 623 case LibFunc_ctermid: 624 case LibFunc_clearerr: 625 case LibFunc_closedir: 626 Changed |= setRetAndArgsNoUndef(F); 627 Changed |= setDoesNotThrow(F); 628 Changed |= setDoesNotCapture(F, 0); 629 return Changed; 630 case LibFunc_atoi: 631 case LibFunc_atol: 632 case LibFunc_atof: 633 case LibFunc_atoll: 634 Changed |= setDoesNotThrow(F); 635 Changed |= setOnlyReadsMemory(F); 636 Changed |= setWillReturn(F); 637 Changed |= setDoesNotCapture(F, 0); 638 return Changed; 639 case LibFunc_access: 640 Changed |= setRetAndArgsNoUndef(F); 641 Changed |= setDoesNotThrow(F); 642 Changed |= setDoesNotCapture(F, 0); 643 Changed |= setOnlyReadsMemory(F, 0); 644 return Changed; 645 case LibFunc_fopen: 646 Changed |= setRetAndArgsNoUndef(F); 647 Changed |= setDoesNotThrow(F); 648 Changed |= setRetDoesNotAlias(F); 649 Changed |= setDoesNotCapture(F, 0); 650 Changed |= setDoesNotCapture(F, 1); 651 Changed |= setOnlyReadsMemory(F, 0); 652 Changed |= setOnlyReadsMemory(F, 1); 653 return Changed; 654 case LibFunc_fdopen: 655 Changed |= setRetAndArgsNoUndef(F); 656 Changed |= setDoesNotThrow(F); 657 Changed |= setRetDoesNotAlias(F); 658 Changed |= setDoesNotCapture(F, 1); 659 Changed |= setOnlyReadsMemory(F, 1); 660 return Changed; 661 case LibFunc_feof: 662 Changed |= setRetAndArgsNoUndef(F); 663 Changed |= setDoesNotThrow(F); 664 Changed |= setDoesNotCapture(F, 0); 665 return Changed; 666 case LibFunc_free: 667 case LibFunc_vec_free: 668 Changed |= setAllocatedPointerParam(F, 0); 669 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F); 670 Changed |= setArgsNoUndef(F); 671 Changed |= setDoesNotThrow(F); 672 Changed |= setWillReturn(F); 673 Changed |= setDoesNotCapture(F, 0); 674 return Changed; 675 case LibFunc_fseek: 676 case LibFunc_ftell: 677 case LibFunc_fgetc: 678 case LibFunc_fgetc_unlocked: 679 case LibFunc_fseeko: 680 case LibFunc_ftello: 681 case LibFunc_fileno: 682 case LibFunc_fflush: 683 case LibFunc_fclose: 684 case LibFunc_fsetpos: 685 case LibFunc_flockfile: 686 case LibFunc_funlockfile: 687 case LibFunc_ftrylockfile: 688 Changed |= setRetAndArgsNoUndef(F); 689 Changed |= setDoesNotThrow(F); 690 Changed |= setDoesNotCapture(F, 0); 691 return Changed; 692 case LibFunc_ferror: 693 Changed |= setRetAndArgsNoUndef(F); 694 Changed |= setDoesNotThrow(F); 695 Changed |= setDoesNotCapture(F, 0); 696 Changed |= setOnlyReadsMemory(F); 697 return Changed; 698 case LibFunc_fputc: 699 case LibFunc_fputc_unlocked: 700 case LibFunc_fstat: 701 Changed |= setRetAndArgsNoUndef(F); 702 Changed |= setDoesNotThrow(F); 703 Changed |= setDoesNotCapture(F, 1); 704 return Changed; 705 case LibFunc_frexp: 706 case LibFunc_frexpf: 707 case LibFunc_frexpl: 708 Changed |= setDoesNotThrow(F); 709 Changed |= setWillReturn(F); 710 Changed |= setDoesNotCapture(F, 1); 711 return Changed; 712 case LibFunc_fstatvfs: 713 Changed |= setRetAndArgsNoUndef(F); 714 Changed |= setDoesNotThrow(F); 715 Changed |= setDoesNotCapture(F, 1); 716 return Changed; 717 case LibFunc_fgets: 718 case LibFunc_fgets_unlocked: 719 Changed |= setRetAndArgsNoUndef(F); 720 Changed |= setDoesNotThrow(F); 721 Changed |= setDoesNotCapture(F, 2); 722 return Changed; 723 case LibFunc_fread: 724 case LibFunc_fread_unlocked: 725 Changed |= setRetAndArgsNoUndef(F); 726 Changed |= setDoesNotThrow(F); 727 Changed |= setDoesNotCapture(F, 0); 728 Changed |= setDoesNotCapture(F, 3); 729 return Changed; 730 case LibFunc_fwrite: 731 case LibFunc_fwrite_unlocked: 732 Changed |= setRetAndArgsNoUndef(F); 733 Changed |= setDoesNotThrow(F); 734 Changed |= setDoesNotCapture(F, 0); 735 Changed |= setDoesNotCapture(F, 3); 736 // FIXME: readonly #1? 737 return Changed; 738 case LibFunc_fputs: 739 case LibFunc_fputs_unlocked: 740 Changed |= setRetAndArgsNoUndef(F); 741 Changed |= setDoesNotThrow(F); 742 Changed |= setDoesNotCapture(F, 0); 743 Changed |= setDoesNotCapture(F, 1); 744 Changed |= setOnlyReadsMemory(F, 0); 745 return Changed; 746 case LibFunc_fscanf: 747 case LibFunc_fprintf: 748 Changed |= setRetAndArgsNoUndef(F); 749 Changed |= setDoesNotThrow(F); 750 Changed |= setDoesNotCapture(F, 0); 751 Changed |= setDoesNotCapture(F, 1); 752 Changed |= setOnlyReadsMemory(F, 1); 753 return Changed; 754 case LibFunc_fgetpos: 755 Changed |= setRetAndArgsNoUndef(F); 756 Changed |= setDoesNotThrow(F); 757 Changed |= setDoesNotCapture(F, 0); 758 Changed |= setDoesNotCapture(F, 1); 759 return Changed; 760 case LibFunc_getc: 761 Changed |= setRetAndArgsNoUndef(F); 762 Changed |= setDoesNotThrow(F); 763 Changed |= setDoesNotCapture(F, 0); 764 return Changed; 765 case LibFunc_getlogin_r: 766 Changed |= setRetAndArgsNoUndef(F); 767 Changed |= setDoesNotThrow(F); 768 Changed |= setDoesNotCapture(F, 0); 769 return Changed; 770 case LibFunc_getc_unlocked: 771 Changed |= setRetAndArgsNoUndef(F); 772 Changed |= setDoesNotThrow(F); 773 Changed |= setDoesNotCapture(F, 0); 774 return Changed; 775 case LibFunc_getenv: 776 Changed |= setRetAndArgsNoUndef(F); 777 Changed |= setDoesNotThrow(F); 778 Changed |= setOnlyReadsMemory(F); 779 Changed |= setDoesNotCapture(F, 0); 780 return Changed; 781 case LibFunc_gets: 782 case LibFunc_getchar: 783 case LibFunc_getchar_unlocked: 784 Changed |= setRetAndArgsNoUndef(F); 785 Changed |= setDoesNotThrow(F); 786 return Changed; 787 case LibFunc_getitimer: 788 Changed |= setRetAndArgsNoUndef(F); 789 Changed |= setDoesNotThrow(F); 790 Changed |= setDoesNotCapture(F, 1); 791 return Changed; 792 case LibFunc_getpwnam: 793 Changed |= setRetAndArgsNoUndef(F); 794 Changed |= setDoesNotThrow(F); 795 Changed |= setDoesNotCapture(F, 0); 796 Changed |= setOnlyReadsMemory(F, 0); 797 return Changed; 798 case LibFunc_ungetc: 799 Changed |= setRetAndArgsNoUndef(F); 800 Changed |= setDoesNotThrow(F); 801 Changed |= setDoesNotCapture(F, 1); 802 return Changed; 803 case LibFunc_uname: 804 Changed |= setRetAndArgsNoUndef(F); 805 Changed |= setDoesNotThrow(F); 806 Changed |= setDoesNotCapture(F, 0); 807 return Changed; 808 case LibFunc_unlink: 809 Changed |= setRetAndArgsNoUndef(F); 810 Changed |= setDoesNotThrow(F); 811 Changed |= setDoesNotCapture(F, 0); 812 Changed |= setOnlyReadsMemory(F, 0); 813 return Changed; 814 case LibFunc_unsetenv: 815 Changed |= setRetAndArgsNoUndef(F); 816 Changed |= setDoesNotThrow(F); 817 Changed |= setDoesNotCapture(F, 0); 818 Changed |= setOnlyReadsMemory(F, 0); 819 return Changed; 820 case LibFunc_utime: 821 case LibFunc_utimes: 822 Changed |= setRetAndArgsNoUndef(F); 823 Changed |= setDoesNotThrow(F); 824 Changed |= setDoesNotCapture(F, 0); 825 Changed |= setDoesNotCapture(F, 1); 826 Changed |= setOnlyReadsMemory(F, 0); 827 Changed |= setOnlyReadsMemory(F, 1); 828 return Changed; 829 case LibFunc_putc: 830 case LibFunc_putc_unlocked: 831 Changed |= setRetAndArgsNoUndef(F); 832 Changed |= setDoesNotThrow(F); 833 Changed |= setDoesNotCapture(F, 1); 834 return Changed; 835 case LibFunc_puts: 836 case LibFunc_printf: 837 case LibFunc_perror: 838 Changed |= setRetAndArgsNoUndef(F); 839 Changed |= setDoesNotThrow(F); 840 Changed |= setDoesNotCapture(F, 0); 841 Changed |= setOnlyReadsMemory(F, 0); 842 return Changed; 843 case LibFunc_pread: 844 // May throw; "pread" is a valid pthread cancellation point. 845 Changed |= setRetAndArgsNoUndef(F); 846 Changed |= setDoesNotCapture(F, 1); 847 return Changed; 848 case LibFunc_pwrite: 849 // May throw; "pwrite" is a valid pthread cancellation point. 850 Changed |= setRetAndArgsNoUndef(F); 851 Changed |= setDoesNotCapture(F, 1); 852 Changed |= setOnlyReadsMemory(F, 1); 853 return Changed; 854 case LibFunc_putchar: 855 case LibFunc_putchar_unlocked: 856 Changed |= setRetAndArgsNoUndef(F); 857 Changed |= setArgExtAttr(F, 0, TLI); 858 Changed |= setDoesNotThrow(F); 859 return Changed; 860 case LibFunc_popen: 861 Changed |= setRetAndArgsNoUndef(F); 862 Changed |= setDoesNotThrow(F); 863 Changed |= setRetDoesNotAlias(F); 864 Changed |= setDoesNotCapture(F, 0); 865 Changed |= setDoesNotCapture(F, 1); 866 Changed |= setOnlyReadsMemory(F, 0); 867 Changed |= setOnlyReadsMemory(F, 1); 868 return Changed; 869 case LibFunc_pclose: 870 Changed |= setRetAndArgsNoUndef(F); 871 Changed |= setDoesNotThrow(F); 872 Changed |= setDoesNotCapture(F, 0); 873 return Changed; 874 case LibFunc_vscanf: 875 Changed |= setRetAndArgsNoUndef(F); 876 Changed |= setDoesNotThrow(F); 877 Changed |= setDoesNotCapture(F, 0); 878 Changed |= setOnlyReadsMemory(F, 0); 879 return Changed; 880 case LibFunc_vsscanf: 881 Changed |= setRetAndArgsNoUndef(F); 882 Changed |= setDoesNotThrow(F); 883 Changed |= setDoesNotCapture(F, 0); 884 Changed |= setDoesNotCapture(F, 1); 885 Changed |= setOnlyReadsMemory(F, 0); 886 Changed |= setOnlyReadsMemory(F, 1); 887 return Changed; 888 case LibFunc_vfscanf: 889 Changed |= setRetAndArgsNoUndef(F); 890 Changed |= setDoesNotThrow(F); 891 Changed |= setDoesNotCapture(F, 0); 892 Changed |= setDoesNotCapture(F, 1); 893 Changed |= setOnlyReadsMemory(F, 1); 894 return Changed; 895 case LibFunc_vprintf: 896 Changed |= setRetAndArgsNoUndef(F); 897 Changed |= setDoesNotThrow(F); 898 Changed |= setDoesNotCapture(F, 0); 899 Changed |= setOnlyReadsMemory(F, 0); 900 return Changed; 901 case LibFunc_vfprintf: 902 case LibFunc_vsprintf: 903 Changed |= setRetAndArgsNoUndef(F); 904 Changed |= setDoesNotThrow(F); 905 Changed |= setDoesNotCapture(F, 0); 906 Changed |= setDoesNotCapture(F, 1); 907 Changed |= setOnlyReadsMemory(F, 1); 908 return Changed; 909 case LibFunc_vsnprintf: 910 Changed |= setRetAndArgsNoUndef(F); 911 Changed |= setDoesNotThrow(F); 912 Changed |= setDoesNotCapture(F, 0); 913 Changed |= setDoesNotCapture(F, 2); 914 Changed |= setOnlyReadsMemory(F, 2); 915 return Changed; 916 case LibFunc_open: 917 // May throw; "open" is a valid pthread cancellation point. 918 Changed |= setRetAndArgsNoUndef(F); 919 Changed |= setDoesNotCapture(F, 0); 920 Changed |= setOnlyReadsMemory(F, 0); 921 return Changed; 922 case LibFunc_opendir: 923 Changed |= setRetAndArgsNoUndef(F); 924 Changed |= setDoesNotThrow(F); 925 Changed |= setRetDoesNotAlias(F); 926 Changed |= setDoesNotCapture(F, 0); 927 Changed |= setOnlyReadsMemory(F, 0); 928 return Changed; 929 case LibFunc_tmpfile: 930 Changed |= setRetAndArgsNoUndef(F); 931 Changed |= setDoesNotThrow(F); 932 Changed |= setRetDoesNotAlias(F); 933 return Changed; 934 case LibFunc_times: 935 Changed |= setRetAndArgsNoUndef(F); 936 Changed |= setDoesNotThrow(F); 937 Changed |= setDoesNotCapture(F, 0); 938 return Changed; 939 case LibFunc_htonl: 940 case LibFunc_htons: 941 case LibFunc_ntohl: 942 case LibFunc_ntohs: 943 Changed |= setDoesNotThrow(F); 944 Changed |= setDoesNotAccessMemory(F); 945 return Changed; 946 case LibFunc_lstat: 947 Changed |= setRetAndArgsNoUndef(F); 948 Changed |= setDoesNotThrow(F); 949 Changed |= setDoesNotCapture(F, 0); 950 Changed |= setDoesNotCapture(F, 1); 951 Changed |= setOnlyReadsMemory(F, 0); 952 return Changed; 953 case LibFunc_lchown: 954 Changed |= setRetAndArgsNoUndef(F); 955 Changed |= setDoesNotThrow(F); 956 Changed |= setDoesNotCapture(F, 0); 957 Changed |= setOnlyReadsMemory(F, 0); 958 return Changed; 959 case LibFunc_qsort: 960 // May throw; places call through function pointer. 961 // Cannot give undef pointer/size 962 Changed |= setRetAndArgsNoUndef(F); 963 Changed |= setDoesNotCapture(F, 3); 964 return Changed; 965 case LibFunc_dunder_strndup: 966 Changed |= setArgNoUndef(F, 1); 967 LLVM_FALLTHROUGH; 968 case LibFunc_dunder_strdup: 969 Changed |= setDoesNotThrow(F); 970 Changed |= setRetDoesNotAlias(F); 971 Changed |= setWillReturn(F); 972 Changed |= setDoesNotCapture(F, 0); 973 Changed |= setOnlyReadsMemory(F, 0); 974 return Changed; 975 case LibFunc_dunder_strtok_r: 976 Changed |= setDoesNotThrow(F); 977 Changed |= setDoesNotCapture(F, 1); 978 Changed |= setOnlyReadsMemory(F, 1); 979 return Changed; 980 case LibFunc_under_IO_getc: 981 Changed |= setRetAndArgsNoUndef(F); 982 Changed |= setDoesNotThrow(F); 983 Changed |= setDoesNotCapture(F, 0); 984 return Changed; 985 case LibFunc_under_IO_putc: 986 Changed |= setRetAndArgsNoUndef(F); 987 Changed |= setDoesNotThrow(F); 988 Changed |= setDoesNotCapture(F, 1); 989 return Changed; 990 case LibFunc_dunder_isoc99_scanf: 991 Changed |= setRetAndArgsNoUndef(F); 992 Changed |= setDoesNotThrow(F); 993 Changed |= setDoesNotCapture(F, 0); 994 Changed |= setOnlyReadsMemory(F, 0); 995 return Changed; 996 case LibFunc_stat64: 997 case LibFunc_lstat64: 998 case LibFunc_statvfs64: 999 Changed |= setRetAndArgsNoUndef(F); 1000 Changed |= setDoesNotThrow(F); 1001 Changed |= setDoesNotCapture(F, 0); 1002 Changed |= setDoesNotCapture(F, 1); 1003 Changed |= setOnlyReadsMemory(F, 0); 1004 return Changed; 1005 case LibFunc_dunder_isoc99_sscanf: 1006 Changed |= setRetAndArgsNoUndef(F); 1007 Changed |= setDoesNotThrow(F); 1008 Changed |= setDoesNotCapture(F, 0); 1009 Changed |= setDoesNotCapture(F, 1); 1010 Changed |= setOnlyReadsMemory(F, 0); 1011 Changed |= setOnlyReadsMemory(F, 1); 1012 return Changed; 1013 case LibFunc_fopen64: 1014 Changed |= setRetAndArgsNoUndef(F); 1015 Changed |= setDoesNotThrow(F); 1016 Changed |= setRetDoesNotAlias(F); 1017 Changed |= setDoesNotCapture(F, 0); 1018 Changed |= setDoesNotCapture(F, 1); 1019 Changed |= setOnlyReadsMemory(F, 0); 1020 Changed |= setOnlyReadsMemory(F, 1); 1021 return Changed; 1022 case LibFunc_fseeko64: 1023 case LibFunc_ftello64: 1024 Changed |= setRetAndArgsNoUndef(F); 1025 Changed |= setDoesNotThrow(F); 1026 Changed |= setDoesNotCapture(F, 0); 1027 return Changed; 1028 case LibFunc_tmpfile64: 1029 Changed |= setRetAndArgsNoUndef(F); 1030 Changed |= setDoesNotThrow(F); 1031 Changed |= setRetDoesNotAlias(F); 1032 return Changed; 1033 case LibFunc_fstat64: 1034 case LibFunc_fstatvfs64: 1035 Changed |= setRetAndArgsNoUndef(F); 1036 Changed |= setDoesNotThrow(F); 1037 Changed |= setDoesNotCapture(F, 1); 1038 return Changed; 1039 case LibFunc_open64: 1040 // May throw; "open" is a valid pthread cancellation point. 1041 Changed |= setRetAndArgsNoUndef(F); 1042 Changed |= setDoesNotCapture(F, 0); 1043 Changed |= setOnlyReadsMemory(F, 0); 1044 return Changed; 1045 case LibFunc_gettimeofday: 1046 // Currently some platforms have the restrict keyword on the arguments to 1047 // gettimeofday. To be conservative, do not add noalias to gettimeofday's 1048 // arguments. 1049 Changed |= setRetAndArgsNoUndef(F); 1050 Changed |= setDoesNotThrow(F); 1051 Changed |= setDoesNotCapture(F, 0); 1052 Changed |= setDoesNotCapture(F, 1); 1053 return Changed; 1054 case LibFunc_memset_pattern4: 1055 case LibFunc_memset_pattern8: 1056 case LibFunc_memset_pattern16: 1057 Changed |= setDoesNotCapture(F, 0); 1058 Changed |= setDoesNotCapture(F, 1); 1059 Changed |= setOnlyReadsMemory(F, 1); 1060 LLVM_FALLTHROUGH; 1061 case LibFunc_memset: 1062 Changed |= setWillReturn(F); 1063 LLVM_FALLTHROUGH; 1064 case LibFunc_memset_chk: 1065 Changed |= setOnlyAccessesArgMemory(F); 1066 Changed |= setOnlyWritesMemory(F, 0); 1067 Changed |= setDoesNotThrow(F); 1068 return Changed; 1069 // int __nvvm_reflect(const char *) 1070 case LibFunc_nvvm_reflect: 1071 Changed |= setRetAndArgsNoUndef(F); 1072 Changed |= setDoesNotAccessMemory(F); 1073 Changed |= setDoesNotThrow(F); 1074 return Changed; 1075 case LibFunc_ldexp: 1076 case LibFunc_ldexpf: 1077 case LibFunc_ldexpl: 1078 Changed |= setArgExtAttr(F, 1, TLI); 1079 Changed |= setWillReturn(F); 1080 return Changed; 1081 case LibFunc_abs: 1082 case LibFunc_acos: 1083 case LibFunc_acosf: 1084 case LibFunc_acosh: 1085 case LibFunc_acoshf: 1086 case LibFunc_acoshl: 1087 case LibFunc_acosl: 1088 case LibFunc_asin: 1089 case LibFunc_asinf: 1090 case LibFunc_asinh: 1091 case LibFunc_asinhf: 1092 case LibFunc_asinhl: 1093 case LibFunc_asinl: 1094 case LibFunc_atan: 1095 case LibFunc_atan2: 1096 case LibFunc_atan2f: 1097 case LibFunc_atan2l: 1098 case LibFunc_atanf: 1099 case LibFunc_atanh: 1100 case LibFunc_atanhf: 1101 case LibFunc_atanhl: 1102 case LibFunc_atanl: 1103 case LibFunc_cbrt: 1104 case LibFunc_cbrtf: 1105 case LibFunc_cbrtl: 1106 case LibFunc_ceil: 1107 case LibFunc_ceilf: 1108 case LibFunc_ceill: 1109 case LibFunc_copysign: 1110 case LibFunc_copysignf: 1111 case LibFunc_copysignl: 1112 case LibFunc_cos: 1113 case LibFunc_cosh: 1114 case LibFunc_coshf: 1115 case LibFunc_coshl: 1116 case LibFunc_cosf: 1117 case LibFunc_cosl: 1118 case LibFunc_cospi: 1119 case LibFunc_cospif: 1120 case LibFunc_exp: 1121 case LibFunc_expf: 1122 case LibFunc_expl: 1123 case LibFunc_exp2: 1124 case LibFunc_exp2f: 1125 case LibFunc_exp2l: 1126 case LibFunc_expm1: 1127 case LibFunc_expm1f: 1128 case LibFunc_expm1l: 1129 case LibFunc_fabs: 1130 case LibFunc_fabsf: 1131 case LibFunc_fabsl: 1132 case LibFunc_ffs: 1133 case LibFunc_ffsl: 1134 case LibFunc_ffsll: 1135 case LibFunc_floor: 1136 case LibFunc_floorf: 1137 case LibFunc_floorl: 1138 case LibFunc_fls: 1139 case LibFunc_flsl: 1140 case LibFunc_flsll: 1141 case LibFunc_fmax: 1142 case LibFunc_fmaxf: 1143 case LibFunc_fmaxl: 1144 case LibFunc_fmin: 1145 case LibFunc_fminf: 1146 case LibFunc_fminl: 1147 case LibFunc_fmod: 1148 case LibFunc_fmodf: 1149 case LibFunc_fmodl: 1150 case LibFunc_isascii: 1151 case LibFunc_isdigit: 1152 case LibFunc_labs: 1153 case LibFunc_llabs: 1154 case LibFunc_log: 1155 case LibFunc_log10: 1156 case LibFunc_log10f: 1157 case LibFunc_log10l: 1158 case LibFunc_log1p: 1159 case LibFunc_log1pf: 1160 case LibFunc_log1pl: 1161 case LibFunc_log2: 1162 case LibFunc_log2f: 1163 case LibFunc_log2l: 1164 case LibFunc_logb: 1165 case LibFunc_logbf: 1166 case LibFunc_logbl: 1167 case LibFunc_logf: 1168 case LibFunc_logl: 1169 case LibFunc_nearbyint: 1170 case LibFunc_nearbyintf: 1171 case LibFunc_nearbyintl: 1172 case LibFunc_pow: 1173 case LibFunc_powf: 1174 case LibFunc_powl: 1175 case LibFunc_rint: 1176 case LibFunc_rintf: 1177 case LibFunc_rintl: 1178 case LibFunc_round: 1179 case LibFunc_roundf: 1180 case LibFunc_roundl: 1181 case LibFunc_sin: 1182 case LibFunc_sincospif_stret: 1183 case LibFunc_sinf: 1184 case LibFunc_sinh: 1185 case LibFunc_sinhf: 1186 case LibFunc_sinhl: 1187 case LibFunc_sinl: 1188 case LibFunc_sinpi: 1189 case LibFunc_sinpif: 1190 case LibFunc_sqrt: 1191 case LibFunc_sqrtf: 1192 case LibFunc_sqrtl: 1193 case LibFunc_tan: 1194 case LibFunc_tanf: 1195 case LibFunc_tanh: 1196 case LibFunc_tanhf: 1197 case LibFunc_tanhl: 1198 case LibFunc_tanl: 1199 case LibFunc_toascii: 1200 case LibFunc_trunc: 1201 case LibFunc_truncf: 1202 case LibFunc_truncl: 1203 Changed |= setDoesNotThrow(F); 1204 Changed |= setDoesNotFreeMemory(F); 1205 Changed |= setOnlyWritesMemory(F); 1206 Changed |= setWillReturn(F); 1207 return Changed; 1208 default: 1209 // FIXME: It'd be really nice to cover all the library functions we're 1210 // aware of here. 1211 return false; 1212 } 1213 } 1214 1215 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty, 1216 LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) { 1217 switch (Ty->getTypeID()) { 1218 case Type::HalfTyID: 1219 return false; 1220 case Type::FloatTyID: 1221 return TLI->has(FloatFn); 1222 case Type::DoubleTyID: 1223 return TLI->has(DoubleFn); 1224 default: 1225 return TLI->has(LongDoubleFn); 1226 } 1227 } 1228 1229 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty, 1230 LibFunc DoubleFn, LibFunc FloatFn, 1231 LibFunc LongDoubleFn) { 1232 assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) && 1233 "Cannot get name for unavailable function!"); 1234 1235 switch (Ty->getTypeID()) { 1236 case Type::HalfTyID: 1237 llvm_unreachable("No name for HalfTy!"); 1238 case Type::FloatTyID: 1239 return TLI->getName(FloatFn); 1240 case Type::DoubleTyID: 1241 return TLI->getName(DoubleFn); 1242 default: 1243 return TLI->getName(LongDoubleFn); 1244 } 1245 } 1246 1247 //- Emit LibCalls ------------------------------------------------------------// 1248 1249 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) { 1250 unsigned AS = V->getType()->getPointerAddressSpace(); 1251 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr"); 1252 } 1253 1254 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType, 1255 ArrayRef<Type *> ParamTypes, 1256 ArrayRef<Value *> Operands, IRBuilderBase &B, 1257 const TargetLibraryInfo *TLI, 1258 bool IsVaArgs = false) { 1259 if (!TLI->has(TheLibFunc)) 1260 return nullptr; 1261 1262 Module *M = B.GetInsertBlock()->getModule(); 1263 StringRef FuncName = TLI->getName(TheLibFunc); 1264 FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs); 1265 FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType); 1266 inferLibFuncAttributes(M, FuncName, *TLI); 1267 CallInst *CI = B.CreateCall(Callee, Operands, FuncName); 1268 if (const Function *F = 1269 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1270 CI->setCallingConv(F->getCallingConv()); 1271 return CI; 1272 } 1273 1274 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL, 1275 const TargetLibraryInfo *TLI) { 1276 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1277 return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context), 1278 B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI); 1279 } 1280 1281 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B, 1282 const TargetLibraryInfo *TLI) { 1283 return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(), 1284 castToCStr(Ptr, B), B, TLI); 1285 } 1286 1287 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B, 1288 const TargetLibraryInfo *TLI) { 1289 Type *I8Ptr = B.getInt8PtrTy(); 1290 Type *I32Ty = B.getInt32Ty(); 1291 return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty}, 1292 {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI); 1293 } 1294 1295 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1296 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1297 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1298 return emitLibCall( 1299 LibFunc_strncmp, B.getInt32Ty(), 1300 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)}, 1301 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1302 } 1303 1304 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, 1305 const TargetLibraryInfo *TLI) { 1306 Type *I8Ptr = Dst->getType(); 1307 return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr}, 1308 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); 1309 } 1310 1311 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, 1312 const TargetLibraryInfo *TLI) { 1313 Type *I8Ptr = B.getInt8PtrTy(); 1314 return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr}, 1315 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); 1316 } 1317 1318 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1319 const TargetLibraryInfo *TLI) { 1320 Type *I8Ptr = B.getInt8PtrTy(); 1321 return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()}, 1322 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); 1323 } 1324 1325 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1326 const TargetLibraryInfo *TLI) { 1327 Type *I8Ptr = B.getInt8PtrTy(); 1328 return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()}, 1329 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); 1330 } 1331 1332 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, 1333 IRBuilderBase &B, const DataLayout &DL, 1334 const TargetLibraryInfo *TLI) { 1335 if (!TLI->has(LibFunc_memcpy_chk)) 1336 return nullptr; 1337 1338 Module *M = B.GetInsertBlock()->getModule(); 1339 AttributeList AS; 1340 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex, 1341 Attribute::NoUnwind); 1342 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1343 FunctionCallee MemCpy = M->getOrInsertFunction( 1344 "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(), 1345 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context), 1346 DL.getIntPtrType(Context)); 1347 Dst = castToCStr(Dst, B); 1348 Src = castToCStr(Src, B); 1349 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize}); 1350 if (const Function *F = 1351 dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts())) 1352 CI->setCallingConv(F->getCallingConv()); 1353 return CI; 1354 } 1355 1356 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, 1357 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1358 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1359 return emitLibCall( 1360 LibFunc_mempcpy, B.getInt8PtrTy(), 1361 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)}, 1362 {Dst, Src, Len}, B, TLI); 1363 } 1364 1365 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, 1366 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1367 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1368 return emitLibCall( 1369 LibFunc_memchr, B.getInt8PtrTy(), 1370 {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)}, 1371 {castToCStr(Ptr, B), Val, Len}, B, TLI); 1372 } 1373 1374 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1375 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1376 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1377 return emitLibCall( 1378 LibFunc_memcmp, B.getInt32Ty(), 1379 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)}, 1380 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1381 } 1382 1383 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, 1384 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1385 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1386 return emitLibCall( 1387 LibFunc_bcmp, B.getInt32Ty(), 1388 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)}, 1389 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); 1390 } 1391 1392 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, 1393 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1394 return emitLibCall( 1395 LibFunc_memccpy, B.getInt8PtrTy(), 1396 {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()}, 1397 {Ptr1, Ptr2, Val, Len}, B, TLI); 1398 } 1399 1400 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, 1401 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B, 1402 const TargetLibraryInfo *TLI) { 1403 SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)}; 1404 llvm::append_range(Args, VariadicArgs); 1405 return emitLibCall(LibFunc_snprintf, B.getInt32Ty(), 1406 {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()}, 1407 Args, B, TLI, /*IsVaArgs=*/true); 1408 } 1409 1410 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt, 1411 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B, 1412 const TargetLibraryInfo *TLI) { 1413 SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)}; 1414 llvm::append_range(Args, VariadicArgs); 1415 return emitLibCall(LibFunc_sprintf, B.getInt32Ty(), 1416 {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI, 1417 /*IsVaArgs=*/true); 1418 } 1419 1420 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, 1421 const TargetLibraryInfo *TLI) { 1422 return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(), 1423 {B.getInt8PtrTy(), B.getInt8PtrTy()}, 1424 {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI); 1425 } 1426 1427 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1428 const TargetLibraryInfo *TLI) { 1429 return emitLibCall(LibFunc_strlcpy, Size->getType(), 1430 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()}, 1431 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1432 } 1433 1434 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1435 const TargetLibraryInfo *TLI) { 1436 return emitLibCall(LibFunc_strlcat, Size->getType(), 1437 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()}, 1438 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1439 } 1440 1441 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, 1442 const TargetLibraryInfo *TLI) { 1443 return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(), 1444 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()}, 1445 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); 1446 } 1447 1448 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, 1449 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1450 return emitLibCall( 1451 LibFunc_vsnprintf, B.getInt32Ty(), 1452 {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()}, 1453 {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI); 1454 } 1455 1456 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, 1457 IRBuilderBase &B, const TargetLibraryInfo *TLI) { 1458 return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(), 1459 {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()}, 1460 {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI); 1461 } 1462 1463 /// Append a suffix to the function name according to the type of 'Op'. 1464 static void appendTypeSuffix(Value *Op, StringRef &Name, 1465 SmallString<20> &NameBuffer) { 1466 if (!Op->getType()->isDoubleTy()) { 1467 NameBuffer += Name; 1468 1469 if (Op->getType()->isFloatTy()) 1470 NameBuffer += 'f'; 1471 else 1472 NameBuffer += 'l'; 1473 1474 Name = NameBuffer; 1475 } 1476 } 1477 1478 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name, 1479 IRBuilderBase &B, 1480 const AttributeList &Attrs) { 1481 assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall"); 1482 1483 Module *M = B.GetInsertBlock()->getModule(); 1484 FunctionCallee Callee = 1485 M->getOrInsertFunction(Name, Op->getType(), Op->getType()); 1486 CallInst *CI = B.CreateCall(Callee, Op, Name); 1487 1488 // The incoming attribute set may have come from a speculatable intrinsic, but 1489 // is being replaced with a library call which is not allowed to be 1490 // speculatable. 1491 CI->setAttributes( 1492 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable)); 1493 if (const Function *F = 1494 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1495 CI->setCallingConv(F->getCallingConv()); 1496 1497 return CI; 1498 } 1499 1500 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B, 1501 const AttributeList &Attrs) { 1502 SmallString<20> NameBuffer; 1503 appendTypeSuffix(Op, Name, NameBuffer); 1504 1505 return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs); 1506 } 1507 1508 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, 1509 LibFunc DoubleFn, LibFunc FloatFn, 1510 LibFunc LongDoubleFn, IRBuilderBase &B, 1511 const AttributeList &Attrs) { 1512 // Get the name of the function according to TLI. 1513 StringRef Name = getFloatFnName(TLI, Op->getType(), 1514 DoubleFn, FloatFn, LongDoubleFn); 1515 1516 return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs); 1517 } 1518 1519 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2, 1520 StringRef Name, IRBuilderBase &B, 1521 const AttributeList &Attrs, 1522 const TargetLibraryInfo *TLI = nullptr) { 1523 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall"); 1524 1525 Module *M = B.GetInsertBlock()->getModule(); 1526 FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(), 1527 Op1->getType(), Op2->getType()); 1528 if (TLI != nullptr) 1529 inferLibFuncAttributes(M, Name, *TLI); 1530 CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name); 1531 1532 // The incoming attribute set may have come from a speculatable intrinsic, but 1533 // is being replaced with a library call which is not allowed to be 1534 // speculatable. 1535 CI->setAttributes( 1536 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable)); 1537 if (const Function *F = 1538 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts())) 1539 CI->setCallingConv(F->getCallingConv()); 1540 1541 return CI; 1542 } 1543 1544 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, 1545 IRBuilderBase &B, 1546 const AttributeList &Attrs) { 1547 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall"); 1548 1549 SmallString<20> NameBuffer; 1550 appendTypeSuffix(Op1, Name, NameBuffer); 1551 1552 return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs); 1553 } 1554 1555 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, 1556 const TargetLibraryInfo *TLI, 1557 LibFunc DoubleFn, LibFunc FloatFn, 1558 LibFunc LongDoubleFn, IRBuilderBase &B, 1559 const AttributeList &Attrs) { 1560 // Get the name of the function according to TLI. 1561 StringRef Name = getFloatFnName(TLI, Op1->getType(), 1562 DoubleFn, FloatFn, LongDoubleFn); 1563 1564 return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs, TLI); 1565 } 1566 1567 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B, 1568 const TargetLibraryInfo *TLI) { 1569 if (!TLI->has(LibFunc_putchar)) 1570 return nullptr; 1571 1572 Module *M = B.GetInsertBlock()->getModule(); 1573 StringRef PutCharName = TLI->getName(LibFunc_putchar); 1574 FunctionCallee PutChar = 1575 M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty()); 1576 inferLibFuncAttributes(M, PutCharName, *TLI); 1577 CallInst *CI = B.CreateCall(PutChar, 1578 B.CreateIntCast(Char, 1579 B.getInt32Ty(), 1580 /*isSigned*/true, 1581 "chari"), 1582 PutCharName); 1583 1584 if (const Function *F = 1585 dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts())) 1586 CI->setCallingConv(F->getCallingConv()); 1587 return CI; 1588 } 1589 1590 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B, 1591 const TargetLibraryInfo *TLI) { 1592 if (!TLI->has(LibFunc_puts)) 1593 return nullptr; 1594 1595 Module *M = B.GetInsertBlock()->getModule(); 1596 StringRef PutsName = TLI->getName(LibFunc_puts); 1597 FunctionCallee PutS = 1598 M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy()); 1599 inferLibFuncAttributes(M, PutsName, *TLI); 1600 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName); 1601 if (const Function *F = 1602 dyn_cast<Function>(PutS.getCallee()->stripPointerCasts())) 1603 CI->setCallingConv(F->getCallingConv()); 1604 return CI; 1605 } 1606 1607 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B, 1608 const TargetLibraryInfo *TLI) { 1609 if (!TLI->has(LibFunc_fputc)) 1610 return nullptr; 1611 1612 Module *M = B.GetInsertBlock()->getModule(); 1613 StringRef FPutcName = TLI->getName(LibFunc_fputc); 1614 FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(), 1615 B.getInt32Ty(), File->getType()); 1616 if (File->getType()->isPointerTy()) 1617 inferLibFuncAttributes(M, FPutcName, *TLI); 1618 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true, 1619 "chari"); 1620 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName); 1621 1622 if (const Function *Fn = 1623 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1624 CI->setCallingConv(Fn->getCallingConv()); 1625 return CI; 1626 } 1627 1628 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B, 1629 const TargetLibraryInfo *TLI) { 1630 if (!TLI->has(LibFunc_fputs)) 1631 return nullptr; 1632 1633 Module *M = B.GetInsertBlock()->getModule(); 1634 StringRef FPutsName = TLI->getName(LibFunc_fputs); 1635 FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(), 1636 B.getInt8PtrTy(), File->getType()); 1637 if (File->getType()->isPointerTy()) 1638 inferLibFuncAttributes(M, FPutsName, *TLI); 1639 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName); 1640 1641 if (const Function *Fn = 1642 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1643 CI->setCallingConv(Fn->getCallingConv()); 1644 return CI; 1645 } 1646 1647 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, 1648 const DataLayout &DL, const TargetLibraryInfo *TLI) { 1649 if (!TLI->has(LibFunc_fwrite)) 1650 return nullptr; 1651 1652 Module *M = B.GetInsertBlock()->getModule(); 1653 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1654 StringRef FWriteName = TLI->getName(LibFunc_fwrite); 1655 FunctionCallee F = M->getOrInsertFunction( 1656 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(), 1657 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType()); 1658 1659 if (File->getType()->isPointerTy()) 1660 inferLibFuncAttributes(M, FWriteName, *TLI); 1661 CallInst *CI = 1662 B.CreateCall(F, {castToCStr(Ptr, B), Size, 1663 ConstantInt::get(DL.getIntPtrType(Context), 1), File}); 1664 1665 if (const Function *Fn = 1666 dyn_cast<Function>(F.getCallee()->stripPointerCasts())) 1667 CI->setCallingConv(Fn->getCallingConv()); 1668 return CI; 1669 } 1670 1671 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, 1672 const TargetLibraryInfo *TLI) { 1673 if (!TLI->has(LibFunc_malloc)) 1674 return nullptr; 1675 1676 Module *M = B.GetInsertBlock()->getModule(); 1677 StringRef MallocName = TLI->getName(LibFunc_malloc); 1678 LLVMContext &Context = B.GetInsertBlock()->getContext(); 1679 FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(), 1680 DL.getIntPtrType(Context)); 1681 inferLibFuncAttributes(M, MallocName, *TLI); 1682 CallInst *CI = B.CreateCall(Malloc, Num, MallocName); 1683 1684 if (const Function *F = 1685 dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts())) 1686 CI->setCallingConv(F->getCallingConv()); 1687 1688 return CI; 1689 } 1690 1691 Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, 1692 const TargetLibraryInfo &TLI) { 1693 if (!TLI.has(LibFunc_calloc)) 1694 return nullptr; 1695 1696 Module *M = B.GetInsertBlock()->getModule(); 1697 StringRef CallocName = TLI.getName(LibFunc_calloc); 1698 const DataLayout &DL = M->getDataLayout(); 1699 IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext())); 1700 FunctionCallee Calloc = 1701 M->getOrInsertFunction(CallocName, B.getInt8PtrTy(), PtrType, PtrType); 1702 inferLibFuncAttributes(M, CallocName, TLI); 1703 CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName); 1704 1705 if (const auto *F = 1706 dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts())) 1707 CI->setCallingConv(F->getCallingConv()); 1708 1709 return CI; 1710 } 1711