LLVM API Documentation

Enumerations
llvm::LibFunc Namespace Reference

Enumerations

enum  Func {
  under_IO_getc, under_IO_putc, 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,
  dunder_isoc99_scanf, dunder_isoc99_sscanf, memcpy_chk, sincospi_stret,
  sincospif_stret, sinpi, sinpif, sqrt_finite,
  sqrtf_finite, sqrtl_finite, dunder_strdup, dunder_strndup,
  dunder_strtok_r, abs, access, acos,
  acosf, acosh, acoshf, acoshl,
  acosl, asin, asinf, asinh,
  asinhf, asinhl, asinl, atan,
  atan2, atan2f, atan2l, atanf,
  atanh, atanhf, atanhl, atanl,
  atof, atoi, atol, atoll,
  bcmp, bcopy, bzero, calloc,
  cbrt, cbrtf, cbrtl, ceil,
  ceilf, ceill, chmod, chown,
  clearerr, closedir, copysign, copysignf,
  copysignl, cos, cosf, cosh,
  coshf, coshl, cosl, ctermid,
  exp, exp10, exp10f, exp10l,
  exp2, exp2f, exp2l, expf,
  expl, expm1, expm1f, expm1l,
  fabs, fabsf, fabsl, fclose,
  fdopen, feof, ferror, fflush,
  ffs, ffsl, ffsll, fgetc,
  fgetpos, fgets, fileno, fiprintf,
  flockfile, floor, floorf, floorl,
  fmax, fmaxf, fmaxl, fmin,
  fminf, fminl, fmod, fmodf,
  fmodl, fopen, fopen64, fprintf,
  fputc, fputs, fread, free,
  frexp, frexpf, frexpl, fscanf,
  fseek, fseeko, fseeko64, fsetpos,
  fstat, fstat64, fstatvfs, fstatvfs64,
  ftell, ftello, ftello64, ftrylockfile,
  funlockfile, fwrite, getc, getc_unlocked,
  getchar, getenv, getitimer, getlogin_r,
  getpwnam, gets, gettimeofday, htonl,
  htons, iprintf, isascii, isdigit,
  labs, lchown, ldexp, ldexpf,
  ldexpl, llabs, log, log10,
  log10f, log10l, log1p, log1pf,
  log1pl, log2, log2f, log2l,
  logb, logbf, logbl, logf,
  logl, lstat, lstat64, malloc,
  memalign, memccpy, memchr, memcmp,
  memcpy, memmove, memrchr, memset,
  memset_pattern16, mkdir, mktime, modf,
  modff, modfl, nearbyint, nearbyintf,
  nearbyintl, ntohl, ntohs, open,
  open64, opendir, pclose, perror,
  popen, posix_memalign, pow, powf,
  powl, pread, printf, putc,
  putchar, puts, pwrite, qsort,
  read, readlink, realloc, reallocf,
  realpath, remove, rename, rewind,
  rint, rintf, rintl, rmdir,
  round, roundf, roundl, scanf,
  setbuf, setitimer, setvbuf, sin,
  sinf, sinh, sinhf, sinhl,
  sinl, siprintf, snprintf, sprintf,
  sqrt, sqrtf, sqrtl, sscanf,
  stat, stat64, statvfs, statvfs64,
  stpcpy, stpncpy, strcasecmp, strcat,
  strchr, strcmp, strcoll, strcpy,
  strcspn, strdup, strlen, strncasecmp,
  strncat, strncmp, strncpy, strndup,
  strnlen, strpbrk, strrchr, strspn,
  strstr, strtod, strtof, strtok,
  strtok_r, strtol, strtold, strtoll,
  strtoul, strtoull, strxfrm, system,
  tan, tanf, tanh, tanhf,
  tanhl, tanl, times, tmpfile,
  tmpfile64, toascii, trunc, truncf,
  truncl, uname, ungetc, unlink,
  unsetenv, utime, utimes, valloc,
  vfprintf, vfscanf, vprintf, vscanf,
  vsnprintf, vsprintf, vsscanf, write,
  NumLibFuncs
}

Enumeration Type Documentation

Enumerator:
under_IO_getc 

int _IO_getc(_IO_FILE * __fp);

under_IO_putc 

int _IO_putc(int __c, _IO_FILE * __fp);

ZdaPv 

void operator delete[](void*);

ZdaPvRKSt9nothrow_t 

void operator delete[](void*, nothrow);

ZdaPvj 

void operator delete[](void*, unsigned int);

ZdaPvm 

void operator delete[](void*, unsigned long);

ZdlPv 

void operator delete(void*);

ZdlPvRKSt9nothrow_t 

void operator delete(void*, nothrow);

ZdlPvj 

void operator delete(void*, unsigned int);

ZdlPvm 

void operator delete(void*, unsigned long);

Znaj 

void *new[](unsigned int);

ZnajRKSt9nothrow_t 

void *new[](unsigned int, nothrow);

Znam 

void *new[](unsigned long);

ZnamRKSt9nothrow_t 

void *new[](unsigned long, nothrow);

Znwj 

void *new(unsigned int);

ZnwjRKSt9nothrow_t 

void *new(unsigned int, nothrow);

Znwm 

void *new(unsigned long);

ZnwmRKSt9nothrow_t 

void *new(unsigned long, nothrow);

cospi 

double __cospi(double x);

cospif 

float __cospif(float x);

cxa_atexit 

int __cxa_atexit(void (*f)(void *), void *p, void *d);

cxa_guard_abort 

void __cxa_guard_abort(guard_t *guard); guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.

cxa_guard_acquire 

int __cxa_guard_acquire(guard_t *guard);

cxa_guard_release 

void __cxa_guard_release(guard_t *guard);

dunder_isoc99_scanf 

int __isoc99_scanf (const char *format, ...)

dunder_isoc99_sscanf 

int __isoc99_sscanf(const char *s, const char *format, ...)

memcpy_chk 

void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);

sincospi_stret 

double __sincospi_stret(double x);

sincospif_stret 

float __sincospif_stret(float x);

sinpi 

double __sinpi(double x);

sinpif 

float __sinpif(float x);

sqrt_finite 

double __sqrt_finite(double x);

sqrtf_finite 

float __sqrt_finite(float x);

sqrtl_finite 

long double __sqrt_finite(long double x);

dunder_strdup 

char * __strdup(const char *s);

dunder_strndup 

char *__strndup(const char *s, size_t n);

dunder_strtok_r 

char * __strtok_r(char *s, const char *delim, char **save_ptr);

abs 

int abs(int j);

access 

int access(const char *path, int amode);

acos 

double acos(double x);

acosf 

float acosf(float x);

acosh 

double acosh(double x);

acoshf 

float acoshf(float x);

acoshl 

long double acoshl(long double x);

acosl 

long double acosl(long double x);

asin 

double asin(double x);

asinf 

float asinf(float x);

asinh 

double asinh(double x);

asinhf 

float asinhf(float x);

asinhl 

long double asinhl(long double x);

asinl 

long double asinl(long double x);

atan 

double atan(double x);

atan2 

double atan2(double y, double x);

atan2f 

float atan2f(float y, float x);

atan2l 

long double atan2l(long double y, long double x);

atanf 

float atanf(float x);

atanh 

double atanh(double x);

atanhf 

float atanhf(float x);

atanhl 

long double atanhl(long double x);

atanl 

long double atanl(long double x);

atof 

double atof(const char *str);

atoi 

int atoi(const char *str);

atol 

long atol(const char *str);

atoll 

long long atoll(const char *nptr);

bcmp 

int bcmp(const void *s1, const void *s2, size_t n);

bcopy 

void bcopy(const void *s1, void *s2, size_t n);

bzero 

void bzero(void *s, size_t n);

calloc 

void *calloc(size_t count, size_t size);

cbrt 

double cbrt(double x);

cbrtf 

float cbrtf(float x);

cbrtl 

long double cbrtl(long double x);

ceil 

double ceil(double x);

ceilf 

float ceilf(float x);

ceill 

long double ceill(long double x);

chmod 

int chmod(const char *path, mode_t mode);

chown 

int chown(const char *path, uid_t owner, gid_t group);

clearerr 

void clearerr(FILE *stream);

closedir 

int closedir(DIR *dirp);

copysign 

double copysign(double x, double y);

copysignf 

float copysignf(float x, float y);

copysignl 

long double copysignl(long double x, long double y);

cos 

double cos(double x);

cosf 

float cosf(float x);

cosh 

double cosh(double x);

coshf 

float coshf(float x);

coshl 

long double coshl(long double x);

cosl 

long double cosl(long double x);

ctermid 

char *ctermid(char *s);

exp 

double exp(double x);

exp10 

double exp10(double x);

exp10f 

float exp10f(float x);

exp10l 

long double exp10l(long double x);

exp2 

double exp2(double x);

exp2f 

float exp2f(float x);

exp2l 

long double exp2l(long double x);

expf 

float expf(float x);

expl 

long double expl(long double x);

expm1 

double expm1(double x);

expm1f 

float expm1f(float x);

expm1l 

long double expm1l(long double x);

fabs 

double fabs(double x);

fabsf 

float fabsf(float x);

fabsl 

long double fabsl(long double x);

fclose 

int fclose(FILE *stream);

fdopen 

FILE *fdopen(int fildes, const char *mode);.

feof 

int feof(FILE *stream);

ferror 

int ferror(FILE *stream);

fflush 

int fflush(FILE *stream);

ffs 

int ffs(int i);

ffsl 

int ffsl(long int i);

ffsll 

int ffsll(long long int i);

fgetc 

int fgetc(FILE *stream);

fgetpos 

int fgetpos(FILE *stream, fpos_t *pos);

fgets 

char *fgets(char *s, int n, FILE *stream);

fileno 

int fileno(FILE *stream);

fiprintf 

int fiprintf(FILE *stream, const char *format, ...);

flockfile 

void flockfile(FILE *file);

floor 

double floor(double x);

floorf 

float floorf(float x);

floorl 

long double floorl(long double x);

fmax 

double fmax(double x, double y);

fmaxf 

float fmaxf(float x, float y);

fmaxl 

long double fmaxl(long double x, long double y);

fmin 

double fmin(double x, double y);

fminf 

float fminf(float x, float y);

fminl 

long double fminl(long double x, long double y);

fmod 

double fmod(double x, double y);

fmodf 

float fmodf(float x, float y);

fmodl 

long double fmodl(long double x, long double y);

fopen 

FILE *fopen(const char *filename, const char *mode);.

fopen64 

FILE *fopen64(const char *filename, const char *opentype)

fprintf 

int fprintf(FILE *stream, const char *format, ...);

fputc 

int fputc(int c, FILE *stream);

fputs 

int fputs(const char *s, FILE *stream);

fread 

size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);

free 

void free(void *ptr);

frexp 

double frexp(double num, int *exp);

frexpf 

float frexpf(float num, int *exp);

frexpl 

long double frexpl(long double num, int *exp);

fscanf 

int fscanf(FILE *stream, const char *format, ... );

fseek 

int fseek(FILE *stream, long offset, int whence);

fseeko 

int fseeko(FILE *stream, off_t offset, int whence);

fseeko64 

int fseeko64(FILE *stream, off64_t offset, int whence)

fsetpos 

int fsetpos(FILE *stream, const fpos_t *pos);

fstat 

int fstat(int fildes, struct stat *buf);

fstat64 

int fstat64(int filedes, struct stat64 *buf)

fstatvfs 

int fstatvfs(int fildes, struct statvfs *buf);

fstatvfs64 

int fstatvfs64(int fildes, struct statvfs64 *buf);

ftell 

long ftell(FILE *stream);

ftello 

off_t ftello(FILE *stream);

ftello64 

off64_t ftello64(FILE *stream)

ftrylockfile 

int ftrylockfile(FILE *file);

funlockfile 

void funlockfile(FILE *file);

fwrite 

size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);

getc 

int getc(FILE *stream);

getc_unlocked 

int getc_unlocked(FILE *stream);

getchar 

int getchar(void);

getenv 

char *getenv(const char *name);

getitimer 

int getitimer(int which, struct itimerval *value);

getlogin_r 

int getlogin_r(char *name, size_t namesize);

getpwnam 

struct passwd *getpwnam(const char *name);

gets 

char *gets(char *s);

gettimeofday 

int gettimeofday(struct timeval *tp, void *tzp);

htonl 

uint32_t htonl(uint32_t hostlong);

htons 

uint16_t htons(uint16_t hostshort);

iprintf 

int iprintf(const char *format, ...);

isascii 

int isascii(int c);

isdigit 

int isdigit(int c);

labs 

long int labs(long int j);

lchown 

int lchown(const char *path, uid_t owner, gid_t group);

ldexp 

double ldexp(double x, int n);

ldexpf 

float ldexpf(float x, int n);

ldexpl 

long double ldexpl(long double x, int n);

llabs 

long long int llabs(long long int j);

log 

double log(double x);

log10 

double log10(double x);

log10f 

float log10f(float x);

log10l 

long double log10l(long double x);

log1p 

double log1p(double x);

log1pf 

float log1pf(float x);

log1pl 

long double log1pl(long double x);

log2 

double log2(double x);

log2f 

float log2f(float x);

log2l 

double long double log2l(long double x);

logb 

double logb(double x);

logbf 

float logbf(float x);

logbl 

long double logbl(long double x);

logf 

float logf(float x);

logl 

long double logl(long double x);

lstat 

int lstat(const char *path, struct stat *buf);

lstat64 

int lstat64(const char *path, struct stat64 *buf);

malloc 

void *malloc(size_t size);

memalign 

void *memalign(size_t boundary, size_t size);

memccpy 

void *memccpy(void *s1, const void *s2, int c, size_t n);

memchr 

void *memchr(const void *s, int c, size_t n);

memcmp 

int memcmp(const void *s1, const void *s2, size_t n);

memcpy 

void *memcpy(void *s1, const void *s2, size_t n);

memmove 

void *memmove(void *s1, const void *s2, size_t n);

memrchr 
memset 

void *memset(void *b, int c, size_t len);

memset_pattern16 

void memset_pattern16(void *b, const void *pattern16, size_t len);

mkdir 

int mkdir(const char *path, mode_t mode);

mktime 

time_t mktime(struct tm *timeptr);

modf 

double modf(double x, double *iptr);

modff 

float modff(float, float *iptr);

modfl 

long double modfl(long double value, long double *iptr);

nearbyint 

double nearbyint(double x);

nearbyintf 

float nearbyintf(float x);

nearbyintl 

long double nearbyintl(long double x);

ntohl 

uint32_t ntohl(uint32_t netlong);

ntohs 

uint16_t ntohs(uint16_t netshort);

open 

int open(const char *path, int oflag, ... );

open64 

int open64(const char *filename, int flags[, mode_t mode])

opendir 

DIR *opendir(const char *dirname);.

pclose 

int pclose(FILE *stream);

perror 

void perror(const char *s);

popen 

FILE *popen(const char *command, const char *mode);.

posix_memalign 

int posix_memalign(void **memptr, size_t alignment, size_t size);

pow 

double pow(double x, double y);

powf 

float powf(float x, float y);

powl 

long double powl(long double x, long double y);

pread 

ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);

printf 

int printf(const char *format, ...);

putc 

int putc(int c, FILE *stream);

putchar 

int putchar(int c);

puts 

int puts(const char *s);

pwrite 

ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);

qsort 

void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));

read 

ssize_t read(int fildes, void *buf, size_t nbyte);

readlink 

ssize_t readlink(const char *path, char *buf, size_t bufsize);

realloc 

void *realloc(void *ptr, size_t size);

reallocf 

void *reallocf(void *ptr, size_t size);

realpath 

char *realpath(const char *file_name, char *resolved_name);

remove 

int remove(const char *path);

rename 

int rename(const char *old, const char *new);

rewind 

void rewind(FILE *stream);

rint 

double rint(double x);

rintf 

float rintf(float x);

rintl 

long double rintl(long double x);

rmdir 

int rmdir(const char *path);

round 

double round(double x);

roundf 

float roundf(float x);

roundl 

long double roundl(long double x);

scanf 

int scanf(const char *restrict format, ... );

setbuf 

void setbuf(FILE *stream, char *buf);

setitimer 

int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);

setvbuf 

int setvbuf(FILE *stream, char *buf, int type, size_t size);

sin 

double sin(double x);

sinf 

float sinf(float x);

sinh 

double sinh(double x);

sinhf 

float sinhf(float x);

sinhl 

long double sinhl(long double x);

sinl 

long double sinl(long double x);

siprintf 

int siprintf(char *str, const char *format, ...);

snprintf 

int snprintf(char *s, size_t n, const char *format, ...);

sprintf 

int sprintf(char *str, const char *format, ...);

sqrt 

double sqrt(double x);

sqrtf 

float sqrtf(float x);

sqrtl 

long double sqrtl(long double x);

sscanf 

int sscanf(const char *s, const char *format, ... );

stat 

int stat(const char *path, struct stat *buf);

stat64 

int stat64(const char *path, struct stat64 *buf);

statvfs 

int statvfs(const char *path, struct statvfs *buf);

statvfs64 

int statvfs64(const char *path, struct statvfs64 *buf)

stpcpy 

char *stpcpy(char *s1, const char *s2);

stpncpy 

char *stpncpy(char *s1, const char *s2, size_t n);

strcasecmp 

int strcasecmp(const char *s1, const char *s2);

strcat 

char *strcat(char *s1, const char *s2);

strchr 

char *strchr(const char *s, int c);

strcmp 

int strcmp(const char *s1, const char *s2);

strcoll 

int strcoll(const char *s1, const char *s2);

strcpy 

char *strcpy(char *s1, const char *s2);

strcspn 

size_t strcspn(const char *s1, const char *s2);

strdup 

char *strdup(const char *s1);

strlen 

size_t strlen(const char *s);

strncasecmp 

int strncasecmp(const char *s1, const char *s2, size_t n);

strncat 

char *strncat(char *s1, const char *s2, size_t n);

strncmp 

int strncmp(const char *s1, const char *s2, size_t n);

strncpy 

char *strncpy(char *s1, const char *s2, size_t n);

strndup 

char *strndup(const char *s1, size_t n);

strnlen 

size_t strnlen(const char *s, size_t maxlen);

strpbrk 

char *strpbrk(const char *s1, const char *s2);

strrchr 

char *strrchr(const char *s, int c);

strspn 

size_t strspn(const char *s1, const char *s2);

strstr 

char *strstr(const char *s1, const char *s2);

strtod 

double strtod(const char *nptr, char **endptr);

strtof 

float strtof(const char *nptr, char **endptr);

strtok 
strtok_r 
strtol 

long int strtol(const char *nptr, char **endptr, int base);

strtold 

long double strtold(const char *nptr, char **endptr);

strtoll 

long long int strtoll(const char *nptr, char **endptr, int base);

strtoul 

unsigned long int strtoul(const char *nptr, char **endptr, int base);

strtoull 

unsigned long long int strtoull(const char *nptr, char **endptr, int base);

strxfrm 

size_t strxfrm(char *s1, const char *s2, size_t n);

system 

int system(const char *command);

tan 

double tan(double x);

tanf 

float tanf(float x);

tanh 

double tanh(double x);

tanhf 

float tanhf(float x);

tanhl 

long double tanhl(long double x);

tanl 

long double tanl(long double x);

times 

clock_t times(struct tms *buffer);

tmpfile 

FILE *tmpfile(void);.

tmpfile64 

FILE *tmpfile64(void)

toascii 

int toascii(int c);

trunc 

double trunc(double x);

truncf 

float truncf(float x);

truncl 

long double truncl(long double x);

uname 

int uname(struct utsname *name);

ungetc 

int ungetc(int c, FILE *stream);

unlink 

int unlink(const char *path);

unsetenv 

int unsetenv(const char *name);

utime 

int utime(const char *path, const struct utimbuf *times);

utimes 

int utimes(const char *path, const struct timeval times[2]);

valloc 

void *valloc(size_t size);

vfprintf 

int vfprintf(FILE *stream, const char *format, va_list ap);

vfscanf 

int vfscanf(FILE *stream, const char *format, va_list arg);

vprintf 

int vprintf(const char *restrict format, va_list ap);

vscanf 

int vscanf(const char *format, va_list arg);

vsnprintf 

int vsnprintf(char *s, size_t n, const char *format, va_list ap);

vsprintf 

int vsprintf(char *s, const char *format, va_list ap);

vsscanf 

int vsscanf(const char *s, const char *format, va_list arg);

write 

ssize_t write(int fildes, const void *buf, size_t nbyte);

NumLibFuncs 

Definition at line 20 of file TargetLibraryInfo.h.