TargetLibraryInfo.h revision cf70590c38ef580758c8a255519959fc7160fdb2 
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
16namespace 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.
633class 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
652public:
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