1//===-- TargetLibraryInfo.def - Library information -------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9// This .def file will either fill in the enum definition or fill in the 10// string representation array definition for TargetLibraryInfo. 11// Which is defined depends on whether TLI_DEFINE_ENUM is defined or 12// TLI_DEFINE_STRING is defined. Only one should be defined at a time. 13 14// NOTE: The nofree attribute is added to Libfuncs which are not 15// listed as free or realloc functions in MemoryBuiltins.cpp 16// 17// When adding a function which frees memory include the LibFunc 18// in lib/Analysis/MemoryBuiltins.cpp "isLibFreeFunction". 19// 20// When adding a LibFunc which reallocates memory include the LibFunc 21// in lib/Analysis/MemoryBuiltins.cpp "AllocationFnData[]". 22 23#if (defined(TLI_DEFINE_ENUM) + \ 24 defined(TLI_DEFINE_STRING) + \ 25 defined(TLI_DEFINE_SIG) != 1) 26#error "Must define exactly one of TLI_DEFINE_ENUM, TLI_DEFINE_STRING, or TLI_DEFINE_SIG for TLI .def." 27#else 28// Exactly one of TLI_DEFINE_ENUM/STRING/SIG is defined. 29 30#if defined(TLI_DEFINE_ENUM) 31#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) LibFunc_##enum_variant, 32#define TLI_DEFINE_STRING_INTERNAL(string_repr) 33#define TLI_DEFINE_SIG_INTERNAL(...) 34#elif defined(TLI_DEFINE_STRING) 35#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) 36#define TLI_DEFINE_STRING_INTERNAL(string_repr) string_repr, 37#define TLI_DEFINE_SIG_INTERNAL(...) 38#else 39#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) 40#define TLI_DEFINE_STRING_INTERNAL(string_repr) 41#define TLI_DEFINE_SIG_INTERNAL(...) { __VA_ARGS__ }, 42#endif 43 44/// void *operator new(unsigned int); 45TLI_DEFINE_ENUM_INTERNAL(msvc_new_int) 46TLI_DEFINE_STRING_INTERNAL("??2@YAPAXI@Z") 47TLI_DEFINE_SIG_INTERNAL(Ptr, Int) 48 49/// void *operator new(unsigned int, const std::nothrow_t&); 50TLI_DEFINE_ENUM_INTERNAL(msvc_new_int_nothrow) 51TLI_DEFINE_STRING_INTERNAL("??2@YAPAXIABUnothrow_t@std@@@Z") 52TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr) 53 54/// void *operator new(unsigned long long); 55TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong) 56TLI_DEFINE_STRING_INTERNAL("??2@YAPEAX_K@Z") 57TLI_DEFINE_SIG_INTERNAL(Ptr, LLong) 58 59/// void *operator new(unsigned long long, const std::nothrow_t&); 60TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong_nothrow) 61TLI_DEFINE_STRING_INTERNAL("??2@YAPEAX_KAEBUnothrow_t@std@@@Z") 62TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr) 63 64/// void operator delete(void*); 65TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32) 66TLI_DEFINE_STRING_INTERNAL("??3@YAXPAX@Z") 67TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 68 69/// void operator delete(void*, const std::nothrow_t&); 70TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_nothrow) 71TLI_DEFINE_STRING_INTERNAL("??3@YAXPAXABUnothrow_t@std@@@Z") 72TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 73 74/// void operator delete(void*, unsigned int); 75TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_int) 76TLI_DEFINE_STRING_INTERNAL("??3@YAXPAXI@Z") 77TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int) 78 79/// void operator delete(void*); 80TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64) 81TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAX@Z") 82TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 83 84/// void operator delete(void*, const std::nothrow_t&); 85TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_nothrow) 86TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAXAEBUnothrow_t@std@@@Z") 87TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 88 89/// void operator delete(void*, unsigned long long); 90TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_longlong) 91TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAX_K@Z") 92TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong) 93 94/// void *operator new[](unsigned int); 95TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int) 96TLI_DEFINE_STRING_INTERNAL("??_U@YAPAXI@Z") 97TLI_DEFINE_SIG_INTERNAL(Ptr, Int) 98 99/// void *operator new[](unsigned int, const std::nothrow_t&); 100TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int_nothrow) 101TLI_DEFINE_STRING_INTERNAL("??_U@YAPAXIABUnothrow_t@std@@@Z") 102TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr) 103 104/// void *operator new[](unsigned long long); 105TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong) 106TLI_DEFINE_STRING_INTERNAL("??_U@YAPEAX_K@Z") 107TLI_DEFINE_SIG_INTERNAL(Ptr, LLong) 108 109/// void *operator new[](unsigned long long, const std::nothrow_t&); 110TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong_nothrow) 111TLI_DEFINE_STRING_INTERNAL("??_U@YAPEAX_KAEBUnothrow_t@std@@@Z") 112TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr) 113 114/// void operator delete[](void*); 115TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32) 116TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAX@Z") 117TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 118 119/// void operator delete[](void*, const std::nothrow_t&); 120TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_nothrow) 121TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAXABUnothrow_t@std@@@Z") 122TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 123 124/// void operator delete[](void*, unsigned int); 125TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_int) 126TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAXI@Z") 127TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int) 128 129/// void operator delete[](void*); 130TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64) 131TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAX@Z") 132TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 133 134/// void operator delete[](void*, const std::nothrow_t&); 135TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_nothrow) 136TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAXAEBUnothrow_t@std@@@Z") 137TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 138 139/// void operator delete[](void*, unsigned long long); 140TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_longlong) 141TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAX_K@Z") 142TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong) 143 144/// int _IO_getc(_IO_FILE * __fp); 145TLI_DEFINE_ENUM_INTERNAL(under_IO_getc) 146TLI_DEFINE_STRING_INTERNAL("_IO_getc") 147TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 148 149/// int _IO_putc(int __c, _IO_FILE * __fp); 150TLI_DEFINE_ENUM_INTERNAL(under_IO_putc) 151TLI_DEFINE_STRING_INTERNAL("_IO_putc") 152TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 153 154/// void operator delete[](void*); 155TLI_DEFINE_ENUM_INTERNAL(ZdaPv) 156TLI_DEFINE_STRING_INTERNAL("_ZdaPv") 157TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 158 159/// void operator delete[](void*, const std::nothrow_t&); 160TLI_DEFINE_ENUM_INTERNAL(ZdaPvRKSt9nothrow_t) 161TLI_DEFINE_STRING_INTERNAL("_ZdaPvRKSt9nothrow_t") 162TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 163 164/// void operator delete[](void*, std::align_val_t); 165TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_t) 166TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_t") 167TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus) 168 169/// void operator delete[](void*, std::align_val_t, const std::nothrow_t&) 170TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_tRKSt9nothrow_t) 171TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_tRKSt9nothrow_t") 172TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr) 173 174/// void operator delete[](void*, unsigned int); 175TLI_DEFINE_ENUM_INTERNAL(ZdaPvj) 176TLI_DEFINE_STRING_INTERNAL("_ZdaPvj") 177TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int) 178 179/// void operator delete[](void*, unsigned int, std::align_val_t); 180TLI_DEFINE_ENUM_INTERNAL(ZdaPvjSt11align_val_t) 181TLI_DEFINE_STRING_INTERNAL("_ZdaPvjSt11align_val_t") 182TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int) 183 184/// void operator delete[](void*, unsigned long); 185TLI_DEFINE_ENUM_INTERNAL(ZdaPvm) 186TLI_DEFINE_STRING_INTERNAL("_ZdaPvm") 187TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long) 188 189/// void operator delete[](void*, unsigned long, std::align_val_t); 190TLI_DEFINE_ENUM_INTERNAL(ZdaPvmSt11align_val_t) 191TLI_DEFINE_STRING_INTERNAL("_ZdaPvmSt11align_val_t") 192TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long) 193 194/// void operator delete(void*); 195TLI_DEFINE_ENUM_INTERNAL(ZdlPv) 196TLI_DEFINE_STRING_INTERNAL("_ZdlPv") 197TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 198 199/// void operator delete(void*, const std::nothrow_t&); 200TLI_DEFINE_ENUM_INTERNAL(ZdlPvRKSt9nothrow_t) 201TLI_DEFINE_STRING_INTERNAL("_ZdlPvRKSt9nothrow_t") 202TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 203 204/// void operator delete(void*, std::align_val_t) 205TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_t) 206TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_t") 207TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus) 208 209/// void operator delete(void*, std::align_val_t, const std::nothrow_t&) 210TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_tRKSt9nothrow_t) 211TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_tRKSt9nothrow_t") 212TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr) 213 214/// void operator delete(void*, unsigned int); 215TLI_DEFINE_ENUM_INTERNAL(ZdlPvj) 216TLI_DEFINE_STRING_INTERNAL("_ZdlPvj") 217TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int) 218 219/// void operator delete(void*, unsigned int, std::align_val_t) 220TLI_DEFINE_ENUM_INTERNAL(ZdlPvjSt11align_val_t) 221TLI_DEFINE_STRING_INTERNAL("_ZdlPvjSt11align_val_t") 222TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int) 223 224/// void operator delete(void*, unsigned long); 225TLI_DEFINE_ENUM_INTERNAL(ZdlPvm) 226TLI_DEFINE_STRING_INTERNAL("_ZdlPvm") 227TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long) 228 229/// void operator delete(void*, unsigned long, std::align_val_t) 230TLI_DEFINE_ENUM_INTERNAL(ZdlPvmSt11align_val_t) 231TLI_DEFINE_STRING_INTERNAL("_ZdlPvmSt11align_val_t") 232TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long) 233 234/// void *operator new[](unsigned int); 235TLI_DEFINE_ENUM_INTERNAL(Znaj) 236TLI_DEFINE_STRING_INTERNAL("_Znaj") 237TLI_DEFINE_SIG_INTERNAL(Ptr, Int) 238 239/// void *operator new[](unsigned int, const std::nothrow_t&); 240TLI_DEFINE_ENUM_INTERNAL(ZnajRKSt9nothrow_t) 241TLI_DEFINE_STRING_INTERNAL("_ZnajRKSt9nothrow_t") 242TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr) 243 244/// void *operator new[](unsigned int, std::align_val_t) 245TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_t) 246TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_t") 247TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int) 248 249/// void *operator new[](unsigned int, std::align_val_t, const std::nothrow_t&) 250TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_tRKSt9nothrow_t) 251TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_tRKSt9nothrow_t") 252TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr) 253 254/// void *operator new[](unsigned long); 255TLI_DEFINE_ENUM_INTERNAL(Znam) 256TLI_DEFINE_STRING_INTERNAL("_Znam") 257TLI_DEFINE_SIG_INTERNAL(Ptr, Long) 258 259/// void *operator new[](unsigned long, const std::nothrow_t&); 260TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t) 261TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t") 262TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr) 263 264/// void *operator new[](unsigned long, std::align_val_t) 265TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t) 266TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t") 267TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long) 268 269/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&) 270TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t) 271TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t") 272TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr) 273 274/// void *operator new(unsigned int); 275TLI_DEFINE_ENUM_INTERNAL(Znwj) 276TLI_DEFINE_STRING_INTERNAL("_Znwj") 277TLI_DEFINE_SIG_INTERNAL(Ptr, Int) 278 279/// void *operator new(unsigned int, const std::nothrow_t&); 280TLI_DEFINE_ENUM_INTERNAL(ZnwjRKSt9nothrow_t) 281TLI_DEFINE_STRING_INTERNAL("_ZnwjRKSt9nothrow_t") 282TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr) 283 284/// void *operator new(unsigned int, std::align_val_t) 285TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_t) 286TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_t") 287TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int) 288 289/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&) 290TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_tRKSt9nothrow_t) 291TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_tRKSt9nothrow_t") 292TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr) 293 294/// void *operator new(unsigned long); 295TLI_DEFINE_ENUM_INTERNAL(Znwm) 296TLI_DEFINE_STRING_INTERNAL("_Znwm") 297TLI_DEFINE_SIG_INTERNAL(Ptr, Long) 298 299/// void *operator new(unsigned long, const std::nothrow_t&); 300TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t) 301TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t") 302TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr) 303 304/// void *operator new(unsigned long, std::align_val_t) 305TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t) 306TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t") 307TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long) 308 309/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&) 310TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t) 311TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t") 312TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr) 313 314/// double __acos_finite(double x); 315TLI_DEFINE_ENUM_INTERNAL(acos_finite) 316TLI_DEFINE_STRING_INTERNAL("__acos_finite") 317TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 318 319/// float __acosf_finite(float x); 320TLI_DEFINE_ENUM_INTERNAL(acosf_finite) 321TLI_DEFINE_STRING_INTERNAL("__acosf_finite") 322TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 323 324/// double __acosh_finite(double x); 325TLI_DEFINE_ENUM_INTERNAL(acosh_finite) 326TLI_DEFINE_STRING_INTERNAL("__acosh_finite") 327TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 328 329/// float __acoshf_finite(float x); 330TLI_DEFINE_ENUM_INTERNAL(acoshf_finite) 331TLI_DEFINE_STRING_INTERNAL("__acoshf_finite") 332TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 333 334/// long double __acoshl_finite(long double x); 335TLI_DEFINE_ENUM_INTERNAL(acoshl_finite) 336TLI_DEFINE_STRING_INTERNAL("__acoshl_finite") 337TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 338 339/// long double __acosl_finite(long double x); 340TLI_DEFINE_ENUM_INTERNAL(acosl_finite) 341TLI_DEFINE_STRING_INTERNAL("__acosl_finite") 342TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 343 344/// double __asin_finite(double x); 345TLI_DEFINE_ENUM_INTERNAL(asin_finite) 346TLI_DEFINE_STRING_INTERNAL("__asin_finite") 347TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 348 349/// float __asinf_finite(float x); 350TLI_DEFINE_ENUM_INTERNAL(asinf_finite) 351TLI_DEFINE_STRING_INTERNAL("__asinf_finite") 352TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 353 354/// long double __asinl_finite(long double x); 355TLI_DEFINE_ENUM_INTERNAL(asinl_finite) 356TLI_DEFINE_STRING_INTERNAL("__asinl_finite") 357TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 358 359/// double atan2_finite(double y, double x); 360TLI_DEFINE_ENUM_INTERNAL(atan2_finite) 361TLI_DEFINE_STRING_INTERNAL("__atan2_finite") 362TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 363 364/// float atan2f_finite(float y, float x); 365TLI_DEFINE_ENUM_INTERNAL(atan2f_finite) 366TLI_DEFINE_STRING_INTERNAL("__atan2f_finite") 367TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 368 369/// long double atan2l_finite(long double y, long double x); 370TLI_DEFINE_ENUM_INTERNAL(atan2l_finite) 371TLI_DEFINE_STRING_INTERNAL("__atan2l_finite") 372TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 373 374/// double __atanh_finite(double x); 375TLI_DEFINE_ENUM_INTERNAL(atanh_finite) 376TLI_DEFINE_STRING_INTERNAL("__atanh_finite") 377TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 378 379/// float __atanhf_finite(float x); 380TLI_DEFINE_ENUM_INTERNAL(atanhf_finite) 381TLI_DEFINE_STRING_INTERNAL("__atanhf_finite") 382TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 383 384/// long double __atanhl_finite(long double x); 385TLI_DEFINE_ENUM_INTERNAL(atanhl_finite) 386TLI_DEFINE_STRING_INTERNAL("__atanhl_finite") 387TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 388 389/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel); 390TLI_DEFINE_ENUM_INTERNAL(atomic_load) 391TLI_DEFINE_STRING_INTERNAL("__atomic_load") 392TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int) 393 394/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel); 395TLI_DEFINE_ENUM_INTERNAL(atomic_store) 396TLI_DEFINE_STRING_INTERNAL("__atomic_store") 397TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int) 398 399/// double __cosh_finite(double x); 400TLI_DEFINE_ENUM_INTERNAL(cosh_finite) 401TLI_DEFINE_STRING_INTERNAL("__cosh_finite") 402TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 403 404/// float __coshf_finite(float x); 405TLI_DEFINE_ENUM_INTERNAL(coshf_finite) 406TLI_DEFINE_STRING_INTERNAL("__coshf_finite") 407TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 408 409/// long double __coshl_finite(long double x); 410TLI_DEFINE_ENUM_INTERNAL(coshl_finite) 411TLI_DEFINE_STRING_INTERNAL("__coshl_finite") 412TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 413 414/// double __cospi(double x); 415TLI_DEFINE_ENUM_INTERNAL(cospi) 416TLI_DEFINE_STRING_INTERNAL("__cospi") 417TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 418 419/// float __cospif(float x); 420TLI_DEFINE_ENUM_INTERNAL(cospif) 421TLI_DEFINE_STRING_INTERNAL("__cospif") 422TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 423 424/// int __cxa_atexit(void (*f)(void *), void *p, void *d); 425TLI_DEFINE_ENUM_INTERNAL(cxa_atexit) 426TLI_DEFINE_STRING_INTERNAL("__cxa_atexit") 427TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 428 429/// void __cxa_guard_abort(guard_t *guard); 430/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi. 431TLI_DEFINE_ENUM_INTERNAL(cxa_guard_abort) 432TLI_DEFINE_STRING_INTERNAL("__cxa_guard_abort") 433TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 434 435/// int __cxa_guard_acquire(guard_t *guard); 436TLI_DEFINE_ENUM_INTERNAL(cxa_guard_acquire) 437TLI_DEFINE_STRING_INTERNAL("__cxa_guard_acquire") 438TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 439 440/// void __cxa_guard_release(guard_t *guard); 441TLI_DEFINE_ENUM_INTERNAL(cxa_guard_release) 442TLI_DEFINE_STRING_INTERNAL("__cxa_guard_release") 443TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 444 445/// double __exp10_finite(double x); 446TLI_DEFINE_ENUM_INTERNAL(exp10_finite) 447TLI_DEFINE_STRING_INTERNAL("__exp10_finite") 448TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 449 450/// float __exp10f_finite(float x); 451TLI_DEFINE_ENUM_INTERNAL(exp10f_finite) 452TLI_DEFINE_STRING_INTERNAL("__exp10f_finite") 453TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 454 455/// long double __exp10l_finite(long double x); 456TLI_DEFINE_ENUM_INTERNAL(exp10l_finite) 457TLI_DEFINE_STRING_INTERNAL("__exp10l_finite") 458TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 459 460/// double __exp2_finite(double x); 461TLI_DEFINE_ENUM_INTERNAL(exp2_finite) 462TLI_DEFINE_STRING_INTERNAL("__exp2_finite") 463TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 464 465/// float __exp2f_finite(float x); 466TLI_DEFINE_ENUM_INTERNAL(exp2f_finite) 467TLI_DEFINE_STRING_INTERNAL("__exp2f_finite") 468TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 469 470/// long double __exp2l_finite(long double x); 471TLI_DEFINE_ENUM_INTERNAL(exp2l_finite) 472TLI_DEFINE_STRING_INTERNAL("__exp2l_finite") 473TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 474 475/// double __exp_finite(double x); 476TLI_DEFINE_ENUM_INTERNAL(exp_finite) 477TLI_DEFINE_STRING_INTERNAL("__exp_finite") 478TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 479 480/// float __expf_finite(float x); 481TLI_DEFINE_ENUM_INTERNAL(expf_finite) 482TLI_DEFINE_STRING_INTERNAL("__expf_finite") 483TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 484 485/// long double __expl_finite(long double x); 486TLI_DEFINE_ENUM_INTERNAL(expl_finite) 487TLI_DEFINE_STRING_INTERNAL("__expl_finite") 488TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 489 490/// int __isoc99_scanf (const char *format, ...) 491TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_scanf) 492TLI_DEFINE_STRING_INTERNAL("__isoc99_scanf") 493TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip) 494 495/// int __isoc99_sscanf(const char *s, const char *format, ...) 496TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_sscanf) 497TLI_DEFINE_STRING_INTERNAL("__isoc99_sscanf") 498TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 499 500/// void* __kmpc_alloc_shared(size_t nbyte); 501TLI_DEFINE_ENUM_INTERNAL(__kmpc_alloc_shared) 502TLI_DEFINE_STRING_INTERNAL("__kmpc_alloc_shared") 503TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT) 504 505/// void __kmpc_free_shared(void *ptr, size_t nbyte); 506TLI_DEFINE_ENUM_INTERNAL(__kmpc_free_shared) 507TLI_DEFINE_STRING_INTERNAL("__kmpc_free_shared") 508TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT) 509 510/// double __log10_finite(double x); 511TLI_DEFINE_ENUM_INTERNAL(log10_finite) 512TLI_DEFINE_STRING_INTERNAL("__log10_finite") 513TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 514 515/// float __log10f_finite(float x); 516TLI_DEFINE_ENUM_INTERNAL(log10f_finite) 517TLI_DEFINE_STRING_INTERNAL("__log10f_finite") 518TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 519 520/// long double __log10l_finite(long double x); 521TLI_DEFINE_ENUM_INTERNAL(log10l_finite) 522TLI_DEFINE_STRING_INTERNAL("__log10l_finite") 523TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 524 525/// double __log2_finite(double x); 526TLI_DEFINE_ENUM_INTERNAL(log2_finite) 527TLI_DEFINE_STRING_INTERNAL("__log2_finite") 528TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 529 530/// float __log2f_finite(float x); 531TLI_DEFINE_ENUM_INTERNAL(log2f_finite) 532TLI_DEFINE_STRING_INTERNAL("__log2f_finite") 533TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 534 535/// long double __log2l_finite(long double x); 536TLI_DEFINE_ENUM_INTERNAL(log2l_finite) 537TLI_DEFINE_STRING_INTERNAL("__log2l_finite") 538TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 539 540/// double __log_finite(double x); 541TLI_DEFINE_ENUM_INTERNAL(log_finite) 542TLI_DEFINE_STRING_INTERNAL("__log_finite") 543TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 544 545/// float __logf_finite(float x); 546TLI_DEFINE_ENUM_INTERNAL(logf_finite) 547TLI_DEFINE_STRING_INTERNAL("__logf_finite") 548TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 549 550/// long double __logl_finite(long double x); 551TLI_DEFINE_ENUM_INTERNAL(logl_finite) 552TLI_DEFINE_STRING_INTERNAL("__logl_finite") 553TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 554 555/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n, 556/// size_t dstsize) 557TLI_DEFINE_ENUM_INTERNAL(memccpy_chk) 558TLI_DEFINE_STRING_INTERNAL("__memccpy_chk") 559TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT, SizeT) 560 561/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size); 562TLI_DEFINE_ENUM_INTERNAL(memcpy_chk) 563TLI_DEFINE_STRING_INTERNAL("__memcpy_chk") 564TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 565 566/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size); 567TLI_DEFINE_ENUM_INTERNAL(memmove_chk) 568TLI_DEFINE_STRING_INTERNAL("__memmove_chk") 569TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 570 571/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size); 572TLI_DEFINE_ENUM_INTERNAL(mempcpy_chk) 573TLI_DEFINE_STRING_INTERNAL("__mempcpy_chk") 574TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 575 576/// void *__memset_chk(void *s, int v, size_t n, size_t s1size); 577TLI_DEFINE_ENUM_INTERNAL(memset_chk) 578TLI_DEFINE_STRING_INTERNAL("__memset_chk") 579TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT, SizeT) 580 581// int __nvvm_reflect(const char *) 582TLI_DEFINE_ENUM_INTERNAL(nvvm_reflect) 583TLI_DEFINE_STRING_INTERNAL("__nvvm_reflect") 584TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 585 586/// double __pow_finite(double x, double y); 587TLI_DEFINE_ENUM_INTERNAL(pow_finite) 588TLI_DEFINE_STRING_INTERNAL("__pow_finite") 589TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 590 591/// float _powf_finite(float x, float y); 592TLI_DEFINE_ENUM_INTERNAL(powf_finite) 593TLI_DEFINE_STRING_INTERNAL("__powf_finite") 594TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 595 596/// long double __powl_finite(long double x, long double y); 597TLI_DEFINE_ENUM_INTERNAL(powl_finite) 598TLI_DEFINE_STRING_INTERNAL("__powl_finite") 599TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 600 601/// double __sincospi_stret(double x); 602TLI_DEFINE_ENUM_INTERNAL(sincospi_stret) 603TLI_DEFINE_STRING_INTERNAL("__sincospi_stret") 604TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */) 605 606/// float __sincospif_stret(float x); 607TLI_DEFINE_ENUM_INTERNAL(sincospif_stret) 608TLI_DEFINE_STRING_INTERNAL("__sincospif_stret") 609TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */) 610 611/// double __sinh_finite(double x); 612TLI_DEFINE_ENUM_INTERNAL(sinh_finite) 613TLI_DEFINE_STRING_INTERNAL("__sinh_finite") 614TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 615 616/// float _sinhf_finite(float x); 617TLI_DEFINE_ENUM_INTERNAL(sinhf_finite) 618TLI_DEFINE_STRING_INTERNAL("__sinhf_finite") 619TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 620 621/// long double __sinhl_finite(long double x); 622TLI_DEFINE_ENUM_INTERNAL(sinhl_finite) 623TLI_DEFINE_STRING_INTERNAL("__sinhl_finite") 624TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 625 626/// double __sinpi(double x); 627TLI_DEFINE_ENUM_INTERNAL(sinpi) 628TLI_DEFINE_STRING_INTERNAL("__sinpi") 629TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 630 631/// float __sinpif(float x); 632TLI_DEFINE_ENUM_INTERNAL(sinpif) 633TLI_DEFINE_STRING_INTERNAL("__sinpif") 634TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 635 636/// int __small_fprintf(FILE *stream, const char *format, ...); 637TLI_DEFINE_ENUM_INTERNAL(small_fprintf) 638TLI_DEFINE_STRING_INTERNAL("__small_fprintf") 639TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 640 641/// int __small_printf(const char *format, ...); 642TLI_DEFINE_ENUM_INTERNAL(small_printf) 643TLI_DEFINE_STRING_INTERNAL("__small_printf") 644TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip) 645 646/// int __small_sprintf(char *str, const char *format, ...); 647TLI_DEFINE_ENUM_INTERNAL(small_sprintf) 648TLI_DEFINE_STRING_INTERNAL("__small_sprintf") 649TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 650 651/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen, 652/// const char *format, ...); 653TLI_DEFINE_ENUM_INTERNAL(snprintf_chk) 654TLI_DEFINE_STRING_INTERNAL("__snprintf_chk") 655TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ellip) 656 657/// int __sprintf_chk(char *str, int flags, size_t str_len, 658/// const char *format, ...); 659TLI_DEFINE_ENUM_INTERNAL(sprintf_chk) 660TLI_DEFINE_STRING_INTERNAL("__sprintf_chk") 661TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ellip) 662 663/// double __sqrt_finite(double x); 664TLI_DEFINE_ENUM_INTERNAL(sqrt_finite) 665TLI_DEFINE_STRING_INTERNAL("__sqrt_finite") 666TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 667 668/// float __sqrt_finite(float x); 669TLI_DEFINE_ENUM_INTERNAL(sqrtf_finite) 670TLI_DEFINE_STRING_INTERNAL("__sqrtf_finite") 671TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 672 673/// long double __sqrt_finite(long double x); 674TLI_DEFINE_ENUM_INTERNAL(sqrtl_finite) 675TLI_DEFINE_STRING_INTERNAL("__sqrtl_finite") 676TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 677 678/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size); 679TLI_DEFINE_ENUM_INTERNAL(stpcpy_chk) 680TLI_DEFINE_STRING_INTERNAL("__stpcpy_chk") 681TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 682 683/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size); 684TLI_DEFINE_ENUM_INTERNAL(stpncpy_chk) 685TLI_DEFINE_STRING_INTERNAL("__stpncpy_chk") 686TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 687 688/// char *__strcat_chk(char *s1, const char *s2, size_t s1size); 689TLI_DEFINE_ENUM_INTERNAL(strcat_chk) 690TLI_DEFINE_STRING_INTERNAL("__strcat_chk") 691TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 692 693/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size); 694TLI_DEFINE_ENUM_INTERNAL(strcpy_chk) 695TLI_DEFINE_STRING_INTERNAL("__strcpy_chk") 696TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 697 698/// char * __strdup(const char *s); 699TLI_DEFINE_ENUM_INTERNAL(dunder_strdup) 700TLI_DEFINE_STRING_INTERNAL("__strdup") 701TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 702 703/// size_t __strlcat_chk(char *dst, const char *src, size_t size, 704/// size_t dstsize); 705TLI_DEFINE_ENUM_INTERNAL(strlcat_chk) 706TLI_DEFINE_STRING_INTERNAL("__strlcat_chk") 707TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT) 708 709/// size_t __strlcpy_chk(char *dst, const char *src, size_t size, 710/// size_t dstsize); 711TLI_DEFINE_ENUM_INTERNAL(strlcpy_chk) 712TLI_DEFINE_STRING_INTERNAL("__strlcpy_chk") 713TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT) 714 715/// size_t __strlen_chk(const char *s1, size_t s1size); 716TLI_DEFINE_ENUM_INTERNAL(strlen_chk) 717TLI_DEFINE_STRING_INTERNAL("__strlen_chk") 718TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT) 719 720/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size); 721TLI_DEFINE_ENUM_INTERNAL(strncat_chk) 722TLI_DEFINE_STRING_INTERNAL("__strncat_chk") 723TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 724 725/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size); 726TLI_DEFINE_ENUM_INTERNAL(strncpy_chk) 727TLI_DEFINE_STRING_INTERNAL("__strncpy_chk") 728TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT) 729 730/// char *__strndup(const char *s, size_t n); 731TLI_DEFINE_ENUM_INTERNAL(dunder_strndup) 732TLI_DEFINE_STRING_INTERNAL("__strndup") 733TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT) 734 735/// char * __strtok_r(char *s, const char *delim, char **save_ptr); 736TLI_DEFINE_ENUM_INTERNAL(dunder_strtok_r) 737TLI_DEFINE_STRING_INTERNAL("__strtok_r") 738TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr) 739 740/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen, 741/// const char *format, va_list ap); 742TLI_DEFINE_ENUM_INTERNAL(vsnprintf_chk) 743TLI_DEFINE_STRING_INTERNAL("__vsnprintf_chk") 744TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ptr) 745 746/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format, 747/// va_list ap); 748TLI_DEFINE_ENUM_INTERNAL(vsprintf_chk) 749TLI_DEFINE_STRING_INTERNAL("__vsprintf_chk") 750TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ptr) 751 752/// int abs(int j); 753TLI_DEFINE_ENUM_INTERNAL(abs) 754TLI_DEFINE_STRING_INTERNAL("abs") 755TLI_DEFINE_SIG_INTERNAL(Int, Int) 756 757/// int access(const char *path, int amode); 758TLI_DEFINE_ENUM_INTERNAL(access) 759TLI_DEFINE_STRING_INTERNAL("access") 760TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int) 761 762/// double acos(double x); 763TLI_DEFINE_ENUM_INTERNAL(acos) 764TLI_DEFINE_STRING_INTERNAL("acos") 765TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 766 767/// float acosf(float x); 768TLI_DEFINE_ENUM_INTERNAL(acosf) 769TLI_DEFINE_STRING_INTERNAL("acosf") 770TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 771 772/// double acosh(double x); 773TLI_DEFINE_ENUM_INTERNAL(acosh) 774TLI_DEFINE_STRING_INTERNAL("acosh") 775TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 776 777/// float acoshf(float x); 778TLI_DEFINE_ENUM_INTERNAL(acoshf) 779TLI_DEFINE_STRING_INTERNAL("acoshf") 780TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 781 782/// long double acoshl(long double x); 783TLI_DEFINE_ENUM_INTERNAL(acoshl) 784TLI_DEFINE_STRING_INTERNAL("acoshl") 785TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 786 787/// long double acosl(long double x); 788TLI_DEFINE_ENUM_INTERNAL(acosl) 789TLI_DEFINE_STRING_INTERNAL("acosl") 790TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 791 792/// void *aligned_alloc(size_t alignment, size_t size); 793TLI_DEFINE_ENUM_INTERNAL(aligned_alloc) 794TLI_DEFINE_STRING_INTERNAL("aligned_alloc") 795TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT) 796 797/// double asin(double x); 798TLI_DEFINE_ENUM_INTERNAL(asin) 799TLI_DEFINE_STRING_INTERNAL("asin") 800TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 801 802/// float asinf(float x); 803TLI_DEFINE_ENUM_INTERNAL(asinf) 804TLI_DEFINE_STRING_INTERNAL("asinf") 805TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 806 807/// double asinh(double x); 808TLI_DEFINE_ENUM_INTERNAL(asinh) 809TLI_DEFINE_STRING_INTERNAL("asinh") 810TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 811 812/// float asinhf(float x); 813TLI_DEFINE_ENUM_INTERNAL(asinhf) 814TLI_DEFINE_STRING_INTERNAL("asinhf") 815TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 816 817/// long double asinhl(long double x); 818TLI_DEFINE_ENUM_INTERNAL(asinhl) 819TLI_DEFINE_STRING_INTERNAL("asinhl") 820TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 821 822/// long double asinl(long double x); 823TLI_DEFINE_ENUM_INTERNAL(asinl) 824TLI_DEFINE_STRING_INTERNAL("asinl") 825TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 826 827/// double atan(double x); 828TLI_DEFINE_ENUM_INTERNAL(atan) 829TLI_DEFINE_STRING_INTERNAL("atan") 830TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 831 832/// double atan2(double y, double x); 833TLI_DEFINE_ENUM_INTERNAL(atan2) 834TLI_DEFINE_STRING_INTERNAL("atan2") 835TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 836 837/// float atan2f(float y, float x); 838TLI_DEFINE_ENUM_INTERNAL(atan2f) 839TLI_DEFINE_STRING_INTERNAL("atan2f") 840TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 841 842/// long double atan2l(long double y, long double x); 843TLI_DEFINE_ENUM_INTERNAL(atan2l) 844TLI_DEFINE_STRING_INTERNAL("atan2l") 845TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 846 847/// float atanf(float x); 848TLI_DEFINE_ENUM_INTERNAL(atanf) 849TLI_DEFINE_STRING_INTERNAL("atanf") 850TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 851 852/// double atanh(double x); 853TLI_DEFINE_ENUM_INTERNAL(atanh) 854TLI_DEFINE_STRING_INTERNAL("atanh") 855TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 856 857/// float atanhf(float x); 858TLI_DEFINE_ENUM_INTERNAL(atanhf) 859TLI_DEFINE_STRING_INTERNAL("atanhf") 860TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 861 862/// long double atanhl(long double x); 863TLI_DEFINE_ENUM_INTERNAL(atanhl) 864TLI_DEFINE_STRING_INTERNAL("atanhl") 865TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 866 867/// long double atanl(long double x); 868TLI_DEFINE_ENUM_INTERNAL(atanl) 869TLI_DEFINE_STRING_INTERNAL("atanl") 870TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 871 872/// double atof(const char *str); 873TLI_DEFINE_ENUM_INTERNAL(atof) 874TLI_DEFINE_STRING_INTERNAL("atof") 875TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr) 876 877/// int atoi(const char *str); 878TLI_DEFINE_ENUM_INTERNAL(atoi) 879TLI_DEFINE_STRING_INTERNAL("atoi") 880TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 881 882/// long atol(const char *str); 883TLI_DEFINE_ENUM_INTERNAL(atol) 884TLI_DEFINE_STRING_INTERNAL("atol") 885TLI_DEFINE_SIG_INTERNAL(Long, Ptr) 886 887/// long long atoll(const char *nptr); 888TLI_DEFINE_ENUM_INTERNAL(atoll) 889TLI_DEFINE_STRING_INTERNAL("atoll") 890TLI_DEFINE_SIG_INTERNAL(LLong, Ptr) 891 892/// int bcmp(const void *s1, const void *s2, size_t n); 893TLI_DEFINE_ENUM_INTERNAL(bcmp) 894TLI_DEFINE_STRING_INTERNAL("bcmp") 895TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT) 896 897/// void bcopy(const void *s1, void *s2, size_t n); 898TLI_DEFINE_ENUM_INTERNAL(bcopy) 899TLI_DEFINE_STRING_INTERNAL("bcopy") 900TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT) 901 902/// void bzero(void *s, size_t n); 903TLI_DEFINE_ENUM_INTERNAL(bzero) 904TLI_DEFINE_STRING_INTERNAL("bzero") 905TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT) 906 907/// double cabs(double complex z) 908TLI_DEFINE_ENUM_INTERNAL(cabs) 909TLI_DEFINE_STRING_INTERNAL("cabs") 910TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */) 911 912/// float cabs(float complex z) 913TLI_DEFINE_ENUM_INTERNAL(cabsf) 914TLI_DEFINE_STRING_INTERNAL("cabsf") 915TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */) 916 917/// long double cabs(long double complex z) 918TLI_DEFINE_ENUM_INTERNAL(cabsl) 919TLI_DEFINE_STRING_INTERNAL("cabsl") 920TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */) 921 922/// void *calloc(size_t count, size_t size); 923TLI_DEFINE_ENUM_INTERNAL(calloc) 924TLI_DEFINE_STRING_INTERNAL("calloc") 925TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT) 926 927/// double cbrt(double x); 928TLI_DEFINE_ENUM_INTERNAL(cbrt) 929TLI_DEFINE_STRING_INTERNAL("cbrt") 930TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 931 932/// float cbrtf(float x); 933TLI_DEFINE_ENUM_INTERNAL(cbrtf) 934TLI_DEFINE_STRING_INTERNAL("cbrtf") 935TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 936 937/// long double cbrtl(long double x); 938TLI_DEFINE_ENUM_INTERNAL(cbrtl) 939TLI_DEFINE_STRING_INTERNAL("cbrtl") 940TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 941 942/// double ceil(double x); 943TLI_DEFINE_ENUM_INTERNAL(ceil) 944TLI_DEFINE_STRING_INTERNAL("ceil") 945TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 946 947/// float ceilf(float x); 948TLI_DEFINE_ENUM_INTERNAL(ceilf) 949TLI_DEFINE_STRING_INTERNAL("ceilf") 950TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 951 952/// long double ceill(long double x); 953TLI_DEFINE_ENUM_INTERNAL(ceill) 954TLI_DEFINE_STRING_INTERNAL("ceill") 955TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 956 957/// int chmod(const char *path, mode_t mode); 958TLI_DEFINE_ENUM_INTERNAL(chmod) 959TLI_DEFINE_STRING_INTERNAL("chmod") 960TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX) 961 962/// int chown(const char *path, uid_t owner, gid_t group); 963TLI_DEFINE_ENUM_INTERNAL(chown) 964TLI_DEFINE_STRING_INTERNAL("chown") 965TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX) 966 967/// void clearerr(FILE *stream); 968TLI_DEFINE_ENUM_INTERNAL(clearerr) 969TLI_DEFINE_STRING_INTERNAL("clearerr") 970TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 971 972/// int closedir(DIR *dirp); 973TLI_DEFINE_ENUM_INTERNAL(closedir) 974TLI_DEFINE_STRING_INTERNAL("closedir") 975TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 976 977/// double copysign(double x, double y); 978TLI_DEFINE_ENUM_INTERNAL(copysign) 979TLI_DEFINE_STRING_INTERNAL("copysign") 980TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 981 982/// float copysignf(float x, float y); 983TLI_DEFINE_ENUM_INTERNAL(copysignf) 984TLI_DEFINE_STRING_INTERNAL("copysignf") 985TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 986 987/// long double copysignl(long double x, long double y); 988TLI_DEFINE_ENUM_INTERNAL(copysignl) 989TLI_DEFINE_STRING_INTERNAL("copysignl") 990TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 991 992/// double cos(double x); 993TLI_DEFINE_ENUM_INTERNAL(cos) 994TLI_DEFINE_STRING_INTERNAL("cos") 995TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 996 997/// float cosf(float x); 998TLI_DEFINE_ENUM_INTERNAL(cosf) 999TLI_DEFINE_STRING_INTERNAL("cosf") 1000TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1001 1002/// double cosh(double x); 1003TLI_DEFINE_ENUM_INTERNAL(cosh) 1004TLI_DEFINE_STRING_INTERNAL("cosh") 1005TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1006 1007/// float coshf(float x); 1008TLI_DEFINE_ENUM_INTERNAL(coshf) 1009TLI_DEFINE_STRING_INTERNAL("coshf") 1010TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1011 1012/// long double coshl(long double x); 1013TLI_DEFINE_ENUM_INTERNAL(coshl) 1014TLI_DEFINE_STRING_INTERNAL("coshl") 1015TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1016 1017/// long double cosl(long double x); 1018TLI_DEFINE_ENUM_INTERNAL(cosl) 1019TLI_DEFINE_STRING_INTERNAL("cosl") 1020TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1021 1022/// char *ctermid(char *s); 1023TLI_DEFINE_ENUM_INTERNAL(ctermid) 1024TLI_DEFINE_STRING_INTERNAL("ctermid") 1025TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 1026 1027/// int execl(const char *path, const char *arg, ...); 1028TLI_DEFINE_ENUM_INTERNAL(execl) 1029TLI_DEFINE_STRING_INTERNAL("execl") 1030TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1031 1032/// int execle(const char *file, const char *arg, ..., char * const envp[]); 1033TLI_DEFINE_ENUM_INTERNAL(execle) 1034TLI_DEFINE_STRING_INTERNAL("execle") 1035TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1036 1037/// int execlp(const char *file, const char *arg, ...); 1038TLI_DEFINE_ENUM_INTERNAL(execlp) 1039TLI_DEFINE_STRING_INTERNAL("execlp") 1040TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1041 1042/// int execv(const char *path, char *const argv[]); 1043TLI_DEFINE_ENUM_INTERNAL(execv) 1044TLI_DEFINE_STRING_INTERNAL("execv") 1045TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1046 1047/// int execvP(const char *file, const char *search_path, char *const argv[]); 1048TLI_DEFINE_ENUM_INTERNAL(execvP) 1049TLI_DEFINE_STRING_INTERNAL("execvP") 1050TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 1051 1052/// int execve(const char *filename, char *const argv[], char *const envp[]); 1053TLI_DEFINE_ENUM_INTERNAL(execve) 1054TLI_DEFINE_STRING_INTERNAL("execve") 1055TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 1056 1057/// int execvp(const char *file, char *const argv[]); 1058TLI_DEFINE_ENUM_INTERNAL(execvp) 1059TLI_DEFINE_STRING_INTERNAL("execvp") 1060TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1061 1062/// int execvpe(const char *file, char *const argv[], char *const envp[]); 1063TLI_DEFINE_ENUM_INTERNAL(execvpe) 1064TLI_DEFINE_STRING_INTERNAL("execvpe") 1065TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 1066 1067/// double exp(double x); 1068TLI_DEFINE_ENUM_INTERNAL(exp) 1069TLI_DEFINE_STRING_INTERNAL("exp") 1070TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1071 1072/// double exp10(double x); 1073TLI_DEFINE_ENUM_INTERNAL(exp10) 1074TLI_DEFINE_STRING_INTERNAL("exp10") 1075TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1076 1077/// float exp10f(float x); 1078TLI_DEFINE_ENUM_INTERNAL(exp10f) 1079TLI_DEFINE_STRING_INTERNAL("exp10f") 1080TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1081 1082/// long double exp10l(long double x); 1083TLI_DEFINE_ENUM_INTERNAL(exp10l) 1084TLI_DEFINE_STRING_INTERNAL("exp10l") 1085TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1086 1087/// double exp2(double x); 1088TLI_DEFINE_ENUM_INTERNAL(exp2) 1089TLI_DEFINE_STRING_INTERNAL("exp2") 1090TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1091 1092/// float exp2f(float x); 1093TLI_DEFINE_ENUM_INTERNAL(exp2f) 1094TLI_DEFINE_STRING_INTERNAL("exp2f") 1095TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1096 1097/// long double exp2l(long double x); 1098TLI_DEFINE_ENUM_INTERNAL(exp2l) 1099TLI_DEFINE_STRING_INTERNAL("exp2l") 1100TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1101 1102/// float expf(float x); 1103TLI_DEFINE_ENUM_INTERNAL(expf) 1104TLI_DEFINE_STRING_INTERNAL("expf") 1105TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1106 1107/// long double expl(long double x); 1108TLI_DEFINE_ENUM_INTERNAL(expl) 1109TLI_DEFINE_STRING_INTERNAL("expl") 1110TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1111 1112/// double expm1(double x); 1113TLI_DEFINE_ENUM_INTERNAL(expm1) 1114TLI_DEFINE_STRING_INTERNAL("expm1") 1115TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1116 1117/// float expm1f(float x); 1118TLI_DEFINE_ENUM_INTERNAL(expm1f) 1119TLI_DEFINE_STRING_INTERNAL("expm1f") 1120TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1121 1122/// long double expm1l(long double x); 1123TLI_DEFINE_ENUM_INTERNAL(expm1l) 1124TLI_DEFINE_STRING_INTERNAL("expm1l") 1125TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1126 1127/// double fabs(double x); 1128TLI_DEFINE_ENUM_INTERNAL(fabs) 1129TLI_DEFINE_STRING_INTERNAL("fabs") 1130TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1131 1132/// float fabsf(float x); 1133TLI_DEFINE_ENUM_INTERNAL(fabsf) 1134TLI_DEFINE_STRING_INTERNAL("fabsf") 1135TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1136 1137/// long double fabsl(long double x); 1138TLI_DEFINE_ENUM_INTERNAL(fabsl) 1139TLI_DEFINE_STRING_INTERNAL("fabsl") 1140TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1141 1142/// int fclose(FILE *stream); 1143TLI_DEFINE_ENUM_INTERNAL(fclose) 1144TLI_DEFINE_STRING_INTERNAL("fclose") 1145TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1146 1147/// FILE *fdopen(int fildes, const char *mode); 1148TLI_DEFINE_ENUM_INTERNAL(fdopen) 1149TLI_DEFINE_STRING_INTERNAL("fdopen") 1150TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr) 1151 1152/// int feof(FILE *stream); 1153TLI_DEFINE_ENUM_INTERNAL(feof) 1154TLI_DEFINE_STRING_INTERNAL("feof") 1155TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1156 1157/// int ferror(FILE *stream); 1158TLI_DEFINE_ENUM_INTERNAL(ferror) 1159TLI_DEFINE_STRING_INTERNAL("ferror") 1160TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1161 1162/// int fflush(FILE *stream); 1163TLI_DEFINE_ENUM_INTERNAL(fflush) 1164TLI_DEFINE_STRING_INTERNAL("fflush") 1165TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1166 1167/// int ffs(int i); 1168TLI_DEFINE_ENUM_INTERNAL(ffs) 1169TLI_DEFINE_STRING_INTERNAL("ffs") 1170TLI_DEFINE_SIG_INTERNAL(Int, Int) 1171 1172/// int ffsl(long int i); 1173TLI_DEFINE_ENUM_INTERNAL(ffsl) 1174TLI_DEFINE_STRING_INTERNAL("ffsl") 1175TLI_DEFINE_SIG_INTERNAL(Int, Long) 1176 1177/// int ffsll(long long int i); 1178TLI_DEFINE_ENUM_INTERNAL(ffsll) 1179TLI_DEFINE_STRING_INTERNAL("ffsll") 1180TLI_DEFINE_SIG_INTERNAL(Int, LLong) 1181 1182/// int fgetc(FILE *stream); 1183TLI_DEFINE_ENUM_INTERNAL(fgetc) 1184TLI_DEFINE_STRING_INTERNAL("fgetc") 1185TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1186 1187/// int fgetc_unlocked(FILE *stream); 1188TLI_DEFINE_ENUM_INTERNAL(fgetc_unlocked) 1189TLI_DEFINE_STRING_INTERNAL("fgetc_unlocked") 1190TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1191 1192/// int fgetpos(FILE *stream, fpos_t *pos); 1193TLI_DEFINE_ENUM_INTERNAL(fgetpos) 1194TLI_DEFINE_STRING_INTERNAL("fgetpos") 1195TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1196 1197/// char *fgets(char *s, int n, FILE *stream); 1198TLI_DEFINE_ENUM_INTERNAL(fgets) 1199TLI_DEFINE_STRING_INTERNAL("fgets") 1200TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr) 1201 1202/// char *fgets_unlocked(char *s, int n, FILE *stream); 1203TLI_DEFINE_ENUM_INTERNAL(fgets_unlocked) 1204TLI_DEFINE_STRING_INTERNAL("fgets_unlocked") 1205TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr) 1206 1207/// int fileno(FILE *stream); 1208TLI_DEFINE_ENUM_INTERNAL(fileno) 1209TLI_DEFINE_STRING_INTERNAL("fileno") 1210TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1211 1212/// int fiprintf(FILE *stream, const char *format, ...); 1213TLI_DEFINE_ENUM_INTERNAL(fiprintf) 1214TLI_DEFINE_STRING_INTERNAL("fiprintf") 1215TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1216 1217/// void flockfile(FILE *file); 1218TLI_DEFINE_ENUM_INTERNAL(flockfile) 1219TLI_DEFINE_STRING_INTERNAL("flockfile") 1220TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 1221 1222/// double floor(double x); 1223TLI_DEFINE_ENUM_INTERNAL(floor) 1224TLI_DEFINE_STRING_INTERNAL("floor") 1225TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1226 1227/// float floorf(float x); 1228TLI_DEFINE_ENUM_INTERNAL(floorf) 1229TLI_DEFINE_STRING_INTERNAL("floorf") 1230TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1231 1232/// long double floorl(long double x); 1233TLI_DEFINE_ENUM_INTERNAL(floorl) 1234TLI_DEFINE_STRING_INTERNAL("floorl") 1235TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1236 1237/// int fls(int i); 1238TLI_DEFINE_ENUM_INTERNAL(fls) 1239TLI_DEFINE_STRING_INTERNAL("fls") 1240TLI_DEFINE_SIG_INTERNAL(Int, Int) 1241 1242/// int flsl(long int i); 1243TLI_DEFINE_ENUM_INTERNAL(flsl) 1244TLI_DEFINE_STRING_INTERNAL("flsl") 1245TLI_DEFINE_SIG_INTERNAL(Int, Long) 1246 1247/// int flsll(long long int i); 1248TLI_DEFINE_ENUM_INTERNAL(flsll) 1249TLI_DEFINE_STRING_INTERNAL("flsll") 1250TLI_DEFINE_SIG_INTERNAL(Int, LLong) 1251 1252// Calls to fmax and fmin library functions expand to the llvm.maxnnum and 1253// llvm.minnum intrinsics with the correct parameter types for the arguments 1254// (all types must match). 1255/// double fmax(double x, double y); 1256TLI_DEFINE_ENUM_INTERNAL(fmax) 1257TLI_DEFINE_STRING_INTERNAL("fmax") 1258TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1259 1260/// float fmaxf(float x, float y); 1261TLI_DEFINE_ENUM_INTERNAL(fmaxf) 1262TLI_DEFINE_STRING_INTERNAL("fmaxf") 1263TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1264 1265/// long double fmaxl(long double x, long double y); 1266TLI_DEFINE_ENUM_INTERNAL(fmaxl) 1267TLI_DEFINE_STRING_INTERNAL("fmaxl") 1268TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1269 1270/// double fmin(double x, double y); 1271TLI_DEFINE_ENUM_INTERNAL(fmin) 1272TLI_DEFINE_STRING_INTERNAL("fmin") 1273TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1274 1275/// float fminf(float x, float y); 1276TLI_DEFINE_ENUM_INTERNAL(fminf) 1277TLI_DEFINE_STRING_INTERNAL("fminf") 1278TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1279 1280/// long double fminl(long double x, long double y); 1281TLI_DEFINE_ENUM_INTERNAL(fminl) 1282TLI_DEFINE_STRING_INTERNAL("fminl") 1283TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same) 1284 1285/// double fmod(double x, double y); 1286TLI_DEFINE_ENUM_INTERNAL(fmod) 1287TLI_DEFINE_STRING_INTERNAL("fmod") 1288TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 1289 1290/// float fmodf(float x, float y); 1291TLI_DEFINE_ENUM_INTERNAL(fmodf) 1292TLI_DEFINE_STRING_INTERNAL("fmodf") 1293TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 1294 1295/// long double fmodl(long double x, long double y); 1296TLI_DEFINE_ENUM_INTERNAL(fmodl) 1297TLI_DEFINE_STRING_INTERNAL("fmodl") 1298TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 1299 1300/// FILE *fopen(const char *filename, const char *mode); 1301TLI_DEFINE_ENUM_INTERNAL(fopen) 1302TLI_DEFINE_STRING_INTERNAL("fopen") 1303TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 1304 1305/// FILE *fopen64(const char *filename, const char *opentype) 1306TLI_DEFINE_ENUM_INTERNAL(fopen64) 1307TLI_DEFINE_STRING_INTERNAL("fopen64") 1308TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 1309 1310/// int fork(); 1311TLI_DEFINE_ENUM_INTERNAL(fork) 1312TLI_DEFINE_STRING_INTERNAL("fork") 1313TLI_DEFINE_SIG_INTERNAL(Int) 1314 1315/// int fprintf(FILE *stream, const char *format, ...); 1316TLI_DEFINE_ENUM_INTERNAL(fprintf) 1317TLI_DEFINE_STRING_INTERNAL("fprintf") 1318TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1319 1320/// int fputc(int c, FILE *stream); 1321TLI_DEFINE_ENUM_INTERNAL(fputc) 1322TLI_DEFINE_STRING_INTERNAL("fputc") 1323TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1324 1325/// int fputc_unlocked(int c, FILE *stream); 1326TLI_DEFINE_ENUM_INTERNAL(fputc_unlocked) 1327TLI_DEFINE_STRING_INTERNAL("fputc_unlocked") 1328TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1329 1330/// int fputs(const char *s, FILE *stream); 1331TLI_DEFINE_ENUM_INTERNAL(fputs) 1332TLI_DEFINE_STRING_INTERNAL("fputs") 1333TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1334 1335/// int fputs_unlocked(const char *s, FILE *stream); 1336TLI_DEFINE_ENUM_INTERNAL(fputs_unlocked) 1337TLI_DEFINE_STRING_INTERNAL("fputs_unlocked") 1338TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1339 1340/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream); 1341TLI_DEFINE_ENUM_INTERNAL(fread) 1342TLI_DEFINE_STRING_INTERNAL("fread") 1343TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr) 1344 1345/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream); 1346TLI_DEFINE_ENUM_INTERNAL(fread_unlocked) 1347TLI_DEFINE_STRING_INTERNAL("fread_unlocked") 1348TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr) 1349 1350/// void free(void *ptr); 1351TLI_DEFINE_ENUM_INTERNAL(free) 1352TLI_DEFINE_STRING_INTERNAL("free") 1353TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 1354 1355/// double frexp(double num, int *exp); 1356TLI_DEFINE_ENUM_INTERNAL(frexp) 1357TLI_DEFINE_STRING_INTERNAL("frexp") 1358TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr) 1359 1360/// float frexpf(float num, int *exp); 1361TLI_DEFINE_ENUM_INTERNAL(frexpf) 1362TLI_DEFINE_STRING_INTERNAL("frexpf") 1363TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr) 1364 1365/// long double frexpl(long double num, int *exp); 1366TLI_DEFINE_ENUM_INTERNAL(frexpl) 1367TLI_DEFINE_STRING_INTERNAL("frexpl") 1368TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr) 1369 1370/// int fscanf(FILE *stream, const char *format, ... ); 1371TLI_DEFINE_ENUM_INTERNAL(fscanf) 1372TLI_DEFINE_STRING_INTERNAL("fscanf") 1373TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 1374 1375/// int fseek(FILE *stream, long offset, int whence); 1376TLI_DEFINE_ENUM_INTERNAL(fseek) 1377TLI_DEFINE_STRING_INTERNAL("fseek") 1378TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Long, Int) 1379 1380/// int fseeko(FILE *stream, off_t offset, int whence); 1381TLI_DEFINE_ENUM_INTERNAL(fseeko) 1382TLI_DEFINE_STRING_INTERNAL("fseeko") 1383TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, Int) 1384 1385/// int fseeko64(FILE *stream, off64_t offset, int whence) 1386TLI_DEFINE_ENUM_INTERNAL(fseeko64) 1387TLI_DEFINE_STRING_INTERNAL("fseeko64") 1388TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int64, Int) 1389 1390/// int fsetpos(FILE *stream, const fpos_t *pos); 1391TLI_DEFINE_ENUM_INTERNAL(fsetpos) 1392TLI_DEFINE_STRING_INTERNAL("fsetpos") 1393TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1394 1395/// int fstat(int fildes, struct stat *buf); 1396TLI_DEFINE_ENUM_INTERNAL(fstat) 1397TLI_DEFINE_STRING_INTERNAL("fstat") 1398TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1399 1400/// int fstat64(int filedes, struct stat64 *buf) 1401TLI_DEFINE_ENUM_INTERNAL(fstat64) 1402TLI_DEFINE_STRING_INTERNAL("fstat64") 1403TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1404 1405/// int fstatvfs(int fildes, struct statvfs *buf); 1406TLI_DEFINE_ENUM_INTERNAL(fstatvfs) 1407TLI_DEFINE_STRING_INTERNAL("fstatvfs") 1408TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1409 1410/// int fstatvfs64(int fildes, struct statvfs64 *buf); 1411TLI_DEFINE_ENUM_INTERNAL(fstatvfs64) 1412TLI_DEFINE_STRING_INTERNAL("fstatvfs64") 1413TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1414 1415/// long ftell(FILE *stream); 1416TLI_DEFINE_ENUM_INTERNAL(ftell) 1417TLI_DEFINE_STRING_INTERNAL("ftell") 1418TLI_DEFINE_SIG_INTERNAL(Long, Ptr) 1419 1420/// off_t ftello(FILE *stream); 1421TLI_DEFINE_ENUM_INTERNAL(ftello) 1422TLI_DEFINE_STRING_INTERNAL("ftello") 1423TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr) 1424 1425/// off64_t ftello64(FILE *stream) 1426TLI_DEFINE_ENUM_INTERNAL(ftello64) 1427TLI_DEFINE_STRING_INTERNAL("ftello64") 1428TLI_DEFINE_SIG_INTERNAL(Int64, Ptr) 1429 1430/// int ftrylockfile(FILE *file); 1431TLI_DEFINE_ENUM_INTERNAL(ftrylockfile) 1432TLI_DEFINE_STRING_INTERNAL("ftrylockfile") 1433TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1434 1435/// void funlockfile(FILE *file); 1436TLI_DEFINE_ENUM_INTERNAL(funlockfile) 1437TLI_DEFINE_STRING_INTERNAL("funlockfile") 1438TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 1439 1440/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream); 1441TLI_DEFINE_ENUM_INTERNAL(fwrite) 1442TLI_DEFINE_STRING_INTERNAL("fwrite") 1443TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr) 1444 1445/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems, FILE *stream); 1446TLI_DEFINE_ENUM_INTERNAL(fwrite_unlocked) 1447TLI_DEFINE_STRING_INTERNAL("fwrite_unlocked") 1448TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr) 1449 1450/// int getc(FILE *stream); 1451TLI_DEFINE_ENUM_INTERNAL(getc) 1452TLI_DEFINE_STRING_INTERNAL("getc") 1453TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1454 1455/// int getc_unlocked(FILE *stream); 1456TLI_DEFINE_ENUM_INTERNAL(getc_unlocked) 1457TLI_DEFINE_STRING_INTERNAL("getc_unlocked") 1458TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1459 1460/// int getchar(void); 1461TLI_DEFINE_ENUM_INTERNAL(getchar) 1462TLI_DEFINE_STRING_INTERNAL("getchar") 1463TLI_DEFINE_SIG_INTERNAL(Int) 1464 1465/// int getchar_unlocked(void); 1466TLI_DEFINE_ENUM_INTERNAL(getchar_unlocked) 1467TLI_DEFINE_STRING_INTERNAL("getchar_unlocked") 1468TLI_DEFINE_SIG_INTERNAL(Int) 1469 1470/// char *getenv(const char *name); 1471TLI_DEFINE_ENUM_INTERNAL(getenv) 1472TLI_DEFINE_STRING_INTERNAL("getenv") 1473TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 1474 1475/// int getitimer(int which, struct itimerval *value); 1476TLI_DEFINE_ENUM_INTERNAL(getitimer) 1477TLI_DEFINE_STRING_INTERNAL("getitimer") 1478TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1479 1480/// int getlogin_r(char *name, size_t namesize); 1481TLI_DEFINE_ENUM_INTERNAL(getlogin_r) 1482TLI_DEFINE_STRING_INTERNAL("getlogin_r") 1483TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT) 1484 1485/// struct passwd *getpwnam(const char *name); 1486TLI_DEFINE_ENUM_INTERNAL(getpwnam) 1487TLI_DEFINE_STRING_INTERNAL("getpwnam") 1488TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 1489 1490/// char *gets(char *s); 1491TLI_DEFINE_ENUM_INTERNAL(gets) 1492TLI_DEFINE_STRING_INTERNAL("gets") 1493TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 1494 1495/// int gettimeofday(struct timeval *tp, void *tzp); 1496TLI_DEFINE_ENUM_INTERNAL(gettimeofday) 1497TLI_DEFINE_STRING_INTERNAL("gettimeofday") 1498TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1499 1500/// uint32_t htonl(uint32_t hostlong); 1501TLI_DEFINE_ENUM_INTERNAL(htonl) 1502TLI_DEFINE_STRING_INTERNAL("htonl") 1503TLI_DEFINE_SIG_INTERNAL(Int32, Int32) 1504 1505/// uint16_t htons(uint16_t hostshort); 1506TLI_DEFINE_ENUM_INTERNAL(htons) 1507TLI_DEFINE_STRING_INTERNAL("htons") 1508TLI_DEFINE_SIG_INTERNAL(Int16, Int16) 1509 1510/// int iprintf(const char *format, ...); 1511TLI_DEFINE_ENUM_INTERNAL(iprintf) 1512TLI_DEFINE_STRING_INTERNAL("iprintf") 1513TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip) 1514 1515/// int isascii(int c); 1516TLI_DEFINE_ENUM_INTERNAL(isascii) 1517TLI_DEFINE_STRING_INTERNAL("isascii") 1518TLI_DEFINE_SIG_INTERNAL(Int, Int) 1519 1520/// int isdigit(int c); 1521TLI_DEFINE_ENUM_INTERNAL(isdigit) 1522TLI_DEFINE_STRING_INTERNAL("isdigit") 1523TLI_DEFINE_SIG_INTERNAL(Int, Int) 1524 1525/// long int labs(long int j); 1526TLI_DEFINE_ENUM_INTERNAL(labs) 1527TLI_DEFINE_STRING_INTERNAL("labs") 1528TLI_DEFINE_SIG_INTERNAL(Long, Long) 1529 1530/// int lchown(const char *path, uid_t owner, gid_t group); 1531TLI_DEFINE_ENUM_INTERNAL(lchown) 1532TLI_DEFINE_STRING_INTERNAL("lchown") 1533TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX) 1534 1535/// double ldexp(double x, int n); 1536TLI_DEFINE_ENUM_INTERNAL(ldexp) 1537TLI_DEFINE_STRING_INTERNAL("ldexp") 1538TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Int) 1539 1540/// float ldexpf(float x, int n); 1541TLI_DEFINE_ENUM_INTERNAL(ldexpf) 1542TLI_DEFINE_STRING_INTERNAL("ldexpf") 1543TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Int) 1544 1545/// long double ldexpl(long double x, int n); 1546TLI_DEFINE_ENUM_INTERNAL(ldexpl) 1547TLI_DEFINE_STRING_INTERNAL("ldexpl") 1548TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Int) 1549 1550/// long long int llabs(long long int j); 1551TLI_DEFINE_ENUM_INTERNAL(llabs) 1552TLI_DEFINE_STRING_INTERNAL("llabs") 1553TLI_DEFINE_SIG_INTERNAL(LLong, LLong) 1554 1555/// double log(double x); 1556TLI_DEFINE_ENUM_INTERNAL(log) 1557TLI_DEFINE_STRING_INTERNAL("log") 1558TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1559 1560/// double log10(double x); 1561TLI_DEFINE_ENUM_INTERNAL(log10) 1562TLI_DEFINE_STRING_INTERNAL("log10") 1563TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1564 1565/// float log10f(float x); 1566TLI_DEFINE_ENUM_INTERNAL(log10f) 1567TLI_DEFINE_STRING_INTERNAL("log10f") 1568TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1569 1570/// long double log10l(long double x); 1571TLI_DEFINE_ENUM_INTERNAL(log10l) 1572TLI_DEFINE_STRING_INTERNAL("log10l") 1573TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1574 1575/// double log1p(double x); 1576TLI_DEFINE_ENUM_INTERNAL(log1p) 1577TLI_DEFINE_STRING_INTERNAL("log1p") 1578TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1579 1580/// float log1pf(float x); 1581TLI_DEFINE_ENUM_INTERNAL(log1pf) 1582TLI_DEFINE_STRING_INTERNAL("log1pf") 1583TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1584 1585/// long double log1pl(long double x); 1586TLI_DEFINE_ENUM_INTERNAL(log1pl) 1587TLI_DEFINE_STRING_INTERNAL("log1pl") 1588TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1589 1590/// double log2(double x); 1591TLI_DEFINE_ENUM_INTERNAL(log2) 1592TLI_DEFINE_STRING_INTERNAL("log2") 1593TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1594 1595/// float log2f(float x); 1596TLI_DEFINE_ENUM_INTERNAL(log2f) 1597TLI_DEFINE_STRING_INTERNAL("log2f") 1598TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1599 1600/// double long double log2l(long double x); 1601TLI_DEFINE_ENUM_INTERNAL(log2l) 1602TLI_DEFINE_STRING_INTERNAL("log2l") 1603TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1604 1605/// double logb(double x); 1606TLI_DEFINE_ENUM_INTERNAL(logb) 1607TLI_DEFINE_STRING_INTERNAL("logb") 1608TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1609 1610/// float logbf(float x); 1611TLI_DEFINE_ENUM_INTERNAL(logbf) 1612TLI_DEFINE_STRING_INTERNAL("logbf") 1613TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1614 1615/// long double logbl(long double x); 1616TLI_DEFINE_ENUM_INTERNAL(logbl) 1617TLI_DEFINE_STRING_INTERNAL("logbl") 1618TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1619 1620/// float logf(float x); 1621TLI_DEFINE_ENUM_INTERNAL(logf) 1622TLI_DEFINE_STRING_INTERNAL("logf") 1623TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1624 1625/// long double logl(long double x); 1626TLI_DEFINE_ENUM_INTERNAL(logl) 1627TLI_DEFINE_STRING_INTERNAL("logl") 1628TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1629 1630/// int lstat(const char *path, struct stat *buf); 1631TLI_DEFINE_ENUM_INTERNAL(lstat) 1632TLI_DEFINE_STRING_INTERNAL("lstat") 1633TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1634 1635/// int lstat64(const char *path, struct stat64 *buf); 1636TLI_DEFINE_ENUM_INTERNAL(lstat64) 1637TLI_DEFINE_STRING_INTERNAL("lstat64") 1638TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1639 1640/// void *malloc(size_t size); 1641TLI_DEFINE_ENUM_INTERNAL(malloc) 1642TLI_DEFINE_STRING_INTERNAL("malloc") 1643TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT) 1644 1645/// void *memalign(size_t boundary, size_t size); 1646TLI_DEFINE_ENUM_INTERNAL(memalign) 1647TLI_DEFINE_STRING_INTERNAL("memalign") 1648TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT) 1649 1650/// void *memccpy(void *s1, const void *s2, int c, size_t n); 1651TLI_DEFINE_ENUM_INTERNAL(memccpy) 1652TLI_DEFINE_STRING_INTERNAL("memccpy") 1653TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT) 1654 1655/// void *memchr(const void *s, int c, size_t n); 1656TLI_DEFINE_ENUM_INTERNAL(memchr) 1657TLI_DEFINE_STRING_INTERNAL("memchr") 1658TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT) 1659 1660/// int memcmp(const void *s1, const void *s2, size_t n); 1661TLI_DEFINE_ENUM_INTERNAL(memcmp) 1662TLI_DEFINE_STRING_INTERNAL("memcmp") 1663TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT) 1664 1665/// void *memcpy(void *s1, const void *s2, size_t n); 1666TLI_DEFINE_ENUM_INTERNAL(memcpy) 1667TLI_DEFINE_STRING_INTERNAL("memcpy") 1668TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 1669 1670/// void *memmove(void *s1, const void *s2, size_t n); 1671TLI_DEFINE_ENUM_INTERNAL(memmove) 1672TLI_DEFINE_STRING_INTERNAL("memmove") 1673TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 1674 1675/// void *mempcpy(void *s1, const void *s2, size_t n); 1676TLI_DEFINE_ENUM_INTERNAL(mempcpy) 1677TLI_DEFINE_STRING_INTERNAL("mempcpy") 1678TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 1679 1680/// void *memrchr(const void *s, int c, size_t n); 1681TLI_DEFINE_ENUM_INTERNAL(memrchr) 1682TLI_DEFINE_STRING_INTERNAL("memrchr") 1683TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT) 1684 1685/// void *memset(void *b, int c, size_t len); 1686TLI_DEFINE_ENUM_INTERNAL(memset) 1687TLI_DEFINE_STRING_INTERNAL("memset") 1688TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT) 1689 1690/// void memset_pattern16(void *b, const void *pattern16, size_t len); 1691TLI_DEFINE_ENUM_INTERNAL(memset_pattern16) 1692TLI_DEFINE_STRING_INTERNAL("memset_pattern16") 1693TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT) 1694 1695/// void memset_pattern4(void *b, const void *pattern4, size_t len); 1696TLI_DEFINE_ENUM_INTERNAL(memset_pattern4) 1697TLI_DEFINE_STRING_INTERNAL("memset_pattern4") 1698TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT) 1699 1700/// void memset_pattern8(void *b, const void *pattern8, size_t len); 1701TLI_DEFINE_ENUM_INTERNAL(memset_pattern8) 1702TLI_DEFINE_STRING_INTERNAL("memset_pattern8") 1703TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT) 1704 1705/// int mkdir(const char *path, mode_t mode); 1706TLI_DEFINE_ENUM_INTERNAL(mkdir) 1707TLI_DEFINE_STRING_INTERNAL("mkdir") 1708TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX) 1709 1710/// time_t mktime(struct tm *timeptr); 1711TLI_DEFINE_ENUM_INTERNAL(mktime) 1712TLI_DEFINE_STRING_INTERNAL("mktime") 1713TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr) 1714 1715/// double modf(double x, double *iptr); 1716TLI_DEFINE_ENUM_INTERNAL(modf) 1717TLI_DEFINE_STRING_INTERNAL("modf") 1718TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr) 1719 1720/// float modff(float, float *iptr); 1721TLI_DEFINE_ENUM_INTERNAL(modff) 1722TLI_DEFINE_STRING_INTERNAL("modff") 1723TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr) 1724 1725/// long double modfl(long double value, long double *iptr); 1726TLI_DEFINE_ENUM_INTERNAL(modfl) 1727TLI_DEFINE_STRING_INTERNAL("modfl") 1728TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr) 1729 1730/// double nearbyint(double x); 1731TLI_DEFINE_ENUM_INTERNAL(nearbyint) 1732TLI_DEFINE_STRING_INTERNAL("nearbyint") 1733TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1734 1735/// float nearbyintf(float x); 1736TLI_DEFINE_ENUM_INTERNAL(nearbyintf) 1737TLI_DEFINE_STRING_INTERNAL("nearbyintf") 1738TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1739 1740/// long double nearbyintl(long double x); 1741TLI_DEFINE_ENUM_INTERNAL(nearbyintl) 1742TLI_DEFINE_STRING_INTERNAL("nearbyintl") 1743TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1744 1745/// uint32_t ntohl(uint32_t netlong); 1746TLI_DEFINE_ENUM_INTERNAL(ntohl) 1747TLI_DEFINE_STRING_INTERNAL("ntohl") 1748TLI_DEFINE_SIG_INTERNAL(Int32, Int32) 1749 1750/// uint16_t ntohs(uint16_t netshort); 1751TLI_DEFINE_ENUM_INTERNAL(ntohs) 1752TLI_DEFINE_STRING_INTERNAL("ntohs") 1753TLI_DEFINE_SIG_INTERNAL(Int16, Int16) 1754 1755/// int open(const char *path, int oflag, ... ); 1756TLI_DEFINE_ENUM_INTERNAL(open) 1757TLI_DEFINE_STRING_INTERNAL("open") 1758TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip) 1759 1760/// int open64(const char *filename, int flags[, mode_t mode]) 1761TLI_DEFINE_ENUM_INTERNAL(open64) 1762TLI_DEFINE_STRING_INTERNAL("open64") 1763TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip) 1764 1765/// DIR *opendir(const char *dirname); 1766TLI_DEFINE_ENUM_INTERNAL(opendir) 1767TLI_DEFINE_STRING_INTERNAL("opendir") 1768TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 1769 1770/// int pclose(FILE *stream); 1771TLI_DEFINE_ENUM_INTERNAL(pclose) 1772TLI_DEFINE_STRING_INTERNAL("pclose") 1773TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1774 1775/// void perror(const char *s); 1776TLI_DEFINE_ENUM_INTERNAL(perror) 1777TLI_DEFINE_STRING_INTERNAL("perror") 1778TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 1779 1780/// FILE *popen(const char *command, const char *mode); 1781TLI_DEFINE_ENUM_INTERNAL(popen) 1782TLI_DEFINE_STRING_INTERNAL("popen") 1783TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 1784 1785/// int posix_memalign(void **memptr, size_t alignment, size_t size); 1786TLI_DEFINE_ENUM_INTERNAL(posix_memalign) 1787TLI_DEFINE_STRING_INTERNAL("posix_memalign") 1788TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, SizeT) 1789 1790/// double pow(double x, double y); 1791TLI_DEFINE_ENUM_INTERNAL(pow) 1792TLI_DEFINE_STRING_INTERNAL("pow") 1793TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 1794 1795/// float powf(float x, float y); 1796TLI_DEFINE_ENUM_INTERNAL(powf) 1797TLI_DEFINE_STRING_INTERNAL("powf") 1798TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 1799 1800/// long double powl(long double x, long double y); 1801TLI_DEFINE_ENUM_INTERNAL(powl) 1802TLI_DEFINE_STRING_INTERNAL("powl") 1803TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 1804 1805/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); 1806TLI_DEFINE_ENUM_INTERNAL(pread) 1807TLI_DEFINE_STRING_INTERNAL("pread") 1808TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT, IntPlus) 1809 1810/// int printf(const char *format, ...); 1811TLI_DEFINE_ENUM_INTERNAL(printf) 1812TLI_DEFINE_STRING_INTERNAL("printf") 1813TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip) 1814 1815/// int putc(int c, FILE *stream); 1816TLI_DEFINE_ENUM_INTERNAL(putc) 1817TLI_DEFINE_STRING_INTERNAL("putc") 1818TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1819 1820/// int putc_unlocked(int c, FILE *stream); 1821TLI_DEFINE_ENUM_INTERNAL(putc_unlocked) 1822TLI_DEFINE_STRING_INTERNAL("putc_unlocked") 1823TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 1824 1825/// int putchar(int c); 1826TLI_DEFINE_ENUM_INTERNAL(putchar) 1827TLI_DEFINE_STRING_INTERNAL("putchar") 1828TLI_DEFINE_SIG_INTERNAL(Int, Int) 1829 1830/// int putchar_unlocked(int c); 1831TLI_DEFINE_ENUM_INTERNAL(putchar_unlocked) 1832TLI_DEFINE_STRING_INTERNAL("putchar_unlocked") 1833TLI_DEFINE_SIG_INTERNAL(Int, Int) 1834 1835/// int puts(const char *s); 1836TLI_DEFINE_ENUM_INTERNAL(puts) 1837TLI_DEFINE_STRING_INTERNAL("puts") 1838TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1839 1840/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); 1841TLI_DEFINE_ENUM_INTERNAL(pwrite) 1842TLI_DEFINE_STRING_INTERNAL("pwrite") 1843TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT, IntPlus) 1844 1845/// void qsort(void *base, size_t nel, size_t width, 1846/// int (*compar)(const void *, const void *)); 1847TLI_DEFINE_ENUM_INTERNAL(qsort) 1848TLI_DEFINE_STRING_INTERNAL("qsort") 1849TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT, SizeT, Ptr) 1850 1851/// ssize_t read(int fildes, void *buf, size_t nbyte); 1852TLI_DEFINE_ENUM_INTERNAL(read) 1853TLI_DEFINE_STRING_INTERNAL("read") 1854TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT) 1855 1856/// ssize_t readlink(const char *path, char *buf, size_t bufsize); 1857TLI_DEFINE_ENUM_INTERNAL(readlink) 1858TLI_DEFINE_STRING_INTERNAL("readlink") 1859TLI_DEFINE_SIG_INTERNAL(SSizeT, Ptr, Ptr, SizeT) 1860 1861/// void *realloc(void *ptr, size_t size); 1862TLI_DEFINE_ENUM_INTERNAL(realloc) 1863TLI_DEFINE_STRING_INTERNAL("realloc") 1864TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT) 1865 1866/// void *reallocf(void *ptr, size_t size); 1867TLI_DEFINE_ENUM_INTERNAL(reallocf) 1868TLI_DEFINE_STRING_INTERNAL("reallocf") 1869TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT) 1870 1871/// char *realpath(const char *file_name, char *resolved_name); 1872TLI_DEFINE_ENUM_INTERNAL(realpath) 1873TLI_DEFINE_STRING_INTERNAL("realpath") 1874TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 1875 1876/// double remainder(double x, double y); 1877TLI_DEFINE_ENUM_INTERNAL(remainder) 1878TLI_DEFINE_STRING_INTERNAL("remainder") 1879TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl) 1880 1881/// float remainderf(float x, float y); 1882TLI_DEFINE_ENUM_INTERNAL(remainderf) 1883TLI_DEFINE_STRING_INTERNAL("remainderf") 1884TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt) 1885 1886/// long double remainderl(long double x, long double y); 1887TLI_DEFINE_ENUM_INTERNAL(remainderl) 1888TLI_DEFINE_STRING_INTERNAL("remainderl") 1889TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl) 1890 1891/// int remove(const char *path); 1892TLI_DEFINE_ENUM_INTERNAL(remove) 1893TLI_DEFINE_STRING_INTERNAL("remove") 1894TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1895 1896/// int rename(const char *old, const char *new); 1897TLI_DEFINE_ENUM_INTERNAL(rename) 1898TLI_DEFINE_STRING_INTERNAL("rename") 1899TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 1900 1901/// void rewind(FILE *stream); 1902TLI_DEFINE_ENUM_INTERNAL(rewind) 1903TLI_DEFINE_STRING_INTERNAL("rewind") 1904TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 1905 1906/// double rint(double x); 1907TLI_DEFINE_ENUM_INTERNAL(rint) 1908TLI_DEFINE_STRING_INTERNAL("rint") 1909TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1910 1911/// float rintf(float x); 1912TLI_DEFINE_ENUM_INTERNAL(rintf) 1913TLI_DEFINE_STRING_INTERNAL("rintf") 1914TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1915 1916/// long double rintl(long double x); 1917TLI_DEFINE_ENUM_INTERNAL(rintl) 1918TLI_DEFINE_STRING_INTERNAL("rintl") 1919TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1920 1921/// int rmdir(const char *path); 1922TLI_DEFINE_ENUM_INTERNAL(rmdir) 1923TLI_DEFINE_STRING_INTERNAL("rmdir") 1924TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 1925 1926/// double round(double x); 1927TLI_DEFINE_ENUM_INTERNAL(round) 1928TLI_DEFINE_STRING_INTERNAL("round") 1929TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1930 1931/// double roundeven(double x); 1932TLI_DEFINE_ENUM_INTERNAL(roundeven) 1933TLI_DEFINE_STRING_INTERNAL("roundeven") 1934TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1935 1936/// float roundevenf(float x); 1937TLI_DEFINE_ENUM_INTERNAL(roundevenf) 1938TLI_DEFINE_STRING_INTERNAL("roundevenf") 1939TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1940 1941/// long double roundevenl(long double x); 1942TLI_DEFINE_ENUM_INTERNAL(roundevenl) 1943TLI_DEFINE_STRING_INTERNAL("roundevenl") 1944TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1945 1946/// float roundf(float x); 1947TLI_DEFINE_ENUM_INTERNAL(roundf) 1948TLI_DEFINE_STRING_INTERNAL("roundf") 1949TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1950 1951/// long double roundl(long double x); 1952TLI_DEFINE_ENUM_INTERNAL(roundl) 1953TLI_DEFINE_STRING_INTERNAL("roundl") 1954TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 1955 1956/// int scanf(const char *restrict format, ... ); 1957TLI_DEFINE_ENUM_INTERNAL(scanf) 1958TLI_DEFINE_STRING_INTERNAL("scanf") 1959TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip) 1960 1961/// void setbuf(FILE *stream, char *buf); 1962TLI_DEFINE_ENUM_INTERNAL(setbuf) 1963TLI_DEFINE_STRING_INTERNAL("setbuf") 1964TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr) 1965 1966/// int setitimer(int which, const struct itimerval *value, 1967/// struct itimerval *ovalue); 1968TLI_DEFINE_ENUM_INTERNAL(setitimer) 1969TLI_DEFINE_STRING_INTERNAL("setitimer") 1970TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr, Ptr) 1971 1972/// int setvbuf(FILE *stream, char *buf, int type, size_t size); 1973TLI_DEFINE_ENUM_INTERNAL(setvbuf) 1974TLI_DEFINE_STRING_INTERNAL("setvbuf") 1975TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Int, SizeT) 1976 1977/// double sin(double x); 1978TLI_DEFINE_ENUM_INTERNAL(sin) 1979TLI_DEFINE_STRING_INTERNAL("sin") 1980TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1981 1982/// float sinf(float x); 1983TLI_DEFINE_ENUM_INTERNAL(sinf) 1984TLI_DEFINE_STRING_INTERNAL("sinf") 1985TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1986 1987/// double sinh(double x); 1988TLI_DEFINE_ENUM_INTERNAL(sinh) 1989TLI_DEFINE_STRING_INTERNAL("sinh") 1990TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 1991 1992/// float sinhf(float x); 1993TLI_DEFINE_ENUM_INTERNAL(sinhf) 1994TLI_DEFINE_STRING_INTERNAL("sinhf") 1995TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 1996 1997/// long double sinhl(long double x); 1998TLI_DEFINE_ENUM_INTERNAL(sinhl) 1999TLI_DEFINE_STRING_INTERNAL("sinhl") 2000TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2001 2002/// long double sinl(long double x); 2003TLI_DEFINE_ENUM_INTERNAL(sinl) 2004TLI_DEFINE_STRING_INTERNAL("sinl") 2005TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2006 2007/// int siprintf(char *str, const char *format, ...); 2008TLI_DEFINE_ENUM_INTERNAL(siprintf) 2009TLI_DEFINE_STRING_INTERNAL("siprintf") 2010TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 2011 2012/// int snprintf(char *s, size_t n, const char *format, ...); 2013TLI_DEFINE_ENUM_INTERNAL(snprintf) 2014TLI_DEFINE_STRING_INTERNAL("snprintf") 2015TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ellip) 2016 2017/// int sprintf(char *str, const char *format, ...); 2018TLI_DEFINE_ENUM_INTERNAL(sprintf) 2019TLI_DEFINE_STRING_INTERNAL("sprintf") 2020TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 2021 2022/// double sqrt(double x); 2023TLI_DEFINE_ENUM_INTERNAL(sqrt) 2024TLI_DEFINE_STRING_INTERNAL("sqrt") 2025TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 2026 2027/// float sqrtf(float x); 2028TLI_DEFINE_ENUM_INTERNAL(sqrtf) 2029TLI_DEFINE_STRING_INTERNAL("sqrtf") 2030TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 2031 2032/// long double sqrtl(long double x); 2033TLI_DEFINE_ENUM_INTERNAL(sqrtl) 2034TLI_DEFINE_STRING_INTERNAL("sqrtl") 2035TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2036 2037/// int sscanf(const char *s, const char *format, ... ); 2038TLI_DEFINE_ENUM_INTERNAL(sscanf) 2039TLI_DEFINE_STRING_INTERNAL("sscanf") 2040TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip) 2041 2042/// int stat(const char *path, struct stat *buf); 2043TLI_DEFINE_ENUM_INTERNAL(stat) 2044TLI_DEFINE_STRING_INTERNAL("stat") 2045TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2046 2047/// int stat64(const char *path, struct stat64 *buf); 2048TLI_DEFINE_ENUM_INTERNAL(stat64) 2049TLI_DEFINE_STRING_INTERNAL("stat64") 2050TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2051 2052/// int statvfs(const char *path, struct statvfs *buf); 2053TLI_DEFINE_ENUM_INTERNAL(statvfs) 2054TLI_DEFINE_STRING_INTERNAL("statvfs") 2055TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2056 2057/// int statvfs64(const char *path, struct statvfs64 *buf) 2058TLI_DEFINE_ENUM_INTERNAL(statvfs64) 2059TLI_DEFINE_STRING_INTERNAL("statvfs64") 2060TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2061 2062/// char *stpcpy(char *s1, const char *s2); 2063TLI_DEFINE_ENUM_INTERNAL(stpcpy) 2064TLI_DEFINE_STRING_INTERNAL("stpcpy") 2065TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2066 2067/// char *stpncpy(char *s1, const char *s2, size_t n); 2068TLI_DEFINE_ENUM_INTERNAL(stpncpy) 2069TLI_DEFINE_STRING_INTERNAL("stpncpy") 2070TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 2071 2072/// int strcasecmp(const char *s1, const char *s2); 2073TLI_DEFINE_ENUM_INTERNAL(strcasecmp) 2074TLI_DEFINE_STRING_INTERNAL("strcasecmp") 2075TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2076 2077/// char *strcat(char *s1, const char *s2); 2078TLI_DEFINE_ENUM_INTERNAL(strcat) 2079TLI_DEFINE_STRING_INTERNAL("strcat") 2080TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2081 2082/// char *strchr(const char *s, int c); 2083TLI_DEFINE_ENUM_INTERNAL(strchr) 2084TLI_DEFINE_STRING_INTERNAL("strchr") 2085TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int) 2086 2087/// int strcmp(const char *s1, const char *s2); 2088TLI_DEFINE_ENUM_INTERNAL(strcmp) 2089TLI_DEFINE_STRING_INTERNAL("strcmp") 2090TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2091 2092/// int strcoll(const char *s1, const char *s2); 2093TLI_DEFINE_ENUM_INTERNAL(strcoll) 2094TLI_DEFINE_STRING_INTERNAL("strcoll") 2095TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2096 2097/// char *strcpy(char *s1, const char *s2); 2098TLI_DEFINE_ENUM_INTERNAL(strcpy) 2099TLI_DEFINE_STRING_INTERNAL("strcpy") 2100TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2101 2102/// size_t strcspn(const char *s1, const char *s2); 2103TLI_DEFINE_ENUM_INTERNAL(strcspn) 2104TLI_DEFINE_STRING_INTERNAL("strcspn") 2105TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr) 2106 2107/// char *strdup(const char *s1); 2108TLI_DEFINE_ENUM_INTERNAL(strdup) 2109TLI_DEFINE_STRING_INTERNAL("strdup") 2110TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr) 2111 2112/// size_t strlcat(char *dst, const char *src, size_t size); 2113TLI_DEFINE_ENUM_INTERNAL(strlcat) 2114TLI_DEFINE_STRING_INTERNAL("strlcat") 2115TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT) 2116 2117/// size_t strlcpy(char *dst, const char *src, size_t size); 2118TLI_DEFINE_ENUM_INTERNAL(strlcpy) 2119TLI_DEFINE_STRING_INTERNAL("strlcpy") 2120TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT) 2121 2122/// size_t strlen(const char *s); 2123TLI_DEFINE_ENUM_INTERNAL(strlen) 2124TLI_DEFINE_STRING_INTERNAL("strlen") 2125TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr) 2126 2127/// int strncasecmp(const char *s1, const char *s2, size_t n); 2128TLI_DEFINE_ENUM_INTERNAL(strncasecmp) 2129TLI_DEFINE_STRING_INTERNAL("strncasecmp") 2130TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT) 2131 2132/// char *strncat(char *s1, const char *s2, size_t n); 2133TLI_DEFINE_ENUM_INTERNAL(strncat) 2134TLI_DEFINE_STRING_INTERNAL("strncat") 2135TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 2136 2137/// int strncmp(const char *s1, const char *s2, size_t n); 2138TLI_DEFINE_ENUM_INTERNAL(strncmp) 2139TLI_DEFINE_STRING_INTERNAL("strncmp") 2140TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT) 2141 2142/// char *strncpy(char *s1, const char *s2, size_t n); 2143TLI_DEFINE_ENUM_INTERNAL(strncpy) 2144TLI_DEFINE_STRING_INTERNAL("strncpy") 2145TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT) 2146 2147/// char *strndup(const char *s1, size_t n); 2148TLI_DEFINE_ENUM_INTERNAL(strndup) 2149TLI_DEFINE_STRING_INTERNAL("strndup") 2150TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT) 2151 2152/// size_t strnlen(const char *s, size_t maxlen); 2153TLI_DEFINE_ENUM_INTERNAL(strnlen) 2154TLI_DEFINE_STRING_INTERNAL("strnlen") 2155TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT) 2156 2157/// char *strpbrk(const char *s1, const char *s2); 2158TLI_DEFINE_ENUM_INTERNAL(strpbrk) 2159TLI_DEFINE_STRING_INTERNAL("strpbrk") 2160TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2161 2162/// char *strrchr(const char *s, int c); 2163TLI_DEFINE_ENUM_INTERNAL(strrchr) 2164TLI_DEFINE_STRING_INTERNAL("strrchr") 2165TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int) 2166 2167/// size_t strspn(const char *s1, const char *s2); 2168TLI_DEFINE_ENUM_INTERNAL(strspn) 2169TLI_DEFINE_STRING_INTERNAL("strspn") 2170TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr) 2171 2172/// char *strstr(const char *s1, const char *s2); 2173TLI_DEFINE_ENUM_INTERNAL(strstr) 2174TLI_DEFINE_STRING_INTERNAL("strstr") 2175TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2176 2177/// double strtod(const char *nptr, char **endptr); 2178TLI_DEFINE_ENUM_INTERNAL(strtod) 2179TLI_DEFINE_STRING_INTERNAL("strtod") 2180TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr, Ptr) 2181 2182/// float strtof(const char *nptr, char **endptr); 2183TLI_DEFINE_ENUM_INTERNAL(strtof) 2184TLI_DEFINE_STRING_INTERNAL("strtof") 2185TLI_DEFINE_SIG_INTERNAL(Flt, Ptr, Ptr) 2186 2187/// char *strtok(char *s1, const char *s2); 2188TLI_DEFINE_ENUM_INTERNAL(strtok) 2189TLI_DEFINE_STRING_INTERNAL("strtok") 2190TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr) 2191 2192/// char *strtok_r(char *s, const char *sep, char **lasts); 2193TLI_DEFINE_ENUM_INTERNAL(strtok_r) 2194TLI_DEFINE_STRING_INTERNAL("strtok_r") 2195TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr) 2196 2197/// long int strtol(const char *nptr, char **endptr, int base); 2198TLI_DEFINE_ENUM_INTERNAL(strtol) 2199TLI_DEFINE_STRING_INTERNAL("strtol") 2200TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int) 2201 2202/// long double strtold(const char *nptr, char **endptr); 2203TLI_DEFINE_ENUM_INTERNAL(strtold) 2204TLI_DEFINE_STRING_INTERNAL("strtold") 2205TLI_DEFINE_SIG_INTERNAL(LDbl, Ptr, Ptr) 2206 2207/// long long int strtoll(const char *nptr, char **endptr, int base); 2208TLI_DEFINE_ENUM_INTERNAL(strtoll) 2209TLI_DEFINE_STRING_INTERNAL("strtoll") 2210TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int) 2211 2212/// unsigned long int strtoul(const char *nptr, char **endptr, int base); 2213TLI_DEFINE_ENUM_INTERNAL(strtoul) 2214TLI_DEFINE_STRING_INTERNAL("strtoul") 2215TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int) 2216 2217/// unsigned long long int strtoull(const char *nptr, char **endptr, int base); 2218TLI_DEFINE_ENUM_INTERNAL(strtoull) 2219TLI_DEFINE_STRING_INTERNAL("strtoull") 2220TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int) 2221 2222/// size_t strxfrm(char *s1, const char *s2, size_t n); 2223TLI_DEFINE_ENUM_INTERNAL(strxfrm) 2224TLI_DEFINE_STRING_INTERNAL("strxfrm") 2225TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT) 2226 2227/// int system(const char *command); 2228TLI_DEFINE_ENUM_INTERNAL(system) 2229TLI_DEFINE_STRING_INTERNAL("system") 2230TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 2231 2232/// double tan(double x); 2233TLI_DEFINE_ENUM_INTERNAL(tan) 2234TLI_DEFINE_STRING_INTERNAL("tan") 2235TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 2236 2237/// float tanf(float x); 2238TLI_DEFINE_ENUM_INTERNAL(tanf) 2239TLI_DEFINE_STRING_INTERNAL("tanf") 2240TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 2241 2242/// double tanh(double x); 2243TLI_DEFINE_ENUM_INTERNAL(tanh) 2244TLI_DEFINE_STRING_INTERNAL("tanh") 2245TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 2246 2247/// float tanhf(float x); 2248TLI_DEFINE_ENUM_INTERNAL(tanhf) 2249TLI_DEFINE_STRING_INTERNAL("tanhf") 2250TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 2251 2252/// long double tanhl(long double x); 2253TLI_DEFINE_ENUM_INTERNAL(tanhl) 2254TLI_DEFINE_STRING_INTERNAL("tanhl") 2255TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2256 2257/// long double tanl(long double x); 2258TLI_DEFINE_ENUM_INTERNAL(tanl) 2259TLI_DEFINE_STRING_INTERNAL("tanl") 2260TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2261 2262/// clock_t times(struct tms *buffer); 2263TLI_DEFINE_ENUM_INTERNAL(times) 2264TLI_DEFINE_STRING_INTERNAL("times") 2265TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr) 2266 2267/// FILE *tmpfile(void); 2268TLI_DEFINE_ENUM_INTERNAL(tmpfile) 2269TLI_DEFINE_STRING_INTERNAL("tmpfile") 2270TLI_DEFINE_SIG_INTERNAL(Ptr) 2271 2272/// FILE *tmpfile64(void) 2273TLI_DEFINE_ENUM_INTERNAL(tmpfile64) 2274TLI_DEFINE_STRING_INTERNAL("tmpfile64") 2275TLI_DEFINE_SIG_INTERNAL(Ptr) 2276 2277/// int toascii(int c); 2278TLI_DEFINE_ENUM_INTERNAL(toascii) 2279TLI_DEFINE_STRING_INTERNAL("toascii") 2280TLI_DEFINE_SIG_INTERNAL(Int, Int) 2281 2282/// double trunc(double x); 2283TLI_DEFINE_ENUM_INTERNAL(trunc) 2284TLI_DEFINE_STRING_INTERNAL("trunc") 2285TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl) 2286 2287/// float truncf(float x); 2288TLI_DEFINE_ENUM_INTERNAL(truncf) 2289TLI_DEFINE_STRING_INTERNAL("truncf") 2290TLI_DEFINE_SIG_INTERNAL(Flt, Flt) 2291 2292/// long double truncl(long double x); 2293TLI_DEFINE_ENUM_INTERNAL(truncl) 2294TLI_DEFINE_STRING_INTERNAL("truncl") 2295TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl) 2296 2297/// int uname(struct utsname *name); 2298TLI_DEFINE_ENUM_INTERNAL(uname) 2299TLI_DEFINE_STRING_INTERNAL("uname") 2300TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 2301 2302/// int ungetc(int c, FILE *stream); 2303TLI_DEFINE_ENUM_INTERNAL(ungetc) 2304TLI_DEFINE_STRING_INTERNAL("ungetc") 2305TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr) 2306 2307/// int unlink(const char *path); 2308TLI_DEFINE_ENUM_INTERNAL(unlink) 2309TLI_DEFINE_STRING_INTERNAL("unlink") 2310TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 2311 2312/// int unsetenv(const char *name); 2313TLI_DEFINE_ENUM_INTERNAL(unsetenv) 2314TLI_DEFINE_STRING_INTERNAL("unsetenv") 2315TLI_DEFINE_SIG_INTERNAL(Int, Ptr) 2316 2317/// int utime(const char *path, const struct utimbuf *times); 2318TLI_DEFINE_ENUM_INTERNAL(utime) 2319TLI_DEFINE_STRING_INTERNAL("utime") 2320TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2321 2322/// int utimes(const char *path, const struct timeval times[2]); 2323TLI_DEFINE_ENUM_INTERNAL(utimes) 2324TLI_DEFINE_STRING_INTERNAL("utimes") 2325TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2326 2327/// void *valloc(size_t size); 2328TLI_DEFINE_ENUM_INTERNAL(valloc) 2329TLI_DEFINE_STRING_INTERNAL("valloc") 2330TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT) 2331 2332/// void *vec_calloc(size_t count, size_t size); 2333TLI_DEFINE_ENUM_INTERNAL(vec_calloc) 2334TLI_DEFINE_STRING_INTERNAL("vec_calloc") 2335TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT) 2336 2337/// void vec_free(void *ptr); 2338TLI_DEFINE_ENUM_INTERNAL(vec_free) 2339TLI_DEFINE_STRING_INTERNAL("vec_free") 2340TLI_DEFINE_SIG_INTERNAL(Void, Ptr) 2341 2342/// void *vec_malloc(size_t size); 2343TLI_DEFINE_ENUM_INTERNAL(vec_malloc) 2344TLI_DEFINE_STRING_INTERNAL("vec_malloc") 2345TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT) 2346 2347/// void *vec_realloc(void *ptr, size_t size); 2348TLI_DEFINE_ENUM_INTERNAL(vec_realloc) 2349TLI_DEFINE_STRING_INTERNAL("vec_realloc") 2350TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT) 2351 2352/// int vfprintf(FILE *stream, const char *format, va_list ap); 2353TLI_DEFINE_ENUM_INTERNAL(vfprintf) 2354TLI_DEFINE_STRING_INTERNAL("vfprintf") 2355TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 2356 2357/// int vfscanf(FILE *stream, const char *format, va_list arg); 2358TLI_DEFINE_ENUM_INTERNAL(vfscanf) 2359TLI_DEFINE_STRING_INTERNAL("vfscanf") 2360TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 2361 2362/// int vprintf(const char *restrict format, va_list ap); 2363TLI_DEFINE_ENUM_INTERNAL(vprintf) 2364TLI_DEFINE_STRING_INTERNAL("vprintf") 2365TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2366 2367/// int vscanf(const char *format, va_list arg); 2368TLI_DEFINE_ENUM_INTERNAL(vscanf) 2369TLI_DEFINE_STRING_INTERNAL("vscanf") 2370TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr) 2371 2372/// int vsnprintf(char *s, size_t n, const char *format, va_list ap); 2373TLI_DEFINE_ENUM_INTERNAL(vsnprintf) 2374TLI_DEFINE_STRING_INTERNAL("vsnprintf") 2375TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ptr) 2376 2377/// int vsprintf(char *s, const char *format, va_list ap); 2378TLI_DEFINE_ENUM_INTERNAL(vsprintf) 2379TLI_DEFINE_STRING_INTERNAL("vsprintf") 2380TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 2381 2382/// int vsscanf(const char *s, const char *format, va_list arg); 2383TLI_DEFINE_ENUM_INTERNAL(vsscanf) 2384TLI_DEFINE_STRING_INTERNAL("vsscanf") 2385TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr) 2386 2387/// size_t wcslen (const wchar_t* wcs); 2388TLI_DEFINE_ENUM_INTERNAL(wcslen) 2389TLI_DEFINE_STRING_INTERNAL("wcslen") 2390TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr) 2391 2392/// ssize_t write(int fildes, const void *buf, size_t nbyte); 2393TLI_DEFINE_ENUM_INTERNAL(write) 2394TLI_DEFINE_STRING_INTERNAL("write") 2395TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT) 2396 2397#undef TLI_DEFINE_ENUM_INTERNAL 2398#undef TLI_DEFINE_STRING_INTERNAL 2399#undef TLI_DEFINE_SIG_INTERNAL 2400#endif // One of TLI_DEFINE_ENUM/STRING are defined. 2401 2402#undef TLI_DEFINE_ENUM 2403#undef TLI_DEFINE_STRING 2404#undef TLI_DEFINE_SIG 2405