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