Index: include/llvm/Analysis/TargetLibraryInfo.h
===================================================================
--- include/llvm/Analysis/TargetLibraryInfo.h
+++ include/llvm/Analysis/TargetLibraryInfo.h
@@ -22,675 +22,8 @@
 
   namespace LibFunc {
     enum Func {
-      /// int _IO_getc(_IO_FILE * __fp);
-      under_IO_getc,
-      /// int _IO_putc(int __c, _IO_FILE * __fp);
-      under_IO_putc,
-      /// void operator delete[](void*);
-      ZdaPv,
-      /// void operator delete[](void*, nothrow);
-      ZdaPvRKSt9nothrow_t,
-      /// void operator delete[](void*, unsigned int);
-      ZdaPvj,
-      /// void operator delete[](void*, unsigned long);
-      ZdaPvm,
-      /// void operator delete(void*);
-      ZdlPv,
-      /// void operator delete(void*, nothrow);
-      ZdlPvRKSt9nothrow_t,
-      /// void operator delete(void*, unsigned int);
-      ZdlPvj,
-      /// void operator delete(void*, unsigned long);
-      ZdlPvm,
-      /// void *new[](unsigned int);
-      Znaj,
-      /// void *new[](unsigned int, nothrow);
-      ZnajRKSt9nothrow_t,
-      /// void *new[](unsigned long);
-      Znam,
-      /// void *new[](unsigned long, nothrow);
-      ZnamRKSt9nothrow_t,
-      /// void *new(unsigned int);
-      Znwj,
-      /// void *new(unsigned int, nothrow);
-      ZnwjRKSt9nothrow_t,
-      /// void *new(unsigned long);
-      Znwm,
-      /// void *new(unsigned long, nothrow);
-      ZnwmRKSt9nothrow_t,
-      /// double __cospi(double x);
-      cospi,
-      /// float __cospif(float x);
-      cospif,
-      /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
-      cxa_atexit,
-      /// void __cxa_guard_abort(guard_t *guard);
-      /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
-      cxa_guard_abort,
-      /// int __cxa_guard_acquire(guard_t *guard);
-      cxa_guard_acquire,
-      /// void __cxa_guard_release(guard_t *guard);
-      cxa_guard_release,
-      /// int __isoc99_scanf (const char *format, ...)
-      dunder_isoc99_scanf,
-      /// int __isoc99_sscanf(const char *s, const char *format, ...)
-      dunder_isoc99_sscanf,
-      /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
-      memcpy_chk,
-      /// void *__memmove_chk(void *s1, const void *s2, size_t n,
-      ///                     size_t s1size);
-      memmove_chk,
-      /// void *__memset_chk(void *s, char v, size_t n, size_t s1size);
-      memset_chk,
-      /// double __sincospi_stret(double x);
-      sincospi_stret,
-      /// float __sincospif_stret(float x);
-      sincospif_stret,
-      /// double __sinpi(double x);
-      sinpi,
-      /// float __sinpif(float x);
-      sinpif,
-      /// double __sqrt_finite(double x);
-      sqrt_finite,
-      /// float __sqrt_finite(float x);
-      sqrtf_finite,
-      /// long double __sqrt_finite(long double x);
-      sqrtl_finite,
-      /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
-      stpcpy_chk,
-      /// char *__stpncpy_chk(char *s1, const char *s2, size_t n,
-      ///                     size_t s1size);
-      stpncpy_chk,
-      /// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
-      strcpy_chk,
-      /// char * __strdup(const char *s);
-      dunder_strdup,
-      /// char *__strncpy_chk(char *s1, const char *s2, size_t n,
-      ///                     size_t s1size);
-      strncpy_chk,
-      /// char *__strndup(const char *s, size_t n);
-      dunder_strndup,
-      /// char * __strtok_r(char *s, const char *delim, char **save_ptr);
-      dunder_strtok_r,
-      /// int abs(int j);
-      abs,
-      /// int access(const char *path, int amode);
-      access,
-      /// double acos(double x);
-      acos,
-      /// float acosf(float x);
-      acosf,
-      /// double acosh(double x);
-      acosh,
-      /// float acoshf(float x);
-      acoshf,
-      /// long double acoshl(long double x);
-      acoshl,
-      /// long double acosl(long double x);
-      acosl,
-      /// double asin(double x);
-      asin,
-      /// float asinf(float x);
-      asinf,
-      /// double asinh(double x);
-      asinh,
-      /// float asinhf(float x);
-      asinhf,
-      /// long double asinhl(long double x);
-      asinhl,
-      /// long double asinl(long double x);
-      asinl,
-      /// double atan(double x);
-      atan,
-      /// double atan2(double y, double x);
-      atan2,
-      /// float atan2f(float y, float x);
-      atan2f,
-      /// long double atan2l(long double y, long double x);
-      atan2l,
-      /// float atanf(float x);
-      atanf,
-      /// double atanh(double x);
-      atanh,
-      /// float atanhf(float x);
-      atanhf,
-      /// long double atanhl(long double x);
-      atanhl,
-      /// long double atanl(long double x);
-      atanl,
-      /// double atof(const char *str);
-      atof,
-      /// int atoi(const char *str);
-      atoi,
-      /// long atol(const char *str);
-      atol,
-      /// long long atoll(const char *nptr);
-      atoll,
-      /// int bcmp(const void *s1, const void *s2, size_t n);
-      bcmp,
-      /// void bcopy(const void *s1, void *s2, size_t n);
-      bcopy,
-      /// void bzero(void *s, size_t n);
-      bzero,
-      /// void *calloc(size_t count, size_t size);
-      calloc,
-      /// double cbrt(double x);
-      cbrt,
-      /// float cbrtf(float x);
-      cbrtf,
-      /// long double cbrtl(long double x);
-      cbrtl,
-      /// double ceil(double x);
-      ceil,
-      /// float ceilf(float x);
-      ceilf,
-      /// long double ceill(long double x);
-      ceill,
-      /// int chmod(const char *path, mode_t mode);
-      chmod,
-      /// int chown(const char *path, uid_t owner, gid_t group);
-      chown,
-      /// void clearerr(FILE *stream);
-      clearerr,
-      /// int closedir(DIR *dirp);
-      closedir,
-      /// double copysign(double x, double y);
-      copysign,
-      /// float copysignf(float x, float y);
-      copysignf,
-      /// long double copysignl(long double x, long double y);
-      copysignl,
-      /// double cos(double x);
-      cos,
-      /// float cosf(float x);
-      cosf,
-      /// double cosh(double x);
-      cosh,
-      /// float coshf(float x);
-      coshf,
-      /// long double coshl(long double x);
-      coshl,
-      /// long double cosl(long double x);
-      cosl,
-      /// char *ctermid(char *s);
-      ctermid,
-      /// double exp(double x);
-      exp,
-      /// double exp10(double x);
-      exp10,
-      /// float exp10f(float x);
-      exp10f,
-      /// long double exp10l(long double x);
-      exp10l,
-      /// double exp2(double x);
-      exp2,
-      /// float exp2f(float x);
-      exp2f,
-      /// long double exp2l(long double x);
-      exp2l,
-      /// float expf(float x);
-      expf,
-      /// long double expl(long double x);
-      expl,
-      /// double expm1(double x);
-      expm1,
-      /// float expm1f(float x);
-      expm1f,
-      /// long double expm1l(long double x);
-      expm1l,
-      /// double fabs(double x);
-      fabs,
-      /// float fabsf(float x);
-      fabsf,
-      /// long double fabsl(long double x);
-      fabsl,
-      /// int fclose(FILE *stream);
-      fclose,
-      /// FILE *fdopen(int fildes, const char *mode);
-      fdopen,
-      /// int feof(FILE *stream);
-      feof,
-      /// int ferror(FILE *stream);
-      ferror,
-      /// int fflush(FILE *stream);
-      fflush,
-      /// int ffs(int i);
-      ffs,
-      /// int ffsl(long int i);
-      ffsl,
-      /// int ffsll(long long int i);
-      ffsll,
-      /// int fgetc(FILE *stream);
-      fgetc,
-      /// int fgetpos(FILE *stream, fpos_t *pos);
-      fgetpos,
-      /// char *fgets(char *s, int n, FILE *stream);
-      fgets,
-      /// int fileno(FILE *stream);
-      fileno,
-      /// int fiprintf(FILE *stream, const char *format, ...);
-      fiprintf,
-      /// void flockfile(FILE *file);
-      flockfile,
-      /// double floor(double x);
-      floor,
-      /// float floorf(float x);
-      floorf,
-      /// long double floorl(long double x);
-      floorl,
-      /// double fmax(double x, double y);
-      fmax,
-      /// float fmaxf(float x, float y);
-      fmaxf,
-      /// long double fmaxl(long double x, long double y);
-      fmaxl,
-      /// double fmin(double x, double y);
-      fmin,
-      /// float fminf(float x, float y);
-      fminf,
-      /// long double fminl(long double x, long double y);
-      fminl,
-      /// double fmod(double x, double y);
-      fmod,
-      /// float fmodf(float x, float y);
-      fmodf,
-      /// long double fmodl(long double x, long double y);
-      fmodl,
-      /// FILE *fopen(const char *filename, const char *mode);
-      fopen,
-      /// FILE *fopen64(const char *filename, const char *opentype)
-      fopen64,
-      /// int fprintf(FILE *stream, const char *format, ...);
-      fprintf,
-      /// int fputc(int c, FILE *stream);
-      fputc,
-      /// int fputs(const char *s, FILE *stream);
-      fputs,
-      /// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
-      fread,
-      /// void free(void *ptr);
-      free,
-      /// double frexp(double num, int *exp);
-      frexp,
-      /// float frexpf(float num, int *exp);
-      frexpf,
-      /// long double frexpl(long double num, int *exp);
-      frexpl,
-      /// int fscanf(FILE *stream, const char *format, ... );
-      fscanf,
-      /// int fseek(FILE *stream, long offset, int whence);
-      fseek,
-      /// int fseeko(FILE *stream, off_t offset, int whence);
-      fseeko,
-      /// int fseeko64(FILE *stream, off64_t offset, int whence)
-      fseeko64,
-      /// int fsetpos(FILE *stream, const fpos_t *pos);
-      fsetpos,
-      /// int fstat(int fildes, struct stat *buf);
-      fstat,
-      /// int fstat64(int filedes, struct stat64 *buf)
-      fstat64,
-      /// int fstatvfs(int fildes, struct statvfs *buf);
-      fstatvfs,
-      /// int fstatvfs64(int fildes, struct statvfs64 *buf);
-      fstatvfs64,
-      /// long ftell(FILE *stream);
-      ftell,
-      /// off_t ftello(FILE *stream);
-      ftello,
-      /// off64_t ftello64(FILE *stream)
-      ftello64,
-      /// int ftrylockfile(FILE *file);
-      ftrylockfile,
-      /// void funlockfile(FILE *file);
-      funlockfile,
-      /// size_t fwrite(const void *ptr, size_t size, size_t nitems,
-      /// FILE *stream);
-      fwrite,
-      /// int getc(FILE *stream);
-      getc,
-      /// int getc_unlocked(FILE *stream);
-      getc_unlocked,
-      /// int getchar(void);
-      getchar,
-      /// char *getenv(const char *name);
-      getenv,
-      /// int getitimer(int which, struct itimerval *value);
-      getitimer,
-      /// int getlogin_r(char *name, size_t namesize);
-      getlogin_r,
-      /// struct passwd *getpwnam(const char *name);
-      getpwnam,
-      /// char *gets(char *s);
-      gets,
-      /// int gettimeofday(struct timeval *tp, void *tzp);
-      gettimeofday,
-      /// uint32_t htonl(uint32_t hostlong);
-      htonl,
-      /// uint16_t htons(uint16_t hostshort);
-      htons,
-      /// int iprintf(const char *format, ...);
-      iprintf,
-      /// int isascii(int c);
-      isascii,
-      /// int isdigit(int c);
-      isdigit,
-      /// long int labs(long int j);
-      labs,
-      /// int lchown(const char *path, uid_t owner, gid_t group);
-      lchown,
-      /// double ldexp(double x, int n);
-      ldexp,
-      /// float ldexpf(float x, int n);
-      ldexpf,
-      /// long double ldexpl(long double x, int n);
-      ldexpl,
-      /// long long int llabs(long long int j);
-      llabs,
-      /// double log(double x);
-      log,
-      /// double log10(double x);
-      log10,
-      /// float log10f(float x);
-      log10f,
-      /// long double log10l(long double x);
-      log10l,
-      /// double log1p(double x);
-      log1p,
-      /// float log1pf(float x);
-      log1pf,
-      /// long double log1pl(long double x);
-      log1pl,
-      /// double log2(double x);
-      log2,
-      /// float log2f(float x);
-      log2f,
-      /// double long double log2l(long double x);
-      log2l,
-      /// double logb(double x);
-      logb,
-      /// float logbf(float x);
-      logbf,
-      /// long double logbl(long double x);
-      logbl,
-      /// float logf(float x);
-      logf,
-      /// long double logl(long double x);
-      logl,
-      /// int lstat(const char *path, struct stat *buf);
-      lstat,
-      /// int lstat64(const char *path, struct stat64 *buf);
-      lstat64,
-      /// void *malloc(size_t size);
-      malloc,
-      /// void *memalign(size_t boundary, size_t size);
-      memalign,
-      /// void *memccpy(void *s1, const void *s2, int c, size_t n);
-      memccpy,
-      /// void *memchr(const void *s, int c, size_t n);
-      memchr,
-      /// int memcmp(const void *s1, const void *s2, size_t n);
-      memcmp,
-      /// void *memcpy(void *s1, const void *s2, size_t n);
-      memcpy,
-      /// void *memmove(void *s1, const void *s2, size_t n);
-      memmove,
-      // void *memrchr(const void *s, int c, size_t n);
-      memrchr,
-      /// void *memset(void *b, int c, size_t len);
-      memset,
-      /// void memset_pattern16(void *b, const void *pattern16, size_t len);
-      memset_pattern16,
-      /// int mkdir(const char *path, mode_t mode);
-      mkdir,
-      /// time_t mktime(struct tm *timeptr);
-      mktime,
-      /// double modf(double x, double *iptr);
-      modf,
-      /// float modff(float, float *iptr);
-      modff,
-      /// long double modfl(long double value, long double *iptr);
-      modfl,
-      /// double nearbyint(double x);
-      nearbyint,
-      /// float nearbyintf(float x);
-      nearbyintf,
-      /// long double nearbyintl(long double x);
-      nearbyintl,
-      /// uint32_t ntohl(uint32_t netlong);
-      ntohl,
-      /// uint16_t ntohs(uint16_t netshort);
-      ntohs,
-      /// int open(const char *path, int oflag, ... );
-      open,
-      /// int open64(const char *filename, int flags[, mode_t mode])
-      open64,
-      /// DIR *opendir(const char *dirname);
-      opendir,
-      /// int pclose(FILE *stream);
-      pclose,
-      /// void perror(const char *s);
-      perror,
-      /// FILE *popen(const char *command, const char *mode);
-      popen,
-      /// int posix_memalign(void **memptr, size_t alignment, size_t size);
-      posix_memalign,
-      /// double pow(double x, double y);
-      pow,
-      /// float powf(float x, float y);
-      powf,
-      /// long double powl(long double x, long double y);
-      powl,
-      /// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
-      pread,
-      /// int printf(const char *format, ...);
-      printf,
-      /// int putc(int c, FILE *stream);
-      putc,
-      /// int putchar(int c);
-      putchar,
-      /// int puts(const char *s);
-      puts,
-      /// ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
-      ///                off_t offset);
-      pwrite,
-      /// void qsort(void *base, size_t nel, size_t width,
-      ///            int (*compar)(const void *, const void *));
-      qsort,
-      /// ssize_t read(int fildes, void *buf, size_t nbyte);
-      read,
-      /// ssize_t readlink(const char *path, char *buf, size_t bufsize);
-      readlink,
-      /// void *realloc(void *ptr, size_t size);
-      realloc,
-      /// void *reallocf(void *ptr, size_t size);
-      reallocf,
-      /// char *realpath(const char *file_name, char *resolved_name);
-      realpath,
-      /// int remove(const char *path);
-      remove,
-      /// int rename(const char *old, const char *new);
-      rename,
-      /// void rewind(FILE *stream);
-      rewind,
-      /// double rint(double x);
-      rint,
-      /// float rintf(float x);
-      rintf,
-      /// long double rintl(long double x);
-      rintl,
-      /// int rmdir(const char *path);
-      rmdir,
-      /// double round(double x);
-      round,
-      /// float roundf(float x);
-      roundf,
-      /// long double roundl(long double x);
-      roundl,
-      /// int scanf(const char *restrict format, ... );
-      scanf,
-      /// void setbuf(FILE *stream, char *buf);
-      setbuf,
-      /// int setitimer(int which, const struct itimerval *value,
-      ///               struct itimerval *ovalue);
-      setitimer,
-      /// int setvbuf(FILE *stream, char *buf, int type, size_t size);
-      setvbuf,
-      /// double sin(double x);
-      sin,
-      /// float sinf(float x);
-      sinf,
-      /// double sinh(double x);
-      sinh,
-      /// float sinhf(float x);
-      sinhf,
-      /// long double sinhl(long double x);
-      sinhl,
-      /// long double sinl(long double x);
-      sinl,
-      /// int siprintf(char *str, const char *format, ...);
-      siprintf,
-      /// int snprintf(char *s, size_t n, const char *format, ...);
-      snprintf,
-      /// int sprintf(char *str, const char *format, ...);
-      sprintf,
-      /// double sqrt(double x);
-      sqrt,
-      /// float sqrtf(float x);
-      sqrtf,
-      /// long double sqrtl(long double x);
-      sqrtl,
-      /// int sscanf(const char *s, const char *format, ... );
-      sscanf,
-      /// int stat(const char *path, struct stat *buf);
-      stat,
-      /// int stat64(const char *path, struct stat64 *buf);
-      stat64,
-      /// int statvfs(const char *path, struct statvfs *buf);
-      statvfs,
-      /// int statvfs64(const char *path, struct statvfs64 *buf)
-      statvfs64,
-      /// char *stpcpy(char *s1, const char *s2);
-      stpcpy,
-      /// char *stpncpy(char *s1, const char *s2, size_t n);
-      stpncpy,
-      /// int strcasecmp(const char *s1, const char *s2);
-      strcasecmp,
-      /// char *strcat(char *s1, const char *s2);
-      strcat,
-      /// char *strchr(const char *s, int c);
-      strchr,
-      /// int strcmp(const char *s1, const char *s2);
-      strcmp,
-      /// int strcoll(const char *s1, const char *s2);
-      strcoll,
-      /// char *strcpy(char *s1, const char *s2);
-      strcpy,
-      /// size_t strcspn(const char *s1, const char *s2);
-      strcspn,
-      /// char *strdup(const char *s1);
-      strdup,
-      /// size_t strlen(const char *s);
-      strlen,
-      /// int strncasecmp(const char *s1, const char *s2, size_t n);
-      strncasecmp,
-      /// char *strncat(char *s1, const char *s2, size_t n);
-      strncat,
-      /// int strncmp(const char *s1, const char *s2, size_t n);
-      strncmp,
-      /// char *strncpy(char *s1, const char *s2, size_t n);
-      strncpy,
-      /// char *strndup(const char *s1, size_t n);
-      strndup,
-      /// size_t strnlen(const char *s, size_t maxlen);
-      strnlen,
-      /// char *strpbrk(const char *s1, const char *s2);
-      strpbrk,
-      /// char *strrchr(const char *s, int c);
-      strrchr,
-      /// size_t strspn(const char *s1, const char *s2);
-      strspn,
-      /// char *strstr(const char *s1, const char *s2);
-      strstr,
-      /// double strtod(const char *nptr, char **endptr);
-      strtod,
-      /// float strtof(const char *nptr, char **endptr);
-      strtof,
-      // char *strtok(char *s1, const char *s2);
-      strtok,
-      // char *strtok_r(char *s, const char *sep, char **lasts);
-      strtok_r,
-      /// long int strtol(const char *nptr, char **endptr, int base);
-      strtol,
-      /// long double strtold(const char *nptr, char **endptr);
-      strtold,
-      /// long long int strtoll(const char *nptr, char **endptr, int base);
-      strtoll,
-      /// unsigned long int strtoul(const char *nptr, char **endptr, int base);
-      strtoul,
-      /// unsigned long long int strtoull(const char *nptr, char **endptr,
-      ///                                 int base);
-      strtoull,
-      /// size_t strxfrm(char *s1, const char *s2, size_t n);
-      strxfrm,
-      /// int system(const char *command);
-      system,
-      /// double tan(double x);
-      tan,
-      /// float tanf(float x);
-      tanf,
-      /// double tanh(double x);
-      tanh,
-      /// float tanhf(float x);
-      tanhf,
-      /// long double tanhl(long double x);
-      tanhl,
-      /// long double tanl(long double x);
-      tanl,
-      /// clock_t times(struct tms *buffer);
-      times,
-      /// FILE *tmpfile(void);
-      tmpfile,
-      /// FILE *tmpfile64(void)
-      tmpfile64,
-      /// int toascii(int c);
-      toascii,
-      /// double trunc(double x);
-      trunc,
-      /// float truncf(float x);
-      truncf,
-      /// long double truncl(long double x);
-      truncl,
-      /// int uname(struct utsname *name);
-      uname,
-      /// int ungetc(int c, FILE *stream);
-      ungetc,
-      /// int unlink(const char *path);
-      unlink,
-      /// int unsetenv(const char *name);
-      unsetenv,
-      /// int utime(const char *path, const struct utimbuf *times);
-      utime,
-      /// int utimes(const char *path, const struct timeval times[2]);
-      utimes,
-      /// void *valloc(size_t size);
-      valloc,
-      /// int vfprintf(FILE *stream, const char *format, va_list ap);
-      vfprintf,
-      /// int vfscanf(FILE *stream, const char *format, va_list arg);
-      vfscanf,
-      /// int vprintf(const char *restrict format, va_list ap);
-      vprintf,
-      /// int vscanf(const char *format, va_list arg);
-      vscanf,
-      /// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
-      vsnprintf,
-      /// int vsprintf(char *s, const char *format, va_list ap);
-      vsprintf,
-      /// int vsscanf(const char *s, const char *format, va_list arg);
-      vsscanf,
-      /// ssize_t write(int fildes, const void *buf, size_t nbyte);
-      write,
+#define TLI_HANDLE_ENUM(enum_variant) enum_variant,
+#include "llvm/Analysis/TargetLibraryInfo.def"
 
       NumLibFuncs
     };
Index: include/llvm/Analysis/TargetLibraryInfo.def
===================================================================
--- /dev/null
+++ include/llvm/Analysis/TargetLibraryInfo.def
@@ -0,0 +1,1021 @@
+//===-- TargetLibraryInfo.def - Library information -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if !(defined(TLI_HANDLE_ENUM) || defined(TLI_HANDLE_STRING))
+#error "Must define TLI_HANDLE_ENUM or TLI_HANDLE_STRING for TLI .def"
+#endif
+
+// This .def file will feed the enum variant name for each TLI function
+// to a user-defined macro TLI_HANDLE_ENUM, if present.
+// Otherwise default to nop.
+#ifndef TLI_HANDLE_ENUM
+#define TLI_HANDLE_ENUM(enum_variant)
+#endif
+
+// Similar, but feed each function's string representation.
+#ifndef TLI_HANDLE_STRING
+#define TLI_HANDLE_STRING(string_repr)
+#endif
+
+/// int _IO_getc(_IO_FILE * __fp);
+TLI_HANDLE_ENUM(under_IO_getc)
+TLI_HANDLE_STRING("_IO_getc")
+/// int _IO_putc(int __c, _IO_FILE * __fp);
+TLI_HANDLE_ENUM(under_IO_putc)
+TLI_HANDLE_STRING("_IO_putc")
+/// void operator delete[](void*);
+TLI_HANDLE_ENUM(ZdaPv)
+TLI_HANDLE_STRING("_ZdaPv")
+/// void operator delete[](void*, nothrow);
+TLI_HANDLE_ENUM(ZdaPvRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZdaPvRKSt9nothrow_t")
+/// void operator delete[](void*, unsigned int);
+TLI_HANDLE_ENUM(ZdaPvj)
+TLI_HANDLE_STRING("_ZdaPvj")
+/// void operator delete[](void*, unsigned long);
+TLI_HANDLE_ENUM(ZdaPvm)
+TLI_HANDLE_STRING("_ZdaPvm")
+/// void operator delete(void*);
+TLI_HANDLE_ENUM(ZdlPv)
+TLI_HANDLE_STRING("_ZdlPv")
+/// void operator delete(void*, nothrow);
+TLI_HANDLE_ENUM(ZdlPvRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZdlPvRKSt9nothrow_t")
+/// void operator delete(void*, unsigned int);
+TLI_HANDLE_ENUM(ZdlPvj)
+TLI_HANDLE_STRING("_ZdlPvj")
+/// void operator delete(void*, unsigned long);
+TLI_HANDLE_ENUM(ZdlPvm)
+TLI_HANDLE_STRING("_ZdlPvm")
+/// void *new[](unsigned int);
+TLI_HANDLE_ENUM(Znaj)
+TLI_HANDLE_STRING("_Znaj")
+/// void *new[](unsigned int, nothrow);
+TLI_HANDLE_ENUM(ZnajRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZnajRKSt9nothrow_t")
+/// void *new[](unsigned long);
+TLI_HANDLE_ENUM(Znam)
+TLI_HANDLE_STRING("_Znam")
+/// void *new[](unsigned long, nothrow);
+TLI_HANDLE_ENUM(ZnamRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZnamRKSt9nothrow_t")
+/// void *new(unsigned int);
+TLI_HANDLE_ENUM(Znwj)
+TLI_HANDLE_STRING("_Znwj")
+/// void *new(unsigned int, nothrow);
+TLI_HANDLE_ENUM(ZnwjRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZnwjRKSt9nothrow_t")
+/// void *new(unsigned long);
+TLI_HANDLE_ENUM(Znwm)
+TLI_HANDLE_STRING("_Znwm")
+/// void *new(unsigned long, nothrow);
+TLI_HANDLE_ENUM(ZnwmRKSt9nothrow_t)
+TLI_HANDLE_STRING("_ZnwmRKSt9nothrow_t")
+/// double __cospi(double x);
+TLI_HANDLE_ENUM(cospi)
+TLI_HANDLE_STRING("__cospi")
+/// float __cospif(float x);
+TLI_HANDLE_ENUM(cospif)
+TLI_HANDLE_STRING("__cospif")
+/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
+TLI_HANDLE_ENUM(cxa_atexit)
+TLI_HANDLE_STRING("__cxa_atexit")
+/// void __cxa_guard_abort(guard_t *guard);
+/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
+TLI_HANDLE_ENUM(cxa_guard_abort)
+TLI_HANDLE_STRING("__cxa_guard_abort")
+/// int __cxa_guard_acquire(guard_t *guard);
+TLI_HANDLE_ENUM(cxa_guard_acquire)
+TLI_HANDLE_STRING("__cxa_guard_acquire")
+/// void __cxa_guard_release(guard_t *guard);
+TLI_HANDLE_ENUM(cxa_guard_release)
+TLI_HANDLE_STRING("__cxa_guard_release")
+/// int __isoc99_scanf (const char *format, ...)
+TLI_HANDLE_ENUM(dunder_isoc99_scanf)
+TLI_HANDLE_STRING("__isoc99_scanf")
+/// int __isoc99_sscanf(const char *s, const char *format, ...)
+TLI_HANDLE_ENUM(dunder_isoc99_sscanf)
+TLI_HANDLE_STRING("__isoc99_sscanf")
+/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
+TLI_HANDLE_ENUM(memcpy_chk)
+TLI_HANDLE_STRING("__memcpy_chk")
+/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
+TLI_HANDLE_ENUM(memmove_chk)
+TLI_HANDLE_STRING("__memmove_chk")
+/// void *__memset_chk(void *s, char v, size_t n, size_t s1size);
+TLI_HANDLE_ENUM(memset_chk)
+TLI_HANDLE_STRING("__memset_chk")
+/// double __sincospi_stret(double x);
+TLI_HANDLE_ENUM(sincospi_stret)
+TLI_HANDLE_STRING("__sincospi_stret")
+/// float __sincospif_stret(float x);
+TLI_HANDLE_ENUM(sincospif_stret)
+TLI_HANDLE_STRING("__sincospif_stret")
+/// double __sinpi(double x);
+TLI_HANDLE_ENUM(sinpi)
+TLI_HANDLE_STRING("__sinpi")
+/// float __sinpif(float x);
+TLI_HANDLE_ENUM(sinpif)
+TLI_HANDLE_STRING("__sinpif")
+/// double __sqrt_finite(double x);
+TLI_HANDLE_ENUM(sqrt_finite)
+TLI_HANDLE_STRING("__sqrt_finite")
+/// float __sqrt_finite(float x);
+TLI_HANDLE_ENUM(sqrtf_finite)
+TLI_HANDLE_STRING("__sqrtf_finite")
+/// long double __sqrt_finite(long double x);
+TLI_HANDLE_ENUM(sqrtl_finite)
+TLI_HANDLE_STRING("__sqrtl_finite")
+/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
+TLI_HANDLE_ENUM(stpcpy_chk)
+TLI_HANDLE_STRING("__stpcpy_chk")
+/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
+TLI_HANDLE_ENUM(stpncpy_chk)
+TLI_HANDLE_STRING("__stpncpy_chk")
+/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
+TLI_HANDLE_ENUM(strcpy_chk)
+TLI_HANDLE_STRING("__strcpy_chk")
+/// char * __strdup(const char *s);
+TLI_HANDLE_ENUM(dunder_strdup)
+TLI_HANDLE_STRING("__strdup")
+/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
+TLI_HANDLE_ENUM(strncpy_chk)
+TLI_HANDLE_STRING("__strncpy_chk")
+/// char *__strndup(const char *s, size_t n);
+TLI_HANDLE_ENUM(dunder_strndup)
+TLI_HANDLE_STRING("__strndup")
+/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
+TLI_HANDLE_ENUM(dunder_strtok_r)
+TLI_HANDLE_STRING("__strtok_r")
+/// int abs(int j);
+TLI_HANDLE_ENUM(abs)
+TLI_HANDLE_STRING("abs")
+/// int access(const char *path, int amode);
+TLI_HANDLE_ENUM(access)
+TLI_HANDLE_STRING("access")
+/// double acos(double x);
+TLI_HANDLE_ENUM(acos)
+TLI_HANDLE_STRING("acos")
+/// float acosf(float x);
+TLI_HANDLE_ENUM(acosf)
+TLI_HANDLE_STRING("acosf")
+/// double acosh(double x);
+TLI_HANDLE_ENUM(acosh)
+TLI_HANDLE_STRING("acosh")
+/// float acoshf(float x);
+TLI_HANDLE_ENUM(acoshf)
+TLI_HANDLE_STRING("acoshf")
+/// long double acoshl(long double x);
+TLI_HANDLE_ENUM(acoshl)
+TLI_HANDLE_STRING("acoshl")
+/// long double acosl(long double x);
+TLI_HANDLE_ENUM(acosl)
+TLI_HANDLE_STRING("acosl")
+/// double asin(double x);
+TLI_HANDLE_ENUM(asin)
+TLI_HANDLE_STRING("asin")
+/// float asinf(float x);
+TLI_HANDLE_ENUM(asinf)
+TLI_HANDLE_STRING("asinf")
+/// double asinh(double x);
+TLI_HANDLE_ENUM(asinh)
+TLI_HANDLE_STRING("asinh")
+/// float asinhf(float x);
+TLI_HANDLE_ENUM(asinhf)
+TLI_HANDLE_STRING("asinhf")
+/// long double asinhl(long double x);
+TLI_HANDLE_ENUM(asinhl)
+TLI_HANDLE_STRING("asinhl")
+/// long double asinl(long double x);
+TLI_HANDLE_ENUM(asinl)
+TLI_HANDLE_STRING("asinl")
+/// double atan(double x);
+TLI_HANDLE_ENUM(atan)
+TLI_HANDLE_STRING("atan")
+/// double atan2(double y, double x);
+TLI_HANDLE_ENUM(atan2)
+TLI_HANDLE_STRING("atan2")
+/// float atan2f(float y, float x);
+TLI_HANDLE_ENUM(atan2f)
+TLI_HANDLE_STRING("atan2f")
+/// long double atan2l(long double y, long double x);
+TLI_HANDLE_ENUM(atan2l)
+TLI_HANDLE_STRING("atan2l")
+/// float atanf(float x);
+TLI_HANDLE_ENUM(atanf)
+TLI_HANDLE_STRING("atanf")
+/// double atanh(double x);
+TLI_HANDLE_ENUM(atanh)
+TLI_HANDLE_STRING("atanh")
+/// float atanhf(float x);
+TLI_HANDLE_ENUM(atanhf)
+TLI_HANDLE_STRING("atanhf")
+/// long double atanhl(long double x);
+TLI_HANDLE_ENUM(atanhl)
+TLI_HANDLE_STRING("atanhl")
+/// long double atanl(long double x);
+TLI_HANDLE_ENUM(atanl)
+TLI_HANDLE_STRING("atanl")
+/// double atof(const char *str);
+TLI_HANDLE_ENUM(atof)
+TLI_HANDLE_STRING("atof")
+/// int atoi(const char *str);
+TLI_HANDLE_ENUM(atoi)
+TLI_HANDLE_STRING("atoi")
+/// long atol(const char *str);
+TLI_HANDLE_ENUM(atol)
+TLI_HANDLE_STRING("atol")
+/// long long atoll(const char *nptr);
+TLI_HANDLE_ENUM(atoll)
+TLI_HANDLE_STRING("atoll")
+/// int bcmp(const void *s1, const void *s2, size_t n);
+TLI_HANDLE_ENUM(bcmp)
+TLI_HANDLE_STRING("bcmp")
+/// void bcopy(const void *s1, void *s2, size_t n);
+TLI_HANDLE_ENUM(bcopy)
+TLI_HANDLE_STRING("bcopy")
+/// void bzero(void *s, size_t n);
+TLI_HANDLE_ENUM(bzero)
+TLI_HANDLE_STRING("bzero")
+/// void *calloc(size_t count, size_t size);
+TLI_HANDLE_ENUM(calloc)
+TLI_HANDLE_STRING("calloc")
+/// double cbrt(double x);
+TLI_HANDLE_ENUM(cbrt)
+TLI_HANDLE_STRING("cbrt")
+/// float cbrtf(float x);
+TLI_HANDLE_ENUM(cbrtf)
+TLI_HANDLE_STRING("cbrtf")
+/// long double cbrtl(long double x);
+TLI_HANDLE_ENUM(cbrtl)
+TLI_HANDLE_STRING("cbrtl")
+/// double ceil(double x);
+TLI_HANDLE_ENUM(ceil)
+TLI_HANDLE_STRING("ceil")
+/// float ceilf(float x);
+TLI_HANDLE_ENUM(ceilf)
+TLI_HANDLE_STRING("ceilf")
+/// long double ceill(long double x);
+TLI_HANDLE_ENUM(ceill)
+TLI_HANDLE_STRING("ceill")
+/// int chmod(const char *path, mode_t mode);
+TLI_HANDLE_ENUM(chmod)
+TLI_HANDLE_STRING("chmod")
+/// int chown(const char *path, uid_t owner, gid_t group);
+TLI_HANDLE_ENUM(chown)
+TLI_HANDLE_STRING("chown")
+/// void clearerr(FILE *stream);
+TLI_HANDLE_ENUM(clearerr)
+TLI_HANDLE_STRING("clearerr")
+/// int closedir(DIR *dirp);
+TLI_HANDLE_ENUM(closedir)
+TLI_HANDLE_STRING("closedir")
+/// double copysign(double x, double y);
+TLI_HANDLE_ENUM(copysign)
+TLI_HANDLE_STRING("copysign")
+/// float copysignf(float x, float y);
+TLI_HANDLE_ENUM(copysignf)
+TLI_HANDLE_STRING("copysignf")
+/// long double copysignl(long double x, long double y);
+TLI_HANDLE_ENUM(copysignl)
+TLI_HANDLE_STRING("copysignl")
+/// double cos(double x);
+TLI_HANDLE_ENUM(cos)
+TLI_HANDLE_STRING("cos")
+/// float cosf(float x);
+TLI_HANDLE_ENUM(cosf)
+TLI_HANDLE_STRING("cosf")
+/// double cosh(double x);
+TLI_HANDLE_ENUM(cosh)
+TLI_HANDLE_STRING("cosh")
+/// float coshf(float x);
+TLI_HANDLE_ENUM(coshf)
+TLI_HANDLE_STRING("coshf")
+/// long double coshl(long double x);
+TLI_HANDLE_ENUM(coshl)
+TLI_HANDLE_STRING("coshl")
+/// long double cosl(long double x);
+TLI_HANDLE_ENUM(cosl)
+TLI_HANDLE_STRING("cosl")
+/// char *ctermid(char *s);
+TLI_HANDLE_ENUM(ctermid)
+TLI_HANDLE_STRING("ctermid")
+/// double exp(double x);
+TLI_HANDLE_ENUM(exp)
+TLI_HANDLE_STRING("exp")
+/// double exp10(double x);
+TLI_HANDLE_ENUM(exp10)
+TLI_HANDLE_STRING("exp10")
+/// float exp10f(float x);
+TLI_HANDLE_ENUM(exp10f)
+TLI_HANDLE_STRING("exp10f")
+/// long double exp10l(long double x);
+TLI_HANDLE_ENUM(exp10l)
+TLI_HANDLE_STRING("exp10l")
+/// double exp2(double x);
+TLI_HANDLE_ENUM(exp2)
+TLI_HANDLE_STRING("exp2")
+/// float exp2f(float x);
+TLI_HANDLE_ENUM(exp2f)
+TLI_HANDLE_STRING("exp2f")
+/// long double exp2l(long double x);
+TLI_HANDLE_ENUM(exp2l)
+TLI_HANDLE_STRING("exp2l")
+/// float expf(float x);
+TLI_HANDLE_ENUM(expf)
+TLI_HANDLE_STRING("expf")
+/// long double expl(long double x);
+TLI_HANDLE_ENUM(expl)
+TLI_HANDLE_STRING("expl")
+/// double expm1(double x);
+TLI_HANDLE_ENUM(expm1)
+TLI_HANDLE_STRING("expm1")
+/// float expm1f(float x);
+TLI_HANDLE_ENUM(expm1f)
+TLI_HANDLE_STRING("expm1f")
+/// long double expm1l(long double x);
+TLI_HANDLE_ENUM(expm1l)
+TLI_HANDLE_STRING("expm1l")
+/// double fabs(double x);
+TLI_HANDLE_ENUM(fabs)
+TLI_HANDLE_STRING("fabs")
+/// float fabsf(float x);
+TLI_HANDLE_ENUM(fabsf)
+TLI_HANDLE_STRING("fabsf")
+/// long double fabsl(long double x);
+TLI_HANDLE_ENUM(fabsl)
+TLI_HANDLE_STRING("fabsl")
+/// int fclose(FILE *stream);
+TLI_HANDLE_ENUM(fclose)
+TLI_HANDLE_STRING("fclose")
+/// FILE *fdopen(int fildes, const char *mode);
+TLI_HANDLE_ENUM(fdopen)
+TLI_HANDLE_STRING("fdopen")
+/// int feof(FILE *stream);
+TLI_HANDLE_ENUM(feof)
+TLI_HANDLE_STRING("feof")
+/// int ferror(FILE *stream);
+TLI_HANDLE_ENUM(ferror)
+TLI_HANDLE_STRING("ferror")
+/// int fflush(FILE *stream);
+TLI_HANDLE_ENUM(fflush)
+TLI_HANDLE_STRING("fflush")
+/// int ffs(int i);
+TLI_HANDLE_ENUM(ffs)
+TLI_HANDLE_STRING("ffs")
+/// int ffsl(long int i);
+TLI_HANDLE_ENUM(ffsl)
+TLI_HANDLE_STRING("ffsl")
+/// int ffsll(long long int i);
+TLI_HANDLE_ENUM(ffsll)
+TLI_HANDLE_STRING("ffsll")
+/// int fgetc(FILE *stream);
+TLI_HANDLE_ENUM(fgetc)
+TLI_HANDLE_STRING("fgetc")
+/// int fgetpos(FILE *stream, fpos_t *pos);
+TLI_HANDLE_ENUM(fgetpos)
+TLI_HANDLE_STRING("fgetpos")
+/// char *fgets(char *s, int n, FILE *stream);
+TLI_HANDLE_ENUM(fgets)
+TLI_HANDLE_STRING("fgets")
+/// int fileno(FILE *stream);
+TLI_HANDLE_ENUM(fileno)
+TLI_HANDLE_STRING("fileno")
+/// int fiprintf(FILE *stream, const char *format, ...);
+TLI_HANDLE_ENUM(fiprintf)
+TLI_HANDLE_STRING("fiprintf")
+/// void flockfile(FILE *file);
+TLI_HANDLE_ENUM(flockfile)
+TLI_HANDLE_STRING("flockfile")
+/// double floor(double x);
+TLI_HANDLE_ENUM(floor)
+TLI_HANDLE_STRING("floor")
+/// float floorf(float x);
+TLI_HANDLE_ENUM(floorf)
+TLI_HANDLE_STRING("floorf")
+/// long double floorl(long double x);
+TLI_HANDLE_ENUM(floorl)
+TLI_HANDLE_STRING("floorl")
+/// double fmax(double x, double y);
+TLI_HANDLE_ENUM(fmax)
+TLI_HANDLE_STRING("fmax")
+/// float fmaxf(float x, float y);
+TLI_HANDLE_ENUM(fmaxf)
+TLI_HANDLE_STRING("fmaxf")
+/// long double fmaxl(long double x, long double y);
+TLI_HANDLE_ENUM(fmaxl)
+TLI_HANDLE_STRING("fmaxl")
+/// double fmin(double x, double y);
+TLI_HANDLE_ENUM(fmin)
+TLI_HANDLE_STRING("fmin")
+/// float fminf(float x, float y);
+TLI_HANDLE_ENUM(fminf)
+TLI_HANDLE_STRING("fminf")
+/// long double fminl(long double x, long double y);
+TLI_HANDLE_ENUM(fminl)
+TLI_HANDLE_STRING("fminl")
+/// double fmod(double x, double y);
+TLI_HANDLE_ENUM(fmod)
+TLI_HANDLE_STRING("fmod")
+/// float fmodf(float x, float y);
+TLI_HANDLE_ENUM(fmodf)
+TLI_HANDLE_STRING("fmodf")
+/// long double fmodl(long double x, long double y);
+TLI_HANDLE_ENUM(fmodl)
+TLI_HANDLE_STRING("fmodl")
+/// FILE *fopen(const char *filename, const char *mode);
+TLI_HANDLE_ENUM(fopen)
+TLI_HANDLE_STRING("fopen")
+/// FILE *fopen64(const char *filename, const char *opentype)
+TLI_HANDLE_ENUM(fopen64)
+TLI_HANDLE_STRING("fopen64")
+/// int fprintf(FILE *stream, const char *format, ...);
+TLI_HANDLE_ENUM(fprintf)
+TLI_HANDLE_STRING("fprintf")
+/// int fputc(int c, FILE *stream);
+TLI_HANDLE_ENUM(fputc)
+TLI_HANDLE_STRING("fputc")
+/// int fputs(const char *s, FILE *stream);
+TLI_HANDLE_ENUM(fputs)
+TLI_HANDLE_STRING("fputs")
+/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
+TLI_HANDLE_ENUM(fread)
+TLI_HANDLE_STRING("fread")
+/// void free(void *ptr);
+TLI_HANDLE_ENUM(free)
+TLI_HANDLE_STRING("free")
+/// double frexp(double num, int *exp);
+TLI_HANDLE_ENUM(frexp)
+TLI_HANDLE_STRING("frexp")
+/// float frexpf(float num, int *exp);
+TLI_HANDLE_ENUM(frexpf)
+TLI_HANDLE_STRING("frexpf")
+/// long double frexpl(long double num, int *exp);
+TLI_HANDLE_ENUM(frexpl)
+TLI_HANDLE_STRING("frexpl")
+/// int fscanf(FILE *stream, const char *format, ... );
+TLI_HANDLE_ENUM(fscanf)
+TLI_HANDLE_STRING("fscanf")
+/// int fseek(FILE *stream, long offset, int whence);
+TLI_HANDLE_ENUM(fseek)
+TLI_HANDLE_STRING("fseek")
+/// int fseeko(FILE *stream, off_t offset, int whence);
+TLI_HANDLE_ENUM(fseeko)
+TLI_HANDLE_STRING("fseeko")
+/// int fseeko64(FILE *stream, off64_t offset, int whence)
+TLI_HANDLE_ENUM(fseeko64)
+TLI_HANDLE_STRING("fseeko64")
+/// int fsetpos(FILE *stream, const fpos_t *pos);
+TLI_HANDLE_ENUM(fsetpos)
+TLI_HANDLE_STRING("fsetpos")
+/// int fstat(int fildes, struct stat *buf);
+TLI_HANDLE_ENUM(fstat)
+TLI_HANDLE_STRING("fstat")
+/// int fstat64(int filedes, struct stat64 *buf)
+TLI_HANDLE_ENUM(fstat64)
+TLI_HANDLE_STRING("fstat64")
+/// int fstatvfs(int fildes, struct statvfs *buf);
+TLI_HANDLE_ENUM(fstatvfs)
+TLI_HANDLE_STRING("fstatvfs")
+/// int fstatvfs64(int fildes, struct statvfs64 *buf);
+TLI_HANDLE_ENUM(fstatvfs64)
+TLI_HANDLE_STRING("fstatvfs64")
+/// long ftell(FILE *stream);
+TLI_HANDLE_ENUM(ftell)
+TLI_HANDLE_STRING("ftell")
+/// off_t ftello(FILE *stream);
+TLI_HANDLE_ENUM(ftello)
+TLI_HANDLE_STRING("ftello")
+/// off64_t ftello64(FILE *stream)
+TLI_HANDLE_ENUM(ftello64)
+TLI_HANDLE_STRING("ftello64")
+/// int ftrylockfile(FILE *file);
+TLI_HANDLE_ENUM(ftrylockfile)
+TLI_HANDLE_STRING("ftrylockfile")
+/// void funlockfile(FILE *file);
+TLI_HANDLE_ENUM(funlockfile)
+TLI_HANDLE_STRING("funlockfile")
+/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+TLI_HANDLE_ENUM(fwrite)
+TLI_HANDLE_STRING("fwrite")
+/// int getc(FILE *stream);
+TLI_HANDLE_ENUM(getc)
+TLI_HANDLE_STRING("getc")
+/// int getc_unlocked(FILE *stream);
+TLI_HANDLE_ENUM(getc_unlocked)
+TLI_HANDLE_STRING("getc_unlocked")
+/// int getchar(void);
+TLI_HANDLE_ENUM(getchar)
+TLI_HANDLE_STRING("getchar")
+/// char *getenv(const char *name);
+TLI_HANDLE_ENUM(getenv)
+TLI_HANDLE_STRING("getenv")
+/// int getitimer(int which, struct itimerval *value);
+TLI_HANDLE_ENUM(getitimer)
+TLI_HANDLE_STRING("getitimer")
+/// int getlogin_r(char *name, size_t namesize);
+TLI_HANDLE_ENUM(getlogin_r)
+TLI_HANDLE_STRING("getlogin_r")
+/// struct passwd *getpwnam(const char *name);
+TLI_HANDLE_ENUM(getpwnam)
+TLI_HANDLE_STRING("getpwnam")
+/// char *gets(char *s);
+TLI_HANDLE_ENUM(gets)
+TLI_HANDLE_STRING("gets")
+/// int gettimeofday(struct timeval *tp, void *tzp);
+TLI_HANDLE_ENUM(gettimeofday)
+TLI_HANDLE_STRING("gettimeofday")
+/// uint32_t htonl(uint32_t hostlong);
+TLI_HANDLE_ENUM(htonl)
+TLI_HANDLE_STRING("htonl")
+/// uint16_t htons(uint16_t hostshort);
+TLI_HANDLE_ENUM(htons)
+TLI_HANDLE_STRING("htons")
+/// int iprintf(const char *format, ...);
+TLI_HANDLE_ENUM(iprintf)
+TLI_HANDLE_STRING("iprintf")
+/// int isascii(int c);
+TLI_HANDLE_ENUM(isascii)
+TLI_HANDLE_STRING("isascii")
+/// int isdigit(int c);
+TLI_HANDLE_ENUM(isdigit)
+TLI_HANDLE_STRING("isdigit")
+/// long int labs(long int j);
+TLI_HANDLE_ENUM(labs)
+TLI_HANDLE_STRING("labs")
+/// int lchown(const char *path, uid_t owner, gid_t group);
+TLI_HANDLE_ENUM(lchown)
+TLI_HANDLE_STRING("lchown")
+/// double ldexp(double x, int n);
+TLI_HANDLE_ENUM(ldexp)
+TLI_HANDLE_STRING("ldexp")
+/// float ldexpf(float x, int n);
+TLI_HANDLE_ENUM(ldexpf)
+TLI_HANDLE_STRING("ldexpf")
+/// long double ldexpl(long double x, int n);
+TLI_HANDLE_ENUM(ldexpl)
+TLI_HANDLE_STRING("ldexpl")
+/// long long int llabs(long long int j);
+TLI_HANDLE_ENUM(llabs)
+TLI_HANDLE_STRING("llabs")
+/// double log(double x);
+TLI_HANDLE_ENUM(log)
+TLI_HANDLE_STRING("log")
+/// double log10(double x);
+TLI_HANDLE_ENUM(log10)
+TLI_HANDLE_STRING("log10")
+/// float log10f(float x);
+TLI_HANDLE_ENUM(log10f)
+TLI_HANDLE_STRING("log10f")
+/// long double log10l(long double x);
+TLI_HANDLE_ENUM(log10l)
+TLI_HANDLE_STRING("log10l")
+/// double log1p(double x);
+TLI_HANDLE_ENUM(log1p)
+TLI_HANDLE_STRING("log1p")
+/// float log1pf(float x);
+TLI_HANDLE_ENUM(log1pf)
+TLI_HANDLE_STRING("log1pf")
+/// long double log1pl(long double x);
+TLI_HANDLE_ENUM(log1pl)
+TLI_HANDLE_STRING("log1pl")
+/// double log2(double x);
+TLI_HANDLE_ENUM(log2)
+TLI_HANDLE_STRING("log2")
+/// float log2f(float x);
+TLI_HANDLE_ENUM(log2f)
+TLI_HANDLE_STRING("log2f")
+/// double long double log2l(long double x);
+TLI_HANDLE_ENUM(log2l)
+TLI_HANDLE_STRING("log2l")
+/// double logb(double x);
+TLI_HANDLE_ENUM(logb)
+TLI_HANDLE_STRING("logb")
+/// float logbf(float x);
+TLI_HANDLE_ENUM(logbf)
+TLI_HANDLE_STRING("logbf")
+/// long double logbl(long double x);
+TLI_HANDLE_ENUM(logbl)
+TLI_HANDLE_STRING("logbl")
+/// float logf(float x);
+TLI_HANDLE_ENUM(logf)
+TLI_HANDLE_STRING("logf")
+/// long double logl(long double x);
+TLI_HANDLE_ENUM(logl)
+TLI_HANDLE_STRING("logl")
+/// int lstat(const char *path, struct stat *buf);
+TLI_HANDLE_ENUM(lstat)
+TLI_HANDLE_STRING("lstat")
+/// int lstat64(const char *path, struct stat64 *buf);
+TLI_HANDLE_ENUM(lstat64)
+TLI_HANDLE_STRING("lstat64")
+/// void *malloc(size_t size);
+TLI_HANDLE_ENUM(malloc)
+TLI_HANDLE_STRING("malloc")
+/// void *memalign(size_t boundary, size_t size);
+TLI_HANDLE_ENUM(memalign)
+TLI_HANDLE_STRING("memalign")
+/// void *memccpy(void *s1, const void *s2, int c, size_t n);
+TLI_HANDLE_ENUM(memccpy)
+TLI_HANDLE_STRING("memccpy")
+/// void *memchr(const void *s, int c, size_t n);
+TLI_HANDLE_ENUM(memchr)
+TLI_HANDLE_STRING("memchr")
+/// int memcmp(const void *s1, const void *s2, size_t n);
+TLI_HANDLE_ENUM(memcmp)
+TLI_HANDLE_STRING("memcmp")
+/// void *memcpy(void *s1, const void *s2, size_t n);
+TLI_HANDLE_ENUM(memcpy)
+TLI_HANDLE_STRING("memcpy")
+/// void *memmove(void *s1, const void *s2, size_t n);
+TLI_HANDLE_ENUM(memmove)
+TLI_HANDLE_STRING("memmove")
+// void *memrchr(const void *s, int c, size_t n);
+TLI_HANDLE_ENUM(memrchr)
+TLI_HANDLE_STRING("memrchr")
+/// void *memset(void *b, int c, size_t len);
+TLI_HANDLE_ENUM(memset)
+TLI_HANDLE_STRING("memset")
+/// void memset_pattern16(void *b, const void *pattern16, size_t len);
+TLI_HANDLE_ENUM(memset_pattern16)
+TLI_HANDLE_STRING("memset_pattern16")
+/// int mkdir(const char *path, mode_t mode);
+TLI_HANDLE_ENUM(mkdir)
+TLI_HANDLE_STRING("mkdir")
+/// time_t mktime(struct tm *timeptr);
+TLI_HANDLE_ENUM(mktime)
+TLI_HANDLE_STRING("mktime")
+/// double modf(double x, double *iptr);
+TLI_HANDLE_ENUM(modf)
+TLI_HANDLE_STRING("modf")
+/// float modff(float, float *iptr);
+TLI_HANDLE_ENUM(modff)
+TLI_HANDLE_STRING("modff")
+/// long double modfl(long double value, long double *iptr);
+TLI_HANDLE_ENUM(modfl)
+TLI_HANDLE_STRING("modfl")
+/// double nearbyint(double x);
+TLI_HANDLE_ENUM(nearbyint)
+TLI_HANDLE_STRING("nearbyint")
+/// float nearbyintf(float x);
+TLI_HANDLE_ENUM(nearbyintf)
+TLI_HANDLE_STRING("nearbyintf")
+/// long double nearbyintl(long double x);
+TLI_HANDLE_ENUM(nearbyintl)
+TLI_HANDLE_STRING("nearbyintl")
+/// uint32_t ntohl(uint32_t netlong);
+TLI_HANDLE_ENUM(ntohl)
+TLI_HANDLE_STRING("ntohl")
+/// uint16_t ntohs(uint16_t netshort);
+TLI_HANDLE_ENUM(ntohs)
+TLI_HANDLE_STRING("ntohs")
+/// int open(const char *path, int oflag, ... );
+TLI_HANDLE_ENUM(open)
+TLI_HANDLE_STRING("open")
+/// int open64(const char *filename, int flags[, mode_t mode])
+TLI_HANDLE_ENUM(open64)
+TLI_HANDLE_STRING("open64")
+/// DIR *opendir(const char *dirname);
+TLI_HANDLE_ENUM(opendir)
+TLI_HANDLE_STRING("opendir")
+/// int pclose(FILE *stream);
+TLI_HANDLE_ENUM(pclose)
+TLI_HANDLE_STRING("pclose")
+/// void perror(const char *s);
+TLI_HANDLE_ENUM(perror)
+TLI_HANDLE_STRING("perror")
+/// FILE *popen(const char *command, const char *mode);
+TLI_HANDLE_ENUM(popen)
+TLI_HANDLE_STRING("popen")
+/// int posix_memalign(void **memptr, size_t alignment, size_t size);
+TLI_HANDLE_ENUM(posix_memalign)
+TLI_HANDLE_STRING("posix_memalign")
+/// double pow(double x, double y);
+TLI_HANDLE_ENUM(pow)
+TLI_HANDLE_STRING("pow")
+/// float powf(float x, float y);
+TLI_HANDLE_ENUM(powf)
+TLI_HANDLE_STRING("powf")
+/// long double powl(long double x, long double y);
+TLI_HANDLE_ENUM(powl)
+TLI_HANDLE_STRING("powl")
+/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
+TLI_HANDLE_ENUM(pread)
+TLI_HANDLE_STRING("pread")
+/// int printf(const char *format, ...);
+TLI_HANDLE_ENUM(printf)
+TLI_HANDLE_STRING("printf")
+/// int putc(int c, FILE *stream);
+TLI_HANDLE_ENUM(putc)
+TLI_HANDLE_STRING("putc")
+/// int putchar(int c);
+TLI_HANDLE_ENUM(putchar)
+TLI_HANDLE_STRING("putchar")
+/// int puts(const char *s);
+TLI_HANDLE_ENUM(puts)
+TLI_HANDLE_STRING("puts")
+/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+TLI_HANDLE_ENUM(pwrite)
+TLI_HANDLE_STRING("pwrite")
+/// void qsort(void *base, size_t nel, size_t width,
+///            int (*compar)(const void *, const void *));
+TLI_HANDLE_ENUM(qsort)
+TLI_HANDLE_STRING("qsort")
+/// ssize_t read(int fildes, void *buf, size_t nbyte);
+TLI_HANDLE_ENUM(read)
+TLI_HANDLE_STRING("read")
+/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
+TLI_HANDLE_ENUM(readlink)
+TLI_HANDLE_STRING("readlink")
+/// void *realloc(void *ptr, size_t size);
+TLI_HANDLE_ENUM(realloc)
+TLI_HANDLE_STRING("realloc")
+/// void *reallocf(void *ptr, size_t size);
+TLI_HANDLE_ENUM(reallocf)
+TLI_HANDLE_STRING("reallocf")
+/// char *realpath(const char *file_name, char *resolved_name);
+TLI_HANDLE_ENUM(realpath)
+TLI_HANDLE_STRING("realpath")
+/// int remove(const char *path);
+TLI_HANDLE_ENUM(remove)
+TLI_HANDLE_STRING("remove")
+/// int rename(const char *old, const char *new);
+TLI_HANDLE_ENUM(rename)
+TLI_HANDLE_STRING("rename")
+/// void rewind(FILE *stream);
+TLI_HANDLE_ENUM(rewind)
+TLI_HANDLE_STRING("rewind")
+/// double rint(double x);
+TLI_HANDLE_ENUM(rint)
+TLI_HANDLE_STRING("rint")
+/// float rintf(float x);
+TLI_HANDLE_ENUM(rintf)
+TLI_HANDLE_STRING("rintf")
+/// long double rintl(long double x);
+TLI_HANDLE_ENUM(rintl)
+TLI_HANDLE_STRING("rintl")
+/// int rmdir(const char *path);
+TLI_HANDLE_ENUM(rmdir)
+TLI_HANDLE_STRING("rmdir")
+/// double round(double x);
+TLI_HANDLE_ENUM(round)
+TLI_HANDLE_STRING("round")
+/// float roundf(float x);
+TLI_HANDLE_ENUM(roundf)
+TLI_HANDLE_STRING("roundf")
+/// long double roundl(long double x);
+TLI_HANDLE_ENUM(roundl)
+TLI_HANDLE_STRING("roundl")
+/// int scanf(const char *restrict format, ... );
+TLI_HANDLE_ENUM(scanf)
+TLI_HANDLE_STRING("scanf")
+/// void setbuf(FILE *stream, char *buf);
+TLI_HANDLE_ENUM(setbuf)
+TLI_HANDLE_STRING("setbuf")
+/// int setitimer(int which, const struct itimerval *value,
+///               struct itimerval *ovalue);
+TLI_HANDLE_ENUM(setitimer)
+TLI_HANDLE_STRING("setitimer")
+/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
+TLI_HANDLE_ENUM(setvbuf)
+TLI_HANDLE_STRING("setvbuf")
+/// double sin(double x);
+TLI_HANDLE_ENUM(sin)
+TLI_HANDLE_STRING("sin")
+/// float sinf(float x);
+TLI_HANDLE_ENUM(sinf)
+TLI_HANDLE_STRING("sinf")
+/// double sinh(double x);
+TLI_HANDLE_ENUM(sinh)
+TLI_HANDLE_STRING("sinh")
+/// float sinhf(float x);
+TLI_HANDLE_ENUM(sinhf)
+TLI_HANDLE_STRING("sinhf")
+/// long double sinhl(long double x);
+TLI_HANDLE_ENUM(sinhl)
+TLI_HANDLE_STRING("sinhl")
+/// long double sinl(long double x);
+TLI_HANDLE_ENUM(sinl)
+TLI_HANDLE_STRING("sinl")
+/// int siprintf(char *str, const char *format, ...);
+TLI_HANDLE_ENUM(siprintf)
+TLI_HANDLE_STRING("siprintf")
+/// int snprintf(char *s, size_t n, const char *format, ...);
+TLI_HANDLE_ENUM(snprintf)
+TLI_HANDLE_STRING("snprintf")
+/// int sprintf(char *str, const char *format, ...);
+TLI_HANDLE_ENUM(sprintf)
+TLI_HANDLE_STRING("sprintf")
+/// double sqrt(double x);
+TLI_HANDLE_ENUM(sqrt)
+TLI_HANDLE_STRING("sqrt")
+/// float sqrtf(float x);
+TLI_HANDLE_ENUM(sqrtf)
+TLI_HANDLE_STRING("sqrtf")
+/// long double sqrtl(long double x);
+TLI_HANDLE_ENUM(sqrtl)
+TLI_HANDLE_STRING("sqrtl")
+/// int sscanf(const char *s, const char *format, ... );
+TLI_HANDLE_ENUM(sscanf)
+TLI_HANDLE_STRING("sscanf")
+/// int stat(const char *path, struct stat *buf);
+TLI_HANDLE_ENUM(stat)
+TLI_HANDLE_STRING("stat")
+/// int stat64(const char *path, struct stat64 *buf);
+TLI_HANDLE_ENUM(stat64)
+TLI_HANDLE_STRING("stat64")
+/// int statvfs(const char *path, struct statvfs *buf);
+TLI_HANDLE_ENUM(statvfs)
+TLI_HANDLE_STRING("statvfs")
+/// int statvfs64(const char *path, struct statvfs64 *buf)
+TLI_HANDLE_ENUM(statvfs64)
+TLI_HANDLE_STRING("statvfs64")
+/// char *stpcpy(char *s1, const char *s2);
+TLI_HANDLE_ENUM(stpcpy)
+TLI_HANDLE_STRING("stpcpy")
+/// char *stpncpy(char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(stpncpy)
+TLI_HANDLE_STRING("stpncpy")
+/// int strcasecmp(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcasecmp)
+TLI_HANDLE_STRING("strcasecmp")
+/// char *strcat(char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcat)
+TLI_HANDLE_STRING("strcat")
+/// char *strchr(const char *s, int c);
+TLI_HANDLE_ENUM(strchr)
+TLI_HANDLE_STRING("strchr")
+/// int strcmp(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcmp)
+TLI_HANDLE_STRING("strcmp")
+/// int strcoll(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcoll)
+TLI_HANDLE_STRING("strcoll")
+/// char *strcpy(char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcpy)
+TLI_HANDLE_STRING("strcpy")
+/// size_t strcspn(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strcspn)
+TLI_HANDLE_STRING("strcspn")
+/// char *strdup(const char *s1);
+TLI_HANDLE_ENUM(strdup)
+TLI_HANDLE_STRING("strdup")
+/// size_t strlen(const char *s);
+TLI_HANDLE_ENUM(strlen)
+TLI_HANDLE_STRING("strlen")
+/// int strncasecmp(const char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(strncasecmp)
+TLI_HANDLE_STRING("strncasecmp")
+/// char *strncat(char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(strncat)
+TLI_HANDLE_STRING("strncat")
+/// int strncmp(const char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(strncmp)
+TLI_HANDLE_STRING("strncmp")
+/// char *strncpy(char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(strncpy)
+TLI_HANDLE_STRING("strncpy")
+/// char *strndup(const char *s1, size_t n);
+TLI_HANDLE_ENUM(strndup)
+TLI_HANDLE_STRING("strndup")
+/// size_t strnlen(const char *s, size_t maxlen);
+TLI_HANDLE_ENUM(strnlen)
+TLI_HANDLE_STRING("strnlen")
+/// char *strpbrk(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strpbrk)
+TLI_HANDLE_STRING("strpbrk")
+/// char *strrchr(const char *s, int c);
+TLI_HANDLE_ENUM(strrchr)
+TLI_HANDLE_STRING("strrchr")
+/// size_t strspn(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strspn)
+TLI_HANDLE_STRING("strspn")
+/// char *strstr(const char *s1, const char *s2);
+TLI_HANDLE_ENUM(strstr)
+TLI_HANDLE_STRING("strstr")
+/// double strtod(const char *nptr, char **endptr);
+TLI_HANDLE_ENUM(strtod)
+TLI_HANDLE_STRING("strtod")
+/// float strtof(const char *nptr, char **endptr);
+TLI_HANDLE_ENUM(strtof)
+TLI_HANDLE_STRING("strtof")
+// char *strtok(char *s1, const char *s2);
+TLI_HANDLE_ENUM(strtok)
+TLI_HANDLE_STRING("strtok")
+// char *strtok_r(char *s, const char *sep, char **lasts);
+TLI_HANDLE_ENUM(strtok_r)
+TLI_HANDLE_STRING("strtok_r")
+/// long int strtol(const char *nptr, char **endptr, int base);
+TLI_HANDLE_ENUM(strtol)
+TLI_HANDLE_STRING("strtol")
+/// long double strtold(const char *nptr, char **endptr);
+TLI_HANDLE_ENUM(strtold)
+TLI_HANDLE_STRING("strtold")
+/// long long int strtoll(const char *nptr, char **endptr, int base);
+TLI_HANDLE_ENUM(strtoll)
+TLI_HANDLE_STRING("strtoll")
+/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
+TLI_HANDLE_ENUM(strtoul)
+TLI_HANDLE_STRING("strtoul")
+/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
+TLI_HANDLE_ENUM(strtoull)
+TLI_HANDLE_STRING("strtoull")
+/// size_t strxfrm(char *s1, const char *s2, size_t n);
+TLI_HANDLE_ENUM(strxfrm)
+TLI_HANDLE_STRING("strxfrm")
+/// int system(const char *command);
+TLI_HANDLE_ENUM(system)
+TLI_HANDLE_STRING("system")
+/// double tan(double x);
+TLI_HANDLE_ENUM(tan)
+TLI_HANDLE_STRING("tan")
+/// float tanf(float x);
+TLI_HANDLE_ENUM(tanf)
+TLI_HANDLE_STRING("tanf")
+/// double tanh(double x);
+TLI_HANDLE_ENUM(tanh)
+TLI_HANDLE_STRING("tanh")
+/// float tanhf(float x);
+TLI_HANDLE_ENUM(tanhf)
+TLI_HANDLE_STRING("tanhf")
+/// long double tanhl(long double x);
+TLI_HANDLE_ENUM(tanhl)
+TLI_HANDLE_STRING("tanhl")
+/// long double tanl(long double x);
+TLI_HANDLE_ENUM(tanl)
+TLI_HANDLE_STRING("tanl")
+/// clock_t times(struct tms *buffer);
+TLI_HANDLE_ENUM(times)
+TLI_HANDLE_STRING("times")
+/// FILE *tmpfile(void);
+TLI_HANDLE_ENUM(tmpfile)
+TLI_HANDLE_STRING("tmpfile")
+/// FILE *tmpfile64(void)
+TLI_HANDLE_ENUM(tmpfile64)
+TLI_HANDLE_STRING("tmpfile64")
+/// int toascii(int c);
+TLI_HANDLE_ENUM(toascii)
+TLI_HANDLE_STRING("toascii")
+/// double trunc(double x);
+TLI_HANDLE_ENUM(trunc)
+TLI_HANDLE_STRING("trunc")
+/// float truncf(float x);
+TLI_HANDLE_ENUM(truncf)
+TLI_HANDLE_STRING("truncf")
+/// long double truncl(long double x);
+TLI_HANDLE_ENUM(truncl)
+TLI_HANDLE_STRING("truncl")
+/// int uname(struct utsname *name);
+TLI_HANDLE_ENUM(uname)
+TLI_HANDLE_STRING("uname")
+/// int ungetc(int c, FILE *stream);
+TLI_HANDLE_ENUM(ungetc)
+TLI_HANDLE_STRING("ungetc")
+/// int unlink(const char *path);
+TLI_HANDLE_ENUM(unlink)
+TLI_HANDLE_STRING("unlink")
+/// int unsetenv(const char *name);
+TLI_HANDLE_ENUM(unsetenv)
+TLI_HANDLE_STRING("unsetenv")
+/// int utime(const char *path, const struct utimbuf *times);
+TLI_HANDLE_ENUM(utime)
+TLI_HANDLE_STRING("utime")
+/// int utimes(const char *path, const struct timeval times[2]);
+TLI_HANDLE_ENUM(utimes)
+TLI_HANDLE_STRING("utimes")
+/// void *valloc(size_t size);
+TLI_HANDLE_ENUM(valloc)
+TLI_HANDLE_STRING("valloc")
+/// int vfprintf(FILE *stream, const char *format, va_list ap);
+TLI_HANDLE_ENUM(vfprintf)
+TLI_HANDLE_STRING("vfprintf")
+/// int vfscanf(FILE *stream, const char *format, va_list arg);
+TLI_HANDLE_ENUM(vfscanf)
+TLI_HANDLE_STRING("vfscanf")
+/// int vprintf(const char *restrict format, va_list ap);
+TLI_HANDLE_ENUM(vprintf)
+TLI_HANDLE_STRING("vprintf")
+/// int vscanf(const char *format, va_list arg);
+TLI_HANDLE_ENUM(vscanf)
+TLI_HANDLE_STRING("vscanf")
+/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
+TLI_HANDLE_ENUM(vsnprintf)
+TLI_HANDLE_STRING("vsnprintf")
+/// int vsprintf(char *s, const char *format, va_list ap);
+TLI_HANDLE_ENUM(vsprintf)
+TLI_HANDLE_STRING("vsprintf")
+/// int vsscanf(const char *s, const char *format, va_list arg);
+TLI_HANDLE_ENUM(vsscanf)
+TLI_HANDLE_STRING("vsscanf")
+/// ssize_t write(int fildes, const void *buf, size_t nbyte);
+TLI_HANDLE_ENUM(write)
+TLI_HANDLE_STRING("write")
+
+#undef TLI_HANDLE_ENUM
+#undef TLI_HANDLE_STRING
Index: lib/Analysis/TargetLibraryInfo.cpp
===================================================================
--- lib/Analysis/TargetLibraryInfo.cpp
+++ lib/Analysis/TargetLibraryInfo.cpp
@@ -17,336 +17,8 @@
 
 const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
   {
-    "_IO_getc",
-    "_IO_putc",
-    "_ZdaPv",
-    "_ZdaPvRKSt9nothrow_t",
-    "_ZdaPvj",
-    "_ZdaPvm",
-    "_ZdlPv",
-    "_ZdlPvRKSt9nothrow_t",
-    "_ZdlPvj",
-    "_ZdlPvm",
-    "_Znaj",
-    "_ZnajRKSt9nothrow_t",
-    "_Znam",
-    "_ZnamRKSt9nothrow_t",
-    "_Znwj",
-    "_ZnwjRKSt9nothrow_t",
-    "_Znwm",
-    "_ZnwmRKSt9nothrow_t",
-    "__cospi",
-    "__cospif",
-    "__cxa_atexit",
-    "__cxa_guard_abort",
-    "__cxa_guard_acquire",
-    "__cxa_guard_release",
-    "__isoc99_scanf",
-    "__isoc99_sscanf",
-    "__memcpy_chk",
-    "__memmove_chk",
-    "__memset_chk",
-    "__sincospi_stret",
-    "__sincospif_stret",
-    "__sinpi",
-    "__sinpif",
-    "__sqrt_finite",
-    "__sqrtf_finite",
-    "__sqrtl_finite",
-    "__stpcpy_chk",
-    "__stpncpy_chk",
-    "__strcpy_chk",
-    "__strdup",
-    "__strncpy_chk",
-    "__strndup",
-    "__strtok_r",
-    "abs",
-    "access",
-    "acos",
-    "acosf",
-    "acosh",
-    "acoshf",
-    "acoshl",
-    "acosl",
-    "asin",
-    "asinf",
-    "asinh",
-    "asinhf",
-    "asinhl",
-    "asinl",
-    "atan",
-    "atan2",
-    "atan2f",
-    "atan2l",
-    "atanf",
-    "atanh",
-    "atanhf",
-    "atanhl",
-    "atanl",
-    "atof",
-    "atoi",
-    "atol",
-    "atoll",
-    "bcmp",
-    "bcopy",
-    "bzero",
-    "calloc",
-    "cbrt",
-    "cbrtf",
-    "cbrtl",
-    "ceil",
-    "ceilf",
-    "ceill",
-    "chmod",
-    "chown",
-    "clearerr",
-    "closedir",
-    "copysign",
-    "copysignf",
-    "copysignl",
-    "cos",
-    "cosf",
-    "cosh",
-    "coshf",
-    "coshl",
-    "cosl",
-    "ctermid",
-    "exp",
-    "exp10",
-    "exp10f",
-    "exp10l",
-    "exp2",
-    "exp2f",
-    "exp2l",
-    "expf",
-    "expl",
-    "expm1",
-    "expm1f",
-    "expm1l",
-    "fabs",
-    "fabsf",
-    "fabsl",
-    "fclose",
-    "fdopen",
-    "feof",
-    "ferror",
-    "fflush",
-    "ffs",
-    "ffsl",
-    "ffsll",
-    "fgetc",
-    "fgetpos",
-    "fgets",
-    "fileno",
-    "fiprintf",
-    "flockfile",
-    "floor",
-    "floorf",
-    "floorl",
-    "fmax",
-    "fmaxf",
-    "fmaxl",
-    "fmin",
-    "fminf",
-    "fminl",
-    "fmod",
-    "fmodf",
-    "fmodl",
-    "fopen",
-    "fopen64",
-    "fprintf",
-    "fputc",
-    "fputs",
-    "fread",
-    "free",
-    "frexp",
-    "frexpf",
-    "frexpl",
-    "fscanf",
-    "fseek",
-    "fseeko",
-    "fseeko64",
-    "fsetpos",
-    "fstat",
-    "fstat64",
-    "fstatvfs",
-    "fstatvfs64",
-    "ftell",
-    "ftello",
-    "ftello64",
-    "ftrylockfile",
-    "funlockfile",
-    "fwrite",
-    "getc",
-    "getc_unlocked",
-    "getchar",
-    "getenv",
-    "getitimer",
-    "getlogin_r",
-    "getpwnam",
-    "gets",
-    "gettimeofday",
-    "htonl",
-    "htons",
-    "iprintf",
-    "isascii",
-    "isdigit",
-    "labs",
-    "lchown",
-    "ldexp",
-    "ldexpf",
-    "ldexpl",
-    "llabs",
-    "log",
-    "log10",
-    "log10f",
-    "log10l",
-    "log1p",
-    "log1pf",
-    "log1pl",
-    "log2",
-    "log2f",
-    "log2l",
-    "logb",
-    "logbf",
-    "logbl",
-    "logf",
-    "logl",
-    "lstat",
-    "lstat64",
-    "malloc",
-    "memalign",
-    "memccpy",
-    "memchr",
-    "memcmp",
-    "memcpy",
-    "memmove",
-    "memrchr",
-    "memset",
-    "memset_pattern16",
-    "mkdir",
-    "mktime",
-    "modf",
-    "modff",
-    "modfl",
-    "nearbyint",
-    "nearbyintf",
-    "nearbyintl",
-    "ntohl",
-    "ntohs",
-    "open",
-    "open64",
-    "opendir",
-    "pclose",
-    "perror",
-    "popen",
-    "posix_memalign",
-    "pow",
-    "powf",
-    "powl",
-    "pread",
-    "printf",
-    "putc",
-    "putchar",
-    "puts",
-    "pwrite",
-    "qsort",
-    "read",
-    "readlink",
-    "realloc",
-    "reallocf",
-    "realpath",
-    "remove",
-    "rename",
-    "rewind",
-    "rint",
-    "rintf",
-    "rintl",
-    "rmdir",
-    "round",
-    "roundf",
-    "roundl",
-    "scanf",
-    "setbuf",
-    "setitimer",
-    "setvbuf",
-    "sin",
-    "sinf",
-    "sinh",
-    "sinhf",
-    "sinhl",
-    "sinl",
-    "siprintf",
-    "snprintf",
-    "sprintf",
-    "sqrt",
-    "sqrtf",
-    "sqrtl",
-    "sscanf",
-    "stat",
-    "stat64",
-    "statvfs",
-    "statvfs64",
-    "stpcpy",
-    "stpncpy",
-    "strcasecmp",
-    "strcat",
-    "strchr",
-    "strcmp",
-    "strcoll",
-    "strcpy",
-    "strcspn",
-    "strdup",
-    "strlen",
-    "strncasecmp",
-    "strncat",
-    "strncmp",
-    "strncpy",
-    "strndup",
-    "strnlen",
-    "strpbrk",
-    "strrchr",
-    "strspn",
-    "strstr",
-    "strtod",
-    "strtof",
-    "strtok",
-    "strtok_r",
-    "strtol",
-    "strtold",
-    "strtoll",
-    "strtoul",
-    "strtoull",
-    "strxfrm",
-    "system",
-    "tan",
-    "tanf",
-    "tanh",
-    "tanhf",
-    "tanhl",
-    "tanl",
-    "times",
-    "tmpfile",
-    "tmpfile64",
-    "toascii",
-    "trunc",
-    "truncf",
-    "truncl",
-    "uname",
-    "ungetc",
-    "unlink",
-    "unsetenv",
-    "utime",
-    "utimes",
-    "valloc",
-    "vfprintf",
-    "vfscanf",
-    "vprintf",
-    "vscanf",
-    "vsnprintf",
-    "vsprintf",
-    "vsscanf",
-    "write"
+#define TLI_HANDLE_STRING(string_repr) string_repr,
+#include "llvm/Analysis/TargetLibraryInfo.def"
   };
 
 static bool hasSinCosPiStret(const Triple &T) {