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