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

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of llvm/include/llvm/Analysis/TargetLibraryInfo.def