1 //===- InferFunctionAttrs.cpp - Infer implicit function attributes --------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/Transforms/IPO/InferFunctionAttrs.h" 11 #include "llvm/ADT/Statistic.h" 12 #include "llvm/Analysis/TargetLibraryInfo.h" 13 #include "llvm/Analysis/MemoryBuiltins.h" 14 #include "llvm/IR/Function.h" 15 #include "llvm/IR/LLVMContext.h" 16 #include "llvm/IR/Module.h" 17 #include "llvm/Support/Debug.h" 18 #include "llvm/Support/raw_ostream.h" 19 using namespace llvm; 20 21 #define DEBUG_TYPE "inferattrs" 22 23 STATISTIC(NumReadNone, "Number of functions inferred as readnone"); 24 STATISTIC(NumReadOnly, "Number of functions inferred as readonly"); 25 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly"); 26 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind"); 27 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture"); 28 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly"); 29 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias"); 30 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns"); 31 32 static bool setDoesNotAccessMemory(Function &F) { 33 if (F.doesNotAccessMemory()) 34 return false; 35 F.setDoesNotAccessMemory(); 36 ++NumReadNone; 37 return true; 38 } 39 40 static bool setOnlyReadsMemory(Function &F) { 41 if (F.onlyReadsMemory()) 42 return false; 43 F.setOnlyReadsMemory(); 44 ++NumReadOnly; 45 return true; 46 } 47 48 static bool setOnlyAccessesArgMemory(Function &F) { 49 if (F.onlyAccessesArgMemory()) 50 return false; 51 F.setOnlyAccessesArgMemory (); 52 ++NumArgMemOnly; 53 return true; 54 } 55 56 57 static bool setDoesNotThrow(Function &F) { 58 if (F.doesNotThrow()) 59 return false; 60 F.setDoesNotThrow(); 61 ++NumNoUnwind; 62 return true; 63 } 64 65 static bool setDoesNotCapture(Function &F, unsigned n) { 66 if (F.doesNotCapture(n)) 67 return false; 68 F.setDoesNotCapture(n); 69 ++NumNoCapture; 70 return true; 71 } 72 73 static bool setOnlyReadsMemory(Function &F, unsigned n) { 74 if (F.onlyReadsMemory(n)) 75 return false; 76 F.setOnlyReadsMemory(n); 77 ++NumReadOnlyArg; 78 return true; 79 } 80 81 static bool setDoesNotAlias(Function &F, unsigned n) { 82 if (F.doesNotAlias(n)) 83 return false; 84 F.setDoesNotAlias(n); 85 ++NumNoAlias; 86 return true; 87 } 88 89 static bool setNonNull(Function &F, unsigned n) { 90 assert((n != AttributeSet::ReturnIndex || 91 F.getReturnType()->isPointerTy()) && 92 "nonnull applies only to pointers"); 93 if (F.getAttributes().hasAttribute(n, Attribute::NonNull)) 94 return false; 95 F.addAttribute(n, Attribute::NonNull); 96 ++NumNonNull; 97 return true; 98 } 99 100 /// Analyze the name and prototype of the given function and set any applicable 101 /// attributes. 102 /// 103 /// Returns true if any attributes were set and false otherwise. 104 static bool inferPrototypeAttributes(Function &F, 105 const TargetLibraryInfo &TLI) { 106 if (F.hasFnAttribute(Attribute::OptimizeNone)) 107 return false; 108 109 LibFunc::Func TheLibFunc; 110 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc))) 111 return false; 112 113 bool Changed = false; 114 switch (TheLibFunc) { 115 case LibFunc::strlen: 116 Changed |= setOnlyReadsMemory(F); 117 Changed |= setDoesNotThrow(F); 118 Changed |= setDoesNotCapture(F, 1); 119 return Changed; 120 case LibFunc::strchr: 121 case LibFunc::strrchr: 122 Changed |= setOnlyReadsMemory(F); 123 Changed |= setDoesNotThrow(F); 124 return Changed; 125 case LibFunc::strtol: 126 case LibFunc::strtod: 127 case LibFunc::strtof: 128 case LibFunc::strtoul: 129 case LibFunc::strtoll: 130 case LibFunc::strtold: 131 case LibFunc::strtoull: 132 Changed |= setDoesNotThrow(F); 133 Changed |= setDoesNotCapture(F, 2); 134 Changed |= setOnlyReadsMemory(F, 1); 135 return Changed; 136 case LibFunc::strcpy: 137 case LibFunc::stpcpy: 138 case LibFunc::strcat: 139 case LibFunc::strncat: 140 case LibFunc::strncpy: 141 case LibFunc::stpncpy: 142 Changed |= setDoesNotThrow(F); 143 Changed |= setDoesNotCapture(F, 2); 144 Changed |= setOnlyReadsMemory(F, 2); 145 return Changed; 146 case LibFunc::strxfrm: 147 Changed |= setDoesNotThrow(F); 148 Changed |= setDoesNotCapture(F, 1); 149 Changed |= setDoesNotCapture(F, 2); 150 Changed |= setOnlyReadsMemory(F, 2); 151 return Changed; 152 case LibFunc::strcmp: // 0,1 153 case LibFunc::strspn: // 0,1 154 case LibFunc::strncmp: // 0,1 155 case LibFunc::strcspn: // 0,1 156 case LibFunc::strcoll: // 0,1 157 case LibFunc::strcasecmp: // 0,1 158 case LibFunc::strncasecmp: // 159 Changed |= setOnlyReadsMemory(F); 160 Changed |= setDoesNotThrow(F); 161 Changed |= setDoesNotCapture(F, 1); 162 Changed |= setDoesNotCapture(F, 2); 163 return Changed; 164 case LibFunc::strstr: 165 case LibFunc::strpbrk: 166 Changed |= setOnlyReadsMemory(F); 167 Changed |= setDoesNotThrow(F); 168 Changed |= setDoesNotCapture(F, 2); 169 return Changed; 170 case LibFunc::strtok: 171 case LibFunc::strtok_r: 172 Changed |= setDoesNotThrow(F); 173 Changed |= setDoesNotCapture(F, 2); 174 Changed |= setOnlyReadsMemory(F, 2); 175 return Changed; 176 case LibFunc::scanf: 177 Changed |= setDoesNotThrow(F); 178 Changed |= setDoesNotCapture(F, 1); 179 Changed |= setOnlyReadsMemory(F, 1); 180 return Changed; 181 case LibFunc::setbuf: 182 case LibFunc::setvbuf: 183 Changed |= setDoesNotThrow(F); 184 Changed |= setDoesNotCapture(F, 1); 185 return Changed; 186 case LibFunc::strdup: 187 case LibFunc::strndup: 188 Changed |= setDoesNotThrow(F); 189 Changed |= setDoesNotAlias(F, 0); 190 Changed |= setDoesNotCapture(F, 1); 191 Changed |= setOnlyReadsMemory(F, 1); 192 return Changed; 193 case LibFunc::stat: 194 case LibFunc::statvfs: 195 Changed |= setDoesNotThrow(F); 196 Changed |= setDoesNotCapture(F, 1); 197 Changed |= setDoesNotCapture(F, 2); 198 Changed |= setOnlyReadsMemory(F, 1); 199 return Changed; 200 case LibFunc::sscanf: 201 Changed |= setDoesNotThrow(F); 202 Changed |= setDoesNotCapture(F, 1); 203 Changed |= setDoesNotCapture(F, 2); 204 Changed |= setOnlyReadsMemory(F, 1); 205 Changed |= setOnlyReadsMemory(F, 2); 206 return Changed; 207 case LibFunc::sprintf: 208 Changed |= setDoesNotThrow(F); 209 Changed |= setDoesNotCapture(F, 1); 210 Changed |= setDoesNotCapture(F, 2); 211 Changed |= setOnlyReadsMemory(F, 2); 212 return Changed; 213 case LibFunc::snprintf: 214 Changed |= setDoesNotThrow(F); 215 Changed |= setDoesNotCapture(F, 1); 216 Changed |= setDoesNotCapture(F, 3); 217 Changed |= setOnlyReadsMemory(F, 3); 218 return Changed; 219 case LibFunc::setitimer: 220 Changed |= setDoesNotThrow(F); 221 Changed |= setDoesNotCapture(F, 2); 222 Changed |= setDoesNotCapture(F, 3); 223 Changed |= setOnlyReadsMemory(F, 2); 224 return Changed; 225 case LibFunc::system: 226 // May throw; "system" is a valid pthread cancellation point. 227 Changed |= setDoesNotCapture(F, 1); 228 Changed |= setOnlyReadsMemory(F, 1); 229 return Changed; 230 case LibFunc::malloc: 231 Changed |= setDoesNotThrow(F); 232 Changed |= setDoesNotAlias(F, 0); 233 return Changed; 234 case LibFunc::memcmp: 235 Changed |= setOnlyReadsMemory(F); 236 Changed |= setDoesNotThrow(F); 237 Changed |= setDoesNotCapture(F, 1); 238 Changed |= setDoesNotCapture(F, 2); 239 return Changed; 240 case LibFunc::memchr: 241 case LibFunc::memrchr: 242 Changed |= setOnlyReadsMemory(F); 243 Changed |= setDoesNotThrow(F); 244 return Changed; 245 case LibFunc::modf: 246 case LibFunc::modff: 247 case LibFunc::modfl: 248 Changed |= setDoesNotThrow(F); 249 Changed |= setDoesNotCapture(F, 2); 250 return Changed; 251 case LibFunc::memcpy: 252 case LibFunc::memccpy: 253 case LibFunc::memmove: 254 Changed |= setDoesNotThrow(F); 255 Changed |= setDoesNotCapture(F, 2); 256 Changed |= setOnlyReadsMemory(F, 2); 257 return Changed; 258 case LibFunc::memalign: 259 Changed |= setDoesNotAlias(F, 0); 260 return Changed; 261 case LibFunc::mkdir: 262 Changed |= setDoesNotThrow(F); 263 Changed |= setDoesNotCapture(F, 1); 264 Changed |= setOnlyReadsMemory(F, 1); 265 return Changed; 266 case LibFunc::mktime: 267 Changed |= setDoesNotThrow(F); 268 Changed |= setDoesNotCapture(F, 1); 269 return Changed; 270 case LibFunc::realloc: 271 Changed |= setDoesNotThrow(F); 272 Changed |= setDoesNotAlias(F, 0); 273 Changed |= setDoesNotCapture(F, 1); 274 return Changed; 275 case LibFunc::read: 276 // May throw; "read" is a valid pthread cancellation point. 277 Changed |= setDoesNotCapture(F, 2); 278 return Changed; 279 case LibFunc::rewind: 280 Changed |= setDoesNotThrow(F); 281 Changed |= setDoesNotCapture(F, 1); 282 return Changed; 283 case LibFunc::rmdir: 284 case LibFunc::remove: 285 case LibFunc::realpath: 286 Changed |= setDoesNotThrow(F); 287 Changed |= setDoesNotCapture(F, 1); 288 Changed |= setOnlyReadsMemory(F, 1); 289 return Changed; 290 case LibFunc::rename: 291 Changed |= setDoesNotThrow(F); 292 Changed |= setDoesNotCapture(F, 1); 293 Changed |= setDoesNotCapture(F, 2); 294 Changed |= setOnlyReadsMemory(F, 1); 295 Changed |= setOnlyReadsMemory(F, 2); 296 return Changed; 297 case LibFunc::readlink: 298 Changed |= setDoesNotThrow(F); 299 Changed |= setDoesNotCapture(F, 1); 300 Changed |= setDoesNotCapture(F, 2); 301 Changed |= setOnlyReadsMemory(F, 1); 302 return Changed; 303 case LibFunc::write: 304 // May throw; "write" is a valid pthread cancellation point. 305 Changed |= setDoesNotCapture(F, 2); 306 Changed |= setOnlyReadsMemory(F, 2); 307 return Changed; 308 case LibFunc::bcopy: 309 Changed |= setDoesNotThrow(F); 310 Changed |= setDoesNotCapture(F, 1); 311 Changed |= setDoesNotCapture(F, 2); 312 Changed |= setOnlyReadsMemory(F, 1); 313 return Changed; 314 case LibFunc::bcmp: 315 Changed |= setDoesNotThrow(F); 316 Changed |= setOnlyReadsMemory(F); 317 Changed |= setDoesNotCapture(F, 1); 318 Changed |= setDoesNotCapture(F, 2); 319 return Changed; 320 case LibFunc::bzero: 321 Changed |= setDoesNotThrow(F); 322 Changed |= setDoesNotCapture(F, 1); 323 return Changed; 324 case LibFunc::calloc: 325 Changed |= setDoesNotThrow(F); 326 Changed |= setDoesNotAlias(F, 0); 327 return Changed; 328 case LibFunc::chmod: 329 case LibFunc::chown: 330 Changed |= setDoesNotThrow(F); 331 Changed |= setDoesNotCapture(F, 1); 332 Changed |= setOnlyReadsMemory(F, 1); 333 return Changed; 334 case LibFunc::ctermid: 335 case LibFunc::clearerr: 336 case LibFunc::closedir: 337 Changed |= setDoesNotThrow(F); 338 Changed |= setDoesNotCapture(F, 1); 339 return Changed; 340 case LibFunc::atoi: 341 case LibFunc::atol: 342 case LibFunc::atof: 343 case LibFunc::atoll: 344 Changed |= setDoesNotThrow(F); 345 Changed |= setOnlyReadsMemory(F); 346 Changed |= setDoesNotCapture(F, 1); 347 return Changed; 348 case LibFunc::access: 349 Changed |= setDoesNotThrow(F); 350 Changed |= setDoesNotCapture(F, 1); 351 Changed |= setOnlyReadsMemory(F, 1); 352 return Changed; 353 case LibFunc::fopen: 354 Changed |= setDoesNotThrow(F); 355 Changed |= setDoesNotAlias(F, 0); 356 Changed |= setDoesNotCapture(F, 1); 357 Changed |= setDoesNotCapture(F, 2); 358 Changed |= setOnlyReadsMemory(F, 1); 359 Changed |= setOnlyReadsMemory(F, 2); 360 return Changed; 361 case LibFunc::fdopen: 362 Changed |= setDoesNotThrow(F); 363 Changed |= setDoesNotAlias(F, 0); 364 Changed |= setDoesNotCapture(F, 2); 365 Changed |= setOnlyReadsMemory(F, 2); 366 return Changed; 367 case LibFunc::feof: 368 case LibFunc::free: 369 case LibFunc::fseek: 370 case LibFunc::ftell: 371 case LibFunc::fgetc: 372 case LibFunc::fseeko: 373 case LibFunc::ftello: 374 case LibFunc::fileno: 375 case LibFunc::fflush: 376 case LibFunc::fclose: 377 case LibFunc::fsetpos: 378 case LibFunc::flockfile: 379 case LibFunc::funlockfile: 380 case LibFunc::ftrylockfile: 381 Changed |= setDoesNotThrow(F); 382 Changed |= setDoesNotCapture(F, 1); 383 return Changed; 384 case LibFunc::ferror: 385 Changed |= setDoesNotThrow(F); 386 Changed |= setDoesNotCapture(F, 1); 387 Changed |= setOnlyReadsMemory(F); 388 return Changed; 389 case LibFunc::fputc: 390 case LibFunc::fstat: 391 case LibFunc::frexp: 392 case LibFunc::frexpf: 393 case LibFunc::frexpl: 394 case LibFunc::fstatvfs: 395 Changed |= setDoesNotThrow(F); 396 Changed |= setDoesNotCapture(F, 2); 397 return Changed; 398 case LibFunc::fgets: 399 Changed |= setDoesNotThrow(F); 400 Changed |= setDoesNotCapture(F, 3); 401 return Changed; 402 case LibFunc::fread: 403 Changed |= setDoesNotThrow(F); 404 Changed |= setDoesNotCapture(F, 1); 405 Changed |= setDoesNotCapture(F, 4); 406 return Changed; 407 case LibFunc::fwrite: 408 Changed |= setDoesNotThrow(F); 409 Changed |= setDoesNotCapture(F, 1); 410 Changed |= setDoesNotCapture(F, 4); 411 return Changed; 412 case LibFunc::fputs: 413 Changed |= setDoesNotThrow(F); 414 Changed |= setDoesNotCapture(F, 1); 415 Changed |= setDoesNotCapture(F, 2); 416 Changed |= setOnlyReadsMemory(F, 1); 417 return Changed; 418 case LibFunc::fscanf: 419 case LibFunc::fprintf: 420 Changed |= setDoesNotThrow(F); 421 Changed |= setDoesNotCapture(F, 1); 422 Changed |= setDoesNotCapture(F, 2); 423 Changed |= setOnlyReadsMemory(F, 2); 424 return Changed; 425 case LibFunc::fgetpos: 426 Changed |= setDoesNotThrow(F); 427 Changed |= setDoesNotCapture(F, 1); 428 Changed |= setDoesNotCapture(F, 2); 429 return Changed; 430 case LibFunc::getc: 431 case LibFunc::getlogin_r: 432 case LibFunc::getc_unlocked: 433 Changed |= setDoesNotThrow(F); 434 Changed |= setDoesNotCapture(F, 1); 435 return Changed; 436 case LibFunc::getenv: 437 Changed |= setDoesNotThrow(F); 438 Changed |= setOnlyReadsMemory(F); 439 Changed |= setDoesNotCapture(F, 1); 440 return Changed; 441 case LibFunc::gets: 442 case LibFunc::getchar: 443 Changed |= setDoesNotThrow(F); 444 return Changed; 445 case LibFunc::getitimer: 446 Changed |= setDoesNotThrow(F); 447 Changed |= setDoesNotCapture(F, 2); 448 return Changed; 449 case LibFunc::getpwnam: 450 Changed |= setDoesNotThrow(F); 451 Changed |= setDoesNotCapture(F, 1); 452 Changed |= setOnlyReadsMemory(F, 1); 453 return Changed; 454 case LibFunc::ungetc: 455 Changed |= setDoesNotThrow(F); 456 Changed |= setDoesNotCapture(F, 2); 457 return Changed; 458 case LibFunc::uname: 459 Changed |= setDoesNotThrow(F); 460 Changed |= setDoesNotCapture(F, 1); 461 return Changed; 462 case LibFunc::unlink: 463 Changed |= setDoesNotThrow(F); 464 Changed |= setDoesNotCapture(F, 1); 465 Changed |= setOnlyReadsMemory(F, 1); 466 return Changed; 467 case LibFunc::unsetenv: 468 Changed |= setDoesNotThrow(F); 469 Changed |= setDoesNotCapture(F, 1); 470 Changed |= setOnlyReadsMemory(F, 1); 471 return Changed; 472 case LibFunc::utime: 473 case LibFunc::utimes: 474 Changed |= setDoesNotThrow(F); 475 Changed |= setDoesNotCapture(F, 1); 476 Changed |= setDoesNotCapture(F, 2); 477 Changed |= setOnlyReadsMemory(F, 1); 478 Changed |= setOnlyReadsMemory(F, 2); 479 return Changed; 480 case LibFunc::putc: 481 Changed |= setDoesNotThrow(F); 482 Changed |= setDoesNotCapture(F, 2); 483 return Changed; 484 case LibFunc::puts: 485 case LibFunc::printf: 486 case LibFunc::perror: 487 Changed |= setDoesNotThrow(F); 488 Changed |= setDoesNotCapture(F, 1); 489 Changed |= setOnlyReadsMemory(F, 1); 490 return Changed; 491 case LibFunc::pread: 492 // May throw; "pread" is a valid pthread cancellation point. 493 Changed |= setDoesNotCapture(F, 2); 494 return Changed; 495 case LibFunc::pwrite: 496 // May throw; "pwrite" is a valid pthread cancellation point. 497 Changed |= setDoesNotCapture(F, 2); 498 Changed |= setOnlyReadsMemory(F, 2); 499 return Changed; 500 case LibFunc::putchar: 501 Changed |= setDoesNotThrow(F); 502 return Changed; 503 case LibFunc::popen: 504 Changed |= setDoesNotThrow(F); 505 Changed |= setDoesNotAlias(F, 0); 506 Changed |= setDoesNotCapture(F, 1); 507 Changed |= setDoesNotCapture(F, 2); 508 Changed |= setOnlyReadsMemory(F, 1); 509 Changed |= setOnlyReadsMemory(F, 2); 510 return Changed; 511 case LibFunc::pclose: 512 Changed |= setDoesNotThrow(F); 513 Changed |= setDoesNotCapture(F, 1); 514 return Changed; 515 case LibFunc::vscanf: 516 Changed |= setDoesNotThrow(F); 517 Changed |= setDoesNotCapture(F, 1); 518 Changed |= setOnlyReadsMemory(F, 1); 519 return Changed; 520 case LibFunc::vsscanf: 521 Changed |= setDoesNotThrow(F); 522 Changed |= setDoesNotCapture(F, 1); 523 Changed |= setDoesNotCapture(F, 2); 524 Changed |= setOnlyReadsMemory(F, 1); 525 Changed |= setOnlyReadsMemory(F, 2); 526 return Changed; 527 case LibFunc::vfscanf: 528 Changed |= setDoesNotThrow(F); 529 Changed |= setDoesNotCapture(F, 1); 530 Changed |= setDoesNotCapture(F, 2); 531 Changed |= setOnlyReadsMemory(F, 2); 532 return Changed; 533 case LibFunc::valloc: 534 Changed |= setDoesNotThrow(F); 535 Changed |= setDoesNotAlias(F, 0); 536 return Changed; 537 case LibFunc::vprintf: 538 Changed |= setDoesNotThrow(F); 539 Changed |= setDoesNotCapture(F, 1); 540 Changed |= setOnlyReadsMemory(F, 1); 541 return Changed; 542 case LibFunc::vfprintf: 543 case LibFunc::vsprintf: 544 Changed |= setDoesNotThrow(F); 545 Changed |= setDoesNotCapture(F, 1); 546 Changed |= setDoesNotCapture(F, 2); 547 Changed |= setOnlyReadsMemory(F, 2); 548 return Changed; 549 case LibFunc::vsnprintf: 550 Changed |= setDoesNotThrow(F); 551 Changed |= setDoesNotCapture(F, 1); 552 Changed |= setDoesNotCapture(F, 3); 553 Changed |= setOnlyReadsMemory(F, 3); 554 return Changed; 555 case LibFunc::open: 556 // May throw; "open" is a valid pthread cancellation point. 557 Changed |= setDoesNotCapture(F, 1); 558 Changed |= setOnlyReadsMemory(F, 1); 559 return Changed; 560 case LibFunc::opendir: 561 Changed |= setDoesNotThrow(F); 562 Changed |= setDoesNotAlias(F, 0); 563 Changed |= setDoesNotCapture(F, 1); 564 Changed |= setOnlyReadsMemory(F, 1); 565 return Changed; 566 case LibFunc::tmpfile: 567 Changed |= setDoesNotThrow(F); 568 Changed |= setDoesNotAlias(F, 0); 569 return Changed; 570 case LibFunc::times: 571 Changed |= setDoesNotThrow(F); 572 Changed |= setDoesNotCapture(F, 1); 573 return Changed; 574 case LibFunc::htonl: 575 case LibFunc::htons: 576 case LibFunc::ntohl: 577 case LibFunc::ntohs: 578 Changed |= setDoesNotThrow(F); 579 Changed |= setDoesNotAccessMemory(F); 580 return Changed; 581 case LibFunc::lstat: 582 Changed |= setDoesNotThrow(F); 583 Changed |= setDoesNotCapture(F, 1); 584 Changed |= setDoesNotCapture(F, 2); 585 Changed |= setOnlyReadsMemory(F, 1); 586 return Changed; 587 case LibFunc::lchown: 588 Changed |= setDoesNotThrow(F); 589 Changed |= setDoesNotCapture(F, 1); 590 Changed |= setOnlyReadsMemory(F, 1); 591 return Changed; 592 case LibFunc::qsort: 593 // May throw; places call through function pointer. 594 Changed |= setDoesNotCapture(F, 4); 595 return Changed; 596 case LibFunc::dunder_strdup: 597 case LibFunc::dunder_strndup: 598 Changed |= setDoesNotThrow(F); 599 Changed |= setDoesNotAlias(F, 0); 600 Changed |= setDoesNotCapture(F, 1); 601 Changed |= setOnlyReadsMemory(F, 1); 602 return Changed; 603 case LibFunc::dunder_strtok_r: 604 Changed |= setDoesNotThrow(F); 605 Changed |= setDoesNotCapture(F, 2); 606 Changed |= setOnlyReadsMemory(F, 2); 607 return Changed; 608 case LibFunc::under_IO_getc: 609 Changed |= setDoesNotThrow(F); 610 Changed |= setDoesNotCapture(F, 1); 611 return Changed; 612 case LibFunc::under_IO_putc: 613 Changed |= setDoesNotThrow(F); 614 Changed |= setDoesNotCapture(F, 2); 615 return Changed; 616 case LibFunc::dunder_isoc99_scanf: 617 Changed |= setDoesNotThrow(F); 618 Changed |= setDoesNotCapture(F, 1); 619 Changed |= setOnlyReadsMemory(F, 1); 620 return Changed; 621 case LibFunc::stat64: 622 case LibFunc::lstat64: 623 case LibFunc::statvfs64: 624 Changed |= setDoesNotThrow(F); 625 Changed |= setDoesNotCapture(F, 1); 626 Changed |= setDoesNotCapture(F, 2); 627 Changed |= setOnlyReadsMemory(F, 1); 628 return Changed; 629 case LibFunc::dunder_isoc99_sscanf: 630 Changed |= setDoesNotThrow(F); 631 Changed |= setDoesNotCapture(F, 1); 632 Changed |= setDoesNotCapture(F, 2); 633 Changed |= setOnlyReadsMemory(F, 1); 634 Changed |= setOnlyReadsMemory(F, 2); 635 return Changed; 636 case LibFunc::fopen64: 637 Changed |= setDoesNotThrow(F); 638 Changed |= setDoesNotAlias(F, 0); 639 Changed |= setDoesNotCapture(F, 1); 640 Changed |= setDoesNotCapture(F, 2); 641 Changed |= setOnlyReadsMemory(F, 1); 642 Changed |= setOnlyReadsMemory(F, 2); 643 return Changed; 644 case LibFunc::fseeko64: 645 case LibFunc::ftello64: 646 Changed |= setDoesNotThrow(F); 647 Changed |= setDoesNotCapture(F, 1); 648 return Changed; 649 case LibFunc::tmpfile64: 650 Changed |= setDoesNotThrow(F); 651 Changed |= setDoesNotAlias(F, 0); 652 return Changed; 653 case LibFunc::fstat64: 654 case LibFunc::fstatvfs64: 655 Changed |= setDoesNotThrow(F); 656 Changed |= setDoesNotCapture(F, 2); 657 return Changed; 658 case LibFunc::open64: 659 // May throw; "open" is a valid pthread cancellation point. 660 Changed |= setDoesNotCapture(F, 1); 661 Changed |= setOnlyReadsMemory(F, 1); 662 return Changed; 663 case LibFunc::gettimeofday: 664 // Currently some platforms have the restrict keyword on the arguments to 665 // gettimeofday. To be conservative, do not add noalias to gettimeofday's 666 // arguments. 667 Changed |= setDoesNotThrow(F); 668 Changed |= setDoesNotCapture(F, 1); 669 Changed |= setDoesNotCapture(F, 2); 670 return Changed; 671 case LibFunc::Znwj: // new(unsigned int) 672 case LibFunc::Znwm: // new(unsigned long) 673 case LibFunc::Znaj: // new[](unsigned int) 674 case LibFunc::Znam: // new[](unsigned long) 675 case LibFunc::msvc_new_int: // new(unsigned int) 676 case LibFunc::msvc_new_longlong: // new(unsigned long long) 677 case LibFunc::msvc_new_array_int: // new[](unsigned int) 678 case LibFunc::msvc_new_array_longlong: // new[](unsigned long long) 679 // Operator new always returns a nonnull noalias pointer 680 Changed |= setNonNull(F, AttributeSet::ReturnIndex); 681 Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex); 682 return Changed; 683 //TODO: add LibFunc entries for: 684 //case LibFunc::memset_pattern4: 685 //case LibFunc::memset_pattern8: 686 case LibFunc::memset_pattern16: 687 Changed |= setOnlyAccessesArgMemory(F); 688 Changed |= setOnlyReadsMemory(F, 2); 689 return Changed; 690 // int __nvvm_reflect(const char *) 691 case LibFunc::nvvm_reflect: 692 Changed |= setDoesNotAccessMemory(F); 693 Changed |= setDoesNotThrow(F); 694 return Changed; 695 696 default: 697 // FIXME: It'd be really nice to cover all the library functions we're 698 // aware of here. 699 return false; 700 } 701 } 702 703 static bool inferAllPrototypeAttributes(Module &M, 704 const TargetLibraryInfo &TLI) { 705 bool Changed = false; 706 707 for (Function &F : M.functions()) 708 // We only infer things using the prototype if the definition isn't around 709 // to analyze directly. 710 if (F.isDeclaration()) 711 Changed |= inferPrototypeAttributes(F, TLI); 712 713 return Changed; 714 } 715 716 PreservedAnalyses InferFunctionAttrsPass::run(Module &M, 717 AnalysisManager<Module> &AM) { 718 auto &TLI = AM.getResult<TargetLibraryAnalysis>(M); 719 720 if (!inferAllPrototypeAttributes(M, TLI)) 721 // If we didn't infer anything, preserve all analyses. 722 return PreservedAnalyses::all(); 723 724 // Otherwise, we may have changed fundamental function attributes, so clear 725 // out all the passes. 726 return PreservedAnalyses::none(); 727 } 728 729 namespace { 730 struct InferFunctionAttrsLegacyPass : public ModulePass { 731 static char ID; // Pass identification, replacement for typeid 732 InferFunctionAttrsLegacyPass() : ModulePass(ID) { 733 initializeInferFunctionAttrsLegacyPassPass( 734 *PassRegistry::getPassRegistry()); 735 } 736 737 void getAnalysisUsage(AnalysisUsage &AU) const override { 738 AU.addRequired<TargetLibraryInfoWrapperPass>(); 739 } 740 741 bool runOnModule(Module &M) override { 742 if (skipModule(M)) 743 return false; 744 745 auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); 746 return inferAllPrototypeAttributes(M, TLI); 747 } 748 }; 749 } 750 751 char InferFunctionAttrsLegacyPass::ID = 0; 752 INITIALIZE_PASS_BEGIN(InferFunctionAttrsLegacyPass, "inferattrs", 753 "Infer set function attributes", false, false) 754 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) 755 INITIALIZE_PASS_END(InferFunctionAttrsLegacyPass, "inferattrs", 756 "Infer set function attributes", false, false) 757 758 Pass *llvm::createInferFunctionAttrsLegacyPass() { 759 return new InferFunctionAttrsLegacyPass(); 760 } 761