[PATCH v2] Add more functions to the TLI.
Meador Inge
meadori at codesourcery.com
Mon Feb 25 13:39:40 PST 2013
Ping.
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
More information about the llvm-commits
mailing list