1 //===-- llvm/Target/TargetLibraryInfo.h - Library information ---*- C++ -*-===// 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 #ifndef LLVM_TARGET_TARGETLIBRARYINFO_H 11 #define LLVM_TARGET_TARGETLIBRARYINFO_H 12 13 #include "llvm/ADT/DenseMap.h" 14 #include "llvm/Pass.h" 15 16 namespace llvm { 17 class Triple; 18 19 namespace LibFunc { 20 enum Func { 21 /// int _IO_getc(_IO_FILE * __fp); 22 under_IO_getc, 23 /// int _IO_putc(int __c, _IO_FILE * __fp); 24 under_IO_putc, 25 /// void operator delete[](void*); 26 ZdaPv, 27 /// void operator delete(void*); 28 ZdlPv, 29 /// void *new[](unsigned int); 30 Znaj, 31 /// void *new[](unsigned int, nothrow); 32 ZnajRKSt9nothrow_t, 33 /// void *new[](unsigned long); 34 Znam, 35 /// void *new[](unsigned long, nothrow); 36 ZnamRKSt9nothrow_t, 37 /// void *new(unsigned int); 38 Znwj, 39 /// void *new(unsigned int, nothrow); 40 ZnwjRKSt9nothrow_t, 41 /// void *new(unsigned long); 42 Znwm, 43 /// void *new(unsigned long, nothrow); 44 ZnwmRKSt9nothrow_t, 45 /// int __cxa_atexit(void (*f)(void *), void *p, void *d); 46 cxa_atexit, 47 /// void __cxa_guard_abort(guard_t *guard); 48 /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi. 49 cxa_guard_abort, 50 /// int __cxa_guard_acquire(guard_t *guard); 51 cxa_guard_acquire, 52 /// void __cxa_guard_release(guard_t *guard); 53 cxa_guard_release, 54 /// int __isoc99_scanf (const char *format, ...) 55 dunder_isoc99_scanf, 56 /// int __isoc99_sscanf(const char *s, const char *format, ...) 57 dunder_isoc99_sscanf, 58 /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size); 59 memcpy_chk, 60 /// char * __strdup(const char *s); 61 dunder_strdup, 62 /// char *__strndup(const char *s, size_t n); 63 dunder_strndup, 64 /// char * __strtok_r(char *s, const char *delim, char **save_ptr); 65 dunder_strtok_r, 66 /// int abs(int j); 67 abs, 68 /// int access(const char *path, int amode); 69 access, 70 /// double acos(double x); 71 acos, 72 /// float acosf(float x); 73 acosf, 74 /// double acosh(double x); 75 acosh, 76 /// float acoshf(float x); 77 acoshf, 78 /// long double acoshl(long double x); 79 acoshl, 80 /// long double acosl(long double x); 81 acosl, 82 /// double asin(double x); 83 asin, 84 /// float asinf(float x); 85 asinf, 86 /// double asinh(double x); 87 asinh, 88 /// float asinhf(float x); 89 asinhf, 90 /// long double asinhl(long double x); 91 asinhl, 92 /// long double asinl(long double x); 93 asinl, 94 /// double atan(double x); 95 atan, 96 /// double atan2(double y, double x); 97 atan2, 98 /// float atan2f(float y, float x); 99 atan2f, 100 /// long double atan2l(long double y, long double x); 101 atan2l, 102 /// float atanf(float x); 103 atanf, 104 /// double atanh(double x); 105 atanh, 106 /// float atanhf(float x); 107 atanhf, 108 /// long double atanhl(long double x); 109 atanhl, 110 /// long double atanl(long double x); 111 atanl, 112 /// double atof(const char *str); 113 atof, 114 /// int atoi(const char *str); 115 atoi, 116 /// long atol(const char *str); 117 atol, 118 /// long long atoll(const char *nptr); 119 atoll, 120 /// int bcmp(const void *s1, const void *s2, size_t n); 121 bcmp, 122 /// void bcopy(const void *s1, void *s2, size_t n); 123 bcopy, 124 /// void bzero(void *s, size_t n); 125 bzero, 126 /// void *calloc(size_t count, size_t size); 127 calloc, 128 /// double cbrt(double x); 129 cbrt, 130 /// float cbrtf(float x); 131 cbrtf, 132 /// long double cbrtl(long double x); 133 cbrtl, 134 /// double ceil(double x); 135 ceil, 136 /// float ceilf(float x); 137 ceilf, 138 /// long double ceill(long double x); 139 ceill, 140 /// int chmod(const char *path, mode_t mode); 141 chmod, 142 /// int chown(const char *path, uid_t owner, gid_t group); 143 chown, 144 /// void clearerr(FILE *stream); 145 clearerr, 146 /// int closedir(DIR *dirp); 147 closedir, 148 /// double copysign(double x, double y); 149 copysign, 150 /// float copysignf(float x, float y); 151 copysignf, 152 /// long double copysignl(long double x, long double y); 153 copysignl, 154 /// double cos(double x); 155 cos, 156 /// float cosf(float x); 157 cosf, 158 /// double cosh(double x); 159 cosh, 160 /// float coshf(float x); 161 coshf, 162 /// long double coshl(long double x); 163 coshl, 164 /// long double cosl(long double x); 165 cosl, 166 /// char *ctermid(char *s); 167 ctermid, 168 /// double exp(double x); 169 exp, 170 /// double exp10(double x); 171 exp10, 172 /// float exp10f(float x); 173 exp10f, 174 /// long double exp10l(long double x); 175 exp10l, 176 /// double exp2(double x); 177 exp2, 178 /// float exp2f(float x); 179 exp2f, 180 /// long double exp2l(long double x); 181 exp2l, 182 /// float expf(float x); 183 expf, 184 /// long double expl(long double x); 185 expl, 186 /// double expm1(double x); 187 expm1, 188 /// float expm1f(float x); 189 expm1f, 190 /// long double expm1l(long double x); 191 expm1l, 192 /// double fabs(double x); 193 fabs, 194 /// float fabsf(float x); 195 fabsf, 196 /// long double fabsl(long double x); 197 fabsl, 198 /// int fclose(FILE *stream); 199 fclose, 200 /// FILE *fdopen(int fildes, const char *mode); 201 fdopen, 202 /// int feof(FILE *stream); 203 feof, 204 /// int ferror(FILE *stream); 205 ferror, 206 /// int fflush(FILE *stream); 207 fflush, 208 /// int ffs(int i); 209 ffs, 210 /// int ffsl(long int i); 211 ffsl, 212 /// int ffsll(long long int i); 213 ffsll, 214 /// int fgetc(FILE *stream); 215 fgetc, 216 /// int fgetpos(FILE *stream, fpos_t *pos); 217 fgetpos, 218 /// char *fgets(char *s, int n, FILE *stream); 219 fgets, 220 /// int fileno(FILE *stream); 221 fileno, 222 /// int fiprintf(FILE *stream, const char *format, ...); 223 fiprintf, 224 /// void flockfile(FILE *file); 225 flockfile, 226 /// double floor(double x); 227 floor, 228 /// float floorf(float x); 229 floorf, 230 /// long double floorl(long double x); 231 floorl, 232 /// double fmod(double x, double y); 233 fmod, 234 /// float fmodf(float x, float y); 235 fmodf, 236 /// long double fmodl(long double x, long double y); 237 fmodl, 238 /// FILE *fopen(const char *filename, const char *mode); 239 fopen, 240 /// FILE *fopen64(const char *filename, const char *opentype) 241 fopen64, 242 /// int fprintf(FILE *stream, const char *format, ...); 243 fprintf, 244 /// int fputc(int c, FILE *stream); 245 fputc, 246 /// int fputs(const char *s, FILE *stream); 247 fputs, 248 /// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream); 249 fread, 250 /// void free(void *ptr); 251 free, 252 /// double frexp(double num, int *exp); 253 frexp, 254 /// float frexpf(float num, int *exp); 255 frexpf, 256 /// long double frexpl(long double num, int *exp); 257 frexpl, 258 /// int fscanf(FILE *stream, const char *format, ... ); 259 fscanf, 260 /// int fseek(FILE *stream, long offset, int whence); 261 fseek, 262 /// int fseeko(FILE *stream, off_t offset, int whence); 263 fseeko, 264 /// int fseeko64(FILE *stream, off64_t offset, int whence) 265 fseeko64, 266 /// int fsetpos(FILE *stream, const fpos_t *pos); 267 fsetpos, 268 /// int fstat(int fildes, struct stat *buf); 269 fstat, 270 /// int fstat64(int filedes, struct stat64 *buf) 271 fstat64, 272 /// int fstatvfs(int fildes, struct statvfs *buf); 273 fstatvfs, 274 /// int fstatvfs64(int fildes, struct statvfs64 *buf); 275 fstatvfs64, 276 /// long ftell(FILE *stream); 277 ftell, 278 /// off_t ftello(FILE *stream); 279 ftello, 280 /// off64_t ftello64(FILE *stream) 281 ftello64, 282 /// int ftrylockfile(FILE *file); 283 ftrylockfile, 284 /// void funlockfile(FILE *file); 285 funlockfile, 286 /// size_t fwrite(const void *ptr, size_t size, size_t nitems, 287 /// FILE *stream); 288 fwrite, 289 /// int getc(FILE *stream); 290 getc, 291 /// int getc_unlocked(FILE *stream); 292 getc_unlocked, 293 /// int getchar(void); 294 getchar, 295 /// char *getenv(const char *name); 296 getenv, 297 /// int getitimer(int which, struct itimerval *value); 298 getitimer, 299 /// int getlogin_r(char *name, size_t namesize); 300 getlogin_r, 301 /// struct passwd *getpwnam(const char *name); 302 getpwnam, 303 /// char *gets(char *s); 304 gets, 305 /// uint32_t htonl(uint32_t hostlong); 306 htonl, 307 /// uint16_t htons(uint16_t hostshort); 308 htons, 309 /// int iprintf(const char *format, ...); 310 iprintf, 311 /// int isascii(int c); 312 isascii, 313 /// int isdigit(int c); 314 isdigit, 315 /// long int labs(long int j); 316 labs, 317 /// int lchown(const char *path, uid_t owner, gid_t group); 318 lchown, 319 /// long long int llabs(long long int j); 320 llabs, 321 /// double log(double x); 322 log, 323 /// double log10(double x); 324 log10, 325 /// float log10f(float x); 326 log10f, 327 /// long double log10l(long double x); 328 log10l, 329 /// double log1p(double x); 330 log1p, 331 /// float log1pf(float x); 332 log1pf, 333 /// long double log1pl(long double x); 334 log1pl, 335 /// double log2(double x); 336 log2, 337 /// float log2f(float x); 338 log2f, 339 /// double long double log2l(long double x); 340 log2l, 341 /// double logb(double x); 342 logb, 343 /// float logbf(float x); 344 logbf, 345 /// long double logbl(long double x); 346 logbl, 347 /// float logf(float x); 348 logf, 349 /// long double logl(long double x); 350 logl, 351 /// int lstat(const char *path, struct stat *buf); 352 lstat, 353 /// int lstat64(const char *path, struct stat64 *buf); 354 lstat64, 355 /// void *malloc(size_t size); 356 malloc, 357 /// void *memalign(size_t boundary, size_t size); 358 memalign, 359 /// void *memccpy(void *s1, const void *s2, int c, size_t n); 360 memccpy, 361 /// void *memchr(const void *s, int c, size_t n); 362 memchr, 363 /// int memcmp(const void *s1, const void *s2, size_t n); 364 memcmp, 365 /// void *memcpy(void *s1, const void *s2, size_t n); 366 memcpy, 367 /// void *memmove(void *s1, const void *s2, size_t n); 368 memmove, 369 // void *memrchr(const void *s, int c, size_t n); 370 memrchr, 371 /// void *memset(void *b, int c, size_t len); 372 memset, 373 /// void memset_pattern16(void *b, const void *pattern16, size_t len); 374 memset_pattern16, 375 /// int mkdir(const char *path, mode_t mode); 376 mkdir, 377 /// time_t mktime(struct tm *timeptr); 378 mktime, 379 /// double modf(double x, double *iptr); 380 modf, 381 /// float modff(float, float *iptr); 382 modff, 383 /// long double modfl(long double value, long double *iptr); 384 modfl, 385 /// double nearbyint(double x); 386 nearbyint, 387 /// float nearbyintf(float x); 388 nearbyintf, 389 /// long double nearbyintl(long double x); 390 nearbyintl, 391 /// uint32_t ntohl(uint32_t netlong); 392 ntohl, 393 /// uint16_t ntohs(uint16_t netshort); 394 ntohs, 395 /// int open(const char *path, int oflag, ... ); 396 open, 397 /// int open64(const char *filename, int flags[, mode_t mode]) 398 open64, 399 /// DIR *opendir(const char *dirname); 400 opendir, 401 /// int pclose(FILE *stream); 402 pclose, 403 /// void perror(const char *s); 404 perror, 405 /// FILE *popen(const char *command, const char *mode); 406 popen, 407 /// int posix_memalign(void **memptr, size_t alignment, size_t size); 408 posix_memalign, 409 /// double pow(double x, double y); 410 pow, 411 /// float powf(float x, float y); 412 powf, 413 /// long double powl(long double x, long double y); 414 powl, 415 /// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); 416 pread, 417 /// int printf(const char *format, ...); 418 printf, 419 /// int putc(int c, FILE *stream); 420 putc, 421 /// int putchar(int c); 422 putchar, 423 /// int puts(const char *s); 424 puts, 425 /// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, 426 /// off_t offset); 427 pwrite, 428 /// void qsort(void *base, size_t nel, size_t width, 429 /// int (*compar)(const void *, const void *)); 430 qsort, 431 /// ssize_t read(int fildes, void *buf, size_t nbyte); 432 read, 433 /// ssize_t readlink(const char *path, char *buf, size_t bufsize); 434 readlink, 435 /// void *realloc(void *ptr, size_t size); 436 realloc, 437 /// void *reallocf(void *ptr, size_t size); 438 reallocf, 439 /// char *realpath(const char *file_name, char *resolved_name); 440 realpath, 441 /// int remove(const char *path); 442 remove, 443 /// int rename(const char *old, const char *new); 444 rename, 445 /// void rewind(FILE *stream); 446 rewind, 447 /// double rint(double x); 448 rint, 449 /// float rintf(float x); 450 rintf, 451 /// long double rintl(long double x); 452 rintl, 453 /// int rmdir(const char *path); 454 rmdir, 455 /// double round(double x); 456 round, 457 /// float roundf(float x); 458 roundf, 459 /// long double roundl(long double x); 460 roundl, 461 /// int scanf(const char *restrict format, ... ); 462 scanf, 463 /// void setbuf(FILE *stream, char *buf); 464 setbuf, 465 /// int setitimer(int which, const struct itimerval *value, 466 /// struct itimerval *ovalue); 467 setitimer, 468 /// int setvbuf(FILE *stream, char *buf, int type, size_t size); 469 setvbuf, 470 /// double sin(double x); 471 sin, 472 /// float sinf(float x); 473 sinf, 474 /// double sinh(double x); 475 sinh, 476 /// float sinhf(float x); 477 sinhf, 478 /// long double sinhl(long double x); 479 sinhl, 480 /// long double sinl(long double x); 481 sinl, 482 /// int siprintf(char *str, const char *format, ...); 483 siprintf, 484 /// int snprintf(char *s, size_t n, const char *format, ...); 485 snprintf, 486 /// int sprintf(char *str, const char *format, ...); 487 sprintf, 488 /// double sqrt(double x); 489 sqrt, 490 /// float sqrtf(float x); 491 sqrtf, 492 /// long double sqrtl(long double x); 493 sqrtl, 494 /// int sscanf(const char *s, const char *format, ... ); 495 sscanf, 496 /// int stat(const char *path, struct stat *buf); 497 stat, 498 /// int stat64(const char *path, struct stat64 *buf); 499 stat64, 500 /// int statvfs(const char *path, struct statvfs *buf); 501 statvfs, 502 /// int statvfs64(const char *path, struct statvfs64 *buf) 503 statvfs64, 504 /// char *stpcpy(char *s1, const char *s2); 505 stpcpy, 506 /// char *stpncpy(char *s1, const char *s2, size_t n); 507 stpncpy, 508 /// int strcasecmp(const char *s1, const char *s2); 509 strcasecmp, 510 /// char *strcat(char *s1, const char *s2); 511 strcat, 512 /// char *strchr(const char *s, int c); 513 strchr, 514 /// int strcmp(const char *s1, const char *s2); 515 strcmp, 516 /// int strcoll(const char *s1, const char *s2); 517 strcoll, 518 /// char *strcpy(char *s1, const char *s2); 519 strcpy, 520 /// size_t strcspn(const char *s1, const char *s2); 521 strcspn, 522 /// char *strdup(const char *s1); 523 strdup, 524 /// size_t strlen(const char *s); 525 strlen, 526 /// int strncasecmp(const char *s1, const char *s2, size_t n); 527 strncasecmp, 528 /// char *strncat(char *s1, const char *s2, size_t n); 529 strncat, 530 /// int strncmp(const char *s1, const char *s2, size_t n); 531 strncmp, 532 /// char *strncpy(char *s1, const char *s2, size_t n); 533 strncpy, 534 /// char *strndup(const char *s1, size_t n); 535 strndup, 536 /// size_t strnlen(const char *s, size_t maxlen); 537 strnlen, 538 /// char *strpbrk(const char *s1, const char *s2); 539 strpbrk, 540 /// char *strrchr(const char *s, int c); 541 strrchr, 542 /// size_t strspn(const char *s1, const char *s2); 543 strspn, 544 /// char *strstr(const char *s1, const char *s2); 545 strstr, 546 /// double strtod(const char *nptr, char **endptr); 547 strtod, 548 /// float strtof(const char *nptr, char **endptr); 549 strtof, 550 // char *strtok(char *s1, const char *s2); 551 strtok, 552 // char *strtok_r(char *s, const char *sep, char **lasts); 553 strtok_r, 554 /// long int strtol(const char *nptr, char **endptr, int base); 555 strtol, 556 /// long double strtold(const char *nptr, char **endptr); 557 strtold, 558 /// long long int strtoll(const char *nptr, char **endptr, int base); 559 strtoll, 560 /// unsigned long int strtoul(const char *nptr, char **endptr, int base); 561 strtoul, 562 /// unsigned long long int strtoull(const char *nptr, char **endptr, 563 /// int base); 564 strtoull, 565 /// size_t strxfrm(char *s1, const char *s2, size_t n); 566 strxfrm, 567 /// int system(const char *command); 568 system, 569 /// double tan(double x); 570 tan, 571 /// float tanf(float x); 572 tanf, 573 /// double tanh(double x); 574 tanh, 575 /// float tanhf(float x); 576 tanhf, 577 /// long double tanhl(long double x); 578 tanhl, 579 /// long double tanl(long double x); 580 tanl, 581 /// clock_t times(struct tms *buffer); 582 times, 583 /// FILE *tmpfile(void); 584 tmpfile, 585 /// FILE *tmpfile64(void) 586 tmpfile64, 587 /// int toascii(int c); 588 toascii, 589 /// double trunc(double x); 590 trunc, 591 /// float truncf(float x); 592 truncf, 593 /// long double truncl(long double x); 594 truncl, 595 /// int uname(struct utsname *name); 596 uname, 597 /// int ungetc(int c, FILE *stream); 598 ungetc, 599 /// int unlink(const char *path); 600 unlink, 601 /// int unsetenv(const char *name); 602 unsetenv, 603 /// int utime(const char *path, const struct utimbuf *times); 604 utime, 605 /// int utimes(const char *path, const struct timeval times[2]); 606 utimes, 607 /// void *valloc(size_t size); 608 valloc, 609 /// int vfprintf(FILE *stream, const char *format, va_list ap); 610 vfprintf, 611 /// int vfscanf(FILE *stream, const char *format, va_list arg); 612 vfscanf, 613 /// int vprintf(const char *restrict format, va_list ap); 614 vprintf, 615 /// int vscanf(const char *format, va_list arg); 616 vscanf, 617 /// int vsnprintf(char *s, size_t n, const char *format, va_list ap); 618 vsnprintf, 619 /// int vsprintf(char *s, const char *format, va_list ap); 620 vsprintf, 621 /// int vsscanf(const char *s, const char *format, va_list arg); 622 vsscanf, 623 /// ssize_t write(int fildes, const void *buf, size_t nbyte); 624 write, 625 626 NumLibFuncs 627 }; 628 } 629 630 /// TargetLibraryInfo - This immutable pass captures information about what 631 /// library functions are available for the current target, and allows a 632 /// frontend to disable optimizations through -fno-builtin etc. 633 class TargetLibraryInfo : public ImmutablePass { 634 virtual void anchor(); 635 unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4]; 636 llvm::DenseMap<unsigned, std::string> CustomNames; 637 static const char* StandardNames[LibFunc::NumLibFuncs]; 638 639 enum AvailabilityState { 640 StandardName = 3, // (memset to all ones) 641 CustomName = 1, 642 Unavailable = 0 // (memset to all zeros) 643 }; 644 void setState(LibFunc::Func F, AvailabilityState State) { 645 AvailableArray[F/4] &= ~(3 << 2*(F&3)); 646 AvailableArray[F/4] |= State << 2*(F&3); 647 } 648 AvailabilityState getState(LibFunc::Func F) const { 649 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3); 650 } 651 652 public: 653 static char ID; 654 TargetLibraryInfo(); 655 TargetLibraryInfo(const Triple &T); 656 explicit TargetLibraryInfo(const TargetLibraryInfo &TLI); 657 658 /// getLibFunc - Search for a particular function name. If it is one of the 659 /// known library functions, return true and set F to the corresponding value. 660 bool getLibFunc(StringRef funcName, LibFunc::Func &F) const; 661 662 /// has - This function is used by optimizations that want to match on or form 663 /// a given library function. 664 bool has(LibFunc::Func F) const { 665 return getState(F) != Unavailable; 666 } 667 668 /// hasOptimizedCodeGen - Return true if the function is both available as 669 /// a builtin and a candidate for optimized code generation. 670 bool hasOptimizedCodeGen(LibFunc::Func F) const { 671 if (getState(F) == Unavailable) 672 return false; 673 switch (F) { 674 default: break; 675 case LibFunc::copysign: case LibFunc::copysignf: case LibFunc::copysignl: 676 case LibFunc::fabs: case LibFunc::fabsf: case LibFunc::fabsl: 677 case LibFunc::sin: case LibFunc::sinf: case LibFunc::sinl: 678 case LibFunc::cos: case LibFunc::cosf: case LibFunc::cosl: 679 case LibFunc::sqrt: case LibFunc::sqrtf: case LibFunc::sqrtl: 680 case LibFunc::floor: case LibFunc::floorf: case LibFunc::floorl: 681 case LibFunc::nearbyint: case LibFunc::nearbyintf: case LibFunc::nearbyintl: 682 case LibFunc::ceil: case LibFunc::ceilf: case LibFunc::ceill: 683 case LibFunc::rint: case LibFunc::rintf: case LibFunc::rintl: 684 case LibFunc::trunc: case LibFunc::truncf: case LibFunc::truncl: 685 case LibFunc::log2: case LibFunc::log2f: case LibFunc::log2l: 686 case LibFunc::exp2: case LibFunc::exp2f: case LibFunc::exp2l: 687 case LibFunc::memcmp: 688 return true; 689 } 690 return false; 691 } 692 693 StringRef getName(LibFunc::Func F) const { 694 AvailabilityState State = getState(F); 695 if (State == Unavailable) 696 return StringRef(); 697 if (State == StandardName) 698 return StandardNames[F]; 699 assert(State == CustomName); 700 return CustomNames.find(F)->second; 701 } 702 703 /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to 704 /// ban use of specific library functions. 705 void setUnavailable(LibFunc::Func F) { 706 setState(F, Unavailable); 707 } 708 709 void setAvailable(LibFunc::Func F) { 710 setState(F, StandardName); 711 } 712 713 void setAvailableWithName(LibFunc::Func F, StringRef Name) { 714 if (StandardNames[F] != Name) { 715 setState(F, CustomName); 716 CustomNames[F] = Name; 717 assert(CustomNames.find(F) != CustomNames.end()); 718 } else { 719 setState(F, StandardName); 720 } 721 } 722 723 /// disableAllFunctions - This disables all builtins, which is used for 724 /// options like -fno-builtin. 725 void disableAllFunctions(); 726 }; 727 728 } // end namespace llvm 729 730 #endif 731
