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