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