958e1b
From 05ea4eb9e64508f25f806683a470b68fb286770e Mon Sep 17 00:00:00 2001
958e1b
Message-Id: <05ea4eb9e64508f25f806683a470b68fb286770e.1418766606.git.jen@redhat.com>
958e1b
In-Reply-To: <6f81b4847eb68ebdf54a8f1a771e19d112d74152.1418766606.git.jen@redhat.com>
958e1b
References: <6f81b4847eb68ebdf54a8f1a771e19d112d74152.1418766606.git.jen@redhat.com>
958e1b
From: Fam Zheng <famz@redhat.com>
958e1b
Date: Thu, 4 Dec 2014 00:05:17 -0600
958e1b
Subject: [CHANGE 23/31] fpu: softfloat: drop INLINE macro
958e1b
To: rhvirt-patches@redhat.com,
958e1b
    jen@redhat.com
958e1b
958e1b
RH-Author: Fam Zheng <famz@redhat.com>
958e1b
Message-id: <1417651524-18041-24-git-send-email-famz@redhat.com>
958e1b
Patchwork-id: 62696
958e1b
O-Subject: [RHEL-7.1 qemu-kvm PATCH v5 23/30] fpu: softfloat: drop INLINE macro
958e1b
Bugzilla: 1002493
958e1b
RH-Acked-by: Jeffrey Cody <jcody@redhat.com>
958e1b
RH-Acked-by: Markus Armbruster <armbru@redhat.com>
958e1b
RH-Acked-by: Max Reitz <mreitz@redhat.com>
958e1b
958e1b
From: Luiz Capitulino <lcapitulino@redhat.com>
958e1b
958e1b
This commit expands all uses of the INLINE macro and drop it.
958e1b
958e1b
The reason for this is to avoid clashes with external libraries with
958e1b
bad name conventions and also because renaming keywords is not a good
958e1b
practice.
958e1b
958e1b
PS: I'm fine with this change to be licensed under softfloat-2a or
958e1b
softfloat-2b.
958e1b
958e1b
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
958e1b
(cherry picked from commit a49db98d1f85ada0c4e5bb22bd93d541e7159c43)
958e1b
Signed-off-by: Fam Zheng <famz@redhat.com>
958e1b
Signed-off-by: Jeff E. Nelson <jen@redhat.com>
958e1b
958e1b
Conflicts:
958e1b
	fpu/softfloat.c
958e1b
	include/fpu/softfloat.h
958e1b
The code that uses "INLINE" is different, but the conflict resolution is
958e1b
trivially expand "INLINE" to "static inline".
958e1b
958e1b
Signed-off-by: Jeff E. Nelson <jen@redhat.com>
958e1b
---
958e1b
 fpu/softfloat-macros.h  | 38 ++++++++++++-------------
958e1b
 fpu/softfloat.c         | 48 ++++++++++++++++----------------
958e1b
 include/fpu/softfloat.h | 73 ++++++++++++++++++++++++-------------------------
958e1b
 3 files changed, 79 insertions(+), 80 deletions(-)
958e1b
958e1b
diff --git a/fpu/softfloat-macros.h b/fpu/softfloat-macros.h
958e1b
index b5164af..24ec452 100644
958e1b
--- a/fpu/softfloat-macros.h
958e1b
+++ b/fpu/softfloat-macros.h
958e1b
@@ -55,7 +55,7 @@ these four paragraphs for those parts of this code that are retained.
958e1b
 | The result is stored in the location pointed to by `zPtr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void shift32RightJamming(uint32_t a, int_fast16_t count, uint32_t *zPtr)
958e1b
+static inline void shift32RightJamming(uint32_t a, int_fast16_t count, uint32_t *zPtr)
958e1b
 {
958e1b
     uint32_t z;
958e1b
 
958e1b
@@ -81,7 +81,7 @@ INLINE void shift32RightJamming(uint32_t a, int_fast16_t count, uint32_t *zPtr)
958e1b
 | The result is stored in the location pointed to by `zPtr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void shift64RightJamming(uint64_t a, int_fast16_t count, uint64_t *zPtr)
958e1b
+static inline void shift64RightJamming(uint64_t a, int_fast16_t count, uint64_t *zPtr)
958e1b
 {
958e1b
     uint64_t z;
958e1b
 
958e1b
@@ -115,7 +115,7 @@ INLINE void shift64RightJamming(uint64_t a, int_fast16_t count, uint64_t *zPtr)
958e1b
 | described above, and is returned at the location pointed to by `z1Ptr'.)
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shift64ExtraRightJamming(
958e1b
      uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
958e1b
 {
958e1b
@@ -152,7 +152,7 @@ INLINE void
958e1b
 | which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shift128Right(
958e1b
      uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
958e1b
 {
958e1b
@@ -187,7 +187,7 @@ INLINE void
958e1b
 | the locations pointed to by `z0Ptr' and `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shift128RightJamming(
958e1b
      uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
958e1b
 {
958e1b
@@ -238,7 +238,7 @@ INLINE void
958e1b
 | `z2Ptr'.)
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shift128ExtraRightJamming(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -296,7 +296,7 @@ INLINE void
958e1b
 | pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shortShift128Left(
958e1b
      uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
958e1b
 {
958e1b
@@ -315,7 +315,7 @@ INLINE void
958e1b
 | `z1Ptr', and `z2Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  shortShift192Left(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -350,7 +350,7 @@ INLINE void
958e1b
 | are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  add128(
958e1b
      uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
958e1b
 {
958e1b
@@ -370,7 +370,7 @@ INLINE void
958e1b
 | `z1Ptr', and `z2Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  add192(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -408,7 +408,7 @@ INLINE void
958e1b
 | `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  sub128(
958e1b
      uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
958e1b
 {
958e1b
@@ -426,7 +426,7 @@ INLINE void
958e1b
 | pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  sub192(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -462,7 +462,7 @@ INLINE void
958e1b
 | `z0Ptr' and `z1Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
958e1b
+static inline void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
958e1b
 {
958e1b
     uint32_t aHigh, aLow, bHigh, bLow;
958e1b
     uint64_t z0, zMiddleA, zMiddleB, z1;
958e1b
@@ -492,7 +492,7 @@ INLINE void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr
958e1b
 | `z2Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  mul128By64To192(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -520,7 +520,7 @@ INLINE void
958e1b
 | the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE void
958e1b
+static inline void
958e1b
  mul128To256(
958e1b
      uint64_t a0,
958e1b
      uint64_t a1,
958e1b
@@ -702,7 +702,7 @@ static int8 countLeadingZeros64( uint64_t a )
958e1b
 | Otherwise, returns 0.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
+static inline flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 {
958e1b
 
958e1b
     return ( a0 == b0 ) && ( a1 == b1 );
958e1b
@@ -715,7 +715,7 @@ INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 | Otherwise, returns 0.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
+static inline flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 {
958e1b
 
958e1b
     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
958e1b
@@ -728,7 +728,7 @@ INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 | returns 0.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
+static inline flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 {
958e1b
 
958e1b
     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
958e1b
@@ -741,7 +741,7 @@ INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 | Otherwise, returns 0.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
+static inline flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
958e1b
 {
958e1b
 
958e1b
     return ( a0 != b0 ) || ( a1 != b1 );
958e1b
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
958e1b
index 7ba51b6..30623cb 100644
958e1b
--- a/fpu/softfloat.c
958e1b
+++ b/fpu/softfloat.c
958e1b
@@ -78,7 +78,7 @@ void set_floatx80_rounding_precision(int val STATUS_PARAM)
958e1b
 | Returns the fraction bits of the half-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint32_t extractFloat16Frac(float16 a)
958e1b
+static inline uint32_t extractFloat16Frac(float16 a)
958e1b
 {
958e1b
     return float16_val(a) & 0x3ff;
958e1b
 }
958e1b
@@ -87,7 +87,7 @@ INLINE uint32_t extractFloat16Frac(float16 a)
958e1b
 | Returns the exponent bits of the half-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE int_fast16_t extractFloat16Exp(float16 a)
958e1b
+static inline int_fast16_t extractFloat16Exp(float16 a)
958e1b
 {
958e1b
     return (float16_val(a) >> 10) & 0x1f;
958e1b
 }
958e1b
@@ -96,7 +96,7 @@ INLINE int_fast16_t extractFloat16Exp(float16 a)
958e1b
 | Returns the sign bit of the single-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag extractFloat16Sign(float16 a)
958e1b
+static inline flag extractFloat16Sign(float16 a)
958e1b
 {
958e1b
     return float16_val(a)>>15;
958e1b
 }
958e1b
@@ -207,7 +207,7 @@ static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1 STATU
958e1b
 | Returns the fraction bits of the single-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint32_t extractFloat32Frac( float32 a )
958e1b
+static inline uint32_t extractFloat32Frac( float32 a )
958e1b
 {
958e1b
 
958e1b
     return float32_val(a) & 0x007FFFFF;
958e1b
@@ -218,7 +218,7 @@ INLINE uint32_t extractFloat32Frac( float32 a )
958e1b
 | Returns the exponent bits of the single-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE int_fast16_t extractFloat32Exp(float32 a)
958e1b
+static inline int_fast16_t extractFloat32Exp(float32 a)
958e1b
 {
958e1b
 
958e1b
     return ( float32_val(a)>>23 ) & 0xFF;
958e1b
@@ -229,7 +229,7 @@ INLINE int_fast16_t extractFloat32Exp(float32 a)
958e1b
 | Returns the sign bit of the single-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag extractFloat32Sign( float32 a )
958e1b
+static inline flag extractFloat32Sign( float32 a )
958e1b
 {
958e1b
 
958e1b
     return float32_val(a)>>31;
958e1b
@@ -280,7 +280,7 @@ static void
958e1b
 | significand.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
958e1b
+static inline float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
958e1b
 {
958e1b
 
958e1b
     return make_float32(
958e1b
@@ -389,7 +389,7 @@ static float32
958e1b
 | Returns the fraction bits of the double-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint64_t extractFloat64Frac( float64 a )
958e1b
+static inline uint64_t extractFloat64Frac( float64 a )
958e1b
 {
958e1b
 
958e1b
     return float64_val(a) & LIT64( 0x000FFFFFFFFFFFFF );
958e1b
@@ -400,7 +400,7 @@ INLINE uint64_t extractFloat64Frac( float64 a )
958e1b
 | Returns the exponent bits of the double-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE int_fast16_t extractFloat64Exp(float64 a)
958e1b
+static inline int_fast16_t extractFloat64Exp(float64 a)
958e1b
 {
958e1b
 
958e1b
     return ( float64_val(a)>>52 ) & 0x7FF;
958e1b
@@ -411,7 +411,7 @@ INLINE int_fast16_t extractFloat64Exp(float64 a)
958e1b
 | Returns the sign bit of the double-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag extractFloat64Sign( float64 a )
958e1b
+static inline flag extractFloat64Sign( float64 a )
958e1b
 {
958e1b
 
958e1b
     return float64_val(a)>>63;
958e1b
@@ -462,7 +462,7 @@ static void
958e1b
 | significand.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
958e1b
+static inline float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
958e1b
 {
958e1b
 
958e1b
     return make_float64(
958e1b
@@ -572,7 +572,7 @@ static float64
958e1b
 | value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint64_t extractFloatx80Frac( floatx80 a )
958e1b
+static inline uint64_t extractFloatx80Frac( floatx80 a )
958e1b
 {
958e1b
 
958e1b
     return a.low;
958e1b
@@ -584,7 +584,7 @@ INLINE uint64_t extractFloatx80Frac( floatx80 a )
958e1b
 | value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE int32 extractFloatx80Exp( floatx80 a )
958e1b
+static inline int32 extractFloatx80Exp( floatx80 a )
958e1b
 {
958e1b
 
958e1b
     return a.high & 0x7FFF;
958e1b
@@ -596,7 +596,7 @@ INLINE int32 extractFloatx80Exp( floatx80 a )
958e1b
 | `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag extractFloatx80Sign( floatx80 a )
958e1b
+static inline flag extractFloatx80Sign( floatx80 a )
958e1b
 {
958e1b
 
958e1b
     return a.high>>15;
958e1b
@@ -626,7 +626,7 @@ static void
958e1b
 | extended double-precision floating-point value, returning the result.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
958e1b
+static inline floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
958e1b
 {
958e1b
     floatx80 z;
958e1b
 
958e1b
@@ -857,7 +857,7 @@ static floatx80
958e1b
 | floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint64_t extractFloat128Frac1( float128 a )
958e1b
+static inline uint64_t extractFloat128Frac1( float128 a )
958e1b
 {
958e1b
 
958e1b
     return a.low;
958e1b
@@ -869,7 +869,7 @@ INLINE uint64_t extractFloat128Frac1( float128 a )
958e1b
 | floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE uint64_t extractFloat128Frac0( float128 a )
958e1b
+static inline uint64_t extractFloat128Frac0( float128 a )
958e1b
 {
958e1b
 
958e1b
     return a.high & LIT64( 0x0000FFFFFFFFFFFF );
958e1b
@@ -881,7 +881,7 @@ INLINE uint64_t extractFloat128Frac0( float128 a )
958e1b
 | `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE int32 extractFloat128Exp( float128 a )
958e1b
+static inline int32 extractFloat128Exp( float128 a )
958e1b
 {
958e1b
 
958e1b
     return ( a.high>>48 ) & 0x7FFF;
958e1b
@@ -892,7 +892,7 @@ INLINE int32 extractFloat128Exp( float128 a )
958e1b
 | Returns the sign bit of the quadruple-precision floating-point value `a'.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE flag extractFloat128Sign( float128 a )
958e1b
+static inline flag extractFloat128Sign( float128 a )
958e1b
 {
958e1b
 
958e1b
     return a.high>>63;
958e1b
@@ -953,7 +953,7 @@ static void
958e1b
 | significand.
958e1b
 *----------------------------------------------------------------------------*/
958e1b
 
958e1b
-INLINE float128
958e1b
+static inline float128
958e1b
  packFloat128( flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 )
958e1b
 {
958e1b
     float128 z;
958e1b
@@ -6560,7 +6560,7 @@ uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)
958e1b
 }
958e1b
 
958e1b
 #define COMPARE(s, nan_exp)                                                  \
958e1b
-INLINE int float ## s ## _compare_internal( float ## s a, float ## s b,      \
958e1b
+static inline int float ## s ## _compare_internal( float ## s a, float ## s b,      \
958e1b
                                       int is_quiet STATUS_PARAM )            \
958e1b
 {                                                                            \
958e1b
     flag aSign, bSign;                                                       \
958e1b
@@ -6612,7 +6612,7 @@ int float ## s ## _compare_quiet( float ## s a, float ## s b STATUS_PARAM )  \
958e1b
 COMPARE(32, 0xff)
958e1b
 COMPARE(64, 0x7ff)
958e1b
 
958e1b
-INLINE int floatx80_compare_internal( floatx80 a, floatx80 b,
958e1b
+static inline int floatx80_compare_internal( floatx80 a, floatx80 b,
958e1b
                                       int is_quiet STATUS_PARAM )
958e1b
 {
958e1b
     flag aSign, bSign;
958e1b
@@ -6658,7 +6658,7 @@ int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )
958e1b
     return floatx80_compare_internal(a, b, 1 STATUS_VAR);
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_compare_internal( float128 a, float128 b,
958e1b
+static inline int float128_compare_internal( float128 a, float128 b,
958e1b
                                       int is_quiet STATUS_PARAM )
958e1b
 {
958e1b
     flag aSign, bSign;
958e1b
@@ -6707,7 +6707,7 @@ int float128_compare_quiet( float128 a, float128 b STATUS_PARAM )
958e1b
  * NaNs and +0 vs -0.
958e1b
  */
958e1b
 #define MINMAX(s, nan_exp)                                              \
958e1b
-INLINE float ## s float ## s ## _minmax(float ## s a, float ## s b,     \
958e1b
+static inline  float ## s float ## s ## _minmax(float ## s a, float ## s b,     \
958e1b
                                         int ismin STATUS_PARAM )        \
958e1b
 {                                                                       \
958e1b
     flag aSign, bSign;                                                  \
958e1b
diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
958e1b
index f3927e2..de4940c 100644
958e1b
--- a/include/fpu/softfloat.h
958e1b
+++ b/include/fpu/softfloat.h
958e1b
@@ -63,7 +63,6 @@ typedef uint64_t uint64;
958e1b
 typedef int64_t int64;
958e1b
 
958e1b
 #define LIT64( a ) a##LL
958e1b
-#define INLINE static inline
958e1b
 
958e1b
 #define STATUS_PARAM , float_status *status
958e1b
 #define STATUS(field) status->field
958e1b
@@ -182,23 +181,23 @@ typedef struct float_status {
958e1b
 
958e1b
 void set_float_rounding_mode(int val STATUS_PARAM);
958e1b
 void set_float_exception_flags(int val STATUS_PARAM);
958e1b
-INLINE void set_float_detect_tininess(int val STATUS_PARAM)
958e1b
+static inline void set_float_detect_tininess(int val STATUS_PARAM)
958e1b
 {
958e1b
     STATUS(float_detect_tininess) = val;
958e1b
 }
958e1b
-INLINE void set_flush_to_zero(flag val STATUS_PARAM)
958e1b
+static inline void set_flush_to_zero(flag val STATUS_PARAM)
958e1b
 {
958e1b
     STATUS(flush_to_zero) = val;
958e1b
 }
958e1b
-INLINE void set_flush_inputs_to_zero(flag val STATUS_PARAM)
958e1b
+static inline void set_flush_inputs_to_zero(flag val STATUS_PARAM)
958e1b
 {
958e1b
     STATUS(flush_inputs_to_zero) = val;
958e1b
 }
958e1b
-INLINE void set_default_nan_mode(flag val STATUS_PARAM)
958e1b
+static inline void set_default_nan_mode(flag val STATUS_PARAM)
958e1b
 {
958e1b
     STATUS(default_nan_mode) = val;
958e1b
 }
958e1b
-INLINE int get_float_exception_flags(float_status *status)
958e1b
+static inline int get_float_exception_flags(float_status *status)
958e1b
 {
958e1b
     return STATUS(float_exception_flags);
958e1b
 }
958e1b
@@ -252,7 +251,7 @@ int float16_is_quiet_nan( float16 );
958e1b
 int float16_is_signaling_nan( float16 );
958e1b
 float16 float16_maybe_silence_nan( float16 );
958e1b
 
958e1b
-INLINE int float16_is_any_nan(float16 a)
958e1b
+static inline int float16_is_any_nan(float16 a)
958e1b
 {
958e1b
     return ((float16_val(a) & ~0x8000) > 0x7c00);
958e1b
 }
958e1b
@@ -307,7 +306,7 @@ int float32_is_signaling_nan( float32 );
958e1b
 float32 float32_maybe_silence_nan( float32 );
958e1b
 float32 float32_scalbn( float32, int STATUS_PARAM );
958e1b
 
958e1b
-INLINE float32 float32_abs(float32 a)
958e1b
+static inline float32 float32_abs(float32 a)
958e1b
 {
958e1b
     /* Note that abs does *not* handle NaN specially, nor does
958e1b
      * it flush denormal inputs to zero.
958e1b
@@ -315,7 +314,7 @@ INLINE float32 float32_abs(float32 a)
958e1b
     return make_float32(float32_val(a) & 0x7fffffff);
958e1b
 }
958e1b
 
958e1b
-INLINE float32 float32_chs(float32 a)
958e1b
+static inline float32 float32_chs(float32 a)
958e1b
 {
958e1b
     /* Note that chs does *not* handle NaN specially, nor does
958e1b
      * it flush denormal inputs to zero.
958e1b
@@ -323,32 +322,32 @@ INLINE float32 float32_chs(float32 a)
958e1b
     return make_float32(float32_val(a) ^ 0x80000000);
958e1b
 }
958e1b
 
958e1b
-INLINE int float32_is_infinity(float32 a)
958e1b
+static inline int float32_is_infinity(float32 a)
958e1b
 {
958e1b
     return (float32_val(a) & 0x7fffffff) == 0x7f800000;
958e1b
 }
958e1b
 
958e1b
-INLINE int float32_is_neg(float32 a)
958e1b
+static inline int float32_is_neg(float32 a)
958e1b
 {
958e1b
     return float32_val(a) >> 31;
958e1b
 }
958e1b
 
958e1b
-INLINE int float32_is_zero(float32 a)
958e1b
+static inline int float32_is_zero(float32 a)
958e1b
 {
958e1b
     return (float32_val(a) & 0x7fffffff) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int float32_is_any_nan(float32 a)
958e1b
+static inline int float32_is_any_nan(float32 a)
958e1b
 {
958e1b
     return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
958e1b
 }
958e1b
 
958e1b
-INLINE int float32_is_zero_or_denormal(float32 a)
958e1b
+static inline int float32_is_zero_or_denormal(float32 a)
958e1b
 {
958e1b
     return (float32_val(a) & 0x7f800000) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE float32 float32_set_sign(float32 a, int sign)
958e1b
+static inline float32 float32_set_sign(float32 a, int sign)
958e1b
 {
958e1b
     return make_float32((float32_val(a) & 0x7fffffff) | (sign << 31));
958e1b
 }
958e1b
@@ -413,7 +412,7 @@ int float64_is_signaling_nan( float64 );
958e1b
 float64 float64_maybe_silence_nan( float64 );
958e1b
 float64 float64_scalbn( float64, int STATUS_PARAM );
958e1b
 
958e1b
-INLINE float64 float64_abs(float64 a)
958e1b
+static inline float64 float64_abs(float64 a)
958e1b
 {
958e1b
     /* Note that abs does *not* handle NaN specially, nor does
958e1b
      * it flush denormal inputs to zero.
958e1b
@@ -421,7 +420,7 @@ INLINE float64 float64_abs(float64 a)
958e1b
     return make_float64(float64_val(a) & 0x7fffffffffffffffLL);
958e1b
 }
958e1b
 
958e1b
-INLINE float64 float64_chs(float64 a)
958e1b
+static inline float64 float64_chs(float64 a)
958e1b
 {
958e1b
     /* Note that chs does *not* handle NaN specially, nor does
958e1b
      * it flush denormal inputs to zero.
958e1b
@@ -429,32 +428,32 @@ INLINE float64 float64_chs(float64 a)
958e1b
     return make_float64(float64_val(a) ^ 0x8000000000000000LL);
958e1b
 }
958e1b
 
958e1b
-INLINE int float64_is_infinity(float64 a)
958e1b
+static inline int float64_is_infinity(float64 a)
958e1b
 {
958e1b
     return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
958e1b
 }
958e1b
 
958e1b
-INLINE int float64_is_neg(float64 a)
958e1b
+static inline int float64_is_neg(float64 a)
958e1b
 {
958e1b
     return float64_val(a) >> 63;
958e1b
 }
958e1b
 
958e1b
-INLINE int float64_is_zero(float64 a)
958e1b
+static inline int float64_is_zero(float64 a)
958e1b
 {
958e1b
     return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int float64_is_any_nan(float64 a)
958e1b
+static inline int float64_is_any_nan(float64 a)
958e1b
 {
958e1b
     return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
958e1b
 }
958e1b
 
958e1b
-INLINE int float64_is_zero_or_denormal(float64 a)
958e1b
+static inline int float64_is_zero_or_denormal(float64 a)
958e1b
 {
958e1b
     return (float64_val(a) & 0x7ff0000000000000LL) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE float64 float64_set_sign(float64 a, int sign)
958e1b
+static inline float64 float64_set_sign(float64 a, int sign)
958e1b
 {
958e1b
     return make_float64((float64_val(a) & 0x7fffffffffffffffULL)
958e1b
                         | ((int64_t)sign << 63));
958e1b
@@ -508,39 +507,39 @@ int floatx80_is_signaling_nan( floatx80 );
958e1b
 floatx80 floatx80_maybe_silence_nan( floatx80 );
958e1b
 floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM );
958e1b
 
958e1b
-INLINE floatx80 floatx80_abs(floatx80 a)
958e1b
+static inline floatx80 floatx80_abs(floatx80 a)
958e1b
 {
958e1b
     a.high &= 0x7fff;
958e1b
     return a;
958e1b
 }
958e1b
 
958e1b
-INLINE floatx80 floatx80_chs(floatx80 a)
958e1b
+static inline floatx80 floatx80_chs(floatx80 a)
958e1b
 {
958e1b
     a.high ^= 0x8000;
958e1b
     return a;
958e1b
 }
958e1b
 
958e1b
-INLINE int floatx80_is_infinity(floatx80 a)
958e1b
+static inline int floatx80_is_infinity(floatx80 a)
958e1b
 {
958e1b
     return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL;
958e1b
 }
958e1b
 
958e1b
-INLINE int floatx80_is_neg(floatx80 a)
958e1b
+static inline int floatx80_is_neg(floatx80 a)
958e1b
 {
958e1b
     return a.high >> 15;
958e1b
 }
958e1b
 
958e1b
-INLINE int floatx80_is_zero(floatx80 a)
958e1b
+static inline int floatx80_is_zero(floatx80 a)
958e1b
 {
958e1b
     return (a.high & 0x7fff) == 0 && a.low == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int floatx80_is_zero_or_denormal(floatx80 a)
958e1b
+static inline int floatx80_is_zero_or_denormal(floatx80 a)
958e1b
 {
958e1b
     return (a.high & 0x7fff) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int floatx80_is_any_nan(floatx80 a)
958e1b
+static inline int floatx80_is_any_nan(floatx80 a)
958e1b
 {
958e1b
     return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
958e1b
 }
958e1b
@@ -593,39 +592,39 @@ int float128_is_signaling_nan( float128 );
958e1b
 float128 float128_maybe_silence_nan( float128 );
958e1b
 float128 float128_scalbn( float128, int STATUS_PARAM );
958e1b
 
958e1b
-INLINE float128 float128_abs(float128 a)
958e1b
+static inline float128 float128_abs(float128 a)
958e1b
 {
958e1b
     a.high &= 0x7fffffffffffffffLL;
958e1b
     return a;
958e1b
 }
958e1b
 
958e1b
-INLINE float128 float128_chs(float128 a)
958e1b
+static inline float128 float128_chs(float128 a)
958e1b
 {
958e1b
     a.high ^= 0x8000000000000000LL;
958e1b
     return a;
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_is_infinity(float128 a)
958e1b
+static inline int float128_is_infinity(float128 a)
958e1b
 {
958e1b
     return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_is_neg(float128 a)
958e1b
+static inline int float128_is_neg(float128 a)
958e1b
 {
958e1b
     return a.high >> 63;
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_is_zero(float128 a)
958e1b
+static inline int float128_is_zero(float128 a)
958e1b
 {
958e1b
     return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_is_zero_or_denormal(float128 a)
958e1b
+static inline int float128_is_zero_or_denormal(float128 a)
958e1b
 {
958e1b
     return (a.high & 0x7fff000000000000LL) == 0;
958e1b
 }
958e1b
 
958e1b
-INLINE int float128_is_any_nan(float128 a)
958e1b
+static inline int float128_is_any_nan(float128 a)
958e1b
 {
958e1b
     return ((a.high >> 48) & 0x7fff) == 0x7fff &&
958e1b
         ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
958e1b
-- 
958e1b
2.1.0
958e1b