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