Add __THROW to all inlines to match prototypes in mathcalls.h.

diff --git a/sysdeps/alpha/fpu/bits/mathinline.h b/sysdeps/alpha/fpu/bits/mathinline.h
index 87765d2..c0911ec 100644 (file)
--- a/sysdeps/alpha/fpu/bits/mathinline.h
+++ b/sysdeps/alpha/fpu/bits/mathinline.h
@@ -1,5 +1,5 @@
 /* Inline math functions for Alpha.
-   Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1999, 2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by David Mosberger-Tang.
 
@@ -60,7 +60,7 @@
 
 #define __inline_copysign(NAME, TYPE)                                  \
 __MATH_INLINE TYPE                                                     \
-NAME (TYPE __x, TYPE __y)                                              \
+NAME (TYPE __x, TYPE __y) __THROW                                      \
 {                                                                      \
   TYPE __z;                                                            \
   __asm ("cpys %1, %2, %0" : "=f" (__z) : "f" (__y), "f" (__x));       \
@@ -76,14 +76,14 @@ __inline_copysign(copysign, double)
 
 
 #if __GNUC_PREREQ (2, 8)
-__MATH_INLINE float __fabsf (float __x) { return __builtin_fabsf (__x); }
-__MATH_INLINE float fabsf (float __x) { return __builtin_fabsf (__x); }
-__MATH_INLINE double __fabs (double __x) { return __builtin_fabs (__x); }
-__MATH_INLINE double fabs (double __x) { return __builtin_fabs (__x); }
+__MATH_INLINE float __fabsf (float __x) __THROW { return __builtin_fabsf (__x); }
+__MATH_INLINE float fabsf (float __x) __THROW { return __builtin_fabsf (__x); }
+__MATH_INLINE double __fabs (double __x) __THROW { return __builtin_fabs (__x); }
+__MATH_INLINE double fabs (double __x) __THROW { return __builtin_fabs (__x); }
 #else
 #define __inline_fabs(NAME, TYPE)                      \
 __MATH_INLINE TYPE                                     \
-NAME (TYPE __x)                                                \
+NAME (TYPE __x) __THROW                                        \
 {                                                      \
   TYPE __z;                                            \
   __asm ("cpys $f31, %1, %0" : "=f" (__z) : "f" (__x));        \
@@ -104,7 +104,7 @@ __inline_fabs(fabs, double)
    must be integral, as this avoids unpleasant integer overflows.  */
 
 __MATH_INLINE float
-__floorf (float __x)
+__floorf (float __x) __THROW
 {
   /* Check not zero since floor(-0) == -0.  */
   if (__x != 0 && fabsf (__x) < 16777216.0f)  /* 1 << FLT_MANT_DIG */
@@ -130,7 +130,7 @@ __floorf (float __x)
 }
 
 __MATH_INLINE double
-__floor (double __x)
+__floor (double __x) __THROW
 {
   if (__x != 0 && fabs (__x) < 9007199254740992.0)  /* 1 << DBL_MANT_DIG */
     {
@@ -148,26 +148,26 @@ __floor (double __x)
   return __x;
 }
 
-__MATH_INLINE float floorf (float __x) { return __floorf(__x); }
-__MATH_INLINE double floor (double __x) { return __floor(__x); }
+__MATH_INLINE float floorf (float __x) __THROW { return __floorf(__x); }
+__MATH_INLINE double floor (double __x) __THROW { return __floor(__x); }
 
 
-__MATH_INLINE float __fdimf (float __x, float __y)
+__MATH_INLINE float __fdimf (float __x, float __y) __THROW
 {
   return __x < __y ? 0.0f : __x - __y;
 }
 
-__MATH_INLINE float fdimf (float __x, float __y)
+__MATH_INLINE float fdimf (float __x, float __y) __THROW
 {
   return __x < __y ? 0.0f : __x - __y;
 }
 
-__MATH_INLINE double __fdim (double __x, double __y)
+__MATH_INLINE double __fdim (double __x, double __y) __THROW
 {
   return __x < __y ? 0.0 : __x - __y;
 }
 
-__MATH_INLINE double fdim (double __x, double __y)
+__MATH_INLINE double fdim (double __x, double __y) __THROW
 {
   return __x < __y ? 0.0 : __x - __y;
 }

diff --git a/sysdeps/m68k/fpu/bits/mathinline.h b/sysdeps/m68k/fpu/bits/mathinline.h
index 9dad4c6..82446d2 100644 (file)
--- a/sysdeps/m68k/fpu/bits/mathinline.h
+++ b/sysdeps/m68k/fpu/bits/mathinline.h
@@ -1,5 +1,5 @@
 /* Definitions of inline math functions implemented by the m68881/2.
-   Copyright (C) 1991,92,93,94,96,97,98,99 Free Software Foundation, Inc.
+   Copyright (C) 1991,92,93,94,96,97,98,99,2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -109,7 +109,7 @@
 #endif
 
 #define __inline_mathop1(float_type,func, op)                                \
-  __m81_defun (float_type, func, (float_type __mathop_x))                    \
+  __m81_defun (float_type, func, (float_type __mathop_x)) __THROW            \
   {                                                                          \
     float_type __result;                                                     \
     __asm("f" __STRING(op) "%.x %1, %0" : "=f" (__result) : "f" (__mathop_x));\
@@ -169,7 +169,7 @@ __inline_mathop(trunc, intrz)
 
 #define __inline_functions(float_type, s)                                \
 __m81_inline float_type                                                          \
-__m81_u(__CONCAT(__frexp,s))(float_type __value, int *__expptr)                  \
+__m81_u(__CONCAT(__frexp,s))(float_type __value, int *__expptr)        __THROW   \
 {                                                                        \
   float_type __mantissa, __exponent;                                     \
   int __iexponent;                                                       \
@@ -190,7 +190,7 @@ __m81_u(__CONCAT(__frexp,s))(float_type __value, int *__expptr)               \
   return __mantissa;                                                     \
 }                                                                        \
                                                                          \
-__m81_defun (float_type, __CONCAT(__floor,s), (float_type __x))                  \
+__m81_defun (float_type, __CONCAT(__floor,s), (float_type __x))        __THROW   \
 {                                                                        \
   float_type __result;                                                   \
   unsigned long int __ctrl_reg;                                                  \
@@ -206,7 +206,7 @@ __m81_defun (float_type, __CONCAT(__floor,s), (float_type __x))               \
   return __result;                                                       \
 }                                                                        \
                                                                          \
-__m81_defun (float_type, __CONCAT(__ceil,s), (float_type __x))           \
+__m81_defun (float_type, __CONCAT(__ceil,s), (float_type __x)) __THROW   \
 {                                                                        \
   float_type __result;                                                   \
   unsigned long int __ctrl_reg;                                                  \
@@ -232,7 +232,7 @@ __inline_functions(long double,l)
 #ifdef __USE_MISC
 
 # define __inline_functions(float_type, s)                               \
-__m81_defun (int, __CONCAT(__isinf,s), (float_type __value))             \
+__m81_defun (int, __CONCAT(__isinf,s), (float_type __value)) __THROW     \
 {                                                                        \
   /* There is no branch-condition for infinity,                                  \
      so we must extract and examine the condition codes manually.  */    \
@@ -242,7 +242,7 @@ __m81_defun (int, __CONCAT(__isinf,s), (float_type __value))                  \
   return (__fpsr & (2 << 24)) ? (__fpsr & (8 << 24) ? -1 : 1) : 0;       \
 }                                                                        \
                                                                          \
-__m81_defun (int, __CONCAT(__finite,s), (float_type __value))            \
+__m81_defun (int, __CONCAT(__finite,s), (float_type __value)) __THROW    \
 {                                                                        \
   /* There is no branch-condition for infinity, so we must extract and   \
      examine the condition codes manually.  */                           \
@@ -253,7 +253,7 @@ __m81_defun (int, __CONCAT(__finite,s), (float_type __value))                 \
 }                                                                        \
                                                                          \
 __m81_defun (float_type, __CONCAT(__scalbn,s),                           \
-            (float_type __x, int __n))                                   \
+            (float_type __x, int __n)) __THROW                           \
 {                                                                        \
   float_type __result;                                                   \
   __asm ("fscale%.l %1, %0" : "=f" (__result) : "dmi" (__n), "0" (__x));  \
@@ -270,7 +270,7 @@ __inline_functions(long double,l)
 #if defined __USE_MISC || defined __USE_XOPEN
 
 # define __inline_functions(float_type, s)                               \
-__m81_defun (int, __CONCAT(__isnan,s), (float_type __value))             \
+__m81_defun (int, __CONCAT(__isnan,s), (float_type __value)) __THROW     \
 {                                                                        \
   char __result;                                                         \
   __asm("ftst%.x %1\n"                                                   \
@@ -290,7 +290,7 @@ __inline_functions(long double,l)
 #ifdef __USE_ISOC99
 
 # define __inline_functions(float_type, s)                               \
-__m81_defun (int, __CONCAT(__signbit,s), (float_type __value))           \
+__m81_defun (int, __CONCAT(__signbit,s), (float_type __value)) __THROW   \
 {                                                                        \
   /* There is no branch-condition for the sign bit, so we must extract   \
      and examine the condition codes manually.  */                       \
@@ -301,12 +301,12 @@ __m81_defun (int, __CONCAT(__signbit,s), (float_type __value))              \
 }                                                                        \
                                                                          \
 __m81_defun (float_type, __CONCAT(__scalbln,s),                                  \
-            (float_type __x, long int __n))                              \
+            (float_type __x, long int __n)) __THROW                      \
 {                                                                        \
   return __CONCAT(__scalbn,s) (__x, __n);                                \
 }                                                                        \
                                                                          \
-__m81_defun (float_type, __CONCAT(__nearbyint,s), (float_type __x))      \
+__m81_defun (float_type, __CONCAT(__nearbyint,s), (float_type __x)) __THROW \
 {                                                                        \
   float_type __result;                                                   \
   unsigned long int __ctrl_reg;                                                  \
@@ -320,7 +320,7 @@ __m81_defun (float_type, __CONCAT(__nearbyint,s), (float_type __x))   \
   return __result;                                                       \
 }                                                                        \
                                                                          \
-__m81_defun (long int, __CONCAT(__lrint,s), (float_type __x))            \
+__m81_defun (long int, __CONCAT(__lrint,s), (float_type __x)) __THROW    \
 {                                                                        \
   long int __result;                                                     \
   __asm ("fmove%.l %1, %0" : "=dm" (__result) : "f" (__x));              \
@@ -329,7 +329,7 @@ __m81_defun (long int, __CONCAT(__lrint,s), (float_type __x))                 \
                                                                          \
 __m81_inline float_type                                                          \
 __m81_u(__CONCAT(__fma,s))(float_type __x, float_type __y,               \
-                          float_type __z)                                \
+                          float_type __z) __THROW                        \
 {                                                                        \
   return (__x * __y) + __z;                                              \
 }
@@ -346,7 +346,7 @@ __inline_functions (long double,l)
 # define __inline_functions(float_type, s)                             \
 __m81_inline void                                                      \
 __m81_u(__CONCAT(__sincos,s))(float_type __x, float_type *__sinx,      \
-                             float_type *__cosx)                       \
+                             float_type *__cosx) __THROW               \
 {                                                                      \
   __asm ("fsincos%.x %2,%1:%0"                                         \
         : "=f" (*__sinx), "=f" (*__cosx) : "f" (__x));                 \
@@ -367,13 +367,13 @@ __inline_functions (long double,l)
    NAME, to make token pasting work correctly with -traditional.  */
 # define __inline_forward_c(rettype, name, args1, args2)       \
 extern __inline rettype __attribute__((__const__))     \
-name args1                                             \
+name args1 __THROW                                     \
 {                                                      \
   return __CONCAT(__,name) args2;                      \
 }
 
 # define __inline_forward(rettype, name, args1, args2) \
-extern __inline rettype name args1                     \
+extern __inline rettype name args1 __THROW             \
 {                                                      \
   return __CONCAT(__,name) args2;                      \
 }