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