This is an archive of the discontinued LLVM Phabricator instance.

Move TargetLibraryInfo data from two files into one common .def file.
ClosedPublic

Authored by jvoung on Feb 23 2015, 5:25 PM.

Download Raw Diff

Details

Reviewers

Commits

rGcd3d25a25fbf: Move TargetLibraryInfo data from two files into one common .def file.
rL231172: Move TargetLibraryInfo data from two files into one common .def file.

Summary

This makes it more obvious that the enum definition and the
"StandardName" array is in sync. Mechanically refactored w/ a
python script.

Diff Detail

Event Timeline

jvoung updated this revision to Diff 20558.Feb 23 2015, 5:25 PM

jvoung retitled this revision from to Move TargetLibraryInfo data from two files into one common .def file..

jvoung updated this object.

jvoung edited the test plan for this revision. (Show Details)

jvoung added a subscriber: Unknown Object (MLST).

Might be nicer to just have the user define whether or not they want TLI_enum or TLI_string for it?

-eric

Split into TLI_HANDLE_ENUM, TLI_HANDLE_STRING macros so user can opt in separately.

Hrm. I was thinking something more like:

#define TLI_HANDLE_ENUM
#include TargetLibraryInfo.def

and then inside have the actual definitions of how to handle them.

Probably want a check to make sure both aren't defined at once as well.

Thoughts?

-eric

Hmm, I don't have strong feelings either way, except that I think the enum and the string in the .def file should be clustered together so that it remains clear both are simultaneously defined whenever adding a TLI function.

I guess there is a spectrum of flexibility vs doing exactly what is needed for the current uses w/ strict error checking.

Most flexible: what I had before. Basically a for-each macro where the user can do whatever with the enum name and the string (e.g., could fill in a bunch of cases in a switch statement, not just define the enums / string table).

Middle: What I have now. Can't for-each on both the enum and the string simultaneously, but can for-each individually. This still has a bit of flexibility so that e.g., you can put the comma earlier or later

enum Func {

InvalidEnum

#define TLI_HANDLE_ENUM(enum_variant) , enum_variant
#include "llvm/Analysis/TargetLibraryInfo.def"
}

enum Func {
#define TLI_HANDLE_ENUM(enum_variant) enum_variant,
#include "llvm/Analysis/TargetLibraryInfo.def"

NumLibraryFuncs

}

Strict:
#define TLI_HANDLE_ENUM
#include "llvm/Analysis/TargetLibraryInfo.def"

And then internally, "llvm/Analysis/TargetLibraryInfo.def" will check that only one of the TLI_HANDLE_* are defined at a time, and probably define some other local macros so that we still get the clustering of the enum and the string in the .def file.

As far as consistency w/ other .def files, from some sample of the existing .def files, they seem to follow the "Middle" option, though I guess many .def files are used for more complicated constructs.

It's fine any of the ways you've got it, I'd gone toward strict just to make it easier to consume and reason about for now since there's no need for the flexibility (afaict), but any of them work.

Thanks!

-eric

Make the .def handle the definition details, and the .h/.cpp just do "#define TLI_DEFINE_ENUM ... #include ..."

Okay, strict sounds good to me. It should be pretty easy to switch to something more flexible later if needed.

LGTM. Thanks for the patience!

-eric

This revision is now accepted and ready to land.Mar 3 2015, 11:22 AM

Closed by commit rL231172: Move TargetLibraryInfo data from two files into one common .def file. (authored by jvoung). · Explain WhyMar 3 2015, 3:44 PM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

include/

llvm/

Analysis/

TargetLibraryInfo.h

671 lines

TargetLibraryInfo.def

1021 lines

lib/

Analysis/

TargetLibraryInfo.cpp

332 lines

Diff 20650

include/llvm/Analysis/TargetLibraryInfo.h

	Show All 16 Lines
	#include "llvm/IR/Module.h"			#include "llvm/IR/Module.h"
	#include "llvm/Pass.h"			#include "llvm/Pass.h"

	namespace llvm {			namespace llvm {
	class PreservedAnalyses;			class PreservedAnalyses;

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

	NumLibFuncs			NumLibFuncs
	};			};
	}			}

	/// \brief Implementation of the target library information.			/// \brief Implementation of the target library information.
	///			///
	/// This class constructs tables that hold the target library information and			/// This class constructs tables that hold the target library information and
	▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

include/llvm/Analysis/TargetLibraryInfo.def

This file was added.

				//===-- TargetLibraryInfo.def - Library information -------------- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#if !(defined(TLI_HANDLE_ENUM) \|\| defined(TLI_HANDLE_STRING))
				#error "Must define TLI_HANDLE_ENUM or TLI_HANDLE_STRING for TLI .def"
				#endif

				// This .def file will feed the enum variant name for each TLI function
				// to a user-defined macro TLI_HANDLE_ENUM, if present.
				// Otherwise default to nop.
				#ifndef TLI_HANDLE_ENUM
				#define TLI_HANDLE_ENUM(enum_variant)
				#endif

				// Similar, but feed each function's string representation.
				#ifndef TLI_HANDLE_STRING
				#define TLI_HANDLE_STRING(string_repr)
				#endif

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

				#undef TLI_HANDLE_ENUM
				#undef TLI_HANDLE_STRING

lib/Analysis/TargetLibraryInfo.cpp

	Show All 11 Lines
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "llvm/Analysis/TargetLibraryInfo.h"			#include "llvm/Analysis/TargetLibraryInfo.h"
	#include "llvm/ADT/Triple.h"			#include "llvm/ADT/Triple.h"
	using namespace llvm;			using namespace llvm;

	const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =			const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
	{			{
	"_IO_getc",			#define TLI_HANDLE_STRING(string_repr) string_repr,
	"_IO_putc",			#include "llvm/Analysis/TargetLibraryInfo.def"
	"_ZdaPv",
	"_ZdaPvRKSt9nothrow_t",
	"_ZdaPvj",
	"_ZdaPvm",
	"_ZdlPv",
	"_ZdlPvRKSt9nothrow_t",
	"_ZdlPvj",
	"_ZdlPvm",
	"_Znaj",
	"_ZnajRKSt9nothrow_t",
	"_Znam",
	"_ZnamRKSt9nothrow_t",
	"_Znwj",
	"_ZnwjRKSt9nothrow_t",
	"_Znwm",
	"_ZnwmRKSt9nothrow_t",
	"__cospi",
	"__cospif",
	"__cxa_atexit",
	"__cxa_guard_abort",
	"__cxa_guard_acquire",
	"__cxa_guard_release",
	"__isoc99_scanf",
	"__isoc99_sscanf",
	"__memcpy_chk",
	"__memmove_chk",
	"__memset_chk",
	"__sincospi_stret",
	"__sincospif_stret",
	"__sinpi",
	"__sinpif",
	"__sqrt_finite",
	"__sqrtf_finite",
	"__sqrtl_finite",
	"__stpcpy_chk",
	"__stpncpy_chk",
	"__strcpy_chk",
	"__strdup",
	"__strncpy_chk",
	"__strndup",
	"__strtok_r",
	"abs",
	"access",
	"acos",
	"acosf",
	"acosh",
	"acoshf",
	"acoshl",
	"acosl",
	"asin",
	"asinf",
	"asinh",
	"asinhf",
	"asinhl",
	"asinl",
	"atan",
	"atan2",
	"atan2f",
	"atan2l",
	"atanf",
	"atanh",
	"atanhf",
	"atanhl",
	"atanl",
	"atof",
	"atoi",
	"atol",
	"atoll",
	"bcmp",
	"bcopy",
	"bzero",
	"calloc",
	"cbrt",
	"cbrtf",
	"cbrtl",
	"ceil",
	"ceilf",
	"ceill",
	"chmod",
	"chown",
	"clearerr",
	"closedir",
	"copysign",
	"copysignf",
	"copysignl",
	"cos",
	"cosf",
	"cosh",
	"coshf",
	"coshl",
	"cosl",
	"ctermid",
	"exp",
	"exp10",
	"exp10f",
	"exp10l",
	"exp2",
	"exp2f",
	"exp2l",
	"expf",
	"expl",
	"expm1",
	"expm1f",
	"expm1l",
	"fabs",
	"fabsf",
	"fabsl",
	"fclose",
	"fdopen",
	"feof",
	"ferror",
	"fflush",
	"ffs",
	"ffsl",
	"ffsll",
	"fgetc",
	"fgetpos",
	"fgets",
	"fileno",
	"fiprintf",
	"flockfile",
	"floor",
	"floorf",
	"floorl",
	"fmax",
	"fmaxf",
	"fmaxl",
	"fmin",
	"fminf",
	"fminl",
	"fmod",
	"fmodf",
	"fmodl",
	"fopen",
	"fopen64",
	"fprintf",
	"fputc",
	"fputs",
	"fread",
	"free",
	"frexp",
	"frexpf",
	"frexpl",
	"fscanf",
	"fseek",
	"fseeko",
	"fseeko64",
	"fsetpos",
	"fstat",
	"fstat64",
	"fstatvfs",
	"fstatvfs64",
	"ftell",
	"ftello",
	"ftello64",
	"ftrylockfile",
	"funlockfile",
	"fwrite",
	"getc",
	"getc_unlocked",
	"getchar",
	"getenv",
	"getitimer",
	"getlogin_r",
	"getpwnam",
	"gets",
	"gettimeofday",
	"htonl",
	"htons",
	"iprintf",
	"isascii",
	"isdigit",
	"labs",
	"lchown",
	"ldexp",
	"ldexpf",
	"ldexpl",
	"llabs",
	"log",
	"log10",
	"log10f",
	"log10l",
	"log1p",
	"log1pf",
	"log1pl",
	"log2",
	"log2f",
	"log2l",
	"logb",
	"logbf",
	"logbl",
	"logf",
	"logl",
	"lstat",
	"lstat64",
	"malloc",
	"memalign",
	"memccpy",
	"memchr",
	"memcmp",
	"memcpy",
	"memmove",
	"memrchr",
	"memset",
	"memset_pattern16",
	"mkdir",
	"mktime",
	"modf",
	"modff",
	"modfl",
	"nearbyint",
	"nearbyintf",
	"nearbyintl",
	"ntohl",
	"ntohs",
	"open",
	"open64",
	"opendir",
	"pclose",
	"perror",
	"popen",
	"posix_memalign",
	"pow",
	"powf",
	"powl",
	"pread",
	"printf",
	"putc",
	"putchar",
	"puts",
	"pwrite",
	"qsort",
	"read",
	"readlink",
	"realloc",
	"reallocf",
	"realpath",
	"remove",
	"rename",
	"rewind",
	"rint",
	"rintf",
	"rintl",
	"rmdir",
	"round",
	"roundf",
	"roundl",
	"scanf",
	"setbuf",
	"setitimer",
	"setvbuf",
	"sin",
	"sinf",
	"sinh",
	"sinhf",
	"sinhl",
	"sinl",
	"siprintf",
	"snprintf",
	"sprintf",
	"sqrt",
	"sqrtf",
	"sqrtl",
	"sscanf",
	"stat",
	"stat64",
	"statvfs",
	"statvfs64",
	"stpcpy",
	"stpncpy",
	"strcasecmp",
	"strcat",
	"strchr",
	"strcmp",
	"strcoll",
	"strcpy",
	"strcspn",
	"strdup",
	"strlen",
	"strncasecmp",
	"strncat",
	"strncmp",
	"strncpy",
	"strndup",
	"strnlen",
	"strpbrk",
	"strrchr",
	"strspn",
	"strstr",
	"strtod",
	"strtof",
	"strtok",
	"strtok_r",
	"strtol",
	"strtold",
	"strtoll",
	"strtoul",
	"strtoull",
	"strxfrm",
	"system",
	"tan",
	"tanf",
	"tanh",
	"tanhf",
	"tanhl",
	"tanl",
	"times",
	"tmpfile",
	"tmpfile64",
	"toascii",
	"trunc",
	"truncf",
	"truncl",
	"uname",
	"ungetc",
	"unlink",
	"unsetenv",
	"utime",
	"utimes",
	"valloc",
	"vfprintf",
	"vfscanf",
	"vprintf",
	"vscanf",
	"vsnprintf",
	"vsprintf",
	"vsscanf",
	"write"
	};			};

	static bool hasSinCosPiStret(const Triple &T) {			static bool hasSinCosPiStret(const Triple &T) {
	// Only Darwin variants have _stret versions of combined trig functions.			// Only Darwin variants have _stret versions of combined trig functions.
	if (!T.isOSDarwin())			if (!T.isOSDarwin())
	return false;			return false;

	// The ABI is rather complicated on x86, so don't do anything special there.			// The ABI is rather complicated on x86, so don't do anything special there.
	▲ Show 20 Lines • Show All 453 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Move TargetLibraryInfo data from two files into one common .def file.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 20650

include/llvm/Analysis/TargetLibraryInfo.h

include/llvm/Analysis/TargetLibraryInfo.def

lib/Analysis/TargetLibraryInfo.cpp

Move TargetLibraryInfo data from two files into one common .def file.
ClosedPublic