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