LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TargetLibraryInfo.h
Go to the documentation of this file.
1 //===-- llvm/Target/TargetLibraryInfo.h - Library information ---*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_TARGET_TARGETLIBRARYINFO_H
11 #define LLVM_TARGET_TARGETLIBRARYINFO_H
12 
13 #include "llvm/ADT/DenseMap.h"
14 #include "llvm/Pass.h"
15 
16 namespace llvm {
17  class Triple;
18 
19  namespace LibFunc {
20  enum Func {
21  /// int _IO_getc(_IO_FILE * __fp);
23  /// int _IO_putc(int __c, _IO_FILE * __fp);
25  /// void operator delete[](void*);
27  /// void operator delete[](void*, nothrow);
29  /// void operator delete(void*);
31  /// void operator delete(void*, nothrow);
33  /// void *new[](unsigned int);
35  /// void *new[](unsigned int, nothrow);
37  /// void *new[](unsigned long);
39  /// void *new[](unsigned long, nothrow);
41  /// void *new(unsigned int);
43  /// void *new(unsigned int, nothrow);
45  /// void *new(unsigned long);
47  /// void *new(unsigned long, nothrow);
49  /// double __cospi(double x);
51  /// float __cospif(float x);
53  /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
55  /// void __cxa_guard_abort(guard_t *guard);
56  /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
58  /// int __cxa_guard_acquire(guard_t *guard);
60  /// void __cxa_guard_release(guard_t *guard);
62  /// int __isoc99_scanf (const char *format, ...)
64  /// int __isoc99_sscanf(const char *s, const char *format, ...)
66  /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
68  /// double __sincospi_stret(double x);
70  /// float __sincospi_stretf(float x);
72  /// double __sinpi(double x);
74  /// float __sinpif(float x);
76  /// double __sqrt_finite(double x);
78  /// float __sqrt_finite(float x);
80  /// long double __sqrt_finite(long double x);
82  /// char * __strdup(const char *s);
84  /// char *__strndup(const char *s, size_t n);
86  /// char * __strtok_r(char *s, const char *delim, char **save_ptr);
88  /// int abs(int j);
89  abs,
90  /// int access(const char *path, int amode);
92  /// double acos(double x);
94  /// float acosf(float x);
96  /// double acosh(double x);
98  /// float acoshf(float x);
100  /// long double acoshl(long double x);
102  /// long double acosl(long double x);
104  /// double asin(double x);
106  /// float asinf(float x);
108  /// double asinh(double x);
110  /// float asinhf(float x);
112  /// long double asinhl(long double x);
114  /// long double asinl(long double x);
116  /// double atan(double x);
118  /// double atan2(double y, double x);
120  /// float atan2f(float y, float x);
122  /// long double atan2l(long double y, long double x);
124  /// float atanf(float x);
126  /// double atanh(double x);
128  /// float atanhf(float x);
130  /// long double atanhl(long double x);
132  /// long double atanl(long double x);
134  /// double atof(const char *str);
136  /// int atoi(const char *str);
138  /// long atol(const char *str);
140  /// long long atoll(const char *nptr);
142  /// int bcmp(const void *s1, const void *s2, size_t n);
144  /// void bcopy(const void *s1, void *s2, size_t n);
146  /// void bzero(void *s, size_t n);
148  /// void *calloc(size_t count, size_t size);
150  /// double cbrt(double x);
152  /// float cbrtf(float x);
154  /// long double cbrtl(long double x);
156  /// double ceil(double x);
158  /// float ceilf(float x);
160  /// long double ceill(long double x);
162  /// int chmod(const char *path, mode_t mode);
164  /// int chown(const char *path, uid_t owner, gid_t group);
166  /// void clearerr(FILE *stream);
168  /// int closedir(DIR *dirp);
170  /// double copysign(double x, double y);
172  /// float copysignf(float x, float y);
174  /// long double copysignl(long double x, long double y);
176  /// double cos(double x);
178  /// float cosf(float x);
180  /// double cosh(double x);
182  /// float coshf(float x);
184  /// long double coshl(long double x);
186  /// long double cosl(long double x);
188  /// char *ctermid(char *s);
190  /// double exp(double x);
192  /// double exp10(double x);
194  /// float exp10f(float x);
196  /// long double exp10l(long double x);
198  /// double exp2(double x);
200  /// float exp2f(float x);
202  /// long double exp2l(long double x);
204  /// float expf(float x);
206  /// long double expl(long double x);
208  /// double expm1(double x);
210  /// float expm1f(float x);
212  /// long double expm1l(long double x);
214  /// double fabs(double x);
216  /// float fabsf(float x);
218  /// long double fabsl(long double x);
220  /// int fclose(FILE *stream);
222  /// FILE *fdopen(int fildes, const char *mode);
224  /// int feof(FILE *stream);
226  /// int ferror(FILE *stream);
228  /// int fflush(FILE *stream);
230  /// int ffs(int i);
232  /// int ffsl(long int i);
234  /// int ffsll(long long int i);
236  /// int fgetc(FILE *stream);
238  /// int fgetpos(FILE *stream, fpos_t *pos);
240  /// char *fgets(char *s, int n, FILE *stream);
242  /// int fileno(FILE *stream);
244  /// int fiprintf(FILE *stream, const char *format, ...);
246  /// void flockfile(FILE *file);
248  /// double floor(double x);
250  /// float floorf(float x);
252  /// long double floorl(long double x);
254  /// double fmod(double x, double y);
256  /// float fmodf(float x, float y);
258  /// long double fmodl(long double x, long double y);
260  /// FILE *fopen(const char *filename, const char *mode);
262  /// FILE *fopen64(const char *filename, const char *opentype)
264  /// int fprintf(FILE *stream, const char *format, ...);
266  /// int fputc(int c, FILE *stream);
268  /// int fputs(const char *s, FILE *stream);
270  /// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
272  /// void free(void *ptr);
274  /// double frexp(double num, int *exp);
276  /// float frexpf(float num, int *exp);
278  /// long double frexpl(long double num, int *exp);
280  /// int fscanf(FILE *stream, const char *format, ... );
282  /// int fseek(FILE *stream, long offset, int whence);
284  /// int fseeko(FILE *stream, off_t offset, int whence);
286  /// int fseeko64(FILE *stream, off64_t offset, int whence)
288  /// int fsetpos(FILE *stream, const fpos_t *pos);
290  /// int fstat(int fildes, struct stat *buf);
292  /// int fstat64(int filedes, struct stat64 *buf)
294  /// int fstatvfs(int fildes, struct statvfs *buf);
296  /// int fstatvfs64(int fildes, struct statvfs64 *buf);
298  /// long ftell(FILE *stream);
300  /// off_t ftello(FILE *stream);
302  /// off64_t ftello64(FILE *stream)
304  /// int ftrylockfile(FILE *file);
306  /// void funlockfile(FILE *file);
308  /// size_t fwrite(const void *ptr, size_t size, size_t nitems,
309  /// FILE *stream);
311  /// int getc(FILE *stream);
313  /// int getc_unlocked(FILE *stream);
315  /// int getchar(void);
317  /// char *getenv(const char *name);
319  /// int getitimer(int which, struct itimerval *value);
321  /// int getlogin_r(char *name, size_t namesize);
323  /// struct passwd *getpwnam(const char *name);
325  /// char *gets(char *s);
327  /// int gettimeofday(struct timeval *tp, void *tzp);
329  /// uint32_t htonl(uint32_t hostlong);
331  /// uint16_t htons(uint16_t hostshort);
333  /// int iprintf(const char *format, ...);
335  /// int isascii(int c);
337  /// int isdigit(int c);
339  /// long int labs(long int j);
341  /// int lchown(const char *path, uid_t owner, gid_t group);
343  /// long long int llabs(long long int j);
345  /// double log(double x);
347  /// double log10(double x);
349  /// float log10f(float x);
351  /// long double log10l(long double x);
353  /// double log1p(double x);
355  /// float log1pf(float x);
357  /// long double log1pl(long double x);
359  /// double log2(double x);
361  /// float log2f(float x);
363  /// double long double log2l(long double x);
365  /// double logb(double x);
367  /// float logbf(float x);
369  /// long double logbl(long double x);
371  /// float logf(float x);
373  /// long double logl(long double x);
375  /// int lstat(const char *path, struct stat *buf);
377  /// int lstat64(const char *path, struct stat64 *buf);
379  /// void *malloc(size_t size);
381  /// void *memalign(size_t boundary, size_t size);
383  /// void *memccpy(void *s1, const void *s2, int c, size_t n);
385  /// void *memchr(const void *s, int c, size_t n);
387  /// int memcmp(const void *s1, const void *s2, size_t n);
389  /// void *memcpy(void *s1, const void *s2, size_t n);
391  /// void *memmove(void *s1, const void *s2, size_t n);
393  // void *memrchr(const void *s, int c, size_t n);
395  /// void *memset(void *b, int c, size_t len);
397  /// void memset_pattern16(void *b, const void *pattern16, size_t len);
399  /// int mkdir(const char *path, mode_t mode);
401  /// time_t mktime(struct tm *timeptr);
403  /// double modf(double x, double *iptr);
405  /// float modff(float, float *iptr);
407  /// long double modfl(long double value, long double *iptr);
409  /// double nearbyint(double x);
411  /// float nearbyintf(float x);
413  /// long double nearbyintl(long double x);
415  /// uint32_t ntohl(uint32_t netlong);
417  /// uint16_t ntohs(uint16_t netshort);
419  /// int open(const char *path, int oflag, ... );
421  /// int open64(const char *filename, int flags[, mode_t mode])
423  /// DIR *opendir(const char *dirname);
425  /// int pclose(FILE *stream);
427  /// void perror(const char *s);
429  /// FILE *popen(const char *command, const char *mode);
431  /// int posix_memalign(void **memptr, size_t alignment, size_t size);
433  /// double pow(double x, double y);
435  /// float powf(float x, float y);
437  /// long double powl(long double x, long double y);
439  /// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
441  /// int printf(const char *format, ...);
443  /// int putc(int c, FILE *stream);
445  /// int putchar(int c);
447  /// int puts(const char *s);
449  /// ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
450  /// off_t offset);
452  /// void qsort(void *base, size_t nel, size_t width,
453  /// int (*compar)(const void *, const void *));
455  /// ssize_t read(int fildes, void *buf, size_t nbyte);
457  /// ssize_t readlink(const char *path, char *buf, size_t bufsize);
459  /// void *realloc(void *ptr, size_t size);
461  /// void *reallocf(void *ptr, size_t size);
463  /// char *realpath(const char *file_name, char *resolved_name);
465  /// int remove(const char *path);
466  remove,
467  /// int rename(const char *old, const char *new);
469  /// void rewind(FILE *stream);
471  /// double rint(double x);
473  /// float rintf(float x);
475  /// long double rintl(long double x);
477  /// int rmdir(const char *path);
479  /// double round(double x);
481  /// float roundf(float x);
483  /// long double roundl(long double x);
485  /// int scanf(const char *restrict format, ... );
487  /// void setbuf(FILE *stream, char *buf);
489  /// int setitimer(int which, const struct itimerval *value,
490  /// struct itimerval *ovalue);
492  /// int setvbuf(FILE *stream, char *buf, int type, size_t size);
494  /// double sin(double x);
496  /// float sinf(float x);
498  /// double sinh(double x);
500  /// float sinhf(float x);
502  /// long double sinhl(long double x);
504  /// long double sinl(long double x);
506  /// int siprintf(char *str, const char *format, ...);
508  /// int snprintf(char *s, size_t n, const char *format, ...);
510  /// int sprintf(char *str, const char *format, ...);
512  /// double sqrt(double x);
514  /// float sqrtf(float x);
516  /// long double sqrtl(long double x);
518  /// int sscanf(const char *s, const char *format, ... );
520  /// int stat(const char *path, struct stat *buf);
522  /// int stat64(const char *path, struct stat64 *buf);
524  /// int statvfs(const char *path, struct statvfs *buf);
526  /// int statvfs64(const char *path, struct statvfs64 *buf)
528  /// char *stpcpy(char *s1, const char *s2);
530  /// char *stpncpy(char *s1, const char *s2, size_t n);
532  /// int strcasecmp(const char *s1, const char *s2);
534  /// char *strcat(char *s1, const char *s2);
536  /// char *strchr(const char *s, int c);
538  /// int strcmp(const char *s1, const char *s2);
540  /// int strcoll(const char *s1, const char *s2);
542  /// char *strcpy(char *s1, const char *s2);
544  /// size_t strcspn(const char *s1, const char *s2);
546  /// char *strdup(const char *s1);
548  /// size_t strlen(const char *s);
550  /// int strncasecmp(const char *s1, const char *s2, size_t n);
552  /// char *strncat(char *s1, const char *s2, size_t n);
554  /// int strncmp(const char *s1, const char *s2, size_t n);
556  /// char *strncpy(char *s1, const char *s2, size_t n);
558  /// char *strndup(const char *s1, size_t n);
560  /// size_t strnlen(const char *s, size_t maxlen);
562  /// char *strpbrk(const char *s1, const char *s2);
564  /// char *strrchr(const char *s, int c);
566  /// size_t strspn(const char *s1, const char *s2);
568  /// char *strstr(const char *s1, const char *s2);
570  /// double strtod(const char *nptr, char **endptr);
572  /// float strtof(const char *nptr, char **endptr);
574  // char *strtok(char *s1, const char *s2);
576  // char *strtok_r(char *s, const char *sep, char **lasts);
578  /// long int strtol(const char *nptr, char **endptr, int base);
580  /// long double strtold(const char *nptr, char **endptr);
582  /// long long int strtoll(const char *nptr, char **endptr, int base);
584  /// unsigned long int strtoul(const char *nptr, char **endptr, int base);
586  /// unsigned long long int strtoull(const char *nptr, char **endptr,
587  /// int base);
589  /// size_t strxfrm(char *s1, const char *s2, size_t n);
591  /// int system(const char *command);
593  /// double tan(double x);
595  /// float tanf(float x);
597  /// double tanh(double x);
599  /// float tanhf(float x);
601  /// long double tanhl(long double x);
603  /// long double tanl(long double x);
605  /// clock_t times(struct tms *buffer);
607  /// FILE *tmpfile(void);
609  /// FILE *tmpfile64(void)
611  /// int toascii(int c);
613  /// double trunc(double x);
615  /// float truncf(float x);
617  /// long double truncl(long double x);
619  /// int uname(struct utsname *name);
621  /// int ungetc(int c, FILE *stream);
623  /// int unlink(const char *path);
625  /// int unsetenv(const char *name);
627  /// int utime(const char *path, const struct utimbuf *times);
629  /// int utimes(const char *path, const struct timeval times[2]);
631  /// void *valloc(size_t size);
633  /// int vfprintf(FILE *stream, const char *format, va_list ap);
635  /// int vfscanf(FILE *stream, const char *format, va_list arg);
637  /// int vprintf(const char *restrict format, va_list ap);
639  /// int vscanf(const char *format, va_list arg);
641  /// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
643  /// int vsprintf(char *s, const char *format, va_list ap);
645  /// int vsscanf(const char *s, const char *format, va_list arg);
647  /// ssize_t write(int fildes, const void *buf, size_t nbyte);
649 
651  };
652  }
653 
654 /// TargetLibraryInfo - This immutable pass captures information about what
655 /// library functions are available for the current target, and allows a
656 /// frontend to disable optimizations through -fno-builtin etc.
658  virtual void anchor();
659  unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
661  static const char* StandardNames[LibFunc::NumLibFuncs];
662 
663  enum AvailabilityState {
664  StandardName = 3, // (memset to all ones)
665  CustomName = 1,
666  Unavailable = 0 // (memset to all zeros)
667  };
668  void setState(LibFunc::Func F, AvailabilityState State) {
669  AvailableArray[F/4] &= ~(3 << 2*(F&3));
670  AvailableArray[F/4] |= State << 2*(F&3);
671  }
672  AvailabilityState getState(LibFunc::Func F) const {
673  return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
674  }
675 
676 public:
677  static char ID;
679  TargetLibraryInfo(const Triple &T);
680  explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
681 
682  /// getLibFunc - Search for a particular function name. If it is one of the
683  /// known library functions, return true and set F to the corresponding value.
684  bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
685 
686  /// has - This function is used by optimizations that want to match on or form
687  /// a given library function.
688  bool has(LibFunc::Func F) const {
689  return getState(F) != Unavailable;
690  }
691 
692  /// hasOptimizedCodeGen - Return true if the function is both available as
693  /// a builtin and a candidate for optimized code generation.
695  if (getState(F) == Unavailable)
696  return false;
697  switch (F) {
698  default: break;
701  case LibFunc::sin: case LibFunc::sinf: case LibFunc::sinl:
702  case LibFunc::cos: case LibFunc::cosf: case LibFunc::cosl:
716  case LibFunc::memchr:
717  return true;
718  }
719  return false;
720  }
721 
723  AvailabilityState State = getState(F);
724  if (State == Unavailable)
725  return StringRef();
726  if (State == StandardName)
727  return StandardNames[F];
728  assert(State == CustomName);
729  return CustomNames.find(F)->second;
730  }
731 
732  /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
733  /// ban use of specific library functions.
735  setState(F, Unavailable);
736  }
737 
739  setState(F, StandardName);
740  }
741 
743  if (StandardNames[F] != Name) {
744  setState(F, CustomName);
745  CustomNames[F] = Name;
746  assert(CustomNames.find(F) != CustomNames.end());
747  } else {
748  setState(F, StandardName);
749  }
750  }
751 
752  /// disableAllFunctions - This disables all builtins, which is used for
753  /// options like -fno-builtin.
754  void disableAllFunctions();
755 };
756 
757 } // end namespace llvm
758 
759 #endif
void flockfile(FILE *file);
int strcmp(const char *s1, const char *s2);
int fseeko(FILE *stream, off_t offset, int whence);
long ftell(FILE *stream);
int uname(struct utsname *name);
int sscanf(const char *s, const char *format, ... );
size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
int sprintf(char *str, const char *format, ...);
void bcopy(const void *s1, void *s2, size_t n);
void *memcpy(void *s1, const void *s2, size_t n);
double sinh(double x);
int fstatvfs64(int fildes, struct statvfs64 *buf);
char *__strndup(const char *s, size_t n);
int chmod(const char *path, mode_t mode);
long double tanl(long double x);
int fstat(int fildes, struct stat *buf);
FILE *tmpfile64(void)
char *strpbrk(const char *s1, const char *s2);
off64_t ftello64(FILE *stream)
int abs(int j);
double rint(double x);
int getc(FILE *stream);
int fstat64(int filedes, struct stat64 *buf)
double tanh(double x);
void funlockfile(FILE *file);
FILE *fdopen(int fildes, const char *mode);.
int printf(const char *format, ...);
long double copysignl(long double x, long double y);
int strncasecmp(const char *s1, const char *s2, size_t n);
void setUnavailable(LibFunc::Func F)
long int strtol(const char *nptr, char **endptr, int base);
long double rintl(long double x);
long double truncl(long double x);
double cos(double x);
int lstat64(const char *path, struct stat64 *buf);
int open(const char *path, int oflag, ... );
float truncf(float x);
DIR *opendir(const char *dirname);.
float cbrtf(float x);
double frexp(double num, int *exp);
float strtof(const char *nptr, char **endptr);
long double sinl(long double x);
void setAvailableWithName(LibFunc::Func F, StringRef Name)
float exp2f(float x);
float expf(float x);
char *ctermid(char *s);
double __sinpi(double x);
void *new(unsigned int);
long double logbl(long double x);
int isdigit(int c);
float modff(float, float *iptr);
int putc(int c, FILE *stream);
long double expl(long double x);
double nearbyint(double x);
char *strcat(char *s1, const char *s2);
void *reallocf(void *ptr, size_t size);
F(f)
FILE *fopen(const char *filename, const char *mode);.
int ffs(int i);
size_t strnlen(const char *s, size_t maxlen);
void *new(unsigned int, nothrow);
void operator delete[](void*, nothrow);
float atan2f(float y, float x);
int __isoc99_sscanf(const char *s, const char *format, ...)
ssize_t read(int fildes, void *buf, size_t nbyte);
double __sqrt_finite(double x);
double log1p(double x);
int fclose(FILE *stream);
float __sqrt_finite(float x);
double strtod(const char *nptr, char **endptr);
long double nearbyintl(long double x);
double trunc(double x);
float sqrtf(float x);
int puts(const char *s);
long double roundl(long double x);
long double coshl(long double x);
long double __sqrt_finite(long double x);
long double fabsl(long double x);
int access(const char *path, int amode);
char *fgets(char *s, int n, FILE *stream);
long double frexpl(long double num, int *exp);
long double cosl(long double x);
double round(double x);
int posix_memalign(void **memptr, size_t alignment, size_t size);
int ftrylockfile(FILE *file);
long double asinl(long double x);
uint32_t ntohl(uint32_t netlong);
int _IO_getc(_IO_FILE * __fp);
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const
double __sincospi_stret(double x);
off_t ftello(FILE *stream);
bool has(LibFunc::Func F) const
int feof(FILE *stream);
bool hasOptimizedCodeGen(LibFunc::Func F) const
double copysign(double x, double y);
void operator delete[](void*);
float atanf(float x);
int closedir(DIR *dirp);
double modf(double x, double *iptr);
float sinhf(float x);
double atof(const char *str);
void operator delete(void*);
double log10(double x);
char *strchr(const char *s, int c);
long double acoshl(long double x);
int gettimeofday(struct timeval *tp, void *tzp);
int strcoll(const char *s1, const char *s2);
ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
int __cxa_atexit(void (*f)(void *), void *p, void *d);
int atoi(const char *str);
float log10f(float x);
int statvfs(const char *path, struct statvfs *buf);
char *gets(char *s);
long long atoll(const char *nptr);
ssize_t readlink(const char *path, char *buf, size_t bufsize);
int system(const char *command);
long long int strtoll(const char *nptr, char **endptr, int base);
size_t strxfrm(char *s1, const char *s2, size_t n);
long double asinhl(long double x);
char *stpncpy(char *s1, const char *s2, size_t n);
int rename(const char *old, const char *new);
double sqrt(double x);
double fmod(double x, double y);
double exp10(double x);
int ungetc(int c, FILE *stream);
char *strndup(const char *s1, size_t n);
double log2(double x);
float fmodf(float x, float y);
int ffsl(long int i);
int rmdir(const char *path);
void *new[](unsigned int);
int vprintf(const char *restrict format, va_list ap);
float log2f(float x);
void memset_pattern16(void *b, const void *pattern16, size_t len);
float tanhf(float x);
int memcmp(const void *s1, const void *s2, size_t n);
char *realpath(const char *file_name, char *resolved_name);
int setvbuf(FILE *stream, char *buf, int type, size_t size);
float floorf(float x);
char *strrchr(const char *s, int c);
long double sinhl(long double x);
float ceilf(float x);
int vfprintf(FILE *stream, const char *format, va_list ap);
int pclose(FILE *stream);
void *new(unsigned long);
long double cbrtl(long double x);
int lstat(const char *path, struct stat *buf);
void clearerr(FILE *stream);
long double floorl(long double x);
uint16_t ntohs(uint16_t netshort);
int getitimer(int which, struct itimerval *value);
int vsnprintf(char *s, size_t n, const char *format, va_list ap);
double cosh(double x);
float exp10f(float x);
int __cxa_guard_acquire(guard_t *guard);
int fstatvfs(int fildes, struct statvfs *buf);
int bcmp(const void *s1, const void *s2, size_t n);
int fgetpos(FILE *stream, fpos_t *pos);
float cosf(float x);
float logf(float x);
void free(void *ptr);
int fsetpos(FILE *stream, const fpos_t *pos);
void *realloc(void *ptr, size_t size);
float roundf(float x);
long double exp10l(long double x);
float rintf(float x);
int utimes(const char *path, const struct timeval times[2]);
int vfscanf(FILE *stream, const char *format, va_list arg);
long double strtold(const char *nptr, char **endptr);
int fseeko64(FILE *stream, off64_t offset, int whence)
float fabsf(float x);
int unlink(const char *path);
float __sincospi_stretf(float x);
void *valloc(size_t size);
int snprintf(char *s, size_t n, const char *format, ...);
float tanf(float x);
double log(double x);
double pow(double x, double y);
float frexpf(float num, int *exp);
void *new[](unsigned int, nothrow);
iterator end()
Definition: DenseMap.h:57
void *memchr(const void *s, int c, size_t n);
float nearbyintf(float x);
int getchar(void);
void perror(const char *s);
int _IO_putc(int __c, _IO_FILE * __fp);
void *memmove(void *s1, const void *s2, size_t n);
uint16_t htons(uint16_t hostshort);
float atanhf(float x);
int mkdir(const char *path, mode_t mode);
void *new[](unsigned long);
float asinhf(float x);
void *new[](unsigned long, nothrow);
char *strstr(const char *s1, const char *s2);
double atan(double x);
FILE *fopen64(const char *filename, const char *opentype)
double exp(double x);
long double expm1l(long double x);
int stat(const char *path, struct stat *buf);
int fputs(const char *s, FILE *stream);
clock_t times(struct tms *buffer);
int stat64(const char *path, struct stat64 *buf);
char *strdup(const char *s1);
int fgetc(FILE *stream);
char * __strdup(const char *s);
void setbuf(FILE *stream, char *buf);
float expm1f(float x);
int getc_unlocked(FILE *stream);
int chown(const char *path, uid_t owner, gid_t group);
double acos(double x);
long double tanhl(long double x);
char *strncat(char *s1, const char *s2, size_t n);
float coshf(float x);
void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
int fiprintf(FILE *stream, const char *format, ...);
float logbf(float x);
long double log10l(long double x);
double atanh(double x);
FILE *tmpfile(void);.
struct passwd *getpwnam(const char *name);
int fprintf(FILE *stream, const char *format, ...);
int vsprintf(char *s, const char *format, va_list ap);
long double atan2l(long double y, long double x);
double cbrt(double x);
void *memccpy(void *s1, const void *s2, int c, size_t n);
size_t strcspn(const char *s1, const char *s2);
long double atanl(long double x);
unsigned long int strtoul(const char *nptr, char **endptr, int base);
long int labs(long int j);
int fflush(FILE *stream);
void *memset(void *b, int c, size_t len);
double asin(double x);
double fabs(double x);
size_t strlen(const char *s);
char *stpcpy(char *s1, const char *s2);
int ffsll(long long int i);
double long double log2l(long double x);
void rewind(FILE *stream);
long double logl(long double x);
int open64(const char *filename, int flags[, mode_t mode])
long double log1pl(long double x);
float powf(float x, float y);
FILE *popen(const char *command, const char *mode);.
int statvfs64(const char *path, struct statvfs64 *buf)
long double acosl(long double x);
int fscanf(FILE *stream, const char *format, ... );
int vsscanf(const char *s, const char *format, va_list arg);
int fputc(int c, FILE *stream);
double sin(double x);
int toascii(int c);
ssize_t write(int fildes, const void *buf, size_t nbyte);
long double atanhl(long double x);
double __cospi(double x);
double expm1(double x);
double asinh(double x);
long double ceill(long double x);
int unsetenv(const char *name);
int ferror(FILE *stream);
double ceil(double x);
void *malloc(size_t size);
double logb(double x);
StringRef getName(LibFunc::Func F) const
void *new(unsigned long, nothrow);
int fseek(FILE *stream, long offset, int whence);
double floor(double x);
int utime(const char *path, const struct utimbuf *times);
char * __strtok_r(char *s, const char *delim, char **save_ptr);
void bzero(void *s, size_t n);
long double fmodl(long double x, long double y);
long double modfl(long double value, long double *iptr);
float acosf(float x);
long long int llabs(long long int j);
int strcasecmp(const char *s1, const char *s2);
int getlogin_r(char *name, size_t namesize);
int fileno(FILE *stream);
void setAvailable(LibFunc::Func F)
float sinf(float x);
float acoshf(float x);
int lchown(const char *path, uid_t owner, gid_t group);
double atan2(double y, double x);
double acosh(double x);
void operator delete(void*, nothrow);
long double exp2l(long double x);
int putchar(int c);
time_t mktime(struct tm *timeptr);
double exp2(double x);
int scanf(const char *restrict format, ... );
char *strcpy(char *s1, const char *s2);
void *memalign(size_t boundary, size_t size);
float __sinpif(float x);
int siprintf(char *str, const char *format, ...);
float log1pf(float x);
int __isoc99_scanf (const char *format, ...)
int strncmp(const char *s1, const char *s2, size_t n);
int vscanf(const char *format, va_list arg);
void __cxa_guard_release(guard_t *guard);
iterator find(const KeyT &Val)
Definition: DenseMap.h:108
long double powl(long double x, long double y);
double tan(double x);
char *getenv(const char *name);
float copysignf(float x, float y);
int isascii(int c);
uint32_t htonl(uint32_t hostlong);
void *calloc(size_t count, size_t size);
int iprintf(const char *format, ...);
float __cospif(float x);
size_t strspn(const char *s1, const char *s2);
float asinf(float x);
long double sqrtl(long double x);
long atol(const char *str);
char *strncpy(char *s1, const char *s2, size_t n);