1691 lines
58 KiB
TableGen
1691 lines
58 KiB
TableGen
//===-- TargetLibraryInfo.td - File that describes library functions ------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
include "llvm/Analysis/TargetLibraryInfoImpl.td"
|
|
|
|
/// void *operator new(unsigned int);
|
|
def msvc_new_int : TargetLibCall<"??2@YAPAXI@Z", Ptr, [Int]>;
|
|
|
|
/// void *operator new(unsigned int, const std::nothrow_t&);
|
|
def msvc_new_int_nothrow
|
|
: TargetLibCall<"??2@YAPAXIABUnothrow_t@std@@@Z", Ptr, [Int, Ptr]>;
|
|
|
|
/// void *operator new(unsigned long long);
|
|
def msvc_new_longlong : TargetLibCall<"??2@YAPEAX_K@Z", Ptr, [LLong]>;
|
|
|
|
/// void *operator new(unsigned long long, const std::nothrow_t&);
|
|
def msvc_new_longlong_nothrow
|
|
: TargetLibCall<"??2@YAPEAX_KAEBUnothrow_t@std@@@Z", Ptr, [LLong, Ptr]>;
|
|
|
|
/// void operator delete(void*);
|
|
def msvc_delete_ptr32 : TargetLibCall<"??3@YAXPAX@Z", Void, [Ptr]>;
|
|
|
|
/// void operator delete(void*, const std::nothrow_t&);
|
|
def msvc_delete_ptr32_nothrow
|
|
: TargetLibCall<"??3@YAXPAXABUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete(void*, unsigned int);
|
|
def msvc_delete_ptr32_int : TargetLibCall<"??3@YAXPAXI@Z", Void, [Ptr, Int]>;
|
|
|
|
/// void operator delete(void*);
|
|
def msvc_delete_ptr64 : TargetLibCall<"??3@YAXPEAX@Z", Void, [Ptr]>;
|
|
|
|
/// void operator delete(void*, const std::nothrow_t&);
|
|
def msvc_delete_ptr64_nothrow
|
|
: TargetLibCall<"??3@YAXPEAXAEBUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete(void*, unsigned long long);
|
|
def msvc_delete_ptr64_longlong
|
|
: TargetLibCall<"??3@YAXPEAX_K@Z", Void, [Ptr, LLong]>;
|
|
|
|
/// void *operator new[](unsigned int);
|
|
def msvc_new_array_int : TargetLibCall<"??_U@YAPAXI@Z", Ptr, [Int]>;
|
|
|
|
/// void *operator new](unsigned int, [const std::nothrow_t&);
|
|
def msvc_new_array_int_nothrow
|
|
: TargetLibCall<"??_U@YAPAXIABUnothrow_t@std@@@Z", Ptr, [Int, Ptr]>;
|
|
|
|
/// void *operator new[](unsigned long long);
|
|
def msvc_new_array_longlong : TargetLibCall<"??_U@YAPEAX_K@Z", Ptr, [LLong]>;
|
|
|
|
/// void *operator new](unsigned long long, [const std::nothrow_t&);
|
|
def msvc_new_array_longlong_nothrow
|
|
: TargetLibCall<"??_U@YAPEAX_KAEBUnothrow_t@std@@@Z", Ptr, [LLong, Ptr]>;
|
|
|
|
/// void operator delete[](void*);
|
|
def msvc_delete_array_ptr32 : TargetLibCall<"??_V@YAXPAX@Z", Void, [Ptr]>;
|
|
|
|
/// void operator delete](void*, [const std::nothrow_t&);
|
|
def msvc_delete_array_ptr32_nothrow
|
|
: TargetLibCall<"??_V@YAXPAXABUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete](void*, [unsigned int);
|
|
def msvc_delete_array_ptr32_int
|
|
: TargetLibCall<"??_V@YAXPAXI@Z", Void, [Ptr, Int]>;
|
|
|
|
/// void operator delete[](void*);
|
|
def msvc_delete_array_ptr64 : TargetLibCall<"??_V@YAXPEAX@Z", Void, [Ptr]>;
|
|
|
|
/// void operator delete](void*, [const std::nothrow_t&);
|
|
def msvc_delete_array_ptr64_nothrow
|
|
: TargetLibCall<"??_V@YAXPEAXAEBUnothrow_t@std@@@Z", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete](void*, [unsigned long long);
|
|
def msvc_delete_array_ptr64_longlong
|
|
: TargetLibCall<"??_V@YAXPEAX_K@Z", Void, [Ptr, LLong]>;
|
|
|
|
/// int _IO_getc(_IO_FILE * __fp);
|
|
def under_IO_getc : TargetLibCall<"_IO_getc", Int, [Ptr]>;
|
|
|
|
/// int _IO_putc(int __c, _IO_FILE * __fp);
|
|
def under_IO_putc : TargetLibCall<"_IO_putc", Int, [Int, Ptr]>;
|
|
|
|
/// void operator delete[](void*);
|
|
def ZdaPv : TargetLibCall<"_ZdaPv", Void, [Ptr]>;
|
|
|
|
/// void operator delete](void*, [const std::nothrow_t&);
|
|
def ZdaPvRKSt9nothrow_t
|
|
: TargetLibCall<"_ZdaPvRKSt9nothrow_t", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete](void*, [std::align_val_t);
|
|
def ZdaPvSt11align_val_t
|
|
: TargetLibCall<"_ZdaPvSt11align_val_t", Void, [Ptr, IntPlus]>;
|
|
|
|
/// void operator delete](void*, [std::align_val_t, const std::nothrow_t&)
|
|
def ZdaPvSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZdaPvSt11align_val_tRKSt9nothrow_t",
|
|
Void, [Ptr, IntPlus, Ptr]>;
|
|
|
|
/// void operator delete](void*, [unsigned int);
|
|
def ZdaPvj : TargetLibCall<"_ZdaPvj", Void, [Ptr, Int]>;
|
|
|
|
/// void operator delete](void*, [unsigned int, std::align_val_t);
|
|
def ZdaPvjSt11align_val_t
|
|
: TargetLibCall<"_ZdaPvjSt11align_val_t", Void, [Ptr, Int, Int]>;
|
|
|
|
/// void operator delete](void*, [unsigned long);
|
|
def ZdaPvm : TargetLibCall<"_ZdaPvm", Void, [Ptr, Long]>;
|
|
|
|
/// void operator delete](void*, [unsigned long, std::align_val_t);
|
|
def ZdaPvmSt11align_val_t
|
|
: TargetLibCall<"_ZdaPvmSt11align_val_t", Void, [Ptr, Long, Long]>;
|
|
|
|
/// void operator delete(void*);
|
|
def ZdlPv : TargetLibCall<"_ZdlPv", Void, [Ptr]>;
|
|
|
|
/// void operator delete(void*, const std::nothrow_t&);
|
|
def ZdlPvRKSt9nothrow_t
|
|
: TargetLibCall<"_ZdlPvRKSt9nothrow_t", Void, [Ptr, Ptr]>;
|
|
|
|
/// void operator delete(void*, std::align_val_t)
|
|
def ZdlPvSt11align_val_t
|
|
: TargetLibCall<"_ZdlPvSt11align_val_t", Void, [Ptr, IntPlus]>;
|
|
|
|
/// void operator delete(void*, std::align_val_t, const std::nothrow_t&)
|
|
def ZdlPvSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZdlPvSt11align_val_tRKSt9nothrow_t",
|
|
Void, [Ptr, IntPlus, Ptr]>;
|
|
|
|
/// void operator delete(void*, unsigned int);
|
|
def ZdlPvj : TargetLibCall<"_ZdlPvj", Void, [Ptr, Int]>;
|
|
|
|
/// void operator delete(void*, unsigned int, std::align_val_t)
|
|
def ZdlPvjSt11align_val_t
|
|
: TargetLibCall<"_ZdlPvjSt11align_val_t", Void, [Ptr, Int, Int]>;
|
|
|
|
/// void operator delete(void*, unsigned long);
|
|
def ZdlPvm : TargetLibCall<"_ZdlPvm", Void, [Ptr, Long]>;
|
|
|
|
/// void operator delete(void*, unsigned long, std::align_val_t)
|
|
def ZdlPvmSt11align_val_t
|
|
: TargetLibCall<"_ZdlPvmSt11align_val_t", Void, [Ptr, Long, Long]>;
|
|
|
|
/// void *operator new[](unsigned int);
|
|
def Znaj : TargetLibCall<"_Znaj", Ptr, [Int]>;
|
|
|
|
/// void *operator new](unsigned int, [const std::nothrow_t&);
|
|
def ZnajRKSt9nothrow_t : TargetLibCall<"_ZnajRKSt9nothrow_t", Ptr, [Int, Ptr]>;
|
|
|
|
/// void *operator new](unsigned int, [std::align_val_t)
|
|
def ZnajSt11align_val_t
|
|
: TargetLibCall<"_ZnajSt11align_val_t", Ptr, [Int, Int]>;
|
|
|
|
/// void *operator new](unsigned int, [std::align_val_t, const std::nothrow_t&)
|
|
def ZnajSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZnajSt11align_val_tRKSt9nothrow_t", Ptr, [Int, Int, Ptr]>;
|
|
|
|
/// void *operator new[](unsigned long);
|
|
def Znam : TargetLibCall<"_Znam", Ptr, [Long]>;
|
|
|
|
/// void *operator new](unsigned long, [__hot_cold_t)
|
|
/// Currently this and other operator new interfaces that take a __hot_cold_t
|
|
/// hint are supported by the open source version of tcmalloc, see:
|
|
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
|
|
/// and for the definition of the __hot_cold_t parameter see:
|
|
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
|
|
def Znam12__hot_cold_t
|
|
: TargetLibCall<"_Znam12__hot_cold_t", Ptr, [Long, Bool]>;
|
|
|
|
/// void *operator new](unsigned long, [const std::nothrow_t&);
|
|
def ZnamRKSt9nothrow_t : TargetLibCall<"_ZnamRKSt9nothrow_t", Ptr, [Long, Ptr]>;
|
|
|
|
/// void *operator new](unsigned long, [const std::nothrow_t&, __hot_cold_t)
|
|
def ZnamRKSt9nothrow_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnamRKSt9nothrow_t12__hot_cold_t",
|
|
Ptr, [Long, Ptr, Bool]>;
|
|
|
|
/// void *operator new](unsigned long, [std::align_val_t)
|
|
def ZnamSt11align_val_t
|
|
: TargetLibCall<"_ZnamSt11align_val_t", Ptr, [Long, Long]>;
|
|
|
|
/// void *operator new](unsigned long, [std::align_val_t, __hot_cold_t)
|
|
def ZnamSt11align_val_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnamSt11align_val_t12__hot_cold_t",
|
|
Ptr, [Long, Long, Bool]>;
|
|
|
|
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&)
|
|
def ZnamSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZnamSt11align_val_tRKSt9nothrow_t",
|
|
Ptr, [Long, Long, Ptr]>;
|
|
|
|
/// void *operator new](unsigned long, [std::align_val_t, const std::nothrow_t&,
|
|
/// __hot_cold_t)
|
|
def ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t",
|
|
Ptr, [Long, Long, Ptr, Bool]>;
|
|
|
|
/// void *operator new(unsigned int);
|
|
def Znwj : TargetLibCall<"_Znwj", Ptr, [Int]>;
|
|
|
|
/// void *operator new(unsigned int, const std::nothrow_t&);
|
|
def ZnwjRKSt9nothrow_t : TargetLibCall<"_ZnwjRKSt9nothrow_t", Ptr, [Int, Ptr]>;
|
|
|
|
/// void *operator new(unsigned int, std::align_val_t)
|
|
def ZnwjSt11align_val_t
|
|
: TargetLibCall<"_ZnwjSt11align_val_t", Ptr, [Int, Int]>;
|
|
|
|
/// void *operator new(unsigned int, std::align_val_t, const std::nothrow_t&)
|
|
def ZnwjSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZnwjSt11align_val_tRKSt9nothrow_t", Ptr, [Int, Int, Ptr]>;
|
|
|
|
/// void *operator new(unsigned long);
|
|
def Znwm : TargetLibCall<"_Znwm", Ptr, [Long]>;
|
|
|
|
/// void *operator new(unsigned long, __hot_cold_t)
|
|
def Znwm12__hot_cold_t
|
|
: TargetLibCall<"_Znwm12__hot_cold_t", Ptr, [Long, Bool]>;
|
|
|
|
/// void *operator new(unsigned long, const std::nothrow_t&);
|
|
def ZnwmRKSt9nothrow_t : TargetLibCall<"_ZnwmRKSt9nothrow_t", Ptr, [Long, Ptr]>;
|
|
|
|
/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
|
|
def ZnwmRKSt9nothrow_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnwmRKSt9nothrow_t12__hot_cold_t",
|
|
Ptr, [Long, Ptr, Bool]>;
|
|
|
|
/// void *operator new(unsigned long, std::align_val_t)
|
|
def ZnwmSt11align_val_t
|
|
: TargetLibCall<"_ZnwmSt11align_val_t", Ptr, [Long, Long]>;
|
|
|
|
/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
|
|
def ZnwmSt11align_val_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnwmSt11align_val_t12__hot_cold_t",
|
|
Ptr, [Long, Long, Bool]>;
|
|
|
|
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
|
|
def ZnwmSt11align_val_tRKSt9nothrow_t
|
|
: TargetLibCall<"_ZnwmSt11align_val_tRKSt9nothrow_t",
|
|
Ptr, [Long, Long, Ptr]>;
|
|
|
|
/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&,
|
|
/// __hot_cold_t)
|
|
def ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t
|
|
: TargetLibCall<"_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t",
|
|
Ptr, [Long, Long, Ptr, Bool]>;
|
|
|
|
/// The following are variants of operator new which return the actual size
|
|
/// reserved by the allocator proposed in P0901R5 (Size feedback in operator
|
|
/// new). https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0901r5.html
|
|
/// They are implemented by tcmalloc, see source at
|
|
/// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
|
|
|
|
/// __sized_ptr_t __size_returning_new(size_t size)
|
|
def size_returning_new
|
|
: TargetLibCall<"__size_returning_new", ? /* Checked manually. */>;
|
|
|
|
/// __sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t)
|
|
def size_returning_new_hot_cold
|
|
: TargetLibCall<"__size_returning_new_hot_cold", ? /* Checked manually. */>;
|
|
|
|
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t)
|
|
def size_returning_new_aligned
|
|
: TargetLibCall<"__size_returning_new_aligned", ? /* Checked manually. */>;
|
|
|
|
/// __sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t,
|
|
/// __hot_cold_t)
|
|
def size_returning_new_aligned_hot_cold
|
|
: TargetLibCall<"__size_returning_new_aligned_hot_cold",
|
|
? /* Checked manually. */>;
|
|
|
|
/// double __acos_finite(double x);
|
|
def acos_finite : TargetLibCall<"__acos_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __acosf_finite(float x);
|
|
def acosf_finite : TargetLibCall<"__acosf_finite", Flt, [Flt]>;
|
|
|
|
/// double __acosh_finite(double x);
|
|
def acosh_finite : TargetLibCall<"__acosh_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __acoshf_finite(float x);
|
|
def acoshf_finite : TargetLibCall<"__acoshf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __acoshl_finite(long double x);
|
|
def acoshl_finite : TargetLibCall<"__acoshl_finite", LDbl, [LDbl]>;
|
|
|
|
/// long double __acosl_finite(long double x);
|
|
def acosl_finite : TargetLibCall<"__acosl_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __asin_finite(double x);
|
|
def asin_finite : TargetLibCall<"__asin_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __asinf_finite(float x);
|
|
def asinf_finite : TargetLibCall<"__asinf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __asinl_finite(long double x);
|
|
def asinl_finite : TargetLibCall<"__asinl_finite", LDbl, [LDbl]>;
|
|
|
|
/// double atan2_finite(double y, double x);
|
|
def atan2_finite : TargetLibCall<"__atan2_finite", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float atan2f_finite(float y, float x);
|
|
def atan2f_finite : TargetLibCall<"__atan2f_finite", Flt, [Flt, Flt]>;
|
|
|
|
/// long double atan2l_finite(long double y, long double x);
|
|
def atan2l_finite : TargetLibCall<"__atan2l_finite", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// double __atanh_finite(double x);
|
|
def atanh_finite : TargetLibCall<"__atanh_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __atanhf_finite(float x);
|
|
def atanhf_finite : TargetLibCall<"__atanhf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __atanhl_finite(long double x);
|
|
def atanhl_finite : TargetLibCall<"__atanhl_finite", LDbl, [LDbl]>;
|
|
|
|
/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
|
|
def atomic_load : TargetLibCall<"__atomic_load", Void, [SizeT, Ptr, Ptr, Int]>;
|
|
|
|
/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
|
|
def atomic_store
|
|
: TargetLibCall<"__atomic_store", Void, [SizeT, Ptr, Ptr, Int]>;
|
|
|
|
/// double __cosh_finite(double x);
|
|
def cosh_finite : TargetLibCall<"__cosh_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __coshf_finite(float x);
|
|
def coshf_finite : TargetLibCall<"__coshf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __coshl_finite(long double x);
|
|
def coshl_finite : TargetLibCall<"__coshl_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __cospi(double x);
|
|
def cospi : TargetLibCall<"__cospi", Dbl, [Dbl]>;
|
|
|
|
/// float __cospif(float x);
|
|
def cospif : TargetLibCall<"__cospif", Flt, [Flt]>;
|
|
|
|
/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
|
|
def cxa_atexit : TargetLibCall<"__cxa_atexit", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int atexit(void (*f)(void));
|
|
def atexit : TargetLibCall<"atexit", Int, [Ptr]>;
|
|
|
|
/// void abort(void)
|
|
def abort : TargetLibCall<"abort", Void, []>;
|
|
|
|
/// void exit(int)
|
|
def exit : TargetLibCall<"exit", Void, [Int]>;
|
|
|
|
/// void _Exit(int)
|
|
def Exit : TargetLibCall<"_Exit", Void, [Int]>;
|
|
|
|
/// void std::terminate();
|
|
def terminate : TargetLibCall<"_ZSt9terminatev", Void, []>;
|
|
|
|
/// void __cxa_throw(void *, void *, void (*)(void *));
|
|
def cxa_throw : TargetLibCall<"__cxa_throw", Void, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// void __cxa_guard_abort(guard_t *guard);
|
|
/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
|
|
def cxa_guard_abort : TargetLibCall<"__cxa_guard_abort", Void, [Ptr]>;
|
|
|
|
/// int __cxa_guard_acquire(guard_t *guard);
|
|
def cxa_guard_acquire : TargetLibCall<"__cxa_guard_acquire", Int, [Ptr]>;
|
|
|
|
/// void __cxa_guard_release(guard_t *guard);
|
|
def cxa_guard_release : TargetLibCall<"__cxa_guard_release", Void, [Ptr]>;
|
|
|
|
/// double __exp10_finite(double x);
|
|
def exp10_finite : TargetLibCall<"__exp10_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __exp10f_finite(float x);
|
|
def exp10f_finite : TargetLibCall<"__exp10f_finite", Flt, [Flt]>;
|
|
|
|
/// long double __exp10l_finite(long double x);
|
|
def exp10l_finite : TargetLibCall<"__exp10l_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __exp2_finite(double x);
|
|
def exp2_finite : TargetLibCall<"__exp2_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __exp2f_finite(float x);
|
|
def exp2f_finite : TargetLibCall<"__exp2f_finite", Flt, [Flt]>;
|
|
|
|
/// long double __exp2l_finite(long double x);
|
|
def exp2l_finite : TargetLibCall<"__exp2l_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __exp_finite(double x);
|
|
def exp_finite : TargetLibCall<"__exp_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __expf_finite(float x);
|
|
def expf_finite : TargetLibCall<"__expf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __expl_finite(long double x);
|
|
def expl_finite : TargetLibCall<"__expl_finite", LDbl, [LDbl]>;
|
|
|
|
/// int __isoc99_scanf (const char *format, ...)
|
|
def dunder_isoc99_scanf : TargetLibCall<"__isoc99_scanf", Int, [Ptr, Ellip]>;
|
|
|
|
/// int __isoc99_sscanf(const char *s, const char *format, ...)
|
|
def dunder_isoc99_sscanf
|
|
: TargetLibCall<"__isoc99_sscanf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// double __log10_finite(double x);
|
|
def log10_finite : TargetLibCall<"__log10_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __log10f_finite(float x);
|
|
def log10f_finite : TargetLibCall<"__log10f_finite", Flt, [Flt]>;
|
|
|
|
/// long double __log10l_finite(long double x);
|
|
def log10l_finite : TargetLibCall<"__log10l_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __log2_finite(double x);
|
|
def log2_finite : TargetLibCall<"__log2_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __log2f_finite(float x);
|
|
def log2f_finite : TargetLibCall<"__log2f_finite", Flt, [Flt]>;
|
|
|
|
/// long double __log2l_finite(long double x);
|
|
def log2l_finite : TargetLibCall<"__log2l_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __log_finite(double x);
|
|
def log_finite : TargetLibCall<"__log_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __logf_finite(float x);
|
|
def logf_finite : TargetLibCall<"__logf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __logl_finite(long double x);
|
|
def logl_finite : TargetLibCall<"__logl_finite", LDbl, [LDbl]>;
|
|
|
|
/// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
|
|
/// size_t dstsize)
|
|
def memccpy_chk
|
|
: TargetLibCall<"__memccpy_chk", Ptr, [Ptr, Ptr, Int, SizeT, SizeT]>;
|
|
|
|
/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
|
|
def memcpy_chk : TargetLibCall<"__memcpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
|
|
def memmove_chk : TargetLibCall<"__memmove_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
|
|
def mempcpy_chk : TargetLibCall<"__mempcpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// void *__memset_chk(void *s, int v, size_t n, size_t s1size);
|
|
def memset_chk : TargetLibCall<"__memset_chk", Ptr, [Ptr, Int, SizeT, SizeT]>;
|
|
|
|
// int __nvvm_reflect(const char *)
|
|
def nvvm_reflect : TargetLibCall<"__nvvm_reflect", Int, [Ptr]>;
|
|
|
|
/// double __pow_finite(double x, double y);
|
|
def pow_finite : TargetLibCall<"__pow_finite", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float _powf_finite(float x, float y);
|
|
def powf_finite : TargetLibCall<"__powf_finite", Flt, [Flt, Flt]>;
|
|
|
|
/// long double __powl_finite(long double x, long double y);
|
|
def powl_finite : TargetLibCall<"__powl_finite", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// double __sincospi_stret(double x);
|
|
def sincospi_stret
|
|
: TargetLibCall<"__sincospi_stret", ? /* Checked manually. */>;
|
|
|
|
/// float __sincospif_stret(float x);
|
|
def sincospif_stret
|
|
: TargetLibCall<"__sincospif_stret", ? /* Checked manually. */>;
|
|
|
|
/// double __sinh_finite(double x);
|
|
def sinh_finite : TargetLibCall<"__sinh_finite", Dbl, [Dbl]>;
|
|
|
|
/// float _sinhf_finite(float x);
|
|
def sinhf_finite : TargetLibCall<"__sinhf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __sinhl_finite(long double x);
|
|
def sinhl_finite : TargetLibCall<"__sinhl_finite", LDbl, [LDbl]>;
|
|
|
|
/// double __sinpi(double x);
|
|
def sinpi : TargetLibCall<"__sinpi", Dbl, [Dbl]>;
|
|
|
|
/// float __sinpif(float x);
|
|
def sinpif : TargetLibCall<"__sinpif", Flt, [Flt]>;
|
|
|
|
/// int __small_fprintf(FILE *stream, const char *format, ...);
|
|
def small_fprintf : TargetLibCall<"__small_fprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int __small_printf(const char *format, ...);
|
|
def small_printf : TargetLibCall<"__small_printf", Int, [Ptr, Ellip]>;
|
|
|
|
/// int __small_sprintf(char *str, const char *format, ...);
|
|
def small_sprintf : TargetLibCall<"__small_sprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int __snprintf_chk(char *s, size_t n, int flags, size_t slen,
|
|
/// const char *format, ...);
|
|
def snprintf_chk : TargetLibCall<"__snprintf_chk",
|
|
Int, [Ptr, SizeT, Int, SizeT, Ptr, Ellip]>;
|
|
|
|
/// int __sprintf_chk(char *str, int flags, size_t str_len,
|
|
/// const char *format, ...);
|
|
def sprintf_chk
|
|
: TargetLibCall<"__sprintf_chk", Int, [Ptr, Int, SizeT, Ptr, Ellip]>;
|
|
|
|
/// double __sqrt_finite(double x);
|
|
def sqrt_finite : TargetLibCall<"__sqrt_finite", Dbl, [Dbl]>;
|
|
|
|
/// float __sqrt_finite(float x);
|
|
def sqrtf_finite : TargetLibCall<"__sqrtf_finite", Flt, [Flt]>;
|
|
|
|
/// long double __sqrt_finite(long double x);
|
|
def sqrtl_finite : TargetLibCall<"__sqrtl_finite", LDbl, [LDbl]>;
|
|
|
|
/// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
|
|
def stpcpy_chk : TargetLibCall<"__stpcpy_chk", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char *__stpncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
|
|
def stpncpy_chk : TargetLibCall<"__stpncpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// char *__strcat_chk(char *s1, const char *s2, size_t s1size);
|
|
def strcat_chk : TargetLibCall<"__strcat_chk", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
|
|
def strcpy_chk : TargetLibCall<"__strcpy_chk", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char * __strdup(const char *s);
|
|
def dunder_strdup : TargetLibCall<"__strdup", Ptr, [Ptr]>;
|
|
|
|
/// size_t __strlcat_chk(char *dst, const char *src, size_t size,
|
|
/// size_t dstsize);
|
|
def strlcat_chk
|
|
: TargetLibCall<"__strlcat_chk", SizeT, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// size_t __strlcpy_chk(char *dst, const char *src, size_t size,
|
|
/// size_t dstsize);
|
|
def strlcpy_chk
|
|
: TargetLibCall<"__strlcpy_chk", SizeT, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// size_t __strlen_chk(const char *s1, size_t s1size);
|
|
def strlen_chk : TargetLibCall<"__strlen_chk", SizeT, [Ptr, SizeT]>;
|
|
|
|
/// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
|
|
def strncat_chk : TargetLibCall<"__strncat_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// char *__strncpy_chk(char *s1, const char *s2, size_t n, size_t s1size);
|
|
def strncpy_chk : TargetLibCall<"__strncpy_chk", Ptr, [Ptr, Ptr, SizeT, SizeT]>;
|
|
|
|
/// char *__strndup(const char *s, size_t n);
|
|
def dunder_strndup : TargetLibCall<"__strndup", Ptr, [Ptr, SizeT]>;
|
|
|
|
/// char * __strtok_r(char *s, const char *delim, char **save_ptr);
|
|
def dunder_strtok_r : TargetLibCall<"__strtok_r", Ptr, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int __vsnprintf_chk(char *s, size_t n, int flags, size_t slen,
|
|
/// const char *format, va_list ap);
|
|
def vsnprintf_chk
|
|
: TargetLibCall<"__vsnprintf_chk", Int, [Ptr, SizeT, Int, SizeT, Ptr, Ptr]>;
|
|
|
|
/// int __vsprintf_chk(char *s, int flags, size_t slen, const char *format,
|
|
/// va_list ap);
|
|
def vsprintf_chk
|
|
: TargetLibCall<"__vsprintf_chk", Int, [Ptr, Int, SizeT, Ptr, Ptr]>;
|
|
|
|
/// int abs(int j);
|
|
def abs : TargetLibCall<"abs", Int, [Int]>;
|
|
|
|
/// int access(const char *path, int amode);
|
|
def access : TargetLibCall<"access", Int, [Ptr, Int]>;
|
|
|
|
/// double acos(double x);
|
|
def acos : TargetLibCall<"acos", Dbl, [Dbl]>;
|
|
|
|
/// float acosf(float x);
|
|
def acosf : TargetLibCall<"acosf", Flt, [Flt]>;
|
|
|
|
/// double acosh(double x);
|
|
def acosh : TargetLibCall<"acosh", Dbl, [Dbl]>;
|
|
|
|
/// float acoshf(float x);
|
|
def acoshf : TargetLibCall<"acoshf", Flt, [Flt]>;
|
|
|
|
/// long double acoshl(long double x);
|
|
def acoshl : TargetLibCall<"acoshl", LDbl, [LDbl]>;
|
|
|
|
/// long double acosl(long double x);
|
|
def acosl : TargetLibCall<"acosl", LDbl, [LDbl]>;
|
|
|
|
/// void *aligned_alloc(size_t alignment, size_t size);
|
|
def aligned_alloc : TargetLibCall<"aligned_alloc", Ptr, [SizeT, SizeT]>;
|
|
|
|
/// double asin(double x);
|
|
def asin : TargetLibCall<"asin", Dbl, [Dbl]>;
|
|
|
|
/// float asinf(float x);
|
|
def asinf : TargetLibCall<"asinf", Flt, [Flt]>;
|
|
|
|
/// double asinh(double x);
|
|
def asinh : TargetLibCall<"asinh", Dbl, [Dbl]>;
|
|
|
|
/// float asinhf(float x);
|
|
def asinhf : TargetLibCall<"asinhf", Flt, [Flt]>;
|
|
|
|
/// long double asinhl(long double x);
|
|
def asinhl : TargetLibCall<"asinhl", LDbl, [LDbl]>;
|
|
|
|
/// long double asinl(long double x);
|
|
def asinl : TargetLibCall<"asinl", LDbl, [LDbl]>;
|
|
|
|
/// double atan(double x);
|
|
def atan : TargetLibCall<"atan", Dbl, [Dbl]>;
|
|
|
|
/// double atan2(double y, double x);
|
|
def atan2 : TargetLibCall<"atan2", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float atan2f(float y, float x);
|
|
def atan2f : TargetLibCall<"atan2f", Flt, [Flt, Flt]>;
|
|
|
|
/// long double atan2l(long double y, long double x);
|
|
def atan2l : TargetLibCall<"atan2l", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// float atanf(float x);
|
|
def atanf : TargetLibCall<"atanf", Flt, [Flt]>;
|
|
|
|
/// double atanh(double x);
|
|
def atanh : TargetLibCall<"atanh", Dbl, [Dbl]>;
|
|
|
|
/// float atanhf(float x);
|
|
def atanhf : TargetLibCall<"atanhf", Flt, [Flt]>;
|
|
|
|
/// long double atanhl(long double x);
|
|
def atanhl : TargetLibCall<"atanhl", LDbl, [LDbl]>;
|
|
|
|
/// long double atanl(long double x);
|
|
def atanl : TargetLibCall<"atanl", LDbl, [LDbl]>;
|
|
|
|
/// double atof(const char *str);
|
|
def atof : TargetLibCall<"atof", Dbl, [Ptr]>;
|
|
|
|
/// int atoi(const char *str);
|
|
def atoi : TargetLibCall<"atoi", Int, [Ptr]>;
|
|
|
|
/// long atol(const char *str);
|
|
def atol : TargetLibCall<"atol", Long, [Ptr]>;
|
|
|
|
/// long long atoll(const char *nptr);
|
|
def atoll : TargetLibCall<"atoll", LLong, [Ptr]>;
|
|
|
|
/// int bcmp(const void *s1, const void *s2, size_t n);
|
|
def bcmp : TargetLibCall<"bcmp", Int, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void bcopy(const void *s1, void *s2, size_t n);
|
|
def bcopy : TargetLibCall<"bcopy", Void, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void bzero(void *s, size_t n);
|
|
def bzero : TargetLibCall<"bzero", Void, [Ptr, SizeT]>;
|
|
|
|
/// double cabs(double complex z)
|
|
def cabs : TargetLibCall<"cabs", ? /* Checked manually. */>;
|
|
|
|
/// float cabs(float complex z)
|
|
def cabsf : TargetLibCall<"cabsf", ? /* Checked manually. */>;
|
|
|
|
/// long double cabs(long double complex z)
|
|
def cabsl : TargetLibCall<"cabsl", ? /* Checked manually. */>;
|
|
|
|
/// void *calloc(size_t count, size_t size);
|
|
def calloc : TargetLibCall<"calloc", Ptr, [SizeT, SizeT]>;
|
|
|
|
/// double cbrt(double x);
|
|
def cbrt : TargetLibCall<"cbrt", Dbl, [Dbl]>;
|
|
|
|
/// float cbrtf(float x);
|
|
def cbrtf : TargetLibCall<"cbrtf", Flt, [Flt]>;
|
|
|
|
/// long double cbrtl(long double x);
|
|
def cbrtl : TargetLibCall<"cbrtl", LDbl, [LDbl]>;
|
|
|
|
/// double ceil(double x);
|
|
def ceil : TargetLibCall<"ceil", Dbl, [Dbl]>;
|
|
|
|
/// float ceilf(float x);
|
|
def ceilf : TargetLibCall<"ceilf", Flt, [Flt]>;
|
|
|
|
/// long double ceill(long double x);
|
|
def ceill : TargetLibCall<"ceill", LDbl, [LDbl]>;
|
|
|
|
/// int chmod(const char *path, mode_t mode);
|
|
def chmod : TargetLibCall<"chmod", Int, [Ptr, IntX]>;
|
|
|
|
/// int chown(const char *path, uid_t owner, gid_t group);
|
|
def chown : TargetLibCall<"chown", Int, [Ptr, IntX, IntX]>;
|
|
|
|
/// void clearerr(FILE *stream);
|
|
def clearerr : TargetLibCall<"clearerr", Void, [Ptr]>;
|
|
|
|
/// int closedir(DIR *dirp);
|
|
def closedir : TargetLibCall<"closedir", Int, [Ptr]>;
|
|
|
|
/// double copysign(double x, double y);
|
|
def copysign : TargetLibCall<"copysign", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float copysignf(float x, float y);
|
|
def copysignf : TargetLibCall<"copysignf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double copysignl(long double x, long double y);
|
|
def copysignl : TargetLibCall<"copysignl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// double cos(double x);
|
|
def cos : TargetLibCall<"cos", Dbl, [Dbl]>;
|
|
|
|
/// float cosf(float x);
|
|
def cosf : TargetLibCall<"cosf", Flt, [Flt]>;
|
|
|
|
/// double cosh(double x);
|
|
def cosh : TargetLibCall<"cosh", Dbl, [Dbl]>;
|
|
|
|
/// float coshf(float x);
|
|
def coshf : TargetLibCall<"coshf", Flt, [Flt]>;
|
|
|
|
/// long double coshl(long double x);
|
|
def coshl : TargetLibCall<"coshl", LDbl, [LDbl]>;
|
|
|
|
/// long double cosl(long double x);
|
|
def cosl : TargetLibCall<"cosl", LDbl, [LDbl]>;
|
|
|
|
/// char *ctermid(char *s);
|
|
def ctermid : TargetLibCall<"ctermid", Ptr, [Ptr]>;
|
|
|
|
/// double erf(double x);
|
|
def erf : TargetLibCall<"erf", Dbl, [Dbl]>;
|
|
|
|
/// float erff(float x);
|
|
def erff : TargetLibCall<"erff", Flt, [Flt]>;
|
|
|
|
/// long double erfl(long double x);
|
|
def erfl : TargetLibCall<"erfl", LDbl, [LDbl]>;
|
|
|
|
/// double tgamma(double x);
|
|
def tgamma : TargetLibCall<"tgamma", Dbl, [Dbl]>;
|
|
|
|
/// float tgammaf(float x);
|
|
def tgammaf : TargetLibCall<"tgammaf", Flt, [Flt]>;
|
|
|
|
/// long double tgammal(long double x);
|
|
def tgammal : TargetLibCall<"tgammal", LDbl, [LDbl]>;
|
|
|
|
/// int execl(const char *path, const char *arg, ...);
|
|
def execl : TargetLibCall<"execl", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int execle(const char *file, const char *arg, ..., char * const envp[]);
|
|
def execle : TargetLibCall<"execle", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int execlp(const char *file, const char *arg, ...);
|
|
def execlp : TargetLibCall<"execlp", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int execv(const char *path, char *const argv[]);
|
|
def execv : TargetLibCall<"execv", Int, [Ptr, Ptr]>;
|
|
|
|
/// int execvP(const char *file, const char *search_path, char *const argv[]);
|
|
def execvP : TargetLibCall<"execvP", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int execve(const char *filename, char *const argv], [char *const envp[]);
|
|
def execve : TargetLibCall<"execve", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int execvp(const char *file, char *const argv[]);
|
|
def execvp : TargetLibCall<"execvp", Int, [Ptr, Ptr]>;
|
|
|
|
/// int execvpe(const char *file, char *const argv], [char *const envp[]);
|
|
def execvpe : TargetLibCall<"execvpe", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// double exp(double x);
|
|
def exp : TargetLibCall<"exp", Dbl, [Dbl]>;
|
|
|
|
/// double exp10(double x);
|
|
def exp10 : TargetLibCall<"exp10", Dbl, [Dbl]>;
|
|
|
|
/// float exp10f(float x);
|
|
def exp10f : TargetLibCall<"exp10f", Flt, [Flt]>;
|
|
|
|
/// long double exp10l(long double x);
|
|
def exp10l : TargetLibCall<"exp10l", LDbl, [LDbl]>;
|
|
|
|
/// double exp2(double x);
|
|
def exp2 : TargetLibCall<"exp2", Dbl, [Dbl]>;
|
|
|
|
/// float exp2f(float x);
|
|
def exp2f : TargetLibCall<"exp2f", Flt, [Flt]>;
|
|
|
|
/// long double exp2l(long double x);
|
|
def exp2l : TargetLibCall<"exp2l", LDbl, [LDbl]>;
|
|
|
|
/// float expf(float x);
|
|
def expf : TargetLibCall<"expf", Flt, [Flt]>;
|
|
|
|
/// long double expl(long double x);
|
|
def expl : TargetLibCall<"expl", LDbl, [LDbl]>;
|
|
|
|
/// double expm1(double x);
|
|
def expm1 : TargetLibCall<"expm1", Dbl, [Dbl]>;
|
|
|
|
/// float expm1f(float x);
|
|
def expm1f : TargetLibCall<"expm1f", Flt, [Flt]>;
|
|
|
|
/// long double expm1l(long double x);
|
|
def expm1l : TargetLibCall<"expm1l", LDbl, [LDbl]>;
|
|
|
|
/// double fabs(double x);
|
|
def fabs : TargetLibCall<"fabs", Dbl, [Dbl]>;
|
|
|
|
/// float fabsf(float x);
|
|
def fabsf : TargetLibCall<"fabsf", Flt, [Flt]>;
|
|
|
|
/// long double fabsl(long double x);
|
|
def fabsl : TargetLibCall<"fabsl", LDbl, [LDbl]>;
|
|
|
|
/// int fclose(FILE *stream);
|
|
def fclose : TargetLibCall<"fclose", Int, [Ptr]>;
|
|
|
|
/// FILE *fdopen(int fildes, const char *mode);
|
|
def fdopen : TargetLibCall<"fdopen", Ptr, [Int, Ptr]>;
|
|
|
|
/// int feof(FILE *stream);
|
|
def feof : TargetLibCall<"feof", Int, [Ptr]>;
|
|
|
|
/// int ferror(FILE *stream);
|
|
def ferror : TargetLibCall<"ferror", Int, [Ptr]>;
|
|
|
|
/// int fflush(FILE *stream);
|
|
def fflush : TargetLibCall<"fflush", Int, [Ptr]>;
|
|
|
|
/// int ffs(int i);
|
|
def ffs : TargetLibCall<"ffs", Int, [Int]>;
|
|
|
|
/// int ffsl(long int i);
|
|
def ffsl : TargetLibCall<"ffsl", Int, [Long]>;
|
|
|
|
/// int ffsll(long long int i);
|
|
def ffsll : TargetLibCall<"ffsll", Int, [LLong]>;
|
|
|
|
/// int fgetc(FILE *stream);
|
|
def fgetc : TargetLibCall<"fgetc", Int, [Ptr]>;
|
|
|
|
/// int fgetc_unlocked(FILE *stream);
|
|
def fgetc_unlocked : TargetLibCall<"fgetc_unlocked", Int, [Ptr]>;
|
|
|
|
/// int fgetpos(FILE *stream, fpos_t *pos);
|
|
def fgetpos : TargetLibCall<"fgetpos", Int, [Ptr, Ptr]>;
|
|
|
|
/// char *fgets(char *s, int n, FILE *stream);
|
|
def fgets : TargetLibCall<"fgets", Ptr, [Ptr, Int, Ptr]>;
|
|
|
|
/// char *fgets_unlocked(char *s, int n, FILE *stream);
|
|
def fgets_unlocked : TargetLibCall<"fgets_unlocked", Ptr, [Ptr, Int, Ptr]>;
|
|
|
|
/// int fileno(FILE *stream);
|
|
def fileno : TargetLibCall<"fileno", Int, [Ptr]>;
|
|
|
|
/// int fiprintf(FILE *stream, const char *format, ...);
|
|
def fiprintf : TargetLibCall<"fiprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// void flockfile(FILE *file);
|
|
def flockfile : TargetLibCall<"flockfile", Void, [Ptr]>;
|
|
|
|
/// double floor(double x);
|
|
def floor : TargetLibCall<"floor", Dbl, [Dbl]>;
|
|
|
|
/// float floorf(float x);
|
|
def floorf : TargetLibCall<"floorf", Flt, [Flt]>;
|
|
|
|
/// long double floorl(long double x);
|
|
def floorl : TargetLibCall<"floorl", LDbl, [LDbl]>;
|
|
|
|
/// int fls(int i);
|
|
def fls : TargetLibCall<"fls", Int, [Int]>;
|
|
|
|
/// int flsl(long int i);
|
|
def flsl : TargetLibCall<"flsl", Int, [Long]>;
|
|
|
|
/// int flsll(long long int i);
|
|
def flsll : TargetLibCall<"flsll", Int, [LLong]>;
|
|
|
|
// Calls to fmax and fmin library functions expand to the llvm.maxnnum and
|
|
// llvm.minnum intrinsics with the correct parameter types for the arguments
|
|
// (all types must match).
|
|
/// double fmax(double x, double y);
|
|
def fmax : TargetLibCall<"fmax", Floating, [Same, Same]>;
|
|
|
|
/// float fmaxf(float x, float y);
|
|
def fmaxf : TargetLibCall<"fmaxf", Floating, [Same, Same]>;
|
|
|
|
/// long double fmaxl(long double x, long double y);
|
|
def fmaxl : TargetLibCall<"fmaxl", Floating, [Same, Same]>;
|
|
|
|
/// double fmin(double x, double y);
|
|
def fmin : TargetLibCall<"fmin", Floating, [Same, Same]>;
|
|
|
|
/// float fminf(float x, float y);
|
|
def fminf : TargetLibCall<"fminf", Floating, [Same, Same]>;
|
|
|
|
/// long double fminl(long double x, long double y);
|
|
def fminl : TargetLibCall<"fminl", Floating, [Same, Same]>;
|
|
|
|
// Calls to fmaximum_num and fminimum_num library functions expand to the
|
|
// llvm.maximumnum and llvm.minimumnum intrinsics with the correct parameter
|
|
// types for the arguments (all types must match).
|
|
/// double fmaximum_num(double x, double y);
|
|
def fmaximum_num : TargetLibCall<"fmaximum_num", Floating, [Same, Same]>;
|
|
|
|
/// float fmaximum_numf(float x, float y);
|
|
def fmaximum_numf : TargetLibCall<"fmaximum_numf", Floating, [Same, Same]>;
|
|
|
|
/// long double fmaximum_numl(long double x, long double y);
|
|
def fmaximum_numl : TargetLibCall<"fmaximum_numl", Floating, [Same, Same]>;
|
|
|
|
/// double fminimum_num(double x, double y);
|
|
def fminimum_num : TargetLibCall<"fminimum_num", Floating, [Same, Same]>;
|
|
|
|
/// float fminimum_numf(float x, float y);
|
|
def fminimum_numf : TargetLibCall<"fminimum_numf", Floating, [Same, Same]>;
|
|
|
|
/// long double fminimum_numl(long double x, long double y);
|
|
def fminimum_numl : TargetLibCall<"fminimum_numl", Floating, [Same, Same]>;
|
|
|
|
/// double fmod(double x, double y);
|
|
def fmod : TargetLibCall<"fmod", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float fmodf(float x, float y);
|
|
def fmodf : TargetLibCall<"fmodf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double fmodl(long double x, long double y);
|
|
def fmodl : TargetLibCall<"fmodl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// FILE *fopen(const char *filename, const char *mode);
|
|
def fopen : TargetLibCall<"fopen", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// FILE *fopen64(const char *filename, const char *opentype)
|
|
def fopen64 : TargetLibCall<"fopen64", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// int fork();
|
|
def fork : TargetLibCall<"fork", Int, []>;
|
|
|
|
/// int fprintf(FILE *stream, const char *format, ...);
|
|
def fprintf : TargetLibCall<"fprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int fputc(int c, FILE *stream);
|
|
def fputc : TargetLibCall<"fputc", Int, [Int, Ptr]>;
|
|
|
|
/// int fputc_unlocked(int c, FILE *stream);
|
|
def fputc_unlocked : TargetLibCall<"fputc_unlocked", Int, [Int, Ptr]>;
|
|
|
|
/// int fputs(const char *s, FILE *stream);
|
|
def fputs : TargetLibCall<"fputs", Int, [Ptr, Ptr]>;
|
|
|
|
/// int fputs_unlocked(const char *s, FILE *stream);
|
|
def fputs_unlocked : TargetLibCall<"fputs_unlocked", Int, [Ptr, Ptr]>;
|
|
|
|
/// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
|
|
def fread : TargetLibCall<"fread", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
|
|
|
|
/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
|
|
def fread_unlocked
|
|
: TargetLibCall<"fread_unlocked", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
|
|
|
|
/// void free(void *ptr);
|
|
def free : TargetLibCall<"free", Void, [Ptr]>;
|
|
|
|
/// double frexp(double num, int *exp);
|
|
def frexp : TargetLibCall<"frexp", Dbl, [Dbl, Ptr]>;
|
|
|
|
/// float frexpf(float num, int *exp);
|
|
def frexpf : TargetLibCall<"frexpf", Flt, [Flt, Ptr]>;
|
|
|
|
/// long double frexpl(long double num, int *exp);
|
|
def frexpl : TargetLibCall<"frexpl", LDbl, [LDbl, Ptr]>;
|
|
|
|
/// int fscanf(FILE *stream, const char *format, ... );
|
|
def fscanf : TargetLibCall<"fscanf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int fseek(FILE *stream, long offset, int whence);
|
|
def fseek : TargetLibCall<"fseek", Int, [Ptr, Long, Int]>;
|
|
|
|
/// int fseeko(FILE *stream, off_t offset, int whence);
|
|
def fseeko : TargetLibCall<"fseeko", Int, [Ptr, IntX, Int]>;
|
|
|
|
/// int fseeko64(FILE *stream, off64_t offset, int whence)
|
|
def fseeko64 : TargetLibCall<"fseeko64", Int, [Ptr, Int64, Int]>;
|
|
|
|
/// int fsetpos(FILE *stream, const fpos_t *pos);
|
|
def fsetpos : TargetLibCall<"fsetpos", Int, [Ptr, Ptr]>;
|
|
|
|
/// int fstat(int fildes, struct stat *buf);
|
|
def fstat : TargetLibCall<"fstat", Int, [Int, Ptr]>;
|
|
|
|
/// int fstat64(int filedes, struct stat64 *buf)
|
|
def fstat64 : TargetLibCall<"fstat64", Int, [Int, Ptr]>;
|
|
|
|
/// int fstatvfs(int fildes, struct statvfs *buf);
|
|
def fstatvfs : TargetLibCall<"fstatvfs", Int, [Int, Ptr]>;
|
|
|
|
/// int fstatvfs64(int fildes, struct statvfs64 *buf);
|
|
def fstatvfs64 : TargetLibCall<"fstatvfs64", Int, [Int, Ptr]>;
|
|
|
|
/// long ftell(FILE *stream);
|
|
def ftell : TargetLibCall<"ftell", Long, [Ptr]>;
|
|
|
|
/// off_t ftello(FILE *stream);
|
|
def ftello : TargetLibCall<"ftello", IntPlus, [Ptr]>;
|
|
|
|
/// off64_t ftello64(FILE *stream)
|
|
def ftello64 : TargetLibCall<"ftello64", Int64, [Ptr]>;
|
|
|
|
/// int ftrylockfile(FILE *file);
|
|
def ftrylockfile : TargetLibCall<"ftrylockfile", Int, [Ptr]>;
|
|
|
|
/// void funlockfile(FILE *file);
|
|
def funlockfile : TargetLibCall<"funlockfile", Void, [Ptr]>;
|
|
|
|
/// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
|
|
def fwrite : TargetLibCall<"fwrite", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
|
|
|
|
/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems,
|
|
/// FILE *stream);
|
|
def fwrite_unlocked
|
|
: TargetLibCall<"fwrite_unlocked", SizeT, [Ptr, SizeT, SizeT, Ptr]>;
|
|
|
|
/// int getc(FILE *stream);
|
|
def getc : TargetLibCall<"getc", Int, [Ptr]>;
|
|
|
|
/// int getc_unlocked(FILE *stream);
|
|
def getc_unlocked : TargetLibCall<"getc_unlocked", Int, [Ptr]>;
|
|
|
|
/// int getchar(void);
|
|
def getchar : TargetLibCall<"getchar", Int, []>;
|
|
|
|
/// int getchar_unlocked(void);
|
|
def getchar_unlocked : TargetLibCall<"getchar_unlocked", Int, []>;
|
|
|
|
/// char *getenv(const char *name);
|
|
def getenv : TargetLibCall<"getenv", Ptr, [Ptr]>;
|
|
|
|
/// int getitimer(int which, struct itimerval *value);
|
|
def getitimer : TargetLibCall<"getitimer", Int, [Int, Ptr]>;
|
|
|
|
/// int getlogin_r(char *name, size_t namesize);
|
|
def getlogin_r : TargetLibCall<"getlogin_r", Int, [Ptr, SizeT]>;
|
|
|
|
/// struct passwd *getpwnam(const char *name);
|
|
def getpwnam : TargetLibCall<"getpwnam", Ptr, [Ptr]>;
|
|
|
|
/// char *gets(char *s);
|
|
def gets : TargetLibCall<"gets", Ptr, [Ptr]>;
|
|
|
|
/// int gettimeofday(struct timeval *tp, void *tzp);
|
|
def gettimeofday : TargetLibCall<"gettimeofday", Int, [Ptr, Ptr]>;
|
|
|
|
/// uint32_t htonl(uint32_t hostlong);
|
|
def htonl : TargetLibCall<"htonl", Int32, [Int32]>;
|
|
|
|
/// uint16_t htons(uint16_t hostshort);
|
|
def htons : TargetLibCall<"htons", Int16, [Int16]>;
|
|
|
|
/// double hypot(double x, double y);
|
|
def hypot : TargetLibCall<"hypot", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float hypotf(float x, float y);
|
|
def hypotf : TargetLibCall<"hypotf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double hypotl(long double x, long double y);
|
|
def hypotl : TargetLibCall<"hypotl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// int iprintf(const char *format, ...);
|
|
def iprintf : TargetLibCall<"iprintf", Int, [Ptr, Ellip]>;
|
|
|
|
/// int isascii(int c);
|
|
def isascii : TargetLibCall<"isascii", Int, [Int]>;
|
|
|
|
/// int isdigit(int c);
|
|
def isdigit : TargetLibCall<"isdigit", Int, [Int]>;
|
|
|
|
/// long int labs(long int j);
|
|
def labs : TargetLibCall<"labs", Long, [Same]>;
|
|
|
|
/// int lchown(const char *path, uid_t owner, gid_t group);
|
|
def lchown : TargetLibCall<"lchown", Int, [Ptr, IntX, IntX]>;
|
|
|
|
/// double ldexp(double x, int n);
|
|
def ldexp : TargetLibCall<"ldexp", Dbl, [Dbl, Int]>;
|
|
|
|
/// float ldexpf(float x, int n);
|
|
def ldexpf : TargetLibCall<"ldexpf", Flt, [Flt, Int]>;
|
|
|
|
/// long double ldexpl(long double x, int n);
|
|
def ldexpl : TargetLibCall<"ldexpl", LDbl, [LDbl, Int]>;
|
|
|
|
/// long long int llabs(long long int j);
|
|
def llabs : TargetLibCall<"llabs", LLong, [LLong]>;
|
|
|
|
/// double log(double x);
|
|
def log : TargetLibCall<"log", Dbl, [Dbl]>;
|
|
|
|
/// double log10(double x);
|
|
def log10 : TargetLibCall<"log10", Dbl, [Dbl]>;
|
|
|
|
/// float log10f(float x);
|
|
def log10f : TargetLibCall<"log10f", Flt, [Flt]>;
|
|
|
|
/// long double log10l(long double x);
|
|
def log10l : TargetLibCall<"log10l", LDbl, [LDbl]>;
|
|
|
|
/// double log1p(double x);
|
|
def log1p : TargetLibCall<"log1p", Dbl, [Dbl]>;
|
|
|
|
/// float log1pf(float x);
|
|
def log1pf : TargetLibCall<"log1pf", Flt, [Flt]>;
|
|
|
|
/// long double log1pl(long double x);
|
|
def log1pl : TargetLibCall<"log1pl", LDbl, [LDbl]>;
|
|
|
|
/// double log2(double x);
|
|
def log2 : TargetLibCall<"log2", Dbl, [Dbl]>;
|
|
|
|
/// float log2f(float x);
|
|
def log2f : TargetLibCall<"log2f", Flt, [Flt]>;
|
|
|
|
/// double long double log2l(long double x);
|
|
def log2l : TargetLibCall<"log2l", LDbl, [LDbl]>;
|
|
|
|
/// int ilogb(double x);
|
|
def ilogb : TargetLibCall<"ilogb", Int, [Dbl]>;
|
|
|
|
/// int ilogbf(float x);
|
|
def ilogbf : TargetLibCall<"ilogbf", Int, [Flt]>;
|
|
|
|
/// int ilogbl(long double x);
|
|
def ilogbl : TargetLibCall<"ilogbl", Int, [LDbl]>;
|
|
|
|
/// double logb(double x);
|
|
def logb : TargetLibCall<"logb", Dbl, [Dbl]>;
|
|
|
|
/// float logbf(float x);
|
|
def logbf : TargetLibCall<"logbf", Flt, [Flt]>;
|
|
|
|
/// long double logbl(long double x);
|
|
def logbl : TargetLibCall<"logbl", LDbl, [LDbl]>;
|
|
|
|
/// float logf(float x);
|
|
def logf : TargetLibCall<"logf", Flt, [Flt]>;
|
|
|
|
/// long double logl(long double x);
|
|
def logl : TargetLibCall<"logl", LDbl, [LDbl]>;
|
|
|
|
/// int lstat(const char *path, struct stat *buf);
|
|
def lstat : TargetLibCall<"lstat", Int, [Ptr, Ptr]>;
|
|
|
|
/// int lstat64(const char *path, struct stat64 *buf);
|
|
def lstat64 : TargetLibCall<"lstat64", Int, [Ptr, Ptr]>;
|
|
|
|
/// void *malloc(size_t size);
|
|
def malloc : TargetLibCall<"malloc", Ptr, [SizeT]>;
|
|
|
|
/// void *memalign(size_t boundary, size_t size);
|
|
def memalign : TargetLibCall<"memalign", Ptr, [SizeT, SizeT]>;
|
|
|
|
/// void *memccpy(void *s1, const void *s2, int c, size_t n);
|
|
def memccpy : TargetLibCall<"memccpy", Ptr, [Ptr, Ptr, Int, SizeT]>;
|
|
|
|
/// void *memchr(const void *s, int c, size_t n);
|
|
def memchr : TargetLibCall<"memchr", Ptr, [Ptr, Int, SizeT]>;
|
|
|
|
/// int memcmp(const void *s1, const void *s2, size_t n);
|
|
def memcmp : TargetLibCall<"memcmp", Int, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void *memcpy(void *s1, const void *s2, size_t n);
|
|
def memcpy : TargetLibCall<"memcpy", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void *memmove(void *s1, const void *s2, size_t n);
|
|
def memmove : TargetLibCall<"memmove", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void *mempcpy(void *s1, const void *s2, size_t n);
|
|
def mempcpy : TargetLibCall<"mempcpy", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void *memrchr(const void *s, int c, size_t n);
|
|
def memrchr : TargetLibCall<"memrchr", Ptr, [Ptr, Int, SizeT]>;
|
|
|
|
/// void *memset(void *b, int c, size_t len);
|
|
def memset : TargetLibCall<"memset", Ptr, [Ptr, Int, SizeT]>;
|
|
|
|
/// void memset_pattern16(void *b, const void *pattern16, size_t len);
|
|
def memset_pattern16
|
|
: TargetLibCall<"memset_pattern16", Void, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void memset_pattern4(void *b, const void *pattern4, size_t len);
|
|
def memset_pattern4 : TargetLibCall<"memset_pattern4", Void, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void memset_pattern8(void *b, const void *pattern8, size_t len);
|
|
def memset_pattern8 : TargetLibCall<"memset_pattern8", Void, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// int mkdir(const char *path, mode_t mode);
|
|
def mkdir : TargetLibCall<"mkdir", Int, [Ptr, IntX]>;
|
|
|
|
/// time_t mktime(struct tm *timeptr);
|
|
def mktime : TargetLibCall<"mktime", IntPlus, [Ptr]>;
|
|
|
|
/// double modf(double x, double *iptr);
|
|
def modf : TargetLibCall<"modf", Dbl, [Dbl, Ptr]>;
|
|
|
|
/// float modff(float, float *iptr);
|
|
def modff : TargetLibCall<"modff", Flt, [Flt, Ptr]>;
|
|
|
|
/// long double modfl(long double value, long double *iptr);
|
|
def modfl : TargetLibCall<"modfl", LDbl, [LDbl, Ptr]>;
|
|
|
|
/// double nan(const char *arg);
|
|
def nan : TargetLibCall<"nan", Dbl, [Ptr]>;
|
|
|
|
/// float nanf(const char *arg);
|
|
def nanf : TargetLibCall<"nanf", Flt, [Ptr]>;
|
|
|
|
/// long double nanl(const char *arg);
|
|
def nanl : TargetLibCall<"nanl", LDbl, [Ptr]>;
|
|
|
|
/// double nearbyint(double x);
|
|
def nearbyint : TargetLibCall<"nearbyint", Dbl, [Dbl]>;
|
|
|
|
/// float nearbyintf(float x);
|
|
def nearbyintf : TargetLibCall<"nearbyintf", Flt, [Flt]>;
|
|
|
|
/// long double nearbyintl(long double x);
|
|
def nearbyintl : TargetLibCall<"nearbyintl", LDbl, [LDbl]>;
|
|
|
|
/// double nextafter(double x, double y);
|
|
def nextafter : TargetLibCall< "nextafter", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float nextafterf(float x, float y);
|
|
def nextafterf : TargetLibCall< "nextafterf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double nextafterl(long double x, long double y);
|
|
def nextafterl : TargetLibCall< "nextafterl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// double nexttoward(double x, long double y);
|
|
def nexttoward : TargetLibCall< "nexttoward", Dbl, [Dbl, LDbl]>;
|
|
|
|
/// float nexttowardf(float x, long double y);
|
|
def nexttowardf : TargetLibCall< "nexttowardf", Flt, [Flt, LDbl]>;
|
|
|
|
/// long double nexttowardl(long double x, long double y);
|
|
def nexttowardl : TargetLibCall< "nexttowardl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// uint32_t ntohl(uint32_t netlong);
|
|
def ntohl : TargetLibCall<"ntohl", Int32, [Int32]>;
|
|
|
|
/// uint16_t ntohs(uint16_t netshort);
|
|
def ntohs : TargetLibCall<"ntohs", Int16, [Int16]>;
|
|
|
|
/// int open(const char *path, int oflag, ... );
|
|
def open : TargetLibCall<"open", Int, [Ptr, Int, Ellip]>;
|
|
|
|
/// int open64(const char *filename, int flags, [mode_t mode])
|
|
def open64 : TargetLibCall<"open64", Int, [Ptr, Int, Ellip]>;
|
|
|
|
/// DIR *opendir(const char *dirname);
|
|
def opendir : TargetLibCall<"opendir", Ptr, [Ptr]>;
|
|
|
|
/// int pclose(FILE *stream);
|
|
def pclose : TargetLibCall<"pclose", Int, [Ptr]>;
|
|
|
|
/// void perror(const char *s);
|
|
def perror : TargetLibCall<"perror", Void, [Ptr]>;
|
|
|
|
/// FILE *popen(const char *command, const char *mode);
|
|
def popen : TargetLibCall<"popen", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// int posix_memalign(void **memptr, size_t alignment, size_t size);
|
|
def posix_memalign : TargetLibCall<"posix_memalign", Int, [Ptr, SizeT, SizeT]>;
|
|
|
|
/// double pow(double x, double y);
|
|
def pow : TargetLibCall<"pow", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float powf(float x, float y);
|
|
def powf : TargetLibCall<"powf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double powl(long double x, long double y);
|
|
def powl : TargetLibCall<"powl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
|
|
def pread : TargetLibCall<"pread", SSizeT, [Int, Ptr, SizeT, IntPlus]>;
|
|
|
|
/// int printf(const char *format, ...);
|
|
def printf : TargetLibCall<"printf", Int, [Ptr, Ellip]>;
|
|
|
|
/// int putc(int c, FILE *stream);
|
|
def putc : TargetLibCall<"putc", Int, [Int, Ptr]>;
|
|
|
|
/// int putc_unlocked(int c, FILE *stream);
|
|
def putc_unlocked : TargetLibCall<"putc_unlocked", Int, [Int, Ptr]>;
|
|
|
|
/// int putchar(int c);
|
|
def putchar : TargetLibCall<"putchar", Int, [Int]>;
|
|
|
|
/// int putchar_unlocked(int c);
|
|
def putchar_unlocked : TargetLibCall<"putchar_unlocked", Int, [Int]>;
|
|
|
|
/// int puts(const char *s);
|
|
def puts : TargetLibCall<"puts", Int, [Ptr]>;
|
|
|
|
/// void *pvalloc(size_t size);
|
|
def pvalloc : TargetLibCall<"pvalloc", Ptr, [SizeT]>;
|
|
|
|
/// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
|
|
def pwrite : TargetLibCall<"pwrite", SSizeT, [Int, Ptr, SizeT, IntPlus]>;
|
|
|
|
/// void qsort(void *base, size_t nel, size_t width,
|
|
/// int (*compar)(const void *, const void *));
|
|
def qsort : TargetLibCall<"qsort", Void, [Ptr, SizeT, SizeT, Ptr]>;
|
|
|
|
/// ssize_t read(int fildes, void *buf, size_t nbyte);
|
|
def read : TargetLibCall<"read", SSizeT, [Int, Ptr, SizeT]>;
|
|
|
|
/// ssize_t readlink(const char *path, char *buf, size_t bufsize);
|
|
def readlink : TargetLibCall<"readlink", SSizeT, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// void *realloc(void *ptr, size_t size);
|
|
def realloc : TargetLibCall<"realloc", Ptr, [Ptr, SizeT]>;
|
|
|
|
/// void *reallocf(void *ptr, size_t size);
|
|
def reallocf : TargetLibCall<"reallocf", Ptr, [Ptr, SizeT]>;
|
|
|
|
/// void *reallocarray(void *ptr, size_t nmemb, size_t size);
|
|
def reallocarray : TargetLibCall<"reallocarray", Ptr, [Ptr, SizeT, SizeT]>;
|
|
|
|
/// char *realpath(const char *file_name, char *resolved_name);
|
|
def realpath : TargetLibCall<"realpath", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// double remainder(double x, double y);
|
|
def remainder : TargetLibCall<"remainder", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float remainderf(float x, float y);
|
|
def remainderf : TargetLibCall<"remainderf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double remainderl(long double x, long double y);
|
|
def remainderl : TargetLibCall<"remainderl", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// double remquo(double x, double y, int *quo);
|
|
def remquo : TargetLibCall<"remquo", Dbl, [Dbl, Dbl, Ptr]>;
|
|
|
|
/// float remquof(float x, float y, int *quo);
|
|
def remquof : TargetLibCall<"remquof", Flt, [Flt, Flt, Ptr]>;
|
|
|
|
/// long double remquol(long double x, long double y, int *quo);
|
|
def remquol : TargetLibCall<"remquol", LDbl, [LDbl, LDbl, Ptr]>;
|
|
|
|
/// double fdim(double x, double y);
|
|
def fdim : TargetLibCall<"fdim", Dbl, [Dbl, Dbl]>;
|
|
|
|
/// float fdimf(float x, float y);
|
|
def fdimf : TargetLibCall<"fdimf", Flt, [Flt, Flt]>;
|
|
|
|
/// long double fdiml(long double x, long double y);
|
|
def fdiml : TargetLibCall<"fdiml", LDbl, [LDbl, LDbl]>;
|
|
|
|
/// int remove(const char *path);
|
|
def remove : TargetLibCall<"remove", Int, [Ptr]>;
|
|
|
|
/// int rename(const char *old, const char *new);
|
|
def rename : TargetLibCall<"rename", Int, [Ptr, Ptr]>;
|
|
|
|
/// void rewind(FILE *stream);
|
|
def rewind : TargetLibCall<"rewind", Void, [Ptr]>;
|
|
|
|
/// double rint(double x);
|
|
def rint : TargetLibCall<"rint", Dbl, [Dbl]>;
|
|
|
|
/// float rintf(float x);
|
|
def rintf : TargetLibCall<"rintf", Flt, [Flt]>;
|
|
|
|
/// long double rintl(long double x);
|
|
def rintl : TargetLibCall<"rintl", LDbl, [LDbl]>;
|
|
|
|
/// int rmdir(const char *path);
|
|
def rmdir : TargetLibCall<"rmdir", Int, [Ptr]>;
|
|
|
|
/// double round(double x);
|
|
def round : TargetLibCall<"round", Dbl, [Dbl]>;
|
|
|
|
/// double roundeven(double x);
|
|
def roundeven : TargetLibCall<"roundeven", Dbl, [Dbl]>;
|
|
|
|
/// float roundevenf(float x);
|
|
def roundevenf : TargetLibCall<"roundevenf", Flt, [Flt]>;
|
|
|
|
/// long double roundevenl(long double x);
|
|
def roundevenl : TargetLibCall<"roundevenl", LDbl, [LDbl]>;
|
|
|
|
/// float roundf(float x);
|
|
def roundf : TargetLibCall<"roundf", Flt, [Flt]>;
|
|
|
|
/// long double roundl(long double x);
|
|
def roundl : TargetLibCall<"roundl", LDbl, [LDbl]>;
|
|
|
|
/// double scalbln(double arg, long exp);
|
|
def scalbln : TargetLibCall<"scalbln", Dbl, [Dbl, Long]>;
|
|
|
|
/// float scalblnf(float arg, long exp);
|
|
def scalblnf : TargetLibCall<"scalblnf", Flt, [Flt, Long]>;
|
|
|
|
/// long double scalblnl(long double arg, long exp);
|
|
def scalblnl : TargetLibCall<"scalblnl", LDbl, [LDbl, Long]>;
|
|
|
|
/// double scalbn(double arg, int exp);
|
|
def scalbn : TargetLibCall<"scalbn", Dbl, [Dbl, Int]>;
|
|
|
|
/// float scalbnf(float arg, int exp);
|
|
def scalbnf : TargetLibCall<"scalbnf", Flt, [Flt, Int]>;
|
|
|
|
/// long double scalbnl(long double arg, int exp);
|
|
def scalbnl : TargetLibCall<"scalbnl", LDbl, [LDbl, Int]>;
|
|
|
|
/// int scanf(const char *restrict format, ... );
|
|
def scanf : TargetLibCall<"scanf", Int, [Ptr, Ellip]>;
|
|
|
|
/// void setbuf(FILE *stream, char *buf);
|
|
def setbuf : TargetLibCall<"setbuf", Void, [Ptr, Ptr]>;
|
|
|
|
/// int setitimer(int which, const struct itimerval *value,
|
|
/// struct itimerval *ovalue);
|
|
def setitimer : TargetLibCall<"setitimer", Int, [Int, Ptr, Ptr]>;
|
|
|
|
/// int setvbuf(FILE *stream, char *buf, int type, size_t size);
|
|
def setvbuf : TargetLibCall<"setvbuf", Int, [Ptr, Ptr, Int, SizeT]>;
|
|
|
|
/// double sin(double x);
|
|
def sin : TargetLibCall<"sin", Dbl, [Dbl]>;
|
|
|
|
/// float sinf(float x);
|
|
def sinf : TargetLibCall<"sinf", Flt, [Flt]>;
|
|
|
|
/// double sinh(double x);
|
|
def sinh : TargetLibCall<"sinh", Dbl, [Dbl]>;
|
|
|
|
/// float sinhf(float x);
|
|
def sinhf : TargetLibCall<"sinhf", Flt, [Flt]>;
|
|
|
|
/// long double sinhl(long double x);
|
|
def sinhl : TargetLibCall<"sinhl", LDbl, [LDbl]>;
|
|
|
|
/// long double sinl(long double x);
|
|
def sinl : TargetLibCall<"sinl", LDbl, [LDbl]>;
|
|
|
|
/// void sincos(double x, double *sin_out, double *cos_out);
|
|
def sincos : TargetLibCall<"sincos", Void, [Dbl, Ptr, Ptr]>;
|
|
|
|
/// void sincosf(float x, float *sin_out, float *cos_out);
|
|
def sincosf : TargetLibCall<"sincosf", Void, [Flt, Ptr, Ptr]>;
|
|
|
|
/// void sincosl(long double x, long double *sin_out, long double *cos_out);
|
|
def sincosl : TargetLibCall<"sincosl", Void, [LDbl, Ptr, Ptr]>;
|
|
|
|
/// int siprintf(char *str, const char *format, ...);
|
|
def siprintf : TargetLibCall<"siprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int snprintf(char *s, size_t n, const char *format, ...);
|
|
def snprintf : TargetLibCall<"snprintf", Int, [Ptr, SizeT, Ptr, Ellip]>;
|
|
|
|
/// int sprintf(char *str, const char *format, ...);
|
|
def sprintf : TargetLibCall<"sprintf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// double sqrt(double x);
|
|
def sqrt : TargetLibCall<"sqrt", Dbl, [Dbl]>;
|
|
|
|
/// float sqrtf(float x);
|
|
def sqrtf : TargetLibCall<"sqrtf", Flt, [Flt]>;
|
|
|
|
/// long double sqrtl(long double x);
|
|
def sqrtl : TargetLibCall<"sqrtl", LDbl, [LDbl]>;
|
|
|
|
/// int sscanf(const char *s, const char *format, ... );
|
|
def sscanf : TargetLibCall<"sscanf", Int, [Ptr, Ptr, Ellip]>;
|
|
|
|
/// int stat(const char *path, struct stat *buf);
|
|
def stat : TargetLibCall<"stat", Int, [Ptr, Ptr]>;
|
|
|
|
/// int stat64(const char *path, struct stat64 *buf);
|
|
def stat64 : TargetLibCall<"stat64", Int, [Ptr, Ptr]>;
|
|
|
|
/// int statvfs(const char *path, struct statvfs *buf);
|
|
def statvfs : TargetLibCall<"statvfs", Int, [Ptr, Ptr]>;
|
|
|
|
/// int statvfs64(const char *path, struct statvfs64 *buf)
|
|
def statvfs64 : TargetLibCall<"statvfs64", Int, [Ptr, Ptr]>;
|
|
|
|
/// char *stpcpy(char *s1, const char *s2);
|
|
def stpcpy : TargetLibCall<"stpcpy", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// char *stpncpy(char *s1, const char *s2, size_t n);
|
|
def stpncpy : TargetLibCall<"stpncpy", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// int strcasecmp(const char *s1, const char *s2);
|
|
def strcasecmp : TargetLibCall<"strcasecmp", Int, [Ptr, Ptr]>;
|
|
|
|
/// char *strcat(char *s1, const char *s2);
|
|
def strcat : TargetLibCall<"strcat", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// char *strchr(const char *s, int c);
|
|
def strchr : TargetLibCall<"strchr", Ptr, [Ptr, Int]>;
|
|
|
|
/// int strcmp(const char *s1, const char *s2);
|
|
def strcmp : TargetLibCall<"strcmp", Int, [Ptr, Ptr]>;
|
|
|
|
/// int strcoll(const char *s1, const char *s2);
|
|
def strcoll : TargetLibCall<"strcoll", Int, [Ptr, Ptr]>;
|
|
|
|
/// char *strcpy(char *s1, const char *s2);
|
|
def strcpy : TargetLibCall<"strcpy", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// size_t strcspn(const char *s1, const char *s2);
|
|
def strcspn : TargetLibCall<"strcspn", SizeT, [Ptr, Ptr]>;
|
|
|
|
/// char *strdup(const char *s1);
|
|
def strdup : TargetLibCall<"strdup", Ptr, [Ptr]>;
|
|
|
|
/// size_t strlcat(char *dst, const char *src, size_t size);
|
|
def strlcat : TargetLibCall<"strlcat", SizeT, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// size_t strlcpy(char *dst, const char *src, size_t size);
|
|
def strlcpy : TargetLibCall<"strlcpy", SizeT, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// size_t strlen(const char *s);
|
|
def strlen : TargetLibCall<"strlen", SizeT, [Ptr]>;
|
|
|
|
/// int strncasecmp(const char *s1, const char *s2, size_t n);
|
|
def strncasecmp : TargetLibCall<"strncasecmp", Int, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char *strncat(char *s1, const char *s2, size_t n);
|
|
def strncat : TargetLibCall<"strncat", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// int strncmp(const char *s1, const char *s2, size_t n);
|
|
def strncmp : TargetLibCall<"strncmp", Int, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char *strncpy(char *s1, const char *s2, size_t n);
|
|
def strncpy : TargetLibCall<"strncpy", Ptr, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// char *strndup(const char *s1, size_t n);
|
|
def strndup : TargetLibCall<"strndup", Ptr, [Ptr, SizeT]>;
|
|
|
|
/// size_t strnlen(const char *s, size_t maxlen);
|
|
def strnlen : TargetLibCall<"strnlen", SizeT, [Ptr, SizeT]>;
|
|
|
|
/// char *strpbrk(const char *s1, const char *s2);
|
|
def strpbrk : TargetLibCall<"strpbrk", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// char *strrchr(const char *s, int c);
|
|
def strrchr : TargetLibCall<"strrchr", Ptr, [Ptr, Int]>;
|
|
|
|
/// size_t strspn(const char *s1, const char *s2);
|
|
def strspn : TargetLibCall<"strspn", SizeT, [Ptr, Ptr]>;
|
|
|
|
/// char *strstr(const char *s1, const char *s2);
|
|
def strstr : TargetLibCall<"strstr", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// double strtod(const char *nptr, char **endptr);
|
|
def strtod : TargetLibCall<"strtod", Dbl, [Ptr, Ptr]>;
|
|
|
|
/// float strtof(const char *nptr, char **endptr);
|
|
def strtof : TargetLibCall<"strtof", Flt, [Ptr, Ptr]>;
|
|
|
|
/// char *strtok(char *s1, const char *s2);
|
|
def strtok : TargetLibCall<"strtok", Ptr, [Ptr, Ptr]>;
|
|
|
|
/// char *strtok_r(char *s, const char *sep, char **lasts);
|
|
def strtok_r : TargetLibCall<"strtok_r", Ptr, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// long int strtol(const char *nptr, char **endptr, int base);
|
|
def strtol : TargetLibCall<"strtol", Long, [Ptr, Ptr, Int]>;
|
|
|
|
/// long double strtold(const char *nptr, char **endptr);
|
|
def strtold : TargetLibCall<"strtold", LDbl, [Ptr, Ptr]>;
|
|
|
|
/// long long int strtoll(const char *nptr, char **endptr, int base);
|
|
def strtoll : TargetLibCall<"strtoll", LLong, [Ptr, Ptr, Int]>;
|
|
|
|
/// unsigned long int strtoul(const char *nptr, char **endptr, int base);
|
|
def strtoul : TargetLibCall<"strtoul", Long, [Ptr, Ptr, Int]>;
|
|
|
|
/// unsigned long long int strtoull(const char *nptr, char **endptr, int base);
|
|
def strtoull : TargetLibCall<"strtoull", LLong, [Ptr, Ptr, Int]>;
|
|
|
|
/// size_t strxfrm(char *s1, const char *s2, size_t n);
|
|
def strxfrm : TargetLibCall<"strxfrm", SizeT, [Ptr, Ptr, SizeT]>;
|
|
|
|
/// int system(const char *command);
|
|
def system : TargetLibCall<"system", Int, [Ptr]>;
|
|
|
|
/// double tan(double x);
|
|
def tan : TargetLibCall<"tan", Dbl, [Dbl]>;
|
|
|
|
/// float tanf(float x);
|
|
def tanf : TargetLibCall<"tanf", Flt, [Flt]>;
|
|
|
|
/// double tanh(double x);
|
|
def tanh : TargetLibCall<"tanh", Dbl, [Dbl]>;
|
|
|
|
/// float tanhf(float x);
|
|
def tanhf : TargetLibCall<"tanhf", Flt, [Flt]>;
|
|
|
|
/// long double tanhl(long double x);
|
|
def tanhl : TargetLibCall<"tanhl", LDbl, [LDbl]>;
|
|
|
|
/// long double tanl(long double x);
|
|
def tanl : TargetLibCall<"tanl", LDbl, [LDbl]>;
|
|
|
|
/// clock_t times(struct tms *buffer);
|
|
def times : TargetLibCall<"times", IntPlus, [Ptr]>;
|
|
|
|
/// FILE *tmpfile(void);
|
|
def tmpfile : TargetLibCall<"tmpfile", Ptr, []>;
|
|
|
|
/// FILE *tmpfile64(void)
|
|
def tmpfile64 : TargetLibCall<"tmpfile64", Ptr, []>;
|
|
|
|
/// int toascii(int c);
|
|
def toascii : TargetLibCall<"toascii", Int, [Int]>;
|
|
|
|
/// double trunc(double x);
|
|
def trunc : TargetLibCall<"trunc", Dbl, [Dbl]>;
|
|
|
|
/// float truncf(float x);
|
|
def truncf : TargetLibCall<"truncf", Flt, [Flt]>;
|
|
|
|
/// long double truncl(long double x);
|
|
def truncl : TargetLibCall<"truncl", LDbl, [LDbl]>;
|
|
|
|
/// int uname(struct utsname *name);
|
|
def uname : TargetLibCall<"uname", Int, [Ptr]>;
|
|
|
|
/// int ungetc(int c, FILE *stream);
|
|
def ungetc : TargetLibCall<"ungetc", Int, [Int, Ptr]>;
|
|
|
|
/// int unlink(const char *path);
|
|
def unlink : TargetLibCall<"unlink", Int, [Ptr]>;
|
|
|
|
/// int unsetenv(const char *name);
|
|
def unsetenv : TargetLibCall<"unsetenv", Int, [Ptr]>;
|
|
|
|
/// int utime(const char *path, const struct utimbuf *times);
|
|
def utime : TargetLibCall<"utime", Int, [Ptr, Ptr]>;
|
|
|
|
/// int utimes(const char *path, const struct timeval times[2]);
|
|
def utimes : TargetLibCall<"utimes", Int, [Ptr, Ptr]>;
|
|
|
|
/// void *valloc(size_t size);
|
|
def valloc : TargetLibCall<"valloc", Ptr, [SizeT]>;
|
|
|
|
/// void *vec_calloc(size_t count, size_t size);
|
|
def vec_calloc : TargetLibCall<"vec_calloc", Ptr, [SizeT, SizeT]>;
|
|
|
|
/// void vec_free(void *ptr);
|
|
def vec_free : TargetLibCall<"vec_free", Void, [Ptr]>;
|
|
|
|
/// void *vec_malloc(size_t size);
|
|
def vec_malloc : TargetLibCall<"vec_malloc", Ptr, [SizeT]>;
|
|
|
|
/// void *vec_realloc(void *ptr, size_t size);
|
|
def vec_realloc : TargetLibCall<"vec_realloc", Ptr, [Ptr, SizeT]>;
|
|
|
|
/// int vfprintf(FILE *stream, const char *format, va_list ap);
|
|
def vfprintf : TargetLibCall<"vfprintf", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int vfscanf(FILE *stream, const char *format, va_list arg);
|
|
def vfscanf : TargetLibCall<"vfscanf", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int vprintf(const char *restrict format, va_list ap);
|
|
def vprintf : TargetLibCall<"vprintf", Int, [Ptr, Ptr]>;
|
|
|
|
/// int vscanf(const char *format, va_list arg);
|
|
def vscanf : TargetLibCall<"vscanf", Int, [Ptr, Ptr]>;
|
|
|
|
/// int vsnprintf(char *s, size_t n, const char *format, va_list ap);
|
|
def vsnprintf : TargetLibCall<"vsnprintf", Int, [Ptr, SizeT, Ptr, Ptr]>;
|
|
|
|
/// int vsprintf(char *s, const char *format, va_list ap);
|
|
def vsprintf : TargetLibCall<"vsprintf", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// int vsscanf(const char *s, const char *format, va_list arg);
|
|
def vsscanf : TargetLibCall<"vsscanf", Int, [Ptr, Ptr, Ptr]>;
|
|
|
|
/// size_t wcslen (const wchar_t* wcs);
|
|
def wcslen : TargetLibCall<"wcslen", SizeT, [Ptr]>;
|
|
|
|
/// ssize_t write(int fildes, const void *buf, size_t nbyte);
|
|
def write : TargetLibCall<"write", SSizeT, [Int, Ptr, SizeT]>;
|