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