Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/llvm/Analysis/TargetLibraryInfo.def is written in an unsupported language. File is not indexed. 

0001 //===-- TargetLibraryInfo.def - Library information -------------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 
0009 // This .def file will either fill in the enum definition or fill in the
0010 // string representation array definition for TargetLibraryInfo.
0011 // Which is defined depends on whether TLI_DEFINE_ENUM is defined or
0012 // TLI_DEFINE_STRING is defined. Only one should be defined at a time.
0013 
0014 // NOTE: The nofree attribute is added to Libfuncs which are not
0015 // listed as free or realloc functions in MemoryBuiltins.cpp
0016 //
0017 // When adding a function which frees memory include the LibFunc
0018 // in lib/Analysis/MemoryBuiltins.cpp "isLibFreeFunction".
0019 //
0020 // When adding a LibFunc which reallocates memory include the LibFunc
0021 // in lib/Analysis/MemoryBuiltins.cpp "AllocationFnData[]".
0022 
0023 #if (defined(TLI_DEFINE_ENUM) +                 \
0024      defined(TLI_DEFINE_STRING) +               \
0025      defined(TLI_DEFINE_SIG) != 1)
0026 #error "Must define exactly one of TLI_DEFINE_ENUM, TLI_DEFINE_STRING, or TLI_DEFINE_SIG for TLI .def."
0027 #else
0028 // Exactly one of TLI_DEFINE_ENUM/STRING/SIG is defined.
0029 
0030 #if defined(TLI_DEFINE_ENUM)
0031 #define TLI_DEFINE_ENUM_INTERNAL(enum_variant) LibFunc_##enum_variant,
0032 #define TLI_DEFINE_STRING_INTERNAL(string_repr)
0033 #define TLI_DEFINE_SIG_INTERNAL(...)
0034 #elif defined(TLI_DEFINE_STRING)
0035 #define TLI_DEFINE_ENUM_INTERNAL(enum_variant)
0036 #define TLI_DEFINE_STRING_INTERNAL(string_repr) string_repr,
0037 #define TLI_DEFINE_SIG_INTERNAL(...)
0038 #else
0039 #define TLI_DEFINE_ENUM_INTERNAL(enum_variant)
0040 #define TLI_DEFINE_STRING_INTERNAL(string_repr)
0041 #define TLI_DEFINE_SIG_INTERNAL(...) { __VA_ARGS__ },
0042 #endif
0043 
0044 /// void *operator new(unsigned int);
0045 TLI_DEFINE_ENUM_INTERNAL(msvc_new_int)
0046 TLI_DEFINE_STRING_INTERNAL("??2@YAPAXI@Z")
0047 TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
0048 
0049 /// void *operator new(unsigned int, const std::nothrow_t&);
0050 TLI_DEFINE_ENUM_INTERNAL(msvc_new_int_nothrow)
0051 TLI_DEFINE_STRING_INTERNAL("??2@YAPAXIABUnothrow_t@std@@@Z")
0052 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
0053 
0054 /// void *operator new(unsigned long long);
0055 TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong)
0056 TLI_DEFINE_STRING_INTERNAL("??2@YAPEAX_K@Z")
0057 TLI_DEFINE_SIG_INTERNAL(Ptr, LLong)
0058 
0059 /// void *operator new(unsigned long long, const std::nothrow_t&);
0060 TLI_DEFINE_ENUM_INTERNAL(msvc_new_longlong_nothrow)
0061 TLI_DEFINE_STRING_INTERNAL("??2@YAPEAX_KAEBUnothrow_t@std@@@Z")
0062 TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr)
0063 
0064 /// void operator delete(void*);
0065 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32)
0066 TLI_DEFINE_STRING_INTERNAL("??3@YAXPAX@Z")
0067 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0068 
0069 /// void operator delete(void*, const std::nothrow_t&);
0070 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_nothrow)
0071 TLI_DEFINE_STRING_INTERNAL("??3@YAXPAXABUnothrow_t@std@@@Z")
0072 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0073 
0074 /// void operator delete(void*, unsigned int);
0075 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr32_int)
0076 TLI_DEFINE_STRING_INTERNAL("??3@YAXPAXI@Z")
0077 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
0078 
0079 /// void operator delete(void*);
0080 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64)
0081 TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAX@Z")
0082 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0083 
0084 /// void operator delete(void*, const std::nothrow_t&);
0085 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_nothrow)
0086 TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAXAEBUnothrow_t@std@@@Z")
0087 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0088 
0089 /// void operator delete(void*, unsigned long long);
0090 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_ptr64_longlong)
0091 TLI_DEFINE_STRING_INTERNAL("??3@YAXPEAX_K@Z")
0092 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong)
0093 
0094 /// void *operator new[](unsigned int);
0095 TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int)
0096 TLI_DEFINE_STRING_INTERNAL("??_U@YAPAXI@Z")
0097 TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
0098 
0099 /// void *operator new[](unsigned int, const std::nothrow_t&);
0100 TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_int_nothrow)
0101 TLI_DEFINE_STRING_INTERNAL("??_U@YAPAXIABUnothrow_t@std@@@Z")
0102 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
0103 
0104 /// void *operator new[](unsigned long long);
0105 TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong)
0106 TLI_DEFINE_STRING_INTERNAL("??_U@YAPEAX_K@Z")
0107 TLI_DEFINE_SIG_INTERNAL(Ptr, LLong)
0108 
0109 /// void *operator new[](unsigned long long, const std::nothrow_t&);
0110 TLI_DEFINE_ENUM_INTERNAL(msvc_new_array_longlong_nothrow)
0111 TLI_DEFINE_STRING_INTERNAL("??_U@YAPEAX_KAEBUnothrow_t@std@@@Z")
0112 TLI_DEFINE_SIG_INTERNAL(Ptr, LLong, Ptr)
0113 
0114 /// void operator delete[](void*);
0115 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32)
0116 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAX@Z")
0117 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0118 
0119 /// void operator delete[](void*, const std::nothrow_t&);
0120 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_nothrow)
0121 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAXABUnothrow_t@std@@@Z")
0122 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0123 
0124 /// void operator delete[](void*, unsigned int);
0125 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr32_int)
0126 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPAXI@Z")
0127 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
0128 
0129 /// void operator delete[](void*);
0130 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64)
0131 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAX@Z")
0132 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0133 
0134 /// void operator delete[](void*, const std::nothrow_t&);
0135 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_nothrow)
0136 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAXAEBUnothrow_t@std@@@Z")
0137 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0138 
0139 /// void operator delete[](void*, unsigned long long);
0140 TLI_DEFINE_ENUM_INTERNAL(msvc_delete_array_ptr64_longlong)
0141 TLI_DEFINE_STRING_INTERNAL("??_V@YAXPEAX_K@Z")
0142 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, LLong)
0143 
0144 /// int _IO_getc(_IO_FILE * __fp);
0145 TLI_DEFINE_ENUM_INTERNAL(under_IO_getc)
0146 TLI_DEFINE_STRING_INTERNAL("_IO_getc")
0147 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
0148 
0149 /// int _IO_putc(int __c, _IO_FILE * __fp);
0150 TLI_DEFINE_ENUM_INTERNAL(under_IO_putc)
0151 TLI_DEFINE_STRING_INTERNAL("_IO_putc")
0152 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
0153 
0154 /// void operator delete[](void*);
0155 TLI_DEFINE_ENUM_INTERNAL(ZdaPv)
0156 TLI_DEFINE_STRING_INTERNAL("_ZdaPv")
0157 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0158 
0159 /// void operator delete[](void*, const std::nothrow_t&);
0160 TLI_DEFINE_ENUM_INTERNAL(ZdaPvRKSt9nothrow_t)
0161 TLI_DEFINE_STRING_INTERNAL("_ZdaPvRKSt9nothrow_t")
0162 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0163 
0164 /// void operator delete[](void*, std::align_val_t);
0165 TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_t)
0166 TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_t")
0167 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus)
0168 
0169 /// void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
0170 TLI_DEFINE_ENUM_INTERNAL(ZdaPvSt11align_val_tRKSt9nothrow_t)
0171 TLI_DEFINE_STRING_INTERNAL("_ZdaPvSt11align_val_tRKSt9nothrow_t")
0172 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr)
0173 
0174 /// void operator delete[](void*, unsigned int);
0175 TLI_DEFINE_ENUM_INTERNAL(ZdaPvj)
0176 TLI_DEFINE_STRING_INTERNAL("_ZdaPvj")
0177 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
0178 
0179 /// void operator delete[](void*, unsigned int, std::align_val_t);
0180 TLI_DEFINE_ENUM_INTERNAL(ZdaPvjSt11align_val_t)
0181 TLI_DEFINE_STRING_INTERNAL("_ZdaPvjSt11align_val_t")
0182 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int)
0183 
0184 /// void operator delete[](void*, unsigned long);
0185 TLI_DEFINE_ENUM_INTERNAL(ZdaPvm)
0186 TLI_DEFINE_STRING_INTERNAL("_ZdaPvm")
0187 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long)
0188 
0189 /// void operator delete[](void*, unsigned long, std::align_val_t);
0190 TLI_DEFINE_ENUM_INTERNAL(ZdaPvmSt11align_val_t)
0191 TLI_DEFINE_STRING_INTERNAL("_ZdaPvmSt11align_val_t")
0192 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long)
0193 
0194 /// void operator delete(void*);
0195 TLI_DEFINE_ENUM_INTERNAL(ZdlPv)
0196 TLI_DEFINE_STRING_INTERNAL("_ZdlPv")
0197 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0198 
0199 /// void operator delete(void*, const std::nothrow_t&);
0200 TLI_DEFINE_ENUM_INTERNAL(ZdlPvRKSt9nothrow_t)
0201 TLI_DEFINE_STRING_INTERNAL("_ZdlPvRKSt9nothrow_t")
0202 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
0203 
0204 /// void operator delete(void*, std::align_val_t)
0205 TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_t)
0206 TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_t")
0207 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus)
0208 
0209 /// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
0210 TLI_DEFINE_ENUM_INTERNAL(ZdlPvSt11align_val_tRKSt9nothrow_t)
0211 TLI_DEFINE_STRING_INTERNAL("_ZdlPvSt11align_val_tRKSt9nothrow_t")
0212 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, IntPlus, Ptr)
0213 
0214 /// void operator delete(void*, unsigned int);
0215 TLI_DEFINE_ENUM_INTERNAL(ZdlPvj)
0216 TLI_DEFINE_STRING_INTERNAL("_ZdlPvj")
0217 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int)
0218 
0219 /// void operator delete(void*, unsigned int, std::align_val_t)
0220 TLI_DEFINE_ENUM_INTERNAL(ZdlPvjSt11align_val_t)
0221 TLI_DEFINE_STRING_INTERNAL("_ZdlPvjSt11align_val_t")
0222 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Int, Int)
0223 
0224 /// void operator delete(void*, unsigned long);
0225 TLI_DEFINE_ENUM_INTERNAL(ZdlPvm)
0226 TLI_DEFINE_STRING_INTERNAL("_ZdlPvm")
0227 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long)
0228 
0229 /// void operator delete(void*, unsigned long, std::align_val_t)
0230 TLI_DEFINE_ENUM_INTERNAL(ZdlPvmSt11align_val_t)
0231 TLI_DEFINE_STRING_INTERNAL("_ZdlPvmSt11align_val_t")
0232 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Long, Long)
0233 
0234 /// void *operator new[](unsigned int);
0235 TLI_DEFINE_ENUM_INTERNAL(Znaj)
0236 TLI_DEFINE_STRING_INTERNAL("_Znaj")
0237 TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
0238 
0239 /// void *operator new[](unsigned int, const std::nothrow_t&);
0240 TLI_DEFINE_ENUM_INTERNAL(ZnajRKSt9nothrow_t)
0241 TLI_DEFINE_STRING_INTERNAL("_ZnajRKSt9nothrow_t")
0242 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
0243 
0244 /// void *operator new[](unsigned int, std::align_val_t)
0245 TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_t)
0246 TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_t")
0247 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int)
0248 
0249 /// void *operator new[](unsigned int, std::align_val_t, const std::nothrow_t&)
0250 TLI_DEFINE_ENUM_INTERNAL(ZnajSt11align_val_tRKSt9nothrow_t)
0251 TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_tRKSt9nothrow_t")
0252 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
0253 
0254 /// void *operator new[](unsigned long);
0255 TLI_DEFINE_ENUM_INTERNAL(Znam)
0256 TLI_DEFINE_STRING_INTERNAL("_Znam")
0257 TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
0258 
0259 /// void *operator new[](unsigned long, __hot_cold_t)
0260 /// Currently this and other operator new interfaces that take a __hot_cold_t
0261 /// hint are supported by the open source version of tcmalloc, see:
0262 /// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
0263 /// and for the definition of the __hot_cold_t parameter see:
0264 /// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
0265 TLI_DEFINE_ENUM_INTERNAL(Znam12__hot_cold_t)
0266 TLI_DEFINE_STRING_INTERNAL("_Znam12__hot_cold_t")
0267 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
0268 
0269 /// void *operator new[](unsigned long, const std::nothrow_t&);
0270 TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t)
0271 TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t")
0272 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
0273 
0274 /// void *operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t)
0275 TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t12__hot_cold_t)
0276 TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t12__hot_cold_t")
0277 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
0278 
0279 /// void *operator new[](unsigned long, std::align_val_t)
0280 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t)
0281 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t")
0282 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
0283 
0284 /// void *operator new[](unsigned long, std::align_val_t, __hot_cold_t)
0285 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t12__hot_cold_t)
0286 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t12__hot_cold_t")
0287 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
0288 
0289 /// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&)
0290 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t)
0291 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t")
0292 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
0293 
0294 /// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
0295 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
0296 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
0297 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
0298 
0299 /// void *operator new(unsigned int);
0300 TLI_DEFINE_ENUM_INTERNAL(Znwj)
0301 TLI_DEFINE_STRING_INTERNAL("_Znwj")
0302 TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
0303 
0304 /// void *operator new(unsigned int, const std::nothrow_t&);
0305 TLI_DEFINE_ENUM_INTERNAL(ZnwjRKSt9nothrow_t)
0306 TLI_DEFINE_STRING_INTERNAL("_ZnwjRKSt9nothrow_t")
0307 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
0308 
0309 /// void *operator new(unsigned int, std::align_val_t)
0310 TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_t)
0311 TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_t")
0312 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int)
0313 
0314 /// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
0315 TLI_DEFINE_ENUM_INTERNAL(ZnwjSt11align_val_tRKSt9nothrow_t)
0316 TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_tRKSt9nothrow_t")
0317 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
0318 
0319 /// void *operator new(unsigned long);
0320 TLI_DEFINE_ENUM_INTERNAL(Znwm)
0321 TLI_DEFINE_STRING_INTERNAL("_Znwm")
0322 TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
0323 
0324 /// void *operator new(unsigned long, __hot_cold_t)
0325 TLI_DEFINE_ENUM_INTERNAL(Znwm12__hot_cold_t)
0326 TLI_DEFINE_STRING_INTERNAL("_Znwm12__hot_cold_t")
0327 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
0328 
0329 /// void *operator new(unsigned long, const std::nothrow_t&);
0330 TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t)
0331 TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t")
0332 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
0333 
0334 /// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
0335 TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t12__hot_cold_t)
0336 TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t12__hot_cold_t")
0337 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
0338 
0339 /// void *operator new(unsigned long, std::align_val_t)
0340 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t)
0341 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t")
0342 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
0343 
0344 /// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
0345 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t12__hot_cold_t)
0346 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t12__hot_cold_t")
0347 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
0348 
0349 /// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
0350 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t)
0351 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t")
0352 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
0353 
0354 /// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
0355 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
0356 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
0357 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
0358 
0359 /// The following are variants of operator new which return the actual size
0360 /// reserved by the allocator proposed in P0901R5 (Size feedback in operator new).
0361 /// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0901r5.html
0362 /// They are implemented by tcmalloc, see source at
0363 /// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
0364 
0365 /// __sized_ptr_t __size_returning_new(size_t size)
0366 TLI_DEFINE_ENUM_INTERNAL(size_returning_new)
0367 TLI_DEFINE_STRING_INTERNAL("__size_returning_new")
0368 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0369 
0370 /// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
0371 TLI_DEFINE_ENUM_INTERNAL(size_returning_new_hot_cold)
0372 TLI_DEFINE_STRING_INTERNAL("__size_returning_new_hot_cold")
0373 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0374 
0375 /// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
0376 TLI_DEFINE_ENUM_INTERNAL(size_returning_new_aligned)
0377 TLI_DEFINE_STRING_INTERNAL("__size_returning_new_aligned")
0378 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0379 
0380 /// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t, __hot_cold_t)
0381 TLI_DEFINE_ENUM_INTERNAL(size_returning_new_aligned_hot_cold)
0382 TLI_DEFINE_STRING_INTERNAL("__size_returning_new_aligned_hot_cold")
0383 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0384 
0385 /// double __acos_finite(double x);
0386 TLI_DEFINE_ENUM_INTERNAL(acos_finite)
0387 TLI_DEFINE_STRING_INTERNAL("__acos_finite")
0388 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0389 
0390 /// float __acosf_finite(float x);
0391 TLI_DEFINE_ENUM_INTERNAL(acosf_finite)
0392 TLI_DEFINE_STRING_INTERNAL("__acosf_finite")
0393 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0394 
0395 /// double __acosh_finite(double x);
0396 TLI_DEFINE_ENUM_INTERNAL(acosh_finite)
0397 TLI_DEFINE_STRING_INTERNAL("__acosh_finite")
0398 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0399 
0400 /// float __acoshf_finite(float x);
0401 TLI_DEFINE_ENUM_INTERNAL(acoshf_finite)
0402 TLI_DEFINE_STRING_INTERNAL("__acoshf_finite")
0403 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0404 
0405 /// long double __acoshl_finite(long double x);
0406 TLI_DEFINE_ENUM_INTERNAL(acoshl_finite)
0407 TLI_DEFINE_STRING_INTERNAL("__acoshl_finite")
0408 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0409 
0410 /// long double __acosl_finite(long double x);
0411 TLI_DEFINE_ENUM_INTERNAL(acosl_finite)
0412 TLI_DEFINE_STRING_INTERNAL("__acosl_finite")
0413 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0414 
0415 /// double __asin_finite(double x);
0416 TLI_DEFINE_ENUM_INTERNAL(asin_finite)
0417 TLI_DEFINE_STRING_INTERNAL("__asin_finite")
0418 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0419 
0420 /// float __asinf_finite(float x);
0421 TLI_DEFINE_ENUM_INTERNAL(asinf_finite)
0422 TLI_DEFINE_STRING_INTERNAL("__asinf_finite")
0423 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0424 
0425 /// long double __asinl_finite(long double x);
0426 TLI_DEFINE_ENUM_INTERNAL(asinl_finite)
0427 TLI_DEFINE_STRING_INTERNAL("__asinl_finite")
0428 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0429 
0430 /// double atan2_finite(double y, double x);
0431 TLI_DEFINE_ENUM_INTERNAL(atan2_finite)
0432 TLI_DEFINE_STRING_INTERNAL("__atan2_finite")
0433 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
0434 
0435 /// float atan2f_finite(float y, float x);
0436 TLI_DEFINE_ENUM_INTERNAL(atan2f_finite)
0437 TLI_DEFINE_STRING_INTERNAL("__atan2f_finite")
0438 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
0439 
0440 /// long double atan2l_finite(long double y, long double x);
0441 TLI_DEFINE_ENUM_INTERNAL(atan2l_finite)
0442 TLI_DEFINE_STRING_INTERNAL("__atan2l_finite")
0443 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
0444 
0445 /// double __atanh_finite(double x);
0446 TLI_DEFINE_ENUM_INTERNAL(atanh_finite)
0447 TLI_DEFINE_STRING_INTERNAL("__atanh_finite")
0448 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0449 
0450 /// float __atanhf_finite(float x);
0451 TLI_DEFINE_ENUM_INTERNAL(atanhf_finite)
0452 TLI_DEFINE_STRING_INTERNAL("__atanhf_finite")
0453 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0454 
0455 /// long double __atanhl_finite(long double x);
0456 TLI_DEFINE_ENUM_INTERNAL(atanhl_finite)
0457 TLI_DEFINE_STRING_INTERNAL("__atanhl_finite")
0458 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0459 
0460 /// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
0461 TLI_DEFINE_ENUM_INTERNAL(atomic_load)
0462 TLI_DEFINE_STRING_INTERNAL("__atomic_load")
0463 TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int)
0464 
0465 /// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
0466 TLI_DEFINE_ENUM_INTERNAL(atomic_store)
0467 TLI_DEFINE_STRING_INTERNAL("__atomic_store")
0468 TLI_DEFINE_SIG_INTERNAL(Void, SizeT, Ptr, Ptr, Int)
0469 
0470 /// double __cosh_finite(double x);
0471 TLI_DEFINE_ENUM_INTERNAL(cosh_finite)
0472 TLI_DEFINE_STRING_INTERNAL("__cosh_finite")
0473 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0474 
0475 /// float __coshf_finite(float x);
0476 TLI_DEFINE_ENUM_INTERNAL(coshf_finite)
0477 TLI_DEFINE_STRING_INTERNAL("__coshf_finite")
0478 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0479 
0480 /// long double __coshl_finite(long double x);
0481 TLI_DEFINE_ENUM_INTERNAL(coshl_finite)
0482 TLI_DEFINE_STRING_INTERNAL("__coshl_finite")
0483 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0484 
0485 /// double __cospi(double x);
0486 TLI_DEFINE_ENUM_INTERNAL(cospi)
0487 TLI_DEFINE_STRING_INTERNAL("__cospi")
0488 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0489 
0490 /// float __cospif(float x);
0491 TLI_DEFINE_ENUM_INTERNAL(cospif)
0492 TLI_DEFINE_STRING_INTERNAL("__cospif")
0493 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0494 
0495 /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
0496 TLI_DEFINE_ENUM_INTERNAL(cxa_atexit)
0497 TLI_DEFINE_STRING_INTERNAL("__cxa_atexit")
0498 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
0499 
0500 /// int atexit(void (*f)(void));
0501 TLI_DEFINE_ENUM_INTERNAL(atexit)
0502 TLI_DEFINE_STRING_INTERNAL("atexit")
0503 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
0504 
0505 /// void abort(void)
0506 TLI_DEFINE_ENUM_INTERNAL(abort)
0507 TLI_DEFINE_STRING_INTERNAL("abort")
0508 TLI_DEFINE_SIG_INTERNAL(Void)
0509 
0510 /// void exit(int)
0511 TLI_DEFINE_ENUM_INTERNAL(exit)
0512 TLI_DEFINE_STRING_INTERNAL("exit")
0513 TLI_DEFINE_SIG_INTERNAL(Void, Int)
0514 
0515 /// void _Exit(int)
0516 TLI_DEFINE_ENUM_INTERNAL(Exit)
0517 TLI_DEFINE_STRING_INTERNAL("_Exit")
0518 TLI_DEFINE_SIG_INTERNAL(Void, Int)
0519 
0520 /// void std::terminate();
0521 TLI_DEFINE_ENUM_INTERNAL(terminate)
0522 TLI_DEFINE_STRING_INTERNAL("_ZSt9terminatev")
0523 TLI_DEFINE_SIG_INTERNAL(Void)
0524 
0525 /// void __cxa_throw(void *, void *, void (*)(void *));
0526 TLI_DEFINE_ENUM_INTERNAL(cxa_throw)
0527 TLI_DEFINE_STRING_INTERNAL("__cxa_throw")
0528 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, Ptr)
0529 
0530 /// void __cxa_guard_abort(guard_t *guard);
0531 /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
0532 TLI_DEFINE_ENUM_INTERNAL(cxa_guard_abort)
0533 TLI_DEFINE_STRING_INTERNAL("__cxa_guard_abort")
0534 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0535 
0536 /// int __cxa_guard_acquire(guard_t *guard);
0537 TLI_DEFINE_ENUM_INTERNAL(cxa_guard_acquire)
0538 TLI_DEFINE_STRING_INTERNAL("__cxa_guard_acquire")
0539 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
0540 
0541 /// void __cxa_guard_release(guard_t *guard);
0542 TLI_DEFINE_ENUM_INTERNAL(cxa_guard_release)
0543 TLI_DEFINE_STRING_INTERNAL("__cxa_guard_release")
0544 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
0545 
0546 /// double __exp10_finite(double x);
0547 TLI_DEFINE_ENUM_INTERNAL(exp10_finite)
0548 TLI_DEFINE_STRING_INTERNAL("__exp10_finite")
0549 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0550 
0551 /// float __exp10f_finite(float x);
0552 TLI_DEFINE_ENUM_INTERNAL(exp10f_finite)
0553 TLI_DEFINE_STRING_INTERNAL("__exp10f_finite")
0554 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0555 
0556 /// long double __exp10l_finite(long double x);
0557 TLI_DEFINE_ENUM_INTERNAL(exp10l_finite)
0558 TLI_DEFINE_STRING_INTERNAL("__exp10l_finite")
0559 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0560 
0561 /// double __exp2_finite(double x);
0562 TLI_DEFINE_ENUM_INTERNAL(exp2_finite)
0563 TLI_DEFINE_STRING_INTERNAL("__exp2_finite")
0564 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0565 
0566 /// float __exp2f_finite(float x);
0567 TLI_DEFINE_ENUM_INTERNAL(exp2f_finite)
0568 TLI_DEFINE_STRING_INTERNAL("__exp2f_finite")
0569 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0570 
0571 /// long double __exp2l_finite(long double x);
0572 TLI_DEFINE_ENUM_INTERNAL(exp2l_finite)
0573 TLI_DEFINE_STRING_INTERNAL("__exp2l_finite")
0574 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0575 
0576 /// double __exp_finite(double x);
0577 TLI_DEFINE_ENUM_INTERNAL(exp_finite)
0578 TLI_DEFINE_STRING_INTERNAL("__exp_finite")
0579 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0580 
0581 /// float __expf_finite(float x);
0582 TLI_DEFINE_ENUM_INTERNAL(expf_finite)
0583 TLI_DEFINE_STRING_INTERNAL("__expf_finite")
0584 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0585 
0586 /// long double __expl_finite(long double x);
0587 TLI_DEFINE_ENUM_INTERNAL(expl_finite)
0588 TLI_DEFINE_STRING_INTERNAL("__expl_finite")
0589 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0590 
0591 /// int __isoc99_scanf (const char *format, ...)
0592 TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_scanf)
0593 TLI_DEFINE_STRING_INTERNAL("__isoc99_scanf")
0594 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
0595 
0596 /// int __isoc99_sscanf(const char *s, const char *format, ...)
0597 TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_sscanf)
0598 TLI_DEFINE_STRING_INTERNAL("__isoc99_sscanf")
0599 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
0600 
0601 /// void* __kmpc_alloc_shared(size_t nbyte);
0602 TLI_DEFINE_ENUM_INTERNAL(__kmpc_alloc_shared)
0603 TLI_DEFINE_STRING_INTERNAL("__kmpc_alloc_shared")
0604 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
0605 
0606 /// void __kmpc_free_shared(void *ptr, size_t nbyte);
0607 TLI_DEFINE_ENUM_INTERNAL(__kmpc_free_shared)
0608 TLI_DEFINE_STRING_INTERNAL("__kmpc_free_shared")
0609 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT)
0610 
0611 /// double __log10_finite(double x);
0612 TLI_DEFINE_ENUM_INTERNAL(log10_finite)
0613 TLI_DEFINE_STRING_INTERNAL("__log10_finite")
0614 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0615 
0616 /// float __log10f_finite(float x);
0617 TLI_DEFINE_ENUM_INTERNAL(log10f_finite)
0618 TLI_DEFINE_STRING_INTERNAL("__log10f_finite")
0619 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0620 
0621 /// long double __log10l_finite(long double x);
0622 TLI_DEFINE_ENUM_INTERNAL(log10l_finite)
0623 TLI_DEFINE_STRING_INTERNAL("__log10l_finite")
0624 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0625 
0626 /// double __log2_finite(double x);
0627 TLI_DEFINE_ENUM_INTERNAL(log2_finite)
0628 TLI_DEFINE_STRING_INTERNAL("__log2_finite")
0629 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0630 
0631 /// float __log2f_finite(float x);
0632 TLI_DEFINE_ENUM_INTERNAL(log2f_finite)
0633 TLI_DEFINE_STRING_INTERNAL("__log2f_finite")
0634 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0635 
0636 /// long double __log2l_finite(long double x);
0637 TLI_DEFINE_ENUM_INTERNAL(log2l_finite)
0638 TLI_DEFINE_STRING_INTERNAL("__log2l_finite")
0639 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0640 
0641 /// double __log_finite(double x);
0642 TLI_DEFINE_ENUM_INTERNAL(log_finite)
0643 TLI_DEFINE_STRING_INTERNAL("__log_finite")
0644 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0645 
0646 /// float __logf_finite(float x);
0647 TLI_DEFINE_ENUM_INTERNAL(logf_finite)
0648 TLI_DEFINE_STRING_INTERNAL("__logf_finite")
0649 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0650 
0651 /// long double __logl_finite(long double x);
0652 TLI_DEFINE_ENUM_INTERNAL(logl_finite)
0653 TLI_DEFINE_STRING_INTERNAL("__logl_finite")
0654 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0655 
0656 /// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
0657 ///                     size_t dstsize)
0658 TLI_DEFINE_ENUM_INTERNAL(memccpy_chk)
0659 TLI_DEFINE_STRING_INTERNAL("__memccpy_chk")
0660 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT, SizeT)
0661 
0662 /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
0663 TLI_DEFINE_ENUM_INTERNAL(memcpy_chk)
0664 TLI_DEFINE_STRING_INTERNAL("__memcpy_chk")
0665 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0666 
0667 /// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
0668 TLI_DEFINE_ENUM_INTERNAL(memmove_chk)
0669 TLI_DEFINE_STRING_INTERNAL("__memmove_chk")
0670 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0671 
0672 /// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
0673 TLI_DEFINE_ENUM_INTERNAL(mempcpy_chk)
0674 TLI_DEFINE_STRING_INTERNAL("__mempcpy_chk")
0675 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0676 
0677 /// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
0678 TLI_DEFINE_ENUM_INTERNAL(memset_chk)
0679 TLI_DEFINE_STRING_INTERNAL("__memset_chk")
0680 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT, SizeT)
0681 
0682 // int __nvvm_reflect(const char *)
0683 TLI_DEFINE_ENUM_INTERNAL(nvvm_reflect)
0684 TLI_DEFINE_STRING_INTERNAL("__nvvm_reflect")
0685 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
0686 
0687 /// double __pow_finite(double x, double y);
0688 TLI_DEFINE_ENUM_INTERNAL(pow_finite)
0689 TLI_DEFINE_STRING_INTERNAL("__pow_finite")
0690 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
0691 
0692 /// float _powf_finite(float x, float y);
0693 TLI_DEFINE_ENUM_INTERNAL(powf_finite)
0694 TLI_DEFINE_STRING_INTERNAL("__powf_finite")
0695 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
0696 
0697 /// long double __powl_finite(long double x, long double y);
0698 TLI_DEFINE_ENUM_INTERNAL(powl_finite)
0699 TLI_DEFINE_STRING_INTERNAL("__powl_finite")
0700 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
0701 
0702 /// double __sincospi_stret(double x);
0703 TLI_DEFINE_ENUM_INTERNAL(sincospi_stret)
0704 TLI_DEFINE_STRING_INTERNAL("__sincospi_stret")
0705 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0706 
0707 /// float __sincospif_stret(float x);
0708 TLI_DEFINE_ENUM_INTERNAL(sincospif_stret)
0709 TLI_DEFINE_STRING_INTERNAL("__sincospif_stret")
0710 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
0711 
0712 /// double __sinh_finite(double x);
0713 TLI_DEFINE_ENUM_INTERNAL(sinh_finite)
0714 TLI_DEFINE_STRING_INTERNAL("__sinh_finite")
0715 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0716 
0717 /// float _sinhf_finite(float x);
0718 TLI_DEFINE_ENUM_INTERNAL(sinhf_finite)
0719 TLI_DEFINE_STRING_INTERNAL("__sinhf_finite")
0720 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0721 
0722 /// long double __sinhl_finite(long double x);
0723 TLI_DEFINE_ENUM_INTERNAL(sinhl_finite)
0724 TLI_DEFINE_STRING_INTERNAL("__sinhl_finite")
0725 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0726 
0727 /// double __sinpi(double x);
0728 TLI_DEFINE_ENUM_INTERNAL(sinpi)
0729 TLI_DEFINE_STRING_INTERNAL("__sinpi")
0730 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0731 
0732 /// float __sinpif(float x);
0733 TLI_DEFINE_ENUM_INTERNAL(sinpif)
0734 TLI_DEFINE_STRING_INTERNAL("__sinpif")
0735 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0736 
0737 /// int __small_fprintf(FILE *stream, const char *format, ...);
0738 TLI_DEFINE_ENUM_INTERNAL(small_fprintf)
0739 TLI_DEFINE_STRING_INTERNAL("__small_fprintf")
0740 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
0741 
0742 /// int __small_printf(const char *format, ...);
0743 TLI_DEFINE_ENUM_INTERNAL(small_printf)
0744 TLI_DEFINE_STRING_INTERNAL("__small_printf")
0745 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
0746 
0747 /// int __small_sprintf(char *str, const char *format, ...);
0748 TLI_DEFINE_ENUM_INTERNAL(small_sprintf)
0749 TLI_DEFINE_STRING_INTERNAL("__small_sprintf")
0750 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
0751 
0752 /// int __snprintf_chk(char *s, size_t n, int flags, size_t slen,
0753 ///                    const char *format, ...);
0754 TLI_DEFINE_ENUM_INTERNAL(snprintf_chk)
0755 TLI_DEFINE_STRING_INTERNAL("__snprintf_chk")
0756 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ellip)
0757 
0758 /// int __sprintf_chk(char *str, int flags, size_t str_len,
0759 ///                   const char *format, ...);
0760 TLI_DEFINE_ENUM_INTERNAL(sprintf_chk)
0761 TLI_DEFINE_STRING_INTERNAL("__sprintf_chk")
0762 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ellip)
0763 
0764 /// double __sqrt_finite(double x);
0765 TLI_DEFINE_ENUM_INTERNAL(sqrt_finite)
0766 TLI_DEFINE_STRING_INTERNAL("__sqrt_finite")
0767 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0768 
0769 /// float __sqrt_finite(float x);
0770 TLI_DEFINE_ENUM_INTERNAL(sqrtf_finite)
0771 TLI_DEFINE_STRING_INTERNAL("__sqrtf_finite")
0772 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0773 
0774 /// long double __sqrt_finite(long double x);
0775 TLI_DEFINE_ENUM_INTERNAL(sqrtl_finite)
0776 TLI_DEFINE_STRING_INTERNAL("__sqrtl_finite")
0777 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0778 
0779 /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
0780 TLI_DEFINE_ENUM_INTERNAL(stpcpy_chk)
0781 TLI_DEFINE_STRING_INTERNAL("__stpcpy_chk")
0782 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
0783 
0784 /// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
0785 TLI_DEFINE_ENUM_INTERNAL(stpncpy_chk)
0786 TLI_DEFINE_STRING_INTERNAL("__stpncpy_chk")
0787 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0788 
0789 /// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
0790 TLI_DEFINE_ENUM_INTERNAL(strcat_chk)
0791 TLI_DEFINE_STRING_INTERNAL("__strcat_chk")
0792 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
0793 
0794 /// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
0795 TLI_DEFINE_ENUM_INTERNAL(strcpy_chk)
0796 TLI_DEFINE_STRING_INTERNAL("__strcpy_chk")
0797 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
0798 
0799 /// char * __strdup(const char *s);
0800 TLI_DEFINE_ENUM_INTERNAL(dunder_strdup)
0801 TLI_DEFINE_STRING_INTERNAL("__strdup")
0802 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
0803 
0804 /// size_t __strlcat_chk(char *dst, const char *src, size_t size,
0805 ///                      size_t dstsize);
0806 TLI_DEFINE_ENUM_INTERNAL(strlcat_chk)
0807 TLI_DEFINE_STRING_INTERNAL("__strlcat_chk")
0808 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT)
0809 
0810 /// size_t __strlcpy_chk(char *dst, const char *src, size_t size,
0811 ///                      size_t dstsize);
0812 TLI_DEFINE_ENUM_INTERNAL(strlcpy_chk)
0813 TLI_DEFINE_STRING_INTERNAL("__strlcpy_chk")
0814 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT, SizeT)
0815 
0816 /// size_t __strlen_chk(const char *s1, size_t s1size);
0817 TLI_DEFINE_ENUM_INTERNAL(strlen_chk)
0818 TLI_DEFINE_STRING_INTERNAL("__strlen_chk")
0819 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT)
0820 
0821 /// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
0822 TLI_DEFINE_ENUM_INTERNAL(strncat_chk)
0823 TLI_DEFINE_STRING_INTERNAL("__strncat_chk")
0824 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0825 
0826 /// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
0827 TLI_DEFINE_ENUM_INTERNAL(strncpy_chk)
0828 TLI_DEFINE_STRING_INTERNAL("__strncpy_chk")
0829 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT, SizeT)
0830 
0831 /// char *__strndup(const char *s, size_t n);
0832 TLI_DEFINE_ENUM_INTERNAL(dunder_strndup)
0833 TLI_DEFINE_STRING_INTERNAL("__strndup")
0834 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
0835 
0836 /// char * __strtok_r(char *s, const char *delim, char **save_ptr);
0837 TLI_DEFINE_ENUM_INTERNAL(dunder_strtok_r)
0838 TLI_DEFINE_STRING_INTERNAL("__strtok_r")
0839 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr)
0840 
0841 /// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen,
0842 ///                     const char *format, va_list ap);
0843 TLI_DEFINE_ENUM_INTERNAL(vsnprintf_chk)
0844 TLI_DEFINE_STRING_INTERNAL("__vsnprintf_chk")
0845 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Int, SizeT, Ptr, Ptr)
0846 
0847 /// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format,
0848 ///                    va_list ap);
0849 TLI_DEFINE_ENUM_INTERNAL(vsprintf_chk)
0850 TLI_DEFINE_STRING_INTERNAL("__vsprintf_chk")
0851 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, SizeT, Ptr, Ptr)
0852 
0853 /// int abs(int j);
0854 TLI_DEFINE_ENUM_INTERNAL(abs)
0855 TLI_DEFINE_STRING_INTERNAL("abs")
0856 TLI_DEFINE_SIG_INTERNAL(Int, Int)
0857 
0858 /// int access(const char *path, int amode);
0859 TLI_DEFINE_ENUM_INTERNAL(access)
0860 TLI_DEFINE_STRING_INTERNAL("access")
0861 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int)
0862 
0863 /// double acos(double x);
0864 TLI_DEFINE_ENUM_INTERNAL(acos)
0865 TLI_DEFINE_STRING_INTERNAL("acos")
0866 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0867 
0868 /// float acosf(float x);
0869 TLI_DEFINE_ENUM_INTERNAL(acosf)
0870 TLI_DEFINE_STRING_INTERNAL("acosf")
0871 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0872 
0873 /// double acosh(double x);
0874 TLI_DEFINE_ENUM_INTERNAL(acosh)
0875 TLI_DEFINE_STRING_INTERNAL("acosh")
0876 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0877 
0878 /// float acoshf(float x);
0879 TLI_DEFINE_ENUM_INTERNAL(acoshf)
0880 TLI_DEFINE_STRING_INTERNAL("acoshf")
0881 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0882 
0883 /// long double acoshl(long double x);
0884 TLI_DEFINE_ENUM_INTERNAL(acoshl)
0885 TLI_DEFINE_STRING_INTERNAL("acoshl")
0886 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0887 
0888 /// long double acosl(long double x);
0889 TLI_DEFINE_ENUM_INTERNAL(acosl)
0890 TLI_DEFINE_STRING_INTERNAL("acosl")
0891 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0892 
0893 /// void *aligned_alloc(size_t alignment, size_t size);
0894 TLI_DEFINE_ENUM_INTERNAL(aligned_alloc)
0895 TLI_DEFINE_STRING_INTERNAL("aligned_alloc")
0896 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
0897 
0898 /// double asin(double x);
0899 TLI_DEFINE_ENUM_INTERNAL(asin)
0900 TLI_DEFINE_STRING_INTERNAL("asin")
0901 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0902 
0903 /// float asinf(float x);
0904 TLI_DEFINE_ENUM_INTERNAL(asinf)
0905 TLI_DEFINE_STRING_INTERNAL("asinf")
0906 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0907 
0908 /// double asinh(double x);
0909 TLI_DEFINE_ENUM_INTERNAL(asinh)
0910 TLI_DEFINE_STRING_INTERNAL("asinh")
0911 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0912 
0913 /// float asinhf(float x);
0914 TLI_DEFINE_ENUM_INTERNAL(asinhf)
0915 TLI_DEFINE_STRING_INTERNAL("asinhf")
0916 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0917 
0918 /// long double asinhl(long double x);
0919 TLI_DEFINE_ENUM_INTERNAL(asinhl)
0920 TLI_DEFINE_STRING_INTERNAL("asinhl")
0921 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0922 
0923 /// long double asinl(long double x);
0924 TLI_DEFINE_ENUM_INTERNAL(asinl)
0925 TLI_DEFINE_STRING_INTERNAL("asinl")
0926 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0927 
0928 /// double atan(double x);
0929 TLI_DEFINE_ENUM_INTERNAL(atan)
0930 TLI_DEFINE_STRING_INTERNAL("atan")
0931 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0932 
0933 /// double atan2(double y, double x);
0934 TLI_DEFINE_ENUM_INTERNAL(atan2)
0935 TLI_DEFINE_STRING_INTERNAL("atan2")
0936 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
0937 
0938 /// float atan2f(float y, float x);
0939 TLI_DEFINE_ENUM_INTERNAL(atan2f)
0940 TLI_DEFINE_STRING_INTERNAL("atan2f")
0941 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
0942 
0943 /// long double atan2l(long double y, long double x);
0944 TLI_DEFINE_ENUM_INTERNAL(atan2l)
0945 TLI_DEFINE_STRING_INTERNAL("atan2l")
0946 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
0947 
0948 /// float atanf(float x);
0949 TLI_DEFINE_ENUM_INTERNAL(atanf)
0950 TLI_DEFINE_STRING_INTERNAL("atanf")
0951 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0952 
0953 /// double atanh(double x);
0954 TLI_DEFINE_ENUM_INTERNAL(atanh)
0955 TLI_DEFINE_STRING_INTERNAL("atanh")
0956 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
0957 
0958 /// float atanhf(float x);
0959 TLI_DEFINE_ENUM_INTERNAL(atanhf)
0960 TLI_DEFINE_STRING_INTERNAL("atanhf")
0961 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
0962 
0963 /// long double atanhl(long double x);
0964 TLI_DEFINE_ENUM_INTERNAL(atanhl)
0965 TLI_DEFINE_STRING_INTERNAL("atanhl")
0966 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0967 
0968 /// long double atanl(long double x);
0969 TLI_DEFINE_ENUM_INTERNAL(atanl)
0970 TLI_DEFINE_STRING_INTERNAL("atanl")
0971 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
0972 
0973 /// double atof(const char *str);
0974 TLI_DEFINE_ENUM_INTERNAL(atof)
0975 TLI_DEFINE_STRING_INTERNAL("atof")
0976 TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr)
0977 
0978 /// int atoi(const char *str);
0979 TLI_DEFINE_ENUM_INTERNAL(atoi)
0980 TLI_DEFINE_STRING_INTERNAL("atoi")
0981 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
0982 
0983 /// long atol(const char *str);
0984 TLI_DEFINE_ENUM_INTERNAL(atol)
0985 TLI_DEFINE_STRING_INTERNAL("atol")
0986 TLI_DEFINE_SIG_INTERNAL(Long, Ptr)
0987 
0988 /// long long atoll(const char *nptr);
0989 TLI_DEFINE_ENUM_INTERNAL(atoll)
0990 TLI_DEFINE_STRING_INTERNAL("atoll")
0991 TLI_DEFINE_SIG_INTERNAL(LLong, Ptr)
0992 
0993 /// int bcmp(const void *s1, const void *s2, size_t n);
0994 TLI_DEFINE_ENUM_INTERNAL(bcmp)
0995 TLI_DEFINE_STRING_INTERNAL("bcmp")
0996 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
0997 
0998 /// void bcopy(const void *s1, void *s2, size_t n);
0999 TLI_DEFINE_ENUM_INTERNAL(bcopy)
1000 TLI_DEFINE_STRING_INTERNAL("bcopy")
1001 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
1002 
1003 /// void bzero(void *s, size_t n);
1004 TLI_DEFINE_ENUM_INTERNAL(bzero)
1005 TLI_DEFINE_STRING_INTERNAL("bzero")
1006 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT)
1007 
1008 /// double cabs(double complex z)
1009 TLI_DEFINE_ENUM_INTERNAL(cabs)
1010 TLI_DEFINE_STRING_INTERNAL("cabs")
1011 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
1012 
1013 /// float cabs(float complex z)
1014 TLI_DEFINE_ENUM_INTERNAL(cabsf)
1015 TLI_DEFINE_STRING_INTERNAL("cabsf")
1016 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
1017 
1018 /// long double cabs(long double complex z)
1019 TLI_DEFINE_ENUM_INTERNAL(cabsl)
1020 TLI_DEFINE_STRING_INTERNAL("cabsl")
1021 TLI_DEFINE_SIG_INTERNAL(/* Checked manually. */)
1022 
1023 /// void *calloc(size_t count, size_t size);
1024 TLI_DEFINE_ENUM_INTERNAL(calloc)
1025 TLI_DEFINE_STRING_INTERNAL("calloc")
1026 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
1027 
1028 /// double cbrt(double x);
1029 TLI_DEFINE_ENUM_INTERNAL(cbrt)
1030 TLI_DEFINE_STRING_INTERNAL("cbrt")
1031 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1032 
1033 /// float cbrtf(float x);
1034 TLI_DEFINE_ENUM_INTERNAL(cbrtf)
1035 TLI_DEFINE_STRING_INTERNAL("cbrtf")
1036 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1037 
1038 /// long double cbrtl(long double x);
1039 TLI_DEFINE_ENUM_INTERNAL(cbrtl)
1040 TLI_DEFINE_STRING_INTERNAL("cbrtl")
1041 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1042 
1043 /// double ceil(double x);
1044 TLI_DEFINE_ENUM_INTERNAL(ceil)
1045 TLI_DEFINE_STRING_INTERNAL("ceil")
1046 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1047 
1048 /// float ceilf(float x);
1049 TLI_DEFINE_ENUM_INTERNAL(ceilf)
1050 TLI_DEFINE_STRING_INTERNAL("ceilf")
1051 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1052 
1053 /// long double ceill(long double x);
1054 TLI_DEFINE_ENUM_INTERNAL(ceill)
1055 TLI_DEFINE_STRING_INTERNAL("ceill")
1056 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1057 
1058 /// int chmod(const char *path, mode_t mode);
1059 TLI_DEFINE_ENUM_INTERNAL(chmod)
1060 TLI_DEFINE_STRING_INTERNAL("chmod")
1061 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX)
1062 
1063 /// int chown(const char *path, uid_t owner, gid_t group);
1064 TLI_DEFINE_ENUM_INTERNAL(chown)
1065 TLI_DEFINE_STRING_INTERNAL("chown")
1066 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX)
1067 
1068 /// void clearerr(FILE *stream);
1069 TLI_DEFINE_ENUM_INTERNAL(clearerr)
1070 TLI_DEFINE_STRING_INTERNAL("clearerr")
1071 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
1072 
1073 /// int closedir(DIR *dirp);
1074 TLI_DEFINE_ENUM_INTERNAL(closedir)
1075 TLI_DEFINE_STRING_INTERNAL("closedir")
1076 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1077 
1078 /// double copysign(double x, double y);
1079 TLI_DEFINE_ENUM_INTERNAL(copysign)
1080 TLI_DEFINE_STRING_INTERNAL("copysign")
1081 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
1082 
1083 /// float copysignf(float x, float y);
1084 TLI_DEFINE_ENUM_INTERNAL(copysignf)
1085 TLI_DEFINE_STRING_INTERNAL("copysignf")
1086 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
1087 
1088 /// long double copysignl(long double x, long double y);
1089 TLI_DEFINE_ENUM_INTERNAL(copysignl)
1090 TLI_DEFINE_STRING_INTERNAL("copysignl")
1091 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
1092 
1093 /// double cos(double x);
1094 TLI_DEFINE_ENUM_INTERNAL(cos)
1095 TLI_DEFINE_STRING_INTERNAL("cos")
1096 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1097 
1098 /// float cosf(float x);
1099 TLI_DEFINE_ENUM_INTERNAL(cosf)
1100 TLI_DEFINE_STRING_INTERNAL("cosf")
1101 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1102 
1103 /// double cosh(double x);
1104 TLI_DEFINE_ENUM_INTERNAL(cosh)
1105 TLI_DEFINE_STRING_INTERNAL("cosh")
1106 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1107 
1108 /// float coshf(float x);
1109 TLI_DEFINE_ENUM_INTERNAL(coshf)
1110 TLI_DEFINE_STRING_INTERNAL("coshf")
1111 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1112 
1113 /// long double coshl(long double x);
1114 TLI_DEFINE_ENUM_INTERNAL(coshl)
1115 TLI_DEFINE_STRING_INTERNAL("coshl")
1116 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1117 
1118 /// long double cosl(long double x);
1119 TLI_DEFINE_ENUM_INTERNAL(cosl)
1120 TLI_DEFINE_STRING_INTERNAL("cosl")
1121 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1122 
1123 /// char *ctermid(char *s);
1124 TLI_DEFINE_ENUM_INTERNAL(ctermid)
1125 TLI_DEFINE_STRING_INTERNAL("ctermid")
1126 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
1127 
1128 /// double erf(double x);
1129 TLI_DEFINE_ENUM_INTERNAL(erf)
1130 TLI_DEFINE_STRING_INTERNAL("erf")
1131 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1132 
1133 /// float erff(float x);
1134 TLI_DEFINE_ENUM_INTERNAL(erff)
1135 TLI_DEFINE_STRING_INTERNAL("erff")
1136 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1137 
1138 /// long double erfl(long double x);
1139 TLI_DEFINE_ENUM_INTERNAL(erfl)
1140 TLI_DEFINE_STRING_INTERNAL("erfl")
1141 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1142 
1143 /// double tgamma(double x);
1144 TLI_DEFINE_ENUM_INTERNAL(tgamma)
1145 TLI_DEFINE_STRING_INTERNAL("tgamma")
1146 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1147 
1148 /// float tgammaf(float x);
1149 TLI_DEFINE_ENUM_INTERNAL(tgammaf)
1150 TLI_DEFINE_STRING_INTERNAL("tgammaf")
1151 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1152 
1153 /// long double tgammal(long double x);
1154 TLI_DEFINE_ENUM_INTERNAL(tgammal)
1155 TLI_DEFINE_STRING_INTERNAL("tgammal")
1156 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1157 
1158 /// int execl(const char *path, const char *arg, ...);
1159 TLI_DEFINE_ENUM_INTERNAL(execl)
1160 TLI_DEFINE_STRING_INTERNAL("execl")
1161 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1162 
1163 /// int execle(const char *file, const char *arg, ..., char * const envp[]);
1164 TLI_DEFINE_ENUM_INTERNAL(execle)
1165 TLI_DEFINE_STRING_INTERNAL("execle")
1166 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1167 
1168 /// int execlp(const char *file, const char *arg, ...);
1169 TLI_DEFINE_ENUM_INTERNAL(execlp)
1170 TLI_DEFINE_STRING_INTERNAL("execlp")
1171 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1172 
1173 /// int execv(const char *path, char *const argv[]);
1174 TLI_DEFINE_ENUM_INTERNAL(execv)
1175 TLI_DEFINE_STRING_INTERNAL("execv")
1176 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1177 
1178 /// int execvP(const char *file, const char *search_path, char *const argv[]);
1179 TLI_DEFINE_ENUM_INTERNAL(execvP)
1180 TLI_DEFINE_STRING_INTERNAL("execvP")
1181 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
1182 
1183 /// int execve(const char *filename, char *const argv[], char *const envp[]);
1184 TLI_DEFINE_ENUM_INTERNAL(execve)
1185 TLI_DEFINE_STRING_INTERNAL("execve")
1186 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
1187 
1188 /// int execvp(const char *file, char *const argv[]);
1189 TLI_DEFINE_ENUM_INTERNAL(execvp)
1190 TLI_DEFINE_STRING_INTERNAL("execvp")
1191 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1192 
1193 /// int execvpe(const char *file, char *const argv[], char *const envp[]);
1194 TLI_DEFINE_ENUM_INTERNAL(execvpe)
1195 TLI_DEFINE_STRING_INTERNAL("execvpe")
1196 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
1197 
1198 /// double exp(double x);
1199 TLI_DEFINE_ENUM_INTERNAL(exp)
1200 TLI_DEFINE_STRING_INTERNAL("exp")
1201 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1202 
1203 /// double exp10(double x);
1204 TLI_DEFINE_ENUM_INTERNAL(exp10)
1205 TLI_DEFINE_STRING_INTERNAL("exp10")
1206 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1207 
1208 /// float exp10f(float x);
1209 TLI_DEFINE_ENUM_INTERNAL(exp10f)
1210 TLI_DEFINE_STRING_INTERNAL("exp10f")
1211 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1212 
1213 /// long double exp10l(long double x);
1214 TLI_DEFINE_ENUM_INTERNAL(exp10l)
1215 TLI_DEFINE_STRING_INTERNAL("exp10l")
1216 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1217 
1218 /// double exp2(double x);
1219 TLI_DEFINE_ENUM_INTERNAL(exp2)
1220 TLI_DEFINE_STRING_INTERNAL("exp2")
1221 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1222 
1223 /// float exp2f(float x);
1224 TLI_DEFINE_ENUM_INTERNAL(exp2f)
1225 TLI_DEFINE_STRING_INTERNAL("exp2f")
1226 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1227 
1228 /// long double exp2l(long double x);
1229 TLI_DEFINE_ENUM_INTERNAL(exp2l)
1230 TLI_DEFINE_STRING_INTERNAL("exp2l")
1231 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1232 
1233 /// float expf(float x);
1234 TLI_DEFINE_ENUM_INTERNAL(expf)
1235 TLI_DEFINE_STRING_INTERNAL("expf")
1236 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1237 
1238 /// long double expl(long double x);
1239 TLI_DEFINE_ENUM_INTERNAL(expl)
1240 TLI_DEFINE_STRING_INTERNAL("expl")
1241 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1242 
1243 /// double expm1(double x);
1244 TLI_DEFINE_ENUM_INTERNAL(expm1)
1245 TLI_DEFINE_STRING_INTERNAL("expm1")
1246 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1247 
1248 /// float expm1f(float x);
1249 TLI_DEFINE_ENUM_INTERNAL(expm1f)
1250 TLI_DEFINE_STRING_INTERNAL("expm1f")
1251 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1252 
1253 /// long double expm1l(long double x);
1254 TLI_DEFINE_ENUM_INTERNAL(expm1l)
1255 TLI_DEFINE_STRING_INTERNAL("expm1l")
1256 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1257 
1258 /// double fabs(double x);
1259 TLI_DEFINE_ENUM_INTERNAL(fabs)
1260 TLI_DEFINE_STRING_INTERNAL("fabs")
1261 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1262 
1263 /// float fabsf(float x);
1264 TLI_DEFINE_ENUM_INTERNAL(fabsf)
1265 TLI_DEFINE_STRING_INTERNAL("fabsf")
1266 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1267 
1268 /// long double fabsl(long double x);
1269 TLI_DEFINE_ENUM_INTERNAL(fabsl)
1270 TLI_DEFINE_STRING_INTERNAL("fabsl")
1271 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1272 
1273 /// int fclose(FILE *stream);
1274 TLI_DEFINE_ENUM_INTERNAL(fclose)
1275 TLI_DEFINE_STRING_INTERNAL("fclose")
1276 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1277 
1278 /// FILE *fdopen(int fildes, const char *mode);
1279 TLI_DEFINE_ENUM_INTERNAL(fdopen)
1280 TLI_DEFINE_STRING_INTERNAL("fdopen")
1281 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Ptr)
1282 
1283 /// int feof(FILE *stream);
1284 TLI_DEFINE_ENUM_INTERNAL(feof)
1285 TLI_DEFINE_STRING_INTERNAL("feof")
1286 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1287 
1288 /// int ferror(FILE *stream);
1289 TLI_DEFINE_ENUM_INTERNAL(ferror)
1290 TLI_DEFINE_STRING_INTERNAL("ferror")
1291 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1292 
1293 /// int fflush(FILE *stream);
1294 TLI_DEFINE_ENUM_INTERNAL(fflush)
1295 TLI_DEFINE_STRING_INTERNAL("fflush")
1296 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1297 
1298 /// int ffs(int i);
1299 TLI_DEFINE_ENUM_INTERNAL(ffs)
1300 TLI_DEFINE_STRING_INTERNAL("ffs")
1301 TLI_DEFINE_SIG_INTERNAL(Int, Int)
1302 
1303 /// int ffsl(long int i);
1304 TLI_DEFINE_ENUM_INTERNAL(ffsl)
1305 TLI_DEFINE_STRING_INTERNAL("ffsl")
1306 TLI_DEFINE_SIG_INTERNAL(Int, Long)
1307 
1308 /// int ffsll(long long int i);
1309 TLI_DEFINE_ENUM_INTERNAL(ffsll)
1310 TLI_DEFINE_STRING_INTERNAL("ffsll")
1311 TLI_DEFINE_SIG_INTERNAL(Int, LLong)
1312 
1313 /// int fgetc(FILE *stream);
1314 TLI_DEFINE_ENUM_INTERNAL(fgetc)
1315 TLI_DEFINE_STRING_INTERNAL("fgetc")
1316 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1317 
1318 /// int fgetc_unlocked(FILE *stream);
1319 TLI_DEFINE_ENUM_INTERNAL(fgetc_unlocked)
1320 TLI_DEFINE_STRING_INTERNAL("fgetc_unlocked")
1321 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1322 
1323 /// int fgetpos(FILE *stream, fpos_t *pos);
1324 TLI_DEFINE_ENUM_INTERNAL(fgetpos)
1325 TLI_DEFINE_STRING_INTERNAL("fgetpos")
1326 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1327 
1328 /// char *fgets(char *s, int n, FILE *stream);
1329 TLI_DEFINE_ENUM_INTERNAL(fgets)
1330 TLI_DEFINE_STRING_INTERNAL("fgets")
1331 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr)
1332 
1333 /// char *fgets_unlocked(char *s, int n, FILE *stream);
1334 TLI_DEFINE_ENUM_INTERNAL(fgets_unlocked)
1335 TLI_DEFINE_STRING_INTERNAL("fgets_unlocked")
1336 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, Ptr)
1337 
1338 /// int fileno(FILE *stream);
1339 TLI_DEFINE_ENUM_INTERNAL(fileno)
1340 TLI_DEFINE_STRING_INTERNAL("fileno")
1341 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1342 
1343 /// int fiprintf(FILE *stream, const char *format, ...);
1344 TLI_DEFINE_ENUM_INTERNAL(fiprintf)
1345 TLI_DEFINE_STRING_INTERNAL("fiprintf")
1346 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1347 
1348 /// void flockfile(FILE *file);
1349 TLI_DEFINE_ENUM_INTERNAL(flockfile)
1350 TLI_DEFINE_STRING_INTERNAL("flockfile")
1351 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
1352 
1353 /// double floor(double x);
1354 TLI_DEFINE_ENUM_INTERNAL(floor)
1355 TLI_DEFINE_STRING_INTERNAL("floor")
1356 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1357 
1358 /// float floorf(float x);
1359 TLI_DEFINE_ENUM_INTERNAL(floorf)
1360 TLI_DEFINE_STRING_INTERNAL("floorf")
1361 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1362 
1363 /// long double floorl(long double x);
1364 TLI_DEFINE_ENUM_INTERNAL(floorl)
1365 TLI_DEFINE_STRING_INTERNAL("floorl")
1366 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1367 
1368 /// int fls(int i);
1369 TLI_DEFINE_ENUM_INTERNAL(fls)
1370 TLI_DEFINE_STRING_INTERNAL("fls")
1371 TLI_DEFINE_SIG_INTERNAL(Int, Int)
1372 
1373 /// int flsl(long int i);
1374 TLI_DEFINE_ENUM_INTERNAL(flsl)
1375 TLI_DEFINE_STRING_INTERNAL("flsl")
1376 TLI_DEFINE_SIG_INTERNAL(Int, Long)
1377 
1378 /// int flsll(long long int i);
1379 TLI_DEFINE_ENUM_INTERNAL(flsll)
1380 TLI_DEFINE_STRING_INTERNAL("flsll")
1381 TLI_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);
1387 TLI_DEFINE_ENUM_INTERNAL(fmax)
1388 TLI_DEFINE_STRING_INTERNAL("fmax")
1389 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1390 
1391 /// float fmaxf(float x, float y);
1392 TLI_DEFINE_ENUM_INTERNAL(fmaxf)
1393 TLI_DEFINE_STRING_INTERNAL("fmaxf")
1394 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1395 
1396 /// long double fmaxl(long double x, long double y);
1397 TLI_DEFINE_ENUM_INTERNAL(fmaxl)
1398 TLI_DEFINE_STRING_INTERNAL("fmaxl")
1399 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1400 
1401 /// double fmin(double x, double y);
1402 TLI_DEFINE_ENUM_INTERNAL(fmin)
1403 TLI_DEFINE_STRING_INTERNAL("fmin")
1404 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1405 
1406 /// float fminf(float x, float y);
1407 TLI_DEFINE_ENUM_INTERNAL(fminf)
1408 TLI_DEFINE_STRING_INTERNAL("fminf")
1409 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1410 
1411 /// long double fminl(long double x, long double y);
1412 TLI_DEFINE_ENUM_INTERNAL(fminl)
1413 TLI_DEFINE_STRING_INTERNAL("fminl")
1414 TLI_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);
1420 TLI_DEFINE_ENUM_INTERNAL(fmaximum_num)
1421 TLI_DEFINE_STRING_INTERNAL("fmaximum_num")
1422 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1423 
1424 /// float fmaximum_numf(float x, float y);
1425 TLI_DEFINE_ENUM_INTERNAL(fmaximum_numf)
1426 TLI_DEFINE_STRING_INTERNAL("fmaximum_numf")
1427 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1428 
1429 /// long double fmaximum_numl(long double x, long double y);
1430 TLI_DEFINE_ENUM_INTERNAL(fmaximum_numl)
1431 TLI_DEFINE_STRING_INTERNAL("fmaximum_numl")
1432 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1433 
1434 /// double fminimum_num(double x, double y);
1435 TLI_DEFINE_ENUM_INTERNAL(fminimum_num)
1436 TLI_DEFINE_STRING_INTERNAL("fminimum_num")
1437 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1438 
1439 /// float fminimum_numf(float x, float y);
1440 TLI_DEFINE_ENUM_INTERNAL(fminimum_numf)
1441 TLI_DEFINE_STRING_INTERNAL("fminimum_numf")
1442 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1443 
1444 /// long double fminimum_numl(long double x, long double y);
1445 TLI_DEFINE_ENUM_INTERNAL(fminimum_numl)
1446 TLI_DEFINE_STRING_INTERNAL("fminimum_numl")
1447 TLI_DEFINE_SIG_INTERNAL(Floating, Same, Same)
1448 
1449 /// double fmod(double x, double y);
1450 TLI_DEFINE_ENUM_INTERNAL(fmod)
1451 TLI_DEFINE_STRING_INTERNAL("fmod")
1452 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
1453 
1454 /// float fmodf(float x, float y);
1455 TLI_DEFINE_ENUM_INTERNAL(fmodf)
1456 TLI_DEFINE_STRING_INTERNAL("fmodf")
1457 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
1458 
1459 /// long double fmodl(long double x, long double y);
1460 TLI_DEFINE_ENUM_INTERNAL(fmodl)
1461 TLI_DEFINE_STRING_INTERNAL("fmodl")
1462 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
1463 
1464 /// FILE *fopen(const char *filename, const char *mode);
1465 TLI_DEFINE_ENUM_INTERNAL(fopen)
1466 TLI_DEFINE_STRING_INTERNAL("fopen")
1467 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
1468 
1469 /// FILE *fopen64(const char *filename, const char *opentype)
1470 TLI_DEFINE_ENUM_INTERNAL(fopen64)
1471 TLI_DEFINE_STRING_INTERNAL("fopen64")
1472 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
1473 
1474 /// int fork();
1475 TLI_DEFINE_ENUM_INTERNAL(fork)
1476 TLI_DEFINE_STRING_INTERNAL("fork")
1477 TLI_DEFINE_SIG_INTERNAL(Int)
1478 
1479 /// int fprintf(FILE *stream, const char *format, ...);
1480 TLI_DEFINE_ENUM_INTERNAL(fprintf)
1481 TLI_DEFINE_STRING_INTERNAL("fprintf")
1482 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1483 
1484 /// int fputc(int c, FILE *stream);
1485 TLI_DEFINE_ENUM_INTERNAL(fputc)
1486 TLI_DEFINE_STRING_INTERNAL("fputc")
1487 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1488 
1489 /// int fputc_unlocked(int c, FILE *stream);
1490 TLI_DEFINE_ENUM_INTERNAL(fputc_unlocked)
1491 TLI_DEFINE_STRING_INTERNAL("fputc_unlocked")
1492 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1493 
1494 /// int fputs(const char *s, FILE *stream);
1495 TLI_DEFINE_ENUM_INTERNAL(fputs)
1496 TLI_DEFINE_STRING_INTERNAL("fputs")
1497 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1498 
1499 /// int fputs_unlocked(const char *s, FILE *stream);
1500 TLI_DEFINE_ENUM_INTERNAL(fputs_unlocked)
1501 TLI_DEFINE_STRING_INTERNAL("fputs_unlocked")
1502 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1503 
1504 /// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
1505 TLI_DEFINE_ENUM_INTERNAL(fread)
1506 TLI_DEFINE_STRING_INTERNAL("fread")
1507 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
1508 
1509 /// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
1510 TLI_DEFINE_ENUM_INTERNAL(fread_unlocked)
1511 TLI_DEFINE_STRING_INTERNAL("fread_unlocked")
1512 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
1513 
1514 /// void free(void *ptr);
1515 TLI_DEFINE_ENUM_INTERNAL(free)
1516 TLI_DEFINE_STRING_INTERNAL("free")
1517 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
1518 
1519 /// double frexp(double num, int *exp);
1520 TLI_DEFINE_ENUM_INTERNAL(frexp)
1521 TLI_DEFINE_STRING_INTERNAL("frexp")
1522 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr)
1523 
1524 /// float frexpf(float num, int *exp);
1525 TLI_DEFINE_ENUM_INTERNAL(frexpf)
1526 TLI_DEFINE_STRING_INTERNAL("frexpf")
1527 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr)
1528 
1529 /// long double frexpl(long double num, int *exp);
1530 TLI_DEFINE_ENUM_INTERNAL(frexpl)
1531 TLI_DEFINE_STRING_INTERNAL("frexpl")
1532 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr)
1533 
1534 /// int fscanf(FILE *stream, const char *format, ... );
1535 TLI_DEFINE_ENUM_INTERNAL(fscanf)
1536 TLI_DEFINE_STRING_INTERNAL("fscanf")
1537 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
1538 
1539 /// int fseek(FILE *stream, long offset, int whence);
1540 TLI_DEFINE_ENUM_INTERNAL(fseek)
1541 TLI_DEFINE_STRING_INTERNAL("fseek")
1542 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Long, Int)
1543 
1544 /// int fseeko(FILE *stream, off_t offset, int whence);
1545 TLI_DEFINE_ENUM_INTERNAL(fseeko)
1546 TLI_DEFINE_STRING_INTERNAL("fseeko")
1547 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, Int)
1548 
1549 /// int fseeko64(FILE *stream, off64_t offset, int whence)
1550 TLI_DEFINE_ENUM_INTERNAL(fseeko64)
1551 TLI_DEFINE_STRING_INTERNAL("fseeko64")
1552 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int64, Int)
1553 
1554 /// int fsetpos(FILE *stream, const fpos_t *pos);
1555 TLI_DEFINE_ENUM_INTERNAL(fsetpos)
1556 TLI_DEFINE_STRING_INTERNAL("fsetpos")
1557 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1558 
1559 /// int fstat(int fildes, struct stat *buf);
1560 TLI_DEFINE_ENUM_INTERNAL(fstat)
1561 TLI_DEFINE_STRING_INTERNAL("fstat")
1562 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1563 
1564 /// int fstat64(int filedes, struct stat64 *buf)
1565 TLI_DEFINE_ENUM_INTERNAL(fstat64)
1566 TLI_DEFINE_STRING_INTERNAL("fstat64")
1567 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1568 
1569 /// int fstatvfs(int fildes, struct statvfs *buf);
1570 TLI_DEFINE_ENUM_INTERNAL(fstatvfs)
1571 TLI_DEFINE_STRING_INTERNAL("fstatvfs")
1572 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1573 
1574 /// int fstatvfs64(int fildes, struct statvfs64 *buf);
1575 TLI_DEFINE_ENUM_INTERNAL(fstatvfs64)
1576 TLI_DEFINE_STRING_INTERNAL("fstatvfs64")
1577 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1578 
1579 /// long ftell(FILE *stream);
1580 TLI_DEFINE_ENUM_INTERNAL(ftell)
1581 TLI_DEFINE_STRING_INTERNAL("ftell")
1582 TLI_DEFINE_SIG_INTERNAL(Long, Ptr)
1583 
1584 /// off_t ftello(FILE *stream);
1585 TLI_DEFINE_ENUM_INTERNAL(ftello)
1586 TLI_DEFINE_STRING_INTERNAL("ftello")
1587 TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
1588 
1589 /// off64_t ftello64(FILE *stream)
1590 TLI_DEFINE_ENUM_INTERNAL(ftello64)
1591 TLI_DEFINE_STRING_INTERNAL("ftello64")
1592 TLI_DEFINE_SIG_INTERNAL(Int64, Ptr)
1593 
1594 /// int ftrylockfile(FILE *file);
1595 TLI_DEFINE_ENUM_INTERNAL(ftrylockfile)
1596 TLI_DEFINE_STRING_INTERNAL("ftrylockfile")
1597 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1598 
1599 /// void funlockfile(FILE *file);
1600 TLI_DEFINE_ENUM_INTERNAL(funlockfile)
1601 TLI_DEFINE_STRING_INTERNAL("funlockfile")
1602 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
1603 
1604 /// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
1605 TLI_DEFINE_ENUM_INTERNAL(fwrite)
1606 TLI_DEFINE_STRING_INTERNAL("fwrite")
1607 TLI_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);
1610 TLI_DEFINE_ENUM_INTERNAL(fwrite_unlocked)
1611 TLI_DEFINE_STRING_INTERNAL("fwrite_unlocked")
1612 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT, SizeT, Ptr)
1613 
1614 /// int getc(FILE *stream);
1615 TLI_DEFINE_ENUM_INTERNAL(getc)
1616 TLI_DEFINE_STRING_INTERNAL("getc")
1617 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1618 
1619 /// int getc_unlocked(FILE *stream);
1620 TLI_DEFINE_ENUM_INTERNAL(getc_unlocked)
1621 TLI_DEFINE_STRING_INTERNAL("getc_unlocked")
1622 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1623 
1624 /// int getchar(void);
1625 TLI_DEFINE_ENUM_INTERNAL(getchar)
1626 TLI_DEFINE_STRING_INTERNAL("getchar")
1627 TLI_DEFINE_SIG_INTERNAL(Int)
1628 
1629 /// int getchar_unlocked(void);
1630 TLI_DEFINE_ENUM_INTERNAL(getchar_unlocked)
1631 TLI_DEFINE_STRING_INTERNAL("getchar_unlocked")
1632 TLI_DEFINE_SIG_INTERNAL(Int)
1633 
1634 /// char *getenv(const char *name);
1635 TLI_DEFINE_ENUM_INTERNAL(getenv)
1636 TLI_DEFINE_STRING_INTERNAL("getenv")
1637 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
1638 
1639 /// int getitimer(int which, struct itimerval *value);
1640 TLI_DEFINE_ENUM_INTERNAL(getitimer)
1641 TLI_DEFINE_STRING_INTERNAL("getitimer")
1642 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
1643 
1644 /// int getlogin_r(char *name, size_t namesize);
1645 TLI_DEFINE_ENUM_INTERNAL(getlogin_r)
1646 TLI_DEFINE_STRING_INTERNAL("getlogin_r")
1647 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT)
1648 
1649 /// struct passwd *getpwnam(const char *name);
1650 TLI_DEFINE_ENUM_INTERNAL(getpwnam)
1651 TLI_DEFINE_STRING_INTERNAL("getpwnam")
1652 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
1653 
1654 /// char *gets(char *s);
1655 TLI_DEFINE_ENUM_INTERNAL(gets)
1656 TLI_DEFINE_STRING_INTERNAL("gets")
1657 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
1658 
1659 /// int gettimeofday(struct timeval *tp, void *tzp);
1660 TLI_DEFINE_ENUM_INTERNAL(gettimeofday)
1661 TLI_DEFINE_STRING_INTERNAL("gettimeofday")
1662 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1663 
1664 /// uint32_t htonl(uint32_t hostlong);
1665 TLI_DEFINE_ENUM_INTERNAL(htonl)
1666 TLI_DEFINE_STRING_INTERNAL("htonl")
1667 TLI_DEFINE_SIG_INTERNAL(Int32, Int32)
1668 
1669 /// uint16_t htons(uint16_t hostshort);
1670 TLI_DEFINE_ENUM_INTERNAL(htons)
1671 TLI_DEFINE_STRING_INTERNAL("htons")
1672 TLI_DEFINE_SIG_INTERNAL(Int16, Int16)
1673 
1674 /// double hypot(double x, double y);
1675 TLI_DEFINE_ENUM_INTERNAL(hypot)
1676 TLI_DEFINE_STRING_INTERNAL("hypot")
1677 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
1678 
1679 /// float hypotf(float x, float y);
1680 TLI_DEFINE_ENUM_INTERNAL(hypotf)
1681 TLI_DEFINE_STRING_INTERNAL("hypotf")
1682 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
1683 
1684 /// long double hypotl(long double x, long double y);
1685 TLI_DEFINE_ENUM_INTERNAL(hypotl)
1686 TLI_DEFINE_STRING_INTERNAL("hypotl")
1687 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
1688 
1689 /// int iprintf(const char *format, ...);
1690 TLI_DEFINE_ENUM_INTERNAL(iprintf)
1691 TLI_DEFINE_STRING_INTERNAL("iprintf")
1692 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
1693 
1694 /// int isascii(int c);
1695 TLI_DEFINE_ENUM_INTERNAL(isascii)
1696 TLI_DEFINE_STRING_INTERNAL("isascii")
1697 TLI_DEFINE_SIG_INTERNAL(Int, Int)
1698 
1699 /// int isdigit(int c);
1700 TLI_DEFINE_ENUM_INTERNAL(isdigit)
1701 TLI_DEFINE_STRING_INTERNAL("isdigit")
1702 TLI_DEFINE_SIG_INTERNAL(Int, Int)
1703 
1704 /// long int labs(long int j);
1705 TLI_DEFINE_ENUM_INTERNAL(labs)
1706 TLI_DEFINE_STRING_INTERNAL("labs")
1707 TLI_DEFINE_SIG_INTERNAL(Long, Same)
1708 
1709 /// int lchown(const char *path, uid_t owner, gid_t group);
1710 TLI_DEFINE_ENUM_INTERNAL(lchown)
1711 TLI_DEFINE_STRING_INTERNAL("lchown")
1712 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX, IntX)
1713 
1714 /// double ldexp(double x, int n);
1715 TLI_DEFINE_ENUM_INTERNAL(ldexp)
1716 TLI_DEFINE_STRING_INTERNAL("ldexp")
1717 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Int)
1718 
1719 /// float ldexpf(float x, int n);
1720 TLI_DEFINE_ENUM_INTERNAL(ldexpf)
1721 TLI_DEFINE_STRING_INTERNAL("ldexpf")
1722 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Int)
1723 
1724 /// long double ldexpl(long double x, int n);
1725 TLI_DEFINE_ENUM_INTERNAL(ldexpl)
1726 TLI_DEFINE_STRING_INTERNAL("ldexpl")
1727 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Int)
1728 
1729 /// long long int llabs(long long int j);
1730 TLI_DEFINE_ENUM_INTERNAL(llabs)
1731 TLI_DEFINE_STRING_INTERNAL("llabs")
1732 TLI_DEFINE_SIG_INTERNAL(LLong, LLong)
1733 
1734 /// double log(double x);
1735 TLI_DEFINE_ENUM_INTERNAL(log)
1736 TLI_DEFINE_STRING_INTERNAL("log")
1737 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1738 
1739 /// double log10(double x);
1740 TLI_DEFINE_ENUM_INTERNAL(log10)
1741 TLI_DEFINE_STRING_INTERNAL("log10")
1742 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1743 
1744 /// float log10f(float x);
1745 TLI_DEFINE_ENUM_INTERNAL(log10f)
1746 TLI_DEFINE_STRING_INTERNAL("log10f")
1747 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1748 
1749 /// long double log10l(long double x);
1750 TLI_DEFINE_ENUM_INTERNAL(log10l)
1751 TLI_DEFINE_STRING_INTERNAL("log10l")
1752 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1753 
1754 /// double log1p(double x);
1755 TLI_DEFINE_ENUM_INTERNAL(log1p)
1756 TLI_DEFINE_STRING_INTERNAL("log1p")
1757 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1758 
1759 /// float log1pf(float x);
1760 TLI_DEFINE_ENUM_INTERNAL(log1pf)
1761 TLI_DEFINE_STRING_INTERNAL("log1pf")
1762 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1763 
1764 /// long double log1pl(long double x);
1765 TLI_DEFINE_ENUM_INTERNAL(log1pl)
1766 TLI_DEFINE_STRING_INTERNAL("log1pl")
1767 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1768 
1769 /// double log2(double x);
1770 TLI_DEFINE_ENUM_INTERNAL(log2)
1771 TLI_DEFINE_STRING_INTERNAL("log2")
1772 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1773 
1774 /// float log2f(float x);
1775 TLI_DEFINE_ENUM_INTERNAL(log2f)
1776 TLI_DEFINE_STRING_INTERNAL("log2f")
1777 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1778 
1779 /// double long double log2l(long double x);
1780 TLI_DEFINE_ENUM_INTERNAL(log2l)
1781 TLI_DEFINE_STRING_INTERNAL("log2l")
1782 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1783 
1784 /// int ilogb(double x);
1785 TLI_DEFINE_ENUM_INTERNAL(ilogb)
1786 TLI_DEFINE_STRING_INTERNAL("ilogb")
1787 TLI_DEFINE_SIG_INTERNAL(Int, Dbl)
1788 
1789 /// int ilogbf(float x);
1790 TLI_DEFINE_ENUM_INTERNAL(ilogbf)
1791 TLI_DEFINE_STRING_INTERNAL("ilogbf")
1792 TLI_DEFINE_SIG_INTERNAL(Int, Flt)
1793 
1794 /// int ilogbl(long double x);
1795 TLI_DEFINE_ENUM_INTERNAL(ilogbl)
1796 TLI_DEFINE_STRING_INTERNAL("ilogbl")
1797 TLI_DEFINE_SIG_INTERNAL(Int, LDbl)
1798 
1799 /// double logb(double x);
1800 TLI_DEFINE_ENUM_INTERNAL(logb)
1801 TLI_DEFINE_STRING_INTERNAL("logb")
1802 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1803 
1804 /// float logbf(float x);
1805 TLI_DEFINE_ENUM_INTERNAL(logbf)
1806 TLI_DEFINE_STRING_INTERNAL("logbf")
1807 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1808 
1809 /// long double logbl(long double x);
1810 TLI_DEFINE_ENUM_INTERNAL(logbl)
1811 TLI_DEFINE_STRING_INTERNAL("logbl")
1812 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1813 
1814 /// float logf(float x);
1815 TLI_DEFINE_ENUM_INTERNAL(logf)
1816 TLI_DEFINE_STRING_INTERNAL("logf")
1817 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1818 
1819 /// long double logl(long double x);
1820 TLI_DEFINE_ENUM_INTERNAL(logl)
1821 TLI_DEFINE_STRING_INTERNAL("logl")
1822 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1823 
1824 /// int lstat(const char *path, struct stat *buf);
1825 TLI_DEFINE_ENUM_INTERNAL(lstat)
1826 TLI_DEFINE_STRING_INTERNAL("lstat")
1827 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1828 
1829 /// int lstat64(const char *path, struct stat64 *buf);
1830 TLI_DEFINE_ENUM_INTERNAL(lstat64)
1831 TLI_DEFINE_STRING_INTERNAL("lstat64")
1832 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
1833 
1834 /// void *malloc(size_t size);
1835 TLI_DEFINE_ENUM_INTERNAL(malloc)
1836 TLI_DEFINE_STRING_INTERNAL("malloc")
1837 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
1838 
1839 /// void *memalign(size_t boundary, size_t size);
1840 TLI_DEFINE_ENUM_INTERNAL(memalign)
1841 TLI_DEFINE_STRING_INTERNAL("memalign")
1842 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
1843 
1844 /// void *memccpy(void *s1, const void *s2, int c, size_t n);
1845 TLI_DEFINE_ENUM_INTERNAL(memccpy)
1846 TLI_DEFINE_STRING_INTERNAL("memccpy")
1847 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Int, SizeT)
1848 
1849 /// void *memchr(const void *s, int c, size_t n);
1850 TLI_DEFINE_ENUM_INTERNAL(memchr)
1851 TLI_DEFINE_STRING_INTERNAL("memchr")
1852 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
1853 
1854 /// int memcmp(const void *s1, const void *s2, size_t n);
1855 TLI_DEFINE_ENUM_INTERNAL(memcmp)
1856 TLI_DEFINE_STRING_INTERNAL("memcmp")
1857 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
1858 
1859 /// void *memcpy(void *s1, const void *s2, size_t n);
1860 TLI_DEFINE_ENUM_INTERNAL(memcpy)
1861 TLI_DEFINE_STRING_INTERNAL("memcpy")
1862 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
1863 
1864 /// void *memmove(void *s1, const void *s2, size_t n);
1865 TLI_DEFINE_ENUM_INTERNAL(memmove)
1866 TLI_DEFINE_STRING_INTERNAL("memmove")
1867 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
1868 
1869 /// void *mempcpy(void *s1, const void *s2, size_t n);
1870 TLI_DEFINE_ENUM_INTERNAL(mempcpy)
1871 TLI_DEFINE_STRING_INTERNAL("mempcpy")
1872 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
1873 
1874 /// void *memrchr(const void *s, int c, size_t n);
1875 TLI_DEFINE_ENUM_INTERNAL(memrchr)
1876 TLI_DEFINE_STRING_INTERNAL("memrchr")
1877 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
1878 
1879 /// void *memset(void *b, int c, size_t len);
1880 TLI_DEFINE_ENUM_INTERNAL(memset)
1881 TLI_DEFINE_STRING_INTERNAL("memset")
1882 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int, SizeT)
1883 
1884 /// void memset_pattern16(void *b, const void *pattern16, size_t len);
1885 TLI_DEFINE_ENUM_INTERNAL(memset_pattern16)
1886 TLI_DEFINE_STRING_INTERNAL("memset_pattern16")
1887 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
1888 
1889 /// void memset_pattern4(void *b, const void *pattern4, size_t len);
1890 TLI_DEFINE_ENUM_INTERNAL(memset_pattern4)
1891 TLI_DEFINE_STRING_INTERNAL("memset_pattern4")
1892 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
1893 
1894 /// void memset_pattern8(void *b, const void *pattern8, size_t len);
1895 TLI_DEFINE_ENUM_INTERNAL(memset_pattern8)
1896 TLI_DEFINE_STRING_INTERNAL("memset_pattern8")
1897 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr, SizeT)
1898 
1899 /// int mkdir(const char *path, mode_t mode);
1900 TLI_DEFINE_ENUM_INTERNAL(mkdir)
1901 TLI_DEFINE_STRING_INTERNAL("mkdir")
1902 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, IntX)
1903 
1904 /// time_t mktime(struct tm *timeptr);
1905 TLI_DEFINE_ENUM_INTERNAL(mktime)
1906 TLI_DEFINE_STRING_INTERNAL("mktime")
1907 TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
1908 
1909 /// double modf(double x, double *iptr);
1910 TLI_DEFINE_ENUM_INTERNAL(modf)
1911 TLI_DEFINE_STRING_INTERNAL("modf")
1912 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Ptr)
1913 
1914 /// float modff(float, float *iptr);
1915 TLI_DEFINE_ENUM_INTERNAL(modff)
1916 TLI_DEFINE_STRING_INTERNAL("modff")
1917 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Ptr)
1918 
1919 /// long double modfl(long double value, long double *iptr);
1920 TLI_DEFINE_ENUM_INTERNAL(modfl)
1921 TLI_DEFINE_STRING_INTERNAL("modfl")
1922 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Ptr)
1923 
1924 /// double nan(const char *arg);
1925 TLI_DEFINE_ENUM_INTERNAL(nan)
1926 TLI_DEFINE_STRING_INTERNAL("nan")
1927 TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr)
1928 
1929 /// float nanf(const char *arg);
1930 TLI_DEFINE_ENUM_INTERNAL(nanf)
1931 TLI_DEFINE_STRING_INTERNAL("nanf")
1932 TLI_DEFINE_SIG_INTERNAL(Flt, Ptr)
1933 
1934 /// long double nanl(const char *arg);
1935 TLI_DEFINE_ENUM_INTERNAL(nanl)
1936 TLI_DEFINE_STRING_INTERNAL("nanl")
1937 TLI_DEFINE_SIG_INTERNAL(LDbl, Ptr)
1938 
1939 /// double nearbyint(double x);
1940 TLI_DEFINE_ENUM_INTERNAL(nearbyint)
1941 TLI_DEFINE_STRING_INTERNAL("nearbyint")
1942 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
1943 
1944 /// float nearbyintf(float x);
1945 TLI_DEFINE_ENUM_INTERNAL(nearbyintf)
1946 TLI_DEFINE_STRING_INTERNAL("nearbyintf")
1947 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
1948 
1949 /// long double nearbyintl(long double x);
1950 TLI_DEFINE_ENUM_INTERNAL(nearbyintl)
1951 TLI_DEFINE_STRING_INTERNAL("nearbyintl")
1952 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
1953 
1954 /// uint32_t ntohl(uint32_t netlong);
1955 TLI_DEFINE_ENUM_INTERNAL(ntohl)
1956 TLI_DEFINE_STRING_INTERNAL("ntohl")
1957 TLI_DEFINE_SIG_INTERNAL(Int32, Int32)
1958 
1959 /// uint16_t ntohs(uint16_t netshort);
1960 TLI_DEFINE_ENUM_INTERNAL(ntohs)
1961 TLI_DEFINE_STRING_INTERNAL("ntohs")
1962 TLI_DEFINE_SIG_INTERNAL(Int16, Int16)
1963 
1964 /// int open(const char *path, int oflag, ... );
1965 TLI_DEFINE_ENUM_INTERNAL(open)
1966 TLI_DEFINE_STRING_INTERNAL("open")
1967 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip)
1968 
1969 /// int open64(const char *filename, int flags[, mode_t mode])
1970 TLI_DEFINE_ENUM_INTERNAL(open64)
1971 TLI_DEFINE_STRING_INTERNAL("open64")
1972 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Int, Ellip)
1973 
1974 /// DIR *opendir(const char *dirname);
1975 TLI_DEFINE_ENUM_INTERNAL(opendir)
1976 TLI_DEFINE_STRING_INTERNAL("opendir")
1977 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
1978 
1979 /// int pclose(FILE *stream);
1980 TLI_DEFINE_ENUM_INTERNAL(pclose)
1981 TLI_DEFINE_STRING_INTERNAL("pclose")
1982 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
1983 
1984 /// void perror(const char *s);
1985 TLI_DEFINE_ENUM_INTERNAL(perror)
1986 TLI_DEFINE_STRING_INTERNAL("perror")
1987 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
1988 
1989 /// FILE *popen(const char *command, const char *mode);
1990 TLI_DEFINE_ENUM_INTERNAL(popen)
1991 TLI_DEFINE_STRING_INTERNAL("popen")
1992 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
1993 
1994 /// int posix_memalign(void **memptr, size_t alignment, size_t size);
1995 TLI_DEFINE_ENUM_INTERNAL(posix_memalign)
1996 TLI_DEFINE_STRING_INTERNAL("posix_memalign")
1997 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, SizeT)
1998 
1999 /// double pow(double x, double y);
2000 TLI_DEFINE_ENUM_INTERNAL(pow)
2001 TLI_DEFINE_STRING_INTERNAL("pow")
2002 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
2003 
2004 /// float powf(float x, float y);
2005 TLI_DEFINE_ENUM_INTERNAL(powf)
2006 TLI_DEFINE_STRING_INTERNAL("powf")
2007 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
2008 
2009 /// long double powl(long double x, long double y);
2010 TLI_DEFINE_ENUM_INTERNAL(powl)
2011 TLI_DEFINE_STRING_INTERNAL("powl")
2012 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
2013 
2014 /// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
2015 TLI_DEFINE_ENUM_INTERNAL(pread)
2016 TLI_DEFINE_STRING_INTERNAL("pread")
2017 TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT, IntPlus)
2018 
2019 /// int printf(const char *format, ...);
2020 TLI_DEFINE_ENUM_INTERNAL(printf)
2021 TLI_DEFINE_STRING_INTERNAL("printf")
2022 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
2023 
2024 /// int putc(int c, FILE *stream);
2025 TLI_DEFINE_ENUM_INTERNAL(putc)
2026 TLI_DEFINE_STRING_INTERNAL("putc")
2027 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
2028 
2029 /// int putc_unlocked(int c, FILE *stream);
2030 TLI_DEFINE_ENUM_INTERNAL(putc_unlocked)
2031 TLI_DEFINE_STRING_INTERNAL("putc_unlocked")
2032 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
2033 
2034 /// int putchar(int c);
2035 TLI_DEFINE_ENUM_INTERNAL(putchar)
2036 TLI_DEFINE_STRING_INTERNAL("putchar")
2037 TLI_DEFINE_SIG_INTERNAL(Int, Int)
2038 
2039 /// int putchar_unlocked(int c);
2040 TLI_DEFINE_ENUM_INTERNAL(putchar_unlocked)
2041 TLI_DEFINE_STRING_INTERNAL("putchar_unlocked")
2042 TLI_DEFINE_SIG_INTERNAL(Int, Int)
2043 
2044 /// int puts(const char *s);
2045 TLI_DEFINE_ENUM_INTERNAL(puts)
2046 TLI_DEFINE_STRING_INTERNAL("puts")
2047 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2048 
2049 /// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
2050 TLI_DEFINE_ENUM_INTERNAL(pwrite)
2051 TLI_DEFINE_STRING_INTERNAL("pwrite")
2052 TLI_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 *));
2056 TLI_DEFINE_ENUM_INTERNAL(qsort)
2057 TLI_DEFINE_STRING_INTERNAL("qsort")
2058 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, SizeT, SizeT, Ptr)
2059 
2060 /// ssize_t read(int fildes, void *buf, size_t nbyte);
2061 TLI_DEFINE_ENUM_INTERNAL(read)
2062 TLI_DEFINE_STRING_INTERNAL("read")
2063 TLI_DEFINE_SIG_INTERNAL(SSizeT, Int, Ptr, SizeT)
2064 
2065 /// ssize_t readlink(const char *path, char *buf, size_t bufsize);
2066 TLI_DEFINE_ENUM_INTERNAL(readlink)
2067 TLI_DEFINE_STRING_INTERNAL("readlink")
2068 TLI_DEFINE_SIG_INTERNAL(SSizeT, Ptr, Ptr, SizeT)
2069 
2070 /// void *realloc(void *ptr, size_t size);
2071 TLI_DEFINE_ENUM_INTERNAL(realloc)
2072 TLI_DEFINE_STRING_INTERNAL("realloc")
2073 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
2074 
2075 /// void *reallocf(void *ptr, size_t size);
2076 TLI_DEFINE_ENUM_INTERNAL(reallocf)
2077 TLI_DEFINE_STRING_INTERNAL("reallocf")
2078 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
2079 
2080 /// void *reallocarray(void *ptr, size_t nmemb, size_t size);
2081 TLI_DEFINE_ENUM_INTERNAL(reallocarray)
2082 TLI_DEFINE_STRING_INTERNAL("reallocarray")
2083 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT, SizeT)
2084 
2085 /// char *realpath(const char *file_name, char *resolved_name);
2086 TLI_DEFINE_ENUM_INTERNAL(realpath)
2087 TLI_DEFINE_STRING_INTERNAL("realpath")
2088 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2089 
2090 /// double remainder(double x, double y);
2091 TLI_DEFINE_ENUM_INTERNAL(remainder)
2092 TLI_DEFINE_STRING_INTERNAL("remainder")
2093 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
2094 
2095 /// float remainderf(float x, float y);
2096 TLI_DEFINE_ENUM_INTERNAL(remainderf)
2097 TLI_DEFINE_STRING_INTERNAL("remainderf")
2098 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
2099 
2100 /// long double remainderl(long double x, long double y);
2101 TLI_DEFINE_ENUM_INTERNAL(remainderl)
2102 TLI_DEFINE_STRING_INTERNAL("remainderl")
2103 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
2104 
2105 /// double remquo(double x, double y, int *quo);
2106 TLI_DEFINE_ENUM_INTERNAL(remquo)
2107 TLI_DEFINE_STRING_INTERNAL("remquo")
2108 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl, Ptr)
2109 
2110 /// float remquof(float x, float y, int *quo);
2111 TLI_DEFINE_ENUM_INTERNAL(remquof)
2112 TLI_DEFINE_STRING_INTERNAL("remquof")
2113 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt, Ptr)
2114 
2115 /// long double remquol(long double x, long double y, int *quo);
2116 TLI_DEFINE_ENUM_INTERNAL(remquol)
2117 TLI_DEFINE_STRING_INTERNAL("remquol")
2118 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl, Ptr)
2119 
2120 /// double fdim(double x, double y);
2121 TLI_DEFINE_ENUM_INTERNAL(fdim)
2122 TLI_DEFINE_STRING_INTERNAL("fdim")
2123 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Dbl)
2124 
2125 /// float fdimf(float x, float y);
2126 TLI_DEFINE_ENUM_INTERNAL(fdimf)
2127 TLI_DEFINE_STRING_INTERNAL("fdimf")
2128 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Flt)
2129 
2130 /// long double fdiml(long double x, long double y);
2131 TLI_DEFINE_ENUM_INTERNAL(fdiml)
2132 TLI_DEFINE_STRING_INTERNAL("fdiml")
2133 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, LDbl)
2134 
2135 /// int remove(const char *path);
2136 TLI_DEFINE_ENUM_INTERNAL(remove)
2137 TLI_DEFINE_STRING_INTERNAL("remove")
2138 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2139 
2140 /// int rename(const char *old, const char *new);
2141 TLI_DEFINE_ENUM_INTERNAL(rename)
2142 TLI_DEFINE_STRING_INTERNAL("rename")
2143 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2144 
2145 /// void rewind(FILE *stream);
2146 TLI_DEFINE_ENUM_INTERNAL(rewind)
2147 TLI_DEFINE_STRING_INTERNAL("rewind")
2148 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
2149 
2150 /// double rint(double x);
2151 TLI_DEFINE_ENUM_INTERNAL(rint)
2152 TLI_DEFINE_STRING_INTERNAL("rint")
2153 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2154 
2155 /// float rintf(float x);
2156 TLI_DEFINE_ENUM_INTERNAL(rintf)
2157 TLI_DEFINE_STRING_INTERNAL("rintf")
2158 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2159 
2160 /// long double rintl(long double x);
2161 TLI_DEFINE_ENUM_INTERNAL(rintl)
2162 TLI_DEFINE_STRING_INTERNAL("rintl")
2163 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2164 
2165 /// int rmdir(const char *path);
2166 TLI_DEFINE_ENUM_INTERNAL(rmdir)
2167 TLI_DEFINE_STRING_INTERNAL("rmdir")
2168 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2169 
2170 /// double round(double x);
2171 TLI_DEFINE_ENUM_INTERNAL(round)
2172 TLI_DEFINE_STRING_INTERNAL("round")
2173 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2174 
2175 /// double roundeven(double x);
2176 TLI_DEFINE_ENUM_INTERNAL(roundeven)
2177 TLI_DEFINE_STRING_INTERNAL("roundeven")
2178 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2179 
2180 /// float roundevenf(float x);
2181 TLI_DEFINE_ENUM_INTERNAL(roundevenf)
2182 TLI_DEFINE_STRING_INTERNAL("roundevenf")
2183 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2184 
2185 /// long double roundevenl(long double x);
2186 TLI_DEFINE_ENUM_INTERNAL(roundevenl)
2187 TLI_DEFINE_STRING_INTERNAL("roundevenl")
2188 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2189 
2190 /// float roundf(float x);
2191 TLI_DEFINE_ENUM_INTERNAL(roundf)
2192 TLI_DEFINE_STRING_INTERNAL("roundf")
2193 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2194 
2195 /// long double roundl(long double x);
2196 TLI_DEFINE_ENUM_INTERNAL(roundl)
2197 TLI_DEFINE_STRING_INTERNAL("roundl")
2198 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2199 
2200 /// double scalbln(double arg, long exp);
2201 TLI_DEFINE_ENUM_INTERNAL(scalbln)
2202 TLI_DEFINE_STRING_INTERNAL("scalbln")
2203 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Long)
2204 
2205 /// float scalblnf(float arg, long exp);
2206 TLI_DEFINE_ENUM_INTERNAL(scalblnf)
2207 TLI_DEFINE_STRING_INTERNAL("scalblnf")
2208 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Long)
2209 
2210 /// long double scalblnl(long double arg, long exp);
2211 TLI_DEFINE_ENUM_INTERNAL(scalblnl)
2212 TLI_DEFINE_STRING_INTERNAL("scalblnl")
2213 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Long)
2214 
2215 /// double scalbn(double arg, int exp);
2216 TLI_DEFINE_ENUM_INTERNAL(scalbn)
2217 TLI_DEFINE_STRING_INTERNAL("scalbn")
2218 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl, Int)
2219 
2220 /// float scalbnf(float arg, int exp);
2221 TLI_DEFINE_ENUM_INTERNAL(scalbnf)
2222 TLI_DEFINE_STRING_INTERNAL("scalbnf")
2223 TLI_DEFINE_SIG_INTERNAL(Flt, Flt, Int)
2224 
2225 /// long double scalbnl(long double arg, int exp);
2226 TLI_DEFINE_ENUM_INTERNAL(scalbnl)
2227 TLI_DEFINE_STRING_INTERNAL("scalbnl")
2228 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl, Int)
2229 
2230 /// int scanf(const char *restrict format, ... );
2231 TLI_DEFINE_ENUM_INTERNAL(scanf)
2232 TLI_DEFINE_STRING_INTERNAL("scanf")
2233 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ellip)
2234 
2235 /// void setbuf(FILE *stream, char *buf);
2236 TLI_DEFINE_ENUM_INTERNAL(setbuf)
2237 TLI_DEFINE_STRING_INTERNAL("setbuf")
2238 TLI_DEFINE_SIG_INTERNAL(Void, Ptr, Ptr)
2239 
2240 /// int setitimer(int which, const struct itimerval *value,
2241 ///               struct itimerval *ovalue);
2242 TLI_DEFINE_ENUM_INTERNAL(setitimer)
2243 TLI_DEFINE_STRING_INTERNAL("setitimer")
2244 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr, Ptr)
2245 
2246 /// int setvbuf(FILE *stream, char *buf, int type, size_t size);
2247 TLI_DEFINE_ENUM_INTERNAL(setvbuf)
2248 TLI_DEFINE_STRING_INTERNAL("setvbuf")
2249 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Int, SizeT)
2250 
2251 /// double sin(double x);
2252 TLI_DEFINE_ENUM_INTERNAL(sin)
2253 TLI_DEFINE_STRING_INTERNAL("sin")
2254 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2255 
2256 /// float sinf(float x);
2257 TLI_DEFINE_ENUM_INTERNAL(sinf)
2258 TLI_DEFINE_STRING_INTERNAL("sinf")
2259 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2260 
2261 /// double sinh(double x);
2262 TLI_DEFINE_ENUM_INTERNAL(sinh)
2263 TLI_DEFINE_STRING_INTERNAL("sinh")
2264 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2265 
2266 /// float sinhf(float x);
2267 TLI_DEFINE_ENUM_INTERNAL(sinhf)
2268 TLI_DEFINE_STRING_INTERNAL("sinhf")
2269 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2270 
2271 /// long double sinhl(long double x);
2272 TLI_DEFINE_ENUM_INTERNAL(sinhl)
2273 TLI_DEFINE_STRING_INTERNAL("sinhl")
2274 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2275 
2276 /// long double sinl(long double x);
2277 TLI_DEFINE_ENUM_INTERNAL(sinl)
2278 TLI_DEFINE_STRING_INTERNAL("sinl")
2279 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2280 
2281 /// void sincos(double x, double *sin_out, double *cos_out);
2282 TLI_DEFINE_ENUM_INTERNAL(sincos)
2283 TLI_DEFINE_STRING_INTERNAL("sincos")
2284 TLI_DEFINE_SIG_INTERNAL(Void, Dbl, Ptr, Ptr)
2285 
2286 /// void sincosf(float x, float *sin_out, float *cos_out);
2287 TLI_DEFINE_ENUM_INTERNAL(sincosf)
2288 TLI_DEFINE_STRING_INTERNAL("sincosf")
2289 TLI_DEFINE_SIG_INTERNAL(Void, Flt, Ptr, Ptr)
2290 
2291 /// void sincosl(long double x, long double *sin_out, long double *cos_out);
2292 TLI_DEFINE_ENUM_INTERNAL(sincosl)
2293 TLI_DEFINE_STRING_INTERNAL("sincosl")
2294 TLI_DEFINE_SIG_INTERNAL(Void, LDbl, Ptr, Ptr)
2295 
2296 /// int siprintf(char *str, const char *format, ...);
2297 TLI_DEFINE_ENUM_INTERNAL(siprintf)
2298 TLI_DEFINE_STRING_INTERNAL("siprintf")
2299 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
2300 
2301 /// int snprintf(char *s, size_t n, const char *format, ...);
2302 TLI_DEFINE_ENUM_INTERNAL(snprintf)
2303 TLI_DEFINE_STRING_INTERNAL("snprintf")
2304 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ellip)
2305 
2306 /// int sprintf(char *str, const char *format, ...);
2307 TLI_DEFINE_ENUM_INTERNAL(sprintf)
2308 TLI_DEFINE_STRING_INTERNAL("sprintf")
2309 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
2310 
2311 /// double sqrt(double x);
2312 TLI_DEFINE_ENUM_INTERNAL(sqrt)
2313 TLI_DEFINE_STRING_INTERNAL("sqrt")
2314 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2315 
2316 /// float sqrtf(float x);
2317 TLI_DEFINE_ENUM_INTERNAL(sqrtf)
2318 TLI_DEFINE_STRING_INTERNAL("sqrtf")
2319 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2320 
2321 /// long double sqrtl(long double x);
2322 TLI_DEFINE_ENUM_INTERNAL(sqrtl)
2323 TLI_DEFINE_STRING_INTERNAL("sqrtl")
2324 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2325 
2326 /// int sscanf(const char *s, const char *format, ... );
2327 TLI_DEFINE_ENUM_INTERNAL(sscanf)
2328 TLI_DEFINE_STRING_INTERNAL("sscanf")
2329 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ellip)
2330 
2331 /// int stat(const char *path, struct stat *buf);
2332 TLI_DEFINE_ENUM_INTERNAL(stat)
2333 TLI_DEFINE_STRING_INTERNAL("stat")
2334 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2335 
2336 /// int stat64(const char *path, struct stat64 *buf);
2337 TLI_DEFINE_ENUM_INTERNAL(stat64)
2338 TLI_DEFINE_STRING_INTERNAL("stat64")
2339 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2340 
2341 /// int statvfs(const char *path, struct statvfs *buf);
2342 TLI_DEFINE_ENUM_INTERNAL(statvfs)
2343 TLI_DEFINE_STRING_INTERNAL("statvfs")
2344 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2345 
2346 /// int statvfs64(const char *path, struct statvfs64 *buf)
2347 TLI_DEFINE_ENUM_INTERNAL(statvfs64)
2348 TLI_DEFINE_STRING_INTERNAL("statvfs64")
2349 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2350 
2351 /// char *stpcpy(char *s1, const char *s2);
2352 TLI_DEFINE_ENUM_INTERNAL(stpcpy)
2353 TLI_DEFINE_STRING_INTERNAL("stpcpy")
2354 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2355 
2356 /// char *stpncpy(char *s1, const char *s2, size_t n);
2357 TLI_DEFINE_ENUM_INTERNAL(stpncpy)
2358 TLI_DEFINE_STRING_INTERNAL("stpncpy")
2359 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
2360 
2361 /// int strcasecmp(const char *s1, const char *s2);
2362 TLI_DEFINE_ENUM_INTERNAL(strcasecmp)
2363 TLI_DEFINE_STRING_INTERNAL("strcasecmp")
2364 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2365 
2366 /// char *strcat(char *s1, const char *s2);
2367 TLI_DEFINE_ENUM_INTERNAL(strcat)
2368 TLI_DEFINE_STRING_INTERNAL("strcat")
2369 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2370 
2371 /// char *strchr(const char *s, int c);
2372 TLI_DEFINE_ENUM_INTERNAL(strchr)
2373 TLI_DEFINE_STRING_INTERNAL("strchr")
2374 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int)
2375 
2376 /// int strcmp(const char *s1, const char *s2);
2377 TLI_DEFINE_ENUM_INTERNAL(strcmp)
2378 TLI_DEFINE_STRING_INTERNAL("strcmp")
2379 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2380 
2381 /// int strcoll(const char *s1, const char *s2);
2382 TLI_DEFINE_ENUM_INTERNAL(strcoll)
2383 TLI_DEFINE_STRING_INTERNAL("strcoll")
2384 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2385 
2386 /// char *strcpy(char *s1, const char *s2);
2387 TLI_DEFINE_ENUM_INTERNAL(strcpy)
2388 TLI_DEFINE_STRING_INTERNAL("strcpy")
2389 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2390 
2391 /// size_t strcspn(const char *s1, const char *s2);
2392 TLI_DEFINE_ENUM_INTERNAL(strcspn)
2393 TLI_DEFINE_STRING_INTERNAL("strcspn")
2394 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr)
2395 
2396 /// char *strdup(const char *s1);
2397 TLI_DEFINE_ENUM_INTERNAL(strdup)
2398 TLI_DEFINE_STRING_INTERNAL("strdup")
2399 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr)
2400 
2401 /// size_t strlcat(char *dst, const char *src, size_t size);
2402 TLI_DEFINE_ENUM_INTERNAL(strlcat)
2403 TLI_DEFINE_STRING_INTERNAL("strlcat")
2404 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
2405 
2406 /// size_t strlcpy(char *dst, const char *src, size_t size);
2407 TLI_DEFINE_ENUM_INTERNAL(strlcpy)
2408 TLI_DEFINE_STRING_INTERNAL("strlcpy")
2409 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
2410 
2411 /// size_t strlen(const char *s);
2412 TLI_DEFINE_ENUM_INTERNAL(strlen)
2413 TLI_DEFINE_STRING_INTERNAL("strlen")
2414 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr)
2415 
2416 /// int strncasecmp(const char *s1, const char *s2, size_t n);
2417 TLI_DEFINE_ENUM_INTERNAL(strncasecmp)
2418 TLI_DEFINE_STRING_INTERNAL("strncasecmp")
2419 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
2420 
2421 /// char *strncat(char *s1, const char *s2, size_t n);
2422 TLI_DEFINE_ENUM_INTERNAL(strncat)
2423 TLI_DEFINE_STRING_INTERNAL("strncat")
2424 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
2425 
2426 /// int strncmp(const char *s1, const char *s2, size_t n);
2427 TLI_DEFINE_ENUM_INTERNAL(strncmp)
2428 TLI_DEFINE_STRING_INTERNAL("strncmp")
2429 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, SizeT)
2430 
2431 /// char *strncpy(char *s1, const char *s2, size_t n);
2432 TLI_DEFINE_ENUM_INTERNAL(strncpy)
2433 TLI_DEFINE_STRING_INTERNAL("strncpy")
2434 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, SizeT)
2435 
2436 /// char *strndup(const char *s1, size_t n);
2437 TLI_DEFINE_ENUM_INTERNAL(strndup)
2438 TLI_DEFINE_STRING_INTERNAL("strndup")
2439 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
2440 
2441 /// size_t strnlen(const char *s, size_t maxlen);
2442 TLI_DEFINE_ENUM_INTERNAL(strnlen)
2443 TLI_DEFINE_STRING_INTERNAL("strnlen")
2444 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, SizeT)
2445 
2446 /// char *strpbrk(const char *s1, const char *s2);
2447 TLI_DEFINE_ENUM_INTERNAL(strpbrk)
2448 TLI_DEFINE_STRING_INTERNAL("strpbrk")
2449 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2450 
2451 /// char *strrchr(const char *s, int c);
2452 TLI_DEFINE_ENUM_INTERNAL(strrchr)
2453 TLI_DEFINE_STRING_INTERNAL("strrchr")
2454 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Int)
2455 
2456 /// size_t strspn(const char *s1, const char *s2);
2457 TLI_DEFINE_ENUM_INTERNAL(strspn)
2458 TLI_DEFINE_STRING_INTERNAL("strspn")
2459 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr)
2460 
2461 /// char *strstr(const char *s1, const char *s2);
2462 TLI_DEFINE_ENUM_INTERNAL(strstr)
2463 TLI_DEFINE_STRING_INTERNAL("strstr")
2464 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2465 
2466 /// double strtod(const char *nptr, char **endptr);
2467 TLI_DEFINE_ENUM_INTERNAL(strtod)
2468 TLI_DEFINE_STRING_INTERNAL("strtod")
2469 TLI_DEFINE_SIG_INTERNAL(Dbl, Ptr, Ptr)
2470 
2471 /// float strtof(const char *nptr, char **endptr);
2472 TLI_DEFINE_ENUM_INTERNAL(strtof)
2473 TLI_DEFINE_STRING_INTERNAL("strtof")
2474 TLI_DEFINE_SIG_INTERNAL(Flt, Ptr, Ptr)
2475 
2476 /// char *strtok(char *s1, const char *s2);
2477 TLI_DEFINE_ENUM_INTERNAL(strtok)
2478 TLI_DEFINE_STRING_INTERNAL("strtok")
2479 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr)
2480 
2481 /// char *strtok_r(char *s, const char *sep, char **lasts);
2482 TLI_DEFINE_ENUM_INTERNAL(strtok_r)
2483 TLI_DEFINE_STRING_INTERNAL("strtok_r")
2484 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, Ptr, Ptr)
2485 
2486 /// long int strtol(const char *nptr, char **endptr, int base);
2487 TLI_DEFINE_ENUM_INTERNAL(strtol)
2488 TLI_DEFINE_STRING_INTERNAL("strtol")
2489 TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int)
2490 
2491 /// long double strtold(const char *nptr, char **endptr);
2492 TLI_DEFINE_ENUM_INTERNAL(strtold)
2493 TLI_DEFINE_STRING_INTERNAL("strtold")
2494 TLI_DEFINE_SIG_INTERNAL(LDbl, Ptr, Ptr)
2495 
2496 /// long long int strtoll(const char *nptr, char **endptr, int base);
2497 TLI_DEFINE_ENUM_INTERNAL(strtoll)
2498 TLI_DEFINE_STRING_INTERNAL("strtoll")
2499 TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int)
2500 
2501 /// unsigned long int strtoul(const char *nptr, char **endptr, int base);
2502 TLI_DEFINE_ENUM_INTERNAL(strtoul)
2503 TLI_DEFINE_STRING_INTERNAL("strtoul")
2504 TLI_DEFINE_SIG_INTERNAL(Long, Ptr, Ptr, Int)
2505 
2506 /// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
2507 TLI_DEFINE_ENUM_INTERNAL(strtoull)
2508 TLI_DEFINE_STRING_INTERNAL("strtoull")
2509 TLI_DEFINE_SIG_INTERNAL(LLong, Ptr, Ptr, Int)
2510 
2511 /// size_t strxfrm(char *s1, const char *s2, size_t n);
2512 TLI_DEFINE_ENUM_INTERNAL(strxfrm)
2513 TLI_DEFINE_STRING_INTERNAL("strxfrm")
2514 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr, Ptr, SizeT)
2515 
2516 /// int system(const char *command);
2517 TLI_DEFINE_ENUM_INTERNAL(system)
2518 TLI_DEFINE_STRING_INTERNAL("system")
2519 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2520 
2521 /// double tan(double x);
2522 TLI_DEFINE_ENUM_INTERNAL(tan)
2523 TLI_DEFINE_STRING_INTERNAL("tan")
2524 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2525 
2526 /// float tanf(float x);
2527 TLI_DEFINE_ENUM_INTERNAL(tanf)
2528 TLI_DEFINE_STRING_INTERNAL("tanf")
2529 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2530 
2531 /// double tanh(double x);
2532 TLI_DEFINE_ENUM_INTERNAL(tanh)
2533 TLI_DEFINE_STRING_INTERNAL("tanh")
2534 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2535 
2536 /// float tanhf(float x);
2537 TLI_DEFINE_ENUM_INTERNAL(tanhf)
2538 TLI_DEFINE_STRING_INTERNAL("tanhf")
2539 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2540 
2541 /// long double tanhl(long double x);
2542 TLI_DEFINE_ENUM_INTERNAL(tanhl)
2543 TLI_DEFINE_STRING_INTERNAL("tanhl")
2544 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2545 
2546 /// long double tanl(long double x);
2547 TLI_DEFINE_ENUM_INTERNAL(tanl)
2548 TLI_DEFINE_STRING_INTERNAL("tanl")
2549 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2550 
2551 /// clock_t times(struct tms *buffer);
2552 TLI_DEFINE_ENUM_INTERNAL(times)
2553 TLI_DEFINE_STRING_INTERNAL("times")
2554 TLI_DEFINE_SIG_INTERNAL(IntPlus, Ptr)
2555 
2556 /// FILE *tmpfile(void);
2557 TLI_DEFINE_ENUM_INTERNAL(tmpfile)
2558 TLI_DEFINE_STRING_INTERNAL("tmpfile")
2559 TLI_DEFINE_SIG_INTERNAL(Ptr)
2560 
2561 /// FILE *tmpfile64(void)
2562 TLI_DEFINE_ENUM_INTERNAL(tmpfile64)
2563 TLI_DEFINE_STRING_INTERNAL("tmpfile64")
2564 TLI_DEFINE_SIG_INTERNAL(Ptr)
2565 
2566 /// int toascii(int c);
2567 TLI_DEFINE_ENUM_INTERNAL(toascii)
2568 TLI_DEFINE_STRING_INTERNAL("toascii")
2569 TLI_DEFINE_SIG_INTERNAL(Int, Int)
2570 
2571 /// double trunc(double x);
2572 TLI_DEFINE_ENUM_INTERNAL(trunc)
2573 TLI_DEFINE_STRING_INTERNAL("trunc")
2574 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
2575 
2576 /// float truncf(float x);
2577 TLI_DEFINE_ENUM_INTERNAL(truncf)
2578 TLI_DEFINE_STRING_INTERNAL("truncf")
2579 TLI_DEFINE_SIG_INTERNAL(Flt, Flt)
2580 
2581 /// long double truncl(long double x);
2582 TLI_DEFINE_ENUM_INTERNAL(truncl)
2583 TLI_DEFINE_STRING_INTERNAL("truncl")
2584 TLI_DEFINE_SIG_INTERNAL(LDbl, LDbl)
2585 
2586 /// int uname(struct utsname *name);
2587 TLI_DEFINE_ENUM_INTERNAL(uname)
2588 TLI_DEFINE_STRING_INTERNAL("uname")
2589 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2590 
2591 /// int ungetc(int c, FILE *stream);
2592 TLI_DEFINE_ENUM_INTERNAL(ungetc)
2593 TLI_DEFINE_STRING_INTERNAL("ungetc")
2594 TLI_DEFINE_SIG_INTERNAL(Int, Int, Ptr)
2595 
2596 /// int unlink(const char *path);
2597 TLI_DEFINE_ENUM_INTERNAL(unlink)
2598 TLI_DEFINE_STRING_INTERNAL("unlink")
2599 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2600 
2601 /// int unsetenv(const char *name);
2602 TLI_DEFINE_ENUM_INTERNAL(unsetenv)
2603 TLI_DEFINE_STRING_INTERNAL("unsetenv")
2604 TLI_DEFINE_SIG_INTERNAL(Int, Ptr)
2605 
2606 /// int utime(const char *path, const struct utimbuf *times);
2607 TLI_DEFINE_ENUM_INTERNAL(utime)
2608 TLI_DEFINE_STRING_INTERNAL("utime")
2609 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2610 
2611 /// int utimes(const char *path, const struct timeval times[2]);
2612 TLI_DEFINE_ENUM_INTERNAL(utimes)
2613 TLI_DEFINE_STRING_INTERNAL("utimes")
2614 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2615 
2616 /// void *valloc(size_t size);
2617 TLI_DEFINE_ENUM_INTERNAL(valloc)
2618 TLI_DEFINE_STRING_INTERNAL("valloc")
2619 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
2620 
2621 /// void *vec_calloc(size_t count, size_t size);
2622 TLI_DEFINE_ENUM_INTERNAL(vec_calloc)
2623 TLI_DEFINE_STRING_INTERNAL("vec_calloc")
2624 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT, SizeT)
2625 
2626 /// void vec_free(void *ptr);
2627 TLI_DEFINE_ENUM_INTERNAL(vec_free)
2628 TLI_DEFINE_STRING_INTERNAL("vec_free")
2629 TLI_DEFINE_SIG_INTERNAL(Void, Ptr)
2630 
2631 /// void *vec_malloc(size_t size);
2632 TLI_DEFINE_ENUM_INTERNAL(vec_malloc)
2633 TLI_DEFINE_STRING_INTERNAL("vec_malloc")
2634 TLI_DEFINE_SIG_INTERNAL(Ptr, SizeT)
2635 
2636 /// void *vec_realloc(void *ptr, size_t size);
2637 TLI_DEFINE_ENUM_INTERNAL(vec_realloc)
2638 TLI_DEFINE_STRING_INTERNAL("vec_realloc")
2639 TLI_DEFINE_SIG_INTERNAL(Ptr, Ptr, SizeT)
2640 
2641 /// int vfprintf(FILE *stream, const char *format, va_list ap);
2642 TLI_DEFINE_ENUM_INTERNAL(vfprintf)
2643 TLI_DEFINE_STRING_INTERNAL("vfprintf")
2644 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
2645 
2646 /// int vfscanf(FILE *stream, const char *format, va_list arg);
2647 TLI_DEFINE_ENUM_INTERNAL(vfscanf)
2648 TLI_DEFINE_STRING_INTERNAL("vfscanf")
2649 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
2650 
2651 /// int vprintf(const char *restrict format, va_list ap);
2652 TLI_DEFINE_ENUM_INTERNAL(vprintf)
2653 TLI_DEFINE_STRING_INTERNAL("vprintf")
2654 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2655 
2656 /// int vscanf(const char *format, va_list arg);
2657 TLI_DEFINE_ENUM_INTERNAL(vscanf)
2658 TLI_DEFINE_STRING_INTERNAL("vscanf")
2659 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr)
2660 
2661 /// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
2662 TLI_DEFINE_ENUM_INTERNAL(vsnprintf)
2663 TLI_DEFINE_STRING_INTERNAL("vsnprintf")
2664 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, SizeT, Ptr, Ptr)
2665 
2666 /// int vsprintf(char *s, const char *format, va_list ap);
2667 TLI_DEFINE_ENUM_INTERNAL(vsprintf)
2668 TLI_DEFINE_STRING_INTERNAL("vsprintf")
2669 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
2670 
2671 /// int vsscanf(const char *s, const char *format, va_list arg);
2672 TLI_DEFINE_ENUM_INTERNAL(vsscanf)
2673 TLI_DEFINE_STRING_INTERNAL("vsscanf")
2674 TLI_DEFINE_SIG_INTERNAL(Int, Ptr, Ptr, Ptr)
2675 
2676 /// size_t wcslen (const wchar_t* wcs);
2677 TLI_DEFINE_ENUM_INTERNAL(wcslen)
2678 TLI_DEFINE_STRING_INTERNAL("wcslen")
2679 TLI_DEFINE_SIG_INTERNAL(SizeT, Ptr)
2680 
2681 /// ssize_t write(int fildes, const void *buf, size_t nbyte);
2682 TLI_DEFINE_ENUM_INTERNAL(write)
2683 TLI_DEFINE_STRING_INTERNAL("write")
2684 TLI_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
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!