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