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