WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/llvm/Analysis/TargetLibraryInfo.def

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

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/llvm/Analysis/TargetLibraryInfo.def – Rev 14