Enumerations

enum Func {
under_IO_getc, under_IO_putc, ZdaPv, ZdaPvRKSt9nothrow_t,
ZdlPv, ZdlPvRKSt9nothrow_t, 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,
dunder_isoc99_scanf, dunder_isoc99_sscanf, memcpy_chk, sincospi_stret,
sincospif_stret, sinpi, sinpif, sqrt_finite,
sqrtf_finite, sqrtl_finite, dunder_strdup, dunder_strndup,
dunder_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,
NumLibFuncs
}

Enumeration Type Documentation

enum llvm::LibFunc::Func

Enumerator:

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

Definition at line 20 of file TargetLibraryInfo.h.