[PATCH v2] Add more functions to the TLI.

Hal Finkel hfinkel at anl.gov
Mon Feb 25 13:57:16 PST 2013


----- Original Message -----
> From: "Meador Inge" <meadori at codesourcery.com>
> To: llvm-commits at cs.uiuc.edu
> Sent: Monday, February 25, 2013 3:39:40 PM
> Subject: Re: [PATCH v2] Add more functions to the TLI.
> 
> Ping.

FWIW, I have no further suggestions for this patch. I am not sufficiently familiar, however, with the motivating refactoring, and so I don't feel qualified to approve.

 -Hal

> 
> On 02/21/2013 12:37 PM, Meador Inge wrote:
> > This patch adds many more functions to the target library
> > information.
> > All of the functions being added were discovered while doing the
> > migration
> > of the simplify-libcalls attribute annotation functionality to the
> > functionattrs pass.  As a part of that work the attribute
> > annotation logic
> > will query TLI to determine if a function should be annotated or
> > not.
> > 
> > OK?
> > 
> > Signed-off-by: Meador Inge <meadori at codesourcery.com>
> > ---
> > Changes since v1:
> > 
> >    * After a discussion with Hal Finkel I decided to not explicitly
> >    enumerate
> >      the \01 prefixed functions in the TLI.  Now I just strip \01
> >      prefix in
> >      'getLibFunc' so that it works for all prefixed functions.
> > 
> >  include/llvm/Target/TargetLibraryInfo.h | 253
> >  ++++++++++++++++++++++++++++++++
> >  lib/Target/TargetLibraryInfo.cpp        | 221
> >  ++++++++++++++++++++++++++--
> >  2 files changed, 465 insertions(+), 9 deletions(-)
> > 
> > diff --git a/include/llvm/Target/TargetLibraryInfo.h
> > b/include/llvm/Target/TargetLibraryInfo.h
> > index ceeba4f..5f01c8d 100644
> > --- a/include/llvm/Target/TargetLibraryInfo.h
> > +++ b/include/llvm/Target/TargetLibraryInfo.h
> > @@ -18,6 +18,10 @@ namespace llvm {
> >  
> >    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*);
> > @@ -47,10 +51,22 @@ namespace llvm {
> >        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,
> > +      /// char * __strdup(const char *s);
> > +      dunder_strdup,
> > +      /// 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);
> > @@ -93,6 +109,20 @@ namespace llvm {
> >        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);
> > @@ -107,6 +137,14 @@ namespace llvm {
> >        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);
> > @@ -125,6 +163,8 @@ namespace llvm {
> >        coshl,
> >        /// long double cosl(long double x);
> >        cosl,
> > +      /// char *ctermid(char *s);
> > +      ctermid,
> >        /// double exp(double x);
> >        exp,
> >        /// double exp10(double x);
> > @@ -155,14 +195,34 @@ namespace llvm {
> >        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);
> > @@ -175,17 +235,77 @@ namespace llvm {
> >        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,
> > +      /// uint32_t htonl(uint32_t hostlong);
> > +      htonl,
> > +      /// uint16_t htons(uint16_t hostshort);
> > +      htons,
> >        /// int iprintf(const char *format, ...);
> >        iprintf,
> >        /// int isascii(int c);
> > @@ -194,6 +314,8 @@ namespace llvm {
> >        isdigit,
> >        /// long int labs(long int j);
> >        labs,
> > +      /// int lchown(const char *path, uid_t owner, gid_t group);
> > +      lchown,
> >        /// long long int llabs(long long int j);
> >        llabs,
> >        /// double log(double x);
> > @@ -226,8 +348,16 @@ namespace llvm {
> >        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);
> > @@ -236,16 +366,44 @@ namespace llvm {
> >        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);
> > @@ -254,28 +412,61 @@ namespace llvm {
> >        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);
> > @@ -290,6 +481,8 @@ namespace llvm {
> >        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);
> > @@ -298,14 +491,30 @@ namespace llvm {
> >        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);
> > @@ -314,6 +523,8 @@ namespace llvm {
> >        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);
> > @@ -336,6 +547,10 @@ namespace llvm {
> >        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);
> > @@ -347,6 +562,10 @@ namespace llvm {
> >        /// 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);
> > @@ -359,6 +578,12 @@ namespace llvm {
> >        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);
> > @@ -367,8 +592,36 @@ namespace llvm {
> >        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,
> >  
> >        NumLibFuncs
> >      };
> > diff --git a/lib/Target/TargetLibraryInfo.cpp
> > b/lib/Target/TargetLibraryInfo.cpp
> > index 3a9ace4..e5fdce2 100644
> > --- a/lib/Target/TargetLibraryInfo.cpp
> > +++ b/lib/Target/TargetLibraryInfo.cpp
> > @@ -24,6 +24,8 @@ void TargetLibraryInfo::anchor() { }
> >  
> >  const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs]
> >  =
> >    {
> > +    "_IO_getc",
> > +    "_IO_putc",
> >      "_ZdaPv",
> >      "_ZdlPv",
> >      "_Znaj",
> > @@ -38,8 +40,14 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "__cxa_guard_abort",
> >      "__cxa_guard_acquire",
> >      "__cxa_guard_release",
> > +    "__isoc99_scanf",
> > +    "__isoc99_sscanf",
> >      "__memcpy_chk",
> > +    "__strdup",
> > +    "__strndup",
> > +    "__strtok_r",
> >      "abs",
> > +    "access",
> >      "acos",
> >      "acosf",
> >      "acosh",
> > @@ -61,6 +69,13 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "atanhf",
> >      "atanhl",
> >      "atanl",
> > +    "atof",
> > +    "atoi",
> > +    "atol",
> > +    "atoll",
> > +    "bcmp",
> > +    "bcopy",
> > +    "bzero",
> >      "calloc",
> >      "cbrt",
> >      "cbrtf",
> > @@ -68,6 +83,10 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "ceil",
> >      "ceilf",
> >      "ceill",
> > +    "chmod",
> > +    "chown",
> > +    "clearerr",
> > +    "closedir",
> >      "copysign",
> >      "copysignf",
> >      "copysignl",
> > @@ -77,6 +96,7 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "coshf",
> >      "coshl",
> >      "cosl",
> > +    "ctermid",
> >      "exp",
> >      "exp10",
> >      "exp10f",
> > @@ -92,25 +112,66 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "fabs",
> >      "fabsf",
> >      "fabsl",
> > +    "fclose",
> > +    "fdopen",
> > +    "feof",
> > +    "ferror",
> > +    "fflush",
> >      "ffs",
> >      "ffsl",
> >      "ffsll",
> > +    "fgetc",
> > +    "fgetpos",
> > +    "fgets",
> > +    "fileno",
> >      "fiprintf",
> > +    "flockfile",
> >      "floor",
> >      "floorf",
> >      "floorl",
> >      "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",
> > +    "htonl",
> > +    "htons",
> >      "iprintf",
> >      "isascii",
> >      "isdigit",
> >      "labs",
> > +    "lchown",
> >      "llabs",
> >      "log",
> >      "log10",
> > @@ -127,31 +188,64 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "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",
> > @@ -159,18 +253,28 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "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",
> > @@ -182,22 +286,43 @@ const char*
> > TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> >      "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",
> > -    "valloc"
> > +    "uname",
> > +    "ungetc",
> > +    "unlink",
> > +    "unsetenv",
> > +    "utime",
> > +    "utimes",
> > +    "valloc",
> > +    "vfprintf",
> > +    "vfscanf",
> > +    "vprintf",
> > +    "vscanf",
> > +    "vsnprintf",
> > +    "vsprintf",
> > +    "vsscanf",
> > +    "write"
> >    };
> >  
> >  /// initialize - Initialize the set of available library functions
> >  based on the
> > @@ -259,7 +384,9 @@ static void initialize(TargetLibraryInfo &TLI,
> > const Triple &T,
> >      TLI.setUnavailable(LibFunc::fabsl);
> >      TLI.setUnavailable(LibFunc::floorl);
> >      TLI.setUnavailable(LibFunc::fmodl);
> > +    TLI.setUnavailable(LibFunc::frexpl);
> >      TLI.setUnavailable(LibFunc::logl);
> > +    TLI.setUnavailable(LibFunc::modfl);
> >      TLI.setUnavailable(LibFunc::powl);
> >      TLI.setUnavailable(LibFunc::sinl);
> >      TLI.setUnavailable(LibFunc::sinhl);
> > @@ -336,16 +463,67 @@ static void initialize(TargetLibraryInfo
> > &TLI, const Triple &T,
> >        TLI.setUnavailable(LibFunc::tanhf);
> >      }
> >  
> > -    // Win32 does *not* provide stpcpy.  It is provided on POSIX
> > systems:
> > -    //
> > http://pubs.opengroup.org/onlinepubs/9699919799/functions/stpcpy.html
> > -    TLI.setUnavailable(LibFunc::stpcpy);
> > -
> > -    // Win32 does *not* provide ffs.  It is provided on POSIX
> > systems:
> > -    //
> > http://pubs.opengroup.org/onlinepubs/009695399/functions/ffs.html
> > +    // Win32 does *not* provide provide these functions, but they
> > are
> > +    // generally available on POSIX-compliant systems:
> > +    TLI.setUnavailable(LibFunc::access);
> > +    TLI.setUnavailable(LibFunc::bcmp);
> > +    TLI.setUnavailable(LibFunc::bcopy);
> > +    TLI.setUnavailable(LibFunc::bzero);
> > +    TLI.setUnavailable(LibFunc::chmod);
> > +    TLI.setUnavailable(LibFunc::chown);
> > +    TLI.setUnavailable(LibFunc::closedir);
> > +    TLI.setUnavailable(LibFunc::ctermid);
> > +    TLI.setUnavailable(LibFunc::fdopen);
> >      TLI.setUnavailable(LibFunc::ffs);
> > +    TLI.setUnavailable(LibFunc::fileno);
> > +    TLI.setUnavailable(LibFunc::flockfile);
> > +    TLI.setUnavailable(LibFunc::fseeko);
> > +    TLI.setUnavailable(LibFunc::fstat);
> > +    TLI.setUnavailable(LibFunc::fstatvfs);
> > +    TLI.setUnavailable(LibFunc::ftello);
> > +    TLI.setUnavailable(LibFunc::ftrylockfile);
> > +    TLI.setUnavailable(LibFunc::funlockfile);
> > +    TLI.setUnavailable(LibFunc::getc_unlocked);
> > +    TLI.setUnavailable(LibFunc::getitimer);
> > +    TLI.setUnavailable(LibFunc::getlogin_r);
> > +    TLI.setUnavailable(LibFunc::getpwnam);
> > +    TLI.setUnavailable(LibFunc::htonl);
> > +    TLI.setUnavailable(LibFunc::htons);
> > +    TLI.setUnavailable(LibFunc::lchown);
> > +    TLI.setUnavailable(LibFunc::lstat);
> > +    TLI.setUnavailable(LibFunc::memccpy);
> > +    TLI.setUnavailable(LibFunc::mkdir);
> > +    TLI.setUnavailable(LibFunc::ntohl);
> > +    TLI.setUnavailable(LibFunc::ntohs);
> > +    TLI.setUnavailable(LibFunc::open);
> > +    TLI.setUnavailable(LibFunc::opendir);
> > +    TLI.setUnavailable(LibFunc::pclose);
> > +    TLI.setUnavailable(LibFunc::popen);
> > +    TLI.setUnavailable(LibFunc::pread);
> > +    TLI.setUnavailable(LibFunc::pwrite);
> > +    TLI.setUnavailable(LibFunc::read);
> > +    TLI.setUnavailable(LibFunc::readlink);
> > +    TLI.setUnavailable(LibFunc::realpath);
> > +    TLI.setUnavailable(LibFunc::rmdir);
> > +    TLI.setUnavailable(LibFunc::setitimer);
> > +    TLI.setUnavailable(LibFunc::stat);
> > +    TLI.setUnavailable(LibFunc::statvfs);
> > +    TLI.setUnavailable(LibFunc::stpcpy);
> > +    TLI.setUnavailable(LibFunc::stpncpy);
> > +    TLI.setUnavailable(LibFunc::strcasecmp);
> > +    TLI.setUnavailable(LibFunc::strncasecmp);
> > +    TLI.setUnavailable(LibFunc::times);
> > +    TLI.setUnavailable(LibFunc::uname);
> > +    TLI.setUnavailable(LibFunc::unlink);
> > +    TLI.setUnavailable(LibFunc::unsetenv);
> > +    TLI.setUnavailable(LibFunc::utime);
> > +    TLI.setUnavailable(LibFunc::utimes);
> > +    TLI.setUnavailable(LibFunc::write);
> >  
> > -    // Win32 does *not* provide llabs.  It is defined in ISO/IEC
> > 9899:1999,
> > -    // but Visual C++ does not support it.
> > +    // Win32 does *not* provide provide these functions, but they
> > are
> > +    // specified by C99:
> > +    TLI.setUnavailable(LibFunc::atoll);
> > +    TLI.setUnavailable(LibFunc::frexpf);
> >      TLI.setUnavailable(LibFunc::llabs);
> >    }
> >  
> > @@ -375,6 +553,27 @@ static void initialize(TargetLibraryInfo &TLI,
> > const Triple &T,
> >    default:
> >      TLI.setUnavailable(LibFunc::ffsll);
> >    }
> > +
> > +  // The following functions are available on at least Linux:
> > +  if (T.getOS() != Triple::Linux) {
> > +    TLI.setUnavailable(LibFunc::dunder_strdup);
> > +    TLI.setUnavailable(LibFunc::dunder_strtok_r);
> > +    TLI.setUnavailable(LibFunc::dunder_isoc99_scanf);
> > +    TLI.setUnavailable(LibFunc::dunder_isoc99_sscanf);
> > +    TLI.setUnavailable(LibFunc::under_IO_getc);
> > +    TLI.setUnavailable(LibFunc::under_IO_putc);
> > +    TLI.setUnavailable(LibFunc::memalign);
> > +    TLI.setUnavailable(LibFunc::fopen64);
> > +    TLI.setUnavailable(LibFunc::fseeko64);
> > +    TLI.setUnavailable(LibFunc::fstat64);
> > +    TLI.setUnavailable(LibFunc::fstatvfs64);
> > +    TLI.setUnavailable(LibFunc::ftello64);
> > +    TLI.setUnavailable(LibFunc::lstat64);
> > +    TLI.setUnavailable(LibFunc::open64);
> > +    TLI.setUnavailable(LibFunc::stat64);
> > +    TLI.setUnavailable(LibFunc::statvfs64);
> > +    TLI.setUnavailable(LibFunc::tmpfile64);
> > +  }
> >  }
> >  
> >  
> > @@ -402,6 +601,10 @@ bool TargetLibraryInfo::getLibFunc(StringRef
> > funcName,
> >                                     LibFunc::Func &F) const {
> >    const char **Start = &StandardNames[0];
> >    const char **End = &StandardNames[LibFunc::NumLibFuncs];
> > +  // Check for \01 prefix that is used to mangle __asm
> > declarations and
> > +  // strip it if present.
> > +  if (!funcName.empty() && funcName.front() == '\01')
> > +    funcName = funcName.substr(1);
> >    const char **I = std::lower_bound(Start, End, funcName);
> >    if (I != End && *I == funcName) {
> >      F = (LibFunc::Func)(I - Start);
> > 
> 
> 
> --
> Meador Inge
> CodeSourcery / Mentor Embedded
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
> 



More information about the llvm-commits mailing list