Tue Jun 4 22:03:02 1996 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
[kopensolaris-gnu/glibc.git] / sysdeps / m68k / fpu / __math.h
1 /* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #ifdef  __GNUC__
20
21 #include <sys/cdefs.h>
22
23 #ifdef  __NO_MATH_INLINES
24 /* This is used when defining the functions themselves.  Define them with
25    __ names, and with `static inline' instead of `extern inline' so the
26    bodies will always be used, never an external function call.  */
27 #define __m81_u(x)      __CONCAT(__,x)
28 #define __m81_inline    static __inline
29 #else
30 #define __m81_u(x)      x
31 #define __m81_inline    extern __inline
32 #define __MATH_INLINES  1
33 #endif
34
35 /* Define a const math function.  */
36 #define __m81_defun(rettype, func, args)                                      \
37   __m81_inline rettype                                                        \
38   __m81_u(func) args __attribute__((__const__));                              \
39   __m81_inline rettype                                                        \
40   __m81_u(func) args
41
42 #define __inline_mathop(func, op)                                             \
43   __m81_defun (double, func, (double __mathop_x))                             \
44   {                                                                           \
45     double __result;                                                          \
46     __asm("f" __STRING(op) "%.x %1, %0" : "=f" (__result) : "f" (__mathop_x));\
47     return __result;                                                          \
48   }
49
50 #define __inline_mathopf(func, op)                                            \
51   __m81_defun (float, func, (float __mathop_x))                               \
52   {                                                                           \
53     float __result;                                                           \
54     __asm("f" __STRING(op) "%.x %1, %0" : "=f" (__result) : "f" (__mathop_x));\
55     return __result;                                                          \
56   }
57
58 #define __inline_mathopl(func, op)                                            \
59   __m81_defun (long double, func, (long double __mathop_x))                   \
60   {                                                                           \
61     long double __result;                                                     \
62     __asm("f" __STRING(op) "%.x %1, %0" : "=f" (__result) : "f" (__mathop_x));\
63     return __result;                                                          \
64   }
65   
66 /* ieee style elementary functions */
67 __inline_mathop(__ieee754_acos, acos)
68 __inline_mathop(__ieee754_asin, asin)
69 __inline_mathop(__ieee754_cosh, cosh)
70 __inline_mathop(__ieee754_sinh, sinh)
71 __inline_mathop(__ieee754_exp, etox)
72 __inline_mathop(__ieee754_log10, log10)
73 __inline_mathop(__ieee754_log, logn)
74 __inline_mathop(__ieee754_sqrt, sqrt)
75 __inline_mathop(__ieee754_atanh, atanh)
76
77 /* ieee style elementary float functions */
78 __inline_mathopf(__ieee754_acosf, acos)
79 __inline_mathopf(__ieee754_asinf, asin)
80 __inline_mathopf(__ieee754_coshf, cosh)
81 __inline_mathopf(__ieee754_sinhf, sinh)
82 __inline_mathopf(__ieee754_expf, etox)
83 __inline_mathopf(__ieee754_log10f, log10)
84 __inline_mathopf(__ieee754_logf, logn)
85 __inline_mathopf(__ieee754_sqrtf, sqrt)
86 __inline_mathopf(__ieee754_atanhf, atan)
87
88 /* ieee style elementary long double functions */
89 __inline_mathopl(__ieee754_acosl, acos)
90 __inline_mathopl(__ieee754_asinl, asin)
91 __inline_mathopl(__ieee754_coshl, cosh)
92 __inline_mathopl(__ieee754_sinhl, sinh)
93 __inline_mathopl(__ieee754_expl, etox)
94 __inline_mathopl(__ieee754_log10l, log10)
95 __inline_mathopl(__ieee754_logl, logn)
96 __inline_mathopl(__ieee754_sqrtl, sqrt)
97 __inline_mathopl(__ieee754_atanhl, atan)
98
99 __inline_mathop(__atan, atan)
100 __inline_mathop(__cos, cos)
101 __inline_mathop(__sin, sin)
102 __inline_mathop(__tan, tan)
103 __inline_mathop(__tanh, tanh)
104 __inline_mathop(__fabs, abs)
105 __inline_mathop(__sqrt, sqrt)
106
107 __inline_mathop(__rint, int)
108 __inline_mathop(__expm1, etoxm1)
109 __inline_mathop(__log1p, lognp1)
110 __inline_mathop(__logb, log2)
111 __inline_mathop(__significand, getman)
112
113 __inline_mathopf(__atanf, atan)
114 __inline_mathopf(__cosf, cos)
115 __inline_mathopf(__sinf, sin)
116 __inline_mathopf(__tanf, tan)
117 __inline_mathopf(__tanhf, tanh)
118 __inline_mathopf(__fabsf, abs)
119 __inline_mathopf(__sqrtf, sqrt)
120
121 __inline_mathopf(__rintf, int)
122 __inline_mathopf(__expm1f, etoxm1)
123 __inline_mathopf(__log1pf, lognp1)
124 __inline_mathopf(__logbf, log2)
125 __inline_mathopf(__significandf, getman)
126
127 __inline_mathopl(__atanl, atan)
128 __inline_mathopl(__cosl, cos)
129 __inline_mathopl(__sinl, sin)
130 __inline_mathopl(__tanl, tan)
131 __inline_mathopl(__tanhl, tanh)
132 __inline_mathopl(__fabsl, abs)
133 __inline_mathopl(__sqrtl, sqrt)
134
135 __inline_mathopl(__rintl, int)
136 __inline_mathopl(__expm1l, etoxm1)
137 __inline_mathopl(__log1pl, lognp1)
138 __inline_mathopl(__logbl, log2)
139 __inline_mathopl(__significandl, getman)
140
141 __m81_defun (double, __ieee754_remainder, (double __x, double __y))
142 {
143   double __result;
144   __asm("frem%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
145   return __result;
146 }
147
148 __m81_defun (double, __ldexp, (double __x, int __e))
149 {
150   double __result;
151   double __double_e = (double) __e;
152   __asm("fscale%.x %1, %0" : "=f" (__result) : "f" (__double_e), "0" (__x));
153   return __result;
154 }
155
156 __m81_defun (double, __ieee754_fmod, (double __x, double __y))
157 {
158   double __result;
159   __asm("fmod%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
160   return __result;
161 }
162
163 __m81_inline double
164 __m81_u(__frexp)(double __value, int *__expptr)
165 {
166   double __mantissa, __exponent;
167   __asm("fgetexp%.x %1, %0" : "=f" (__exponent) : "f" (__value));
168   __asm("fgetman%.x %1, %0" : "=f" (__mantissa) : "f" (__value));
169   *__expptr = (int) __exponent;
170   return __mantissa;
171 }
172
173 __m81_defun (double, __floor, (double __x))
174 {
175   double __result;
176   unsigned long int __ctrl_reg;
177   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
178   /* Set rounding towards negative infinity.  */
179   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */ 
180                       : "dmi" ((__ctrl_reg & ~0x10) | 0x20));
181   /* Convert X to an integer, using -Inf rounding.  */
182   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
183   /* Restore the previous rounding mode.  */
184   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
185                       : "dmi" (__ctrl_reg));
186   return __result;
187 }
188
189 __m81_defun (double, __ieee754_pow, (double __x, double __y))
190 {
191   double __result;
192   if (__x == 0.0)
193     {
194       if (__y <= 0.0)
195         __result = 0.0 / 0.0;
196       else
197         __result = 0.0;
198     }
199   else if (__y == 0.0 || __x == 1.0)
200     __result = 1.0;
201   else if (__y == 1.0)
202     __result = __x;
203   else if (__y == 2.0)
204     __result = __x * __x;
205   else if (__x == 10.0)
206     __asm("ftentox%.x %1, %0" : "=f" (__result) : "f" (__y));
207   else if (__x == 2.0)
208     __asm("ftwotox%.x %1, %0" : "=f" (__result) : "f" (__y));
209   else if (__x < 0.0)
210     {
211       double __temp = __m81_u (__rint) (__y);
212       if (__y == __temp)
213         {
214           int i = (int) __y;
215           __result = __m81_u(__ieee754_exp)(__y * __m81_u(__ieee754_log)(-__x));
216           if (i & 1)
217             __result = -__result;
218         }
219       else
220         __result = 0.0 / 0.0;
221     }
222   else
223     __result = __m81_u(__ieee754_exp)(__y * __m81_u(__ieee754_log)(__x));
224   return __result;
225 }
226
227 __m81_defun (double, __ceil, (double __x))
228 {
229   double __result;
230   unsigned long int __ctrl_reg;
231   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
232   /* Set rounding towards positive infinity.  */
233   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
234                       : "dmi" (__ctrl_reg | 0x30));
235   /* Convert X to an integer, using +Inf rounding.  */
236   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
237   /* Restore the previous rounding mode.  */
238   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
239                       : "dmi" (__ctrl_reg));
240   return __result;
241 }
242
243 __m81_inline double
244 __m81_u(__modf)(double __value, double *__iptr)
245 {
246   double __modf_int;
247   __asm ("fintrz%.x %1, %0" : "=f" (__modf_int) : "f" (__value));
248   *__iptr = __modf_int;
249   return __value - __modf_int;
250 }
251
252 __m81_defun (int, __isinf, (double __value))
253 {
254   /* There is no branch-condition for infinity,
255      so we must extract and examine the condition codes manually.  */
256   unsigned long int __fpsr;
257   __asm("ftst%.x %1\n"
258         "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
259   return (__fpsr & (2 << 24)) ? (__fpsr & (8 << 24) ? -1 : 1) : 0;
260 }
261
262 __m81_defun (int, __isnan, (double __value))
263 {
264   char __result;
265   __asm("ftst%.x %1\n"
266         "fsun %0" : "=dm" (__result) : "f" (__value));
267   return __result;
268 }
269
270 __m81_defun (int, __finite, (double __value))
271 {
272   /* There is no branch-condition for infinity, so we must extract and
273      examine the condition codes manually.  */
274   unsigned long int __fpsr;
275   __asm ("ftst%.x %1\n"
276          "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
277   return (__fpsr & (3 << 24)) == 0;
278 }
279
280 __m81_defun (int, __ilogb, (double __x))
281 {
282   double __result;
283   __asm("fgetexp%.x %1, %0" : "=f" (__result) : "f" (__x));
284   return (int) __result;
285 }
286
287 __m81_defun (double, __ieee754_scalb, (double __x, double __n))
288 {
289   double __result;
290   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__n), "0" (__x));
291   return __result;
292 }
293
294 __m81_defun (double, __scalbn, (double __x, int __n))
295 {
296   double __result;
297   double __double_n = (double) __n;
298   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__double_n), "0" (__x));
299   return __result;
300 }
301
302 __m81_defun (float, __ieee754_remainderf, (float __x, float __y))
303 {
304   float __result;
305   __asm("frem%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
306   return __result;
307 }
308
309 __m81_defun (float, __ldexpf, (float __x, int __e))
310 {
311   float __result;
312   float __float_e = (float) __e;
313   __asm("fscale%.x %1, %0" : "=f" (__result) : "f" (__float_e), "0" (__x));
314   return __result;
315 }
316
317 __m81_defun (float, __ieee754_fmodf, (float __x, float __y))
318 {
319   float __result;
320   __asm("fmod%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
321   return __result;
322 }
323
324 __m81_inline float
325 __m81_u(__frexpf)(float __value, int *__expptr)
326 {
327   float __mantissa, __exponent;
328   __asm("fgetexp%.x %1, %0" : "=f" (__exponent) : "f" (__value));
329   __asm("fgetman%.x %1, %0" : "=f" (__mantissa) : "f" (__value));
330   *__expptr = (int) __exponent;
331   return __mantissa;
332 }
333
334 __m81_defun (float, __floorf, (float __x))
335 {
336   float __result;
337   unsigned long int __ctrl_reg;
338   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
339   /* Set rounding towards negative infinity.  */
340   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */ 
341                       : "dmi" ((__ctrl_reg & ~0x10) | 0x20));
342   /* Convert X to an integer, using -Inf rounding.  */
343   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
344   /* Restore the previous rounding mode.  */
345   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
346                       : "dmi" (__ctrl_reg));
347   return __result;
348 }
349
350 __m81_defun (float, __ieee754_powf, (float __x, float __y))
351 {
352   float __result;
353   if (__x == 0.0f)
354     {
355       if (__y <= 0.0f)
356         __result = 0.0f / 0.0f;
357       else
358         __result = 0.0f;
359     }
360   else if (__y == 0.0f || __x == 1.0f)
361     __result = 1.0;
362   else if (__y == 1.0f)
363     __result = __x;
364   else if (__y == 2.0f)
365     __result = __x * __x;
366   else if (__x == 10.0f)
367     __asm("ftentox%.x %1, %0" : "=f" (__result) : "f" (__y));
368   else if (__x == 2.0f)
369     __asm("ftwotox%.x %1, %0" : "=f" (__result) : "f" (__y));
370   else if (__x < 0.0f)
371     {
372       float __temp = __m81_u(__rintf)(__y);
373       if (__y == __temp)
374         {
375           int i = (int) __y;
376           __result = __m81_u(__ieee754_expf)(__y * __m81_u(__ieee754_logf)(-__x));
377           if (i & 1)
378             __result = -__result;
379         }
380       else
381         __result = 0.0f / 0.0f;
382     }
383   else
384     __result = __m81_u(__ieee754_expf)(__y * __m81_u(__ieee754_logf)(__x));
385   return __result;
386 }
387
388 __m81_defun (float, __ceilf, (float __x))
389 {
390   float __result;
391   unsigned long int __ctrl_reg;
392   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
393   /* Set rounding towards positive infinity.  */
394   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
395                       : "dmi" (__ctrl_reg | 0x30));
396   /* Convert X to an integer, using +Inf rounding.  */
397   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
398   /* Restore the previous rounding mode.  */
399   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
400                       : "dmi" (__ctrl_reg));
401   return __result;
402 }
403
404 __m81_inline float
405 __m81_u(__modff)(float __value, float *__iptr)
406 {
407   float __modf_int;
408   __asm ("fintrz%.x %1, %0" : "=f" (__modf_int) : "f" (__value));
409   *__iptr = __modf_int;
410   return __value - __modf_int;
411 }
412
413 __m81_defun (int, __isinff, (float __value))
414 {
415   /* There is no branch-condition for infinity,
416      so we must extract and examine the condition codes manually.  */
417   unsigned long int __fpsr;
418   __asm("ftst%.x %1\n"
419         "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
420   return (__fpsr & (2 << 24)) ? (__fpsr & (8 << 24) ? -1 : 1) : 0;
421 }
422
423 __m81_defun (int, __isnanf, (float __value))
424 {
425   char __result;
426   __asm("ftst%.x %1\n"
427         "fsun %0" : "=dm" (__result) : "f" (__value));
428   return __result;
429 }
430
431 __m81_defun (int, __finitef, (float __value))
432 {
433   /* There is no branch-condition for infinity, so we must extract and
434      examine the condition codes manually.  */
435   unsigned long int __fpsr;
436   __asm ("ftst%.x %1\n"
437          "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
438   return (__fpsr & (3 << 24)) == 0;
439 }
440
441 __m81_defun (int, __ilogbf, (float __x))
442 {
443   float __result;
444   __asm("fgetexp%.x %1, %0" : "=f" (__result) : "f" (__x));
445   return (int) __result;
446 }
447
448 __m81_defun (float, __ieee754_scalbf, (float __x, float __n))
449 {
450   float __result;
451   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__n), "0" (__x));
452   return __result;
453 }
454
455 __m81_defun (float, __scalbnf, (float __x, int __n))
456 {
457   float __result;
458   float __float_n = (float) __n;
459   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__float_n), "0" (__x));
460   return __result;
461 }
462
463 __m81_defun (long double, __ieee754_remainderl, (long double __x,
464                                                  long double __y))
465 {
466   long double __result;
467   __asm ("frem%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
468   return __result;
469 }
470
471 __m81_defun (long double, __ldexpl, (long double __x, int __e))
472 {
473   long double __result;
474   long double __float_e = (long double) __e;
475   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__float_e), "0" (__x));
476   return __result;
477 }
478
479 __m81_defun (long double, __ieee754_fmodl, (long double __x, long double __y))
480 {
481   long double __result;
482   __asm("fmod%.x %1, %0" : "=f" (__result) : "f" (__y), "0" (__x));
483   return __result;
484 }
485
486 __m81_inline long double
487 __m81_u(__frexpl)(long double __value, int *__expptr)
488 {
489   long double __mantissa, __exponent;
490   __asm("fgetexp%.x %1, %0" : "=f" (__exponent) : "f" (__value));
491   __asm("fgetman%.x %1, %0" : "=f" (__mantissa) : "f" (__value));
492   *__expptr = (int) __exponent;
493   return __mantissa;
494 }
495
496 __m81_defun (long double, __floorl, (long double __x))
497 {
498   long double __result;
499   unsigned long int __ctrl_reg;
500   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
501   /* Set rounding towards negative infinity.  */
502   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */ 
503                       : "dmi" ((__ctrl_reg & ~0x10) | 0x20));
504   /* Convert X to an integer, using -Inf rounding.  */
505   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
506   /* Restore the previous rounding mode.  */
507   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
508                       : "dmi" (__ctrl_reg));
509   return __result;
510 }
511
512 __m81_defun (long double, __ieee754_powl, (long double __x, long double __y))
513 {
514   long double __result;
515   if (__x == 0.0l)
516     {
517       if (__y <= 0.0l)
518         __result = 0.0l / 0.0l;
519       else
520         __result = 0.0l;
521     }
522   else if (__y == 0.0l || __x == 1.0l)
523     __result = 1.0;
524   else if (__y == 1.0l)
525     __result = __x;
526   else if (__y == 2.0l)
527     __result = __x * __x;
528   else if (__x == 10.0l)
529     __asm("ftentox%.x %1, %0" : "=f" (__result) : "f" (__y));
530   else if (__x == 2.0l)
531     __asm("ftwotox%.x %1, %0" : "=f" (__result) : "f" (__y));
532   else if (__x < 0.0l)
533     {
534       long double __temp = __m81_u(__rintl)(__y);
535       if (__y == __temp)
536         {
537           int i = (int) __y;
538           __result
539             = __m81_u(__ieee754_expl)(__y * __m81_u(__ieee754_logl)(-__x));
540           if (i & 1)
541             __result = -__result;
542         }
543       else
544         __result = 0.0l / 0.0l;
545     }
546   else
547     __result = __m81_u(__ieee754_expl)(__y * __m81_u(__ieee754_logl)(__x));
548   return __result;
549 }
550
551 __m81_defun (long double, __ceill, (long double __x))
552 {
553   long double __result;
554   unsigned long int __ctrl_reg;
555   __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
556   /* Set rounding towards positive infinity.  */
557   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
558                       : "dmi" (__ctrl_reg | 0x30));
559   /* Convert X to an integer, using +Inf rounding.  */
560   __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
561   /* Restore the previous rounding mode.  */
562   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */
563                       : "dmi" (__ctrl_reg));
564   return __result;
565 }
566
567 __m81_inline long double
568 __m81_u(__modfl)(long double __value, long double *__iptr)
569 {
570   long double __modf_int;
571   __asm ("fintrz%.x %1, %0" : "=f" (__modf_int) : "f" (__value));
572   *__iptr = __modf_int;
573   return __value - __modf_int;
574 }
575
576 __m81_defun (int, __isinfl, (long double __value))
577 {
578   /* There is no branch-condition for infinity,
579      so we must extract and examine the condition codes manually.  */
580   unsigned long int __fpsr;
581   __asm("ftst%.x %1\n"
582         "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
583   return (__fpsr & (2 << 24)) ? (__fpsr & (8 << 24) ? -1 : 1) : 0;
584 }
585
586 __m81_defun (int, __isnanl, (long double __value))
587 {
588   char __result;
589   __asm("ftst%.x %1\n"
590         "fsun %0" : "=dm" (__result) : "f" (__value));
591   return __result;
592 }
593
594 __m81_defun (int, __finitel, (long double __value))
595 {
596   /* There is no branch-condition for infinity, so we must extract and
597      examine the condition codes manually.  */
598   unsigned long int __fpsr;
599   __asm ("ftst%.x %1\n"
600          "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
601   return (__fpsr & (3 << 24)) == 0;
602 }
603
604 __m81_defun (int, __ilogbl, (long double __x))
605 {
606   long double __result;
607   __asm("fgetexp%.x %1, %0" : "=f" (__result) : "f" (__x));
608   return (int) __result;
609 }
610
611 __m81_defun (long double, __ieee754_scalbl, (long double __x, long double __n))
612 {
613   long double __result;
614   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__n), "0" (__x));
615   return __result;
616 }
617
618 __m81_defun (long double, __scalbnl, (long double __x, int __n))
619 {
620   long double __result;
621   long double __float_n = (long double) __n;
622   __asm ("fscale%.x %1, %0" : "=f" (__result) : "f" (__float_n), "0" (__x));
623   return __result;
624 }
625
626 #endif  /* GCC.  */