llvm-6502/include/llvm/Target/TargetLibraryInfo.h
Benjamin Kramer fb0ad6bd15 SimplifyLibCalls: Push TLI through the exp2->ldexp transform.
For the odd case of platforms with exp2 available but not ldexp.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@200795 91177308-0d34-0410-b5e6-96231b3b80d8
2014-02-04 20:27:23 +00:00

780 lines
24 KiB
C++

//===-- llvm/Target/TargetLibraryInfo.h - 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 LLVM_TARGET_TARGETLIBRARYINFO_H
#define LLVM_TARGET_TARGETLIBRARYINFO_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/Pass.h"
namespace llvm {
class Triple;
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*);
ZdlPv,
/// void operator delete(void*, nothrow);
ZdlPvRKSt9nothrow_t,
/// 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,
/// 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 * __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);
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,
NumLibFuncs
};
}
/// TargetLibraryInfo - This immutable pass captures information about what
/// library functions are available for the current target, and allows a
/// frontend to disable optimizations through -fno-builtin etc.
class TargetLibraryInfo : public ImmutablePass {
virtual void anchor();
unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
llvm::DenseMap<unsigned, std::string> CustomNames;
static const char* StandardNames[LibFunc::NumLibFuncs];
enum AvailabilityState {
StandardName = 3, // (memset to all ones)
CustomName = 1,
Unavailable = 0 // (memset to all zeros)
};
void setState(LibFunc::Func F, AvailabilityState State) {
AvailableArray[F/4] &= ~(3 << 2*(F&3));
AvailableArray[F/4] |= State << 2*(F&3);
}
AvailabilityState getState(LibFunc::Func F) const {
return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
}
public:
static char ID;
TargetLibraryInfo();
TargetLibraryInfo(const Triple &T);
explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
/// getLibFunc - Search for a particular function name. If it is one of the
/// known library functions, return true and set F to the corresponding value.
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
/// has - This function is used by optimizations that want to match on or form
/// a given library function.
bool has(LibFunc::Func F) const {
return getState(F) != Unavailable;
}
/// hasOptimizedCodeGen - Return true if the function is both available as
/// a builtin and a candidate for optimized code generation.
bool hasOptimizedCodeGen(LibFunc::Func F) const {
if (getState(F) == Unavailable)
return false;
switch (F) {
default: break;
case LibFunc::copysign: case LibFunc::copysignf: case LibFunc::copysignl:
case LibFunc::fabs: case LibFunc::fabsf: case LibFunc::fabsl:
case LibFunc::sin: case LibFunc::sinf: case LibFunc::sinl:
case LibFunc::cos: case LibFunc::cosf: case LibFunc::cosl:
case LibFunc::sqrt: case LibFunc::sqrtf: case LibFunc::sqrtl:
case LibFunc::sqrt_finite: case LibFunc::sqrtf_finite:
case LibFunc::sqrtl_finite:
case LibFunc::fmax: case LibFunc::fmaxf: case LibFunc::fmaxl:
case LibFunc::fmin: case LibFunc::fminf: case LibFunc::fminl:
case LibFunc::floor: case LibFunc::floorf: case LibFunc::floorl:
case LibFunc::nearbyint: case LibFunc::nearbyintf: case LibFunc::nearbyintl:
case LibFunc::ceil: case LibFunc::ceilf: case LibFunc::ceill:
case LibFunc::rint: case LibFunc::rintf: case LibFunc::rintl:
case LibFunc::round: case LibFunc::roundf: case LibFunc::roundl:
case LibFunc::trunc: case LibFunc::truncf: case LibFunc::truncl:
case LibFunc::log2: case LibFunc::log2f: case LibFunc::log2l:
case LibFunc::exp2: case LibFunc::exp2f: case LibFunc::exp2l:
case LibFunc::memcmp: case LibFunc::strcmp: case LibFunc::strcpy:
case LibFunc::stpcpy: case LibFunc::strlen: case LibFunc::strnlen:
case LibFunc::memchr:
return true;
}
return false;
}
StringRef getName(LibFunc::Func F) const {
AvailabilityState State = getState(F);
if (State == Unavailable)
return StringRef();
if (State == StandardName)
return StandardNames[F];
assert(State == CustomName);
return CustomNames.find(F)->second;
}
/// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
/// ban use of specific library functions.
void setUnavailable(LibFunc::Func F) {
setState(F, Unavailable);
}
void setAvailable(LibFunc::Func F) {
setState(F, StandardName);
}
void setAvailableWithName(LibFunc::Func F, StringRef Name) {
if (StandardNames[F] != Name) {
setState(F, CustomName);
CustomNames[F] = Name;
assert(CustomNames.find(F) != CustomNames.end());
} else {
setState(F, StandardName);
}
}
/// disableAllFunctions - This disables all builtins, which is used for
/// options like -fno-builtin.
void disableAllFunctions();
};
} // end namespace llvm
#endif