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, memmove_chk,
  memset_chk, sincospi_stret, sincospif_stret, sinpi,
  sinpif, sqrt_finite, sqrtf_finite, sqrtl_finite,
  stpcpy_chk, stpncpy_chk, strcpy_chk, dunder_strdup,
  strncpy_chk, 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);

memmove_chk 

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

memset_chk 

void *__memset_chk(void *s, char v, 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);

stpcpy_chk 

char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);

stpncpy_chk 

char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);

strcpy_chk 

char *__strcpy_chk(char *s1, const char *s2, size_t s1size);

dunder_strdup 

char * __strdup(const char *s);

strncpy_chk 

char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);

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.