1#[cfg(target_arch = "x86_64")]
2macro_rules! ld_wrapper {
3 ($name:ident, $base:path, f64_ret) => {
4 #[no_mangle]
5 pub unsafe extern "C" fn $name(x: f64) -> f64 {
6 $base(x)
7 }
8 };
9 ($name:ident, $base:path, f64_f64_ret) => {
10 #[no_mangle]
11 pub unsafe extern "C" fn $name(x: f64, y: f64) -> f64 {
12 $base(x, y)
13 }
14 };
15 ($name:ident, $base:path, f64_int_ret) => {
16 #[no_mangle]
17 pub unsafe extern "C" fn $name(x: f64, n: i32) -> f64 {
18 $base(x, n)
19 }
20 };
21 ($name:ident, $base:path, f64_long_ret) => {
22 #[no_mangle]
23 pub unsafe extern "C" fn $name(x: f64, n: core::ffi::c_long) -> f64 {
24 $base(x, n)
25 }
26 };
27 ($name:ident, $base:path, f64_f64_f64_ret) => {
28 #[no_mangle]
29 pub unsafe extern "C" fn $name(x: f64, y: f64, z: f64) -> f64 {
30 $base(x, y, z)
31 }
32 };
33 ($name:ident, $base:path, int_f64_ret) => {
34 #[no_mangle]
35 pub unsafe extern "C" fn $name(x: f64) -> i32 {
36 $base(x)
37 }
38 };
39 ($name:ident, $base:path, long_f64_ret) => {
40 #[no_mangle]
41 pub unsafe extern "C" fn $name(x: f64) -> core::ffi::c_long {
42 $base(x)
43 }
44 };
45 ($name:ident, $base:path, longlong_f64_ret) => {
46 #[no_mangle]
47 pub unsafe extern "C" fn $name(x: f64) -> i64 {
48 $base(x)
49 }
50 };
51}
52
53#[cfg(target_arch = "aarch64")]
54macro_rules! ld_wrapper {
55 ($name:ident, $base:path, f64_ret) => {
56 #[no_mangle]
57 pub unsafe extern "C" fn $name(x: f128) -> f128 {
58 $base(x as f64) as f128
59 }
60 };
61 ($name:ident, $base:path, f64_f64_ret) => {
62 #[no_mangle]
63 pub unsafe extern "C" fn $name(x: f128, y: f128) -> f128 {
64 $base(x as f64, y as f64) as f128
65 }
66 };
67 ($name:ident, $base:path, f64_int_ret) => {
68 #[no_mangle]
69 pub unsafe extern "C" fn $name(x: f128, n: i32) -> f128 {
70 $base(x as f64, n) as f128
71 }
72 };
73 ($name:ident, $base:path, f64_long_ret) => {
74 #[no_mangle]
75 pub unsafe extern "C" fn $name(x: f128, n: core::ffi::c_long) -> f128 {
76 $base(x as f64, n) as f128
77 }
78 };
79 ($name:ident, $base:path, f64_f64_f64_ret) => {
80 #[no_mangle]
81 pub unsafe extern "C" fn $name(x: f128, y: f128, z: f128) -> f128 {
82 $base(x as f64, y as f64, z as f64) as f128
83 }
84 };
85 ($name:ident, $base:path, int_f64_ret) => {
86 #[no_mangle]
87 pub unsafe extern "C" fn $name(x: f128) -> i32 {
88 $base(x as f64)
89 }
90 };
91 ($name:ident, $base:path, long_f64_ret) => {
92 #[no_mangle]
93 pub unsafe extern "C" fn $name(x: f128) -> core::ffi::c_long {
94 $base(x as f64)
95 }
96 };
97 ($name:ident, $base:path, longlong_f64_ret) => {
98 #[no_mangle]
99 pub unsafe extern "C" fn $name(x: f128) -> i64 {
100 $base(x as f64)
101 }
102 };
103}
104
105#[cfg(target_arch = "riscv64")]
106macro_rules! ld_wrapper {
107 ($name:ident, $base:path, f64_ret) => {
108 #[no_mangle]
109 pub unsafe extern "C" fn $name(x: f128) -> f128 {
110 $base(x as f64) as f128
111 }
112 };
113 ($name:ident, $base:path, f64_f64_ret) => {
114 #[no_mangle]
115 pub unsafe extern "C" fn $name(x: f128, y: f128) -> f128 {
116 $base(x as f64, y as f64) as f128
117 }
118 };
119 ($name:ident, $base:path, f64_int_ret) => {
120 #[no_mangle]
121 pub unsafe extern "C" fn $name(x: f128, n: i32) -> f128 {
122 $base(x as f64, n) as f128
123 }
124 };
125 ($name:ident, $base:path, f64_long_ret) => {
126 #[no_mangle]
127 pub unsafe extern "C" fn $name(x: f128, n: core::ffi::c_long) -> f128 {
128 $base(x as f64, n) as f128
129 }
130 };
131 ($name:ident, $base:path, f64_f64_f64_ret) => {
132 #[no_mangle]
133 pub unsafe extern "C" fn $name(x: f128, y: f128, z: f128) -> f128 {
134 $base(x as f64, y as f64, z as f64) as f128
135 }
136 };
137 ($name:ident, $base:path, int_f64_ret) => {
138 #[no_mangle]
139 pub unsafe extern "C" fn $name(x: f128) -> i32 {
140 $base(x as f64)
141 }
142 };
143 ($name:ident, $base:path, long_f64_ret) => {
144 #[no_mangle]
145 pub unsafe extern "C" fn $name(x: f128) -> core::ffi::c_long {
146 $base(x as f64)
147 }
148 };
149 ($name:ident, $base:path, longlong_f64_ret) => {
150 #[no_mangle]
151 pub unsafe extern "C" fn $name(x: f128) -> i64 {
152 $base(x as f64)
153 }
154 };
155}
156
157ld_wrapper!(acosl, crate::acos, f64_ret);
158ld_wrapper!(asinl, crate::asin, f64_ret);
159ld_wrapper!(atanl, crate::atan, f64_ret);
160ld_wrapper!(ceill, crate::ceil, f64_ret);
161ld_wrapper!(cosl, crate::cos, f64_ret);
162ld_wrapper!(coshl, crate::cosh, f64_ret);
163ld_wrapper!(expl, crate::exp, f64_ret);
164ld_wrapper!(fabsl, crate::fabs, f64_ret);
165ld_wrapper!(floorl, crate::floor, f64_ret);
166ld_wrapper!(hypotl, crate::hypot, f64_f64_ret);
167ld_wrapper!(ldexpl, crate::ldexp, f64_int_ret);
168ld_wrapper!(logl, crate::log, f64_ret);
169ld_wrapper!(log2l, crate::log2, f64_ret);
170ld_wrapper!(log10l, crate::log10, f64_ret);
171ld_wrapper!(powl, crate::pow, f64_f64_ret);
172ld_wrapper!(roundl, crate::round, f64_ret);
173ld_wrapper!(scalblnl, crate::scalbln, f64_long_ret);
174ld_wrapper!(scalbnl, crate::scalbn, f64_int_ret);
175ld_wrapper!(sinl, crate::sin, f64_ret);
176ld_wrapper!(sinhl, crate::sinh, f64_ret);
177ld_wrapper!(sqrtl, crate::sqrt, f64_ret);
178ld_wrapper!(tanl, crate::tan, f64_ret);
179ld_wrapper!(tanhl, crate::tanh, f64_ret);
180ld_wrapper!(truncl, crate::trunc, f64_ret);
181ld_wrapper!(atan2l, crate::atan2, f64_f64_ret);
182ld_wrapper!(copysignl, crate::copysign, f64_f64_ret);
183ld_wrapper!(fmodl, crate::fmod, f64_f64_ret);
184
185#[no_mangle]
186pub unsafe extern "C" fn frexpl(x: f64, exp: *mut i32) -> f64 {
187 crate::frexp(x, exp)
188}
189
190#[no_mangle]
191pub unsafe extern "C" fn modfl(x: f64, iptr: *mut f64) -> f64 {
192 crate::modf(x, iptr)
193}
194
195#[no_mangle]
196pub unsafe extern "C" fn nanl(_tagp: *const core::ffi::c_char) -> f64 {
197 f64::NAN
198}
199
200#[no_mangle]
201pub unsafe extern "C" fn sincosl(x: f64, s: *mut f64, c: *mut f64) {
202 *s = crate::sin(x);
203 *c = crate::cos(x);
204}
205
206#[no_mangle]
207pub unsafe extern "C" fn remquol(x: f64, y: f64, quo: *mut i32) -> f64 {
208 crate::remquo(x, y, quo)
209}
210
211#[no_mangle]
212pub unsafe extern "C" fn a64l(s: *const core::ffi::c_char) -> i64 {
213 let mut result: i64 = 0;
214 let mut i = 0;
215 while i < 6 {
216 let c = *s.add(i) as u8;
217 if c == 0 { break; }
218 let val = match c {
219 b'.' => 0,
220 b'/' => 1,
221 b'0'..=b'9' => c - b'/' + 1,
222 b'A'..=b'Z' => c - b'A' + 12,
223 b'a'..=b'z' => c - b'a' + 38,
224 _ => 0,
225 };
226 result |= (val as i64) << (i * 6);
227 i += 1;
228 }
229 result
230}
231
232#[no_mangle]
233pub unsafe extern "C" fn exp10l(x: f64) -> f64 {
234 crate::pow(10.0, x)
235}
236
237ld_wrapper!(acoshl, crate::acosh, f64_ret);
238ld_wrapper!(asinhl, crate::asinh, f64_ret);
239ld_wrapper!(atanhl, crate::atanh, f64_ret);
240ld_wrapper!(cbrtl, crate::cbrt, f64_ret);
241ld_wrapper!(erfl, crate::erf, f64_ret);
242ld_wrapper!(erfcl, libm::erfc, f64_ret);
245ld_wrapper!(exp2l, libm::exp2, f64_ret);
246ld_wrapper!(expm1l, crate::expm1, f64_ret);
247ld_wrapper!(fdiml, crate::fdim, f64_f64_ret);
248ld_wrapper!(fmal, crate::fma, f64_f64_f64_ret);
249ld_wrapper!(fmaxl, crate::fmax_impl, f64_f64_ret);
250ld_wrapper!(fminl, crate::fmin_impl, f64_f64_ret);
251ld_wrapper!(ilogbl, crate::ilogb, int_f64_ret);
252ld_wrapper!(lgammal, crate::lgamma, f64_ret);
253ld_wrapper!(log1pl, crate::log1p, f64_ret);
254ld_wrapper!(logbl, crate::logb, f64_ret);
255ld_wrapper!(nearbyintl, crate::nearbyint, f64_ret);
256ld_wrapper!(nextafterl, crate::nextafter, f64_f64_ret);
257ld_wrapper!(nexttowardl, crate::nexttoward, f64_f64_ret);
258ld_wrapper!(remainderl, crate::remainder, f64_f64_ret);
259ld_wrapper!(rintl, crate::rint, f64_ret);
260ld_wrapper!(tgammal, crate::tgamma, f64_ret);
261ld_wrapper!(lroundl, crate::lround, long_f64_ret);
262ld_wrapper!(llroundl, crate::llround, longlong_f64_ret);