Skip to contentSkip to conversation

fpu: Simplify floatx80ToCommonNaN function.

PATCH In review Thomas Schwinge 4 participants 7 messages May 31, 2013 – Jun 3, 2013

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 fpu: Simplify floatx80ToCommonNaN function.

---
 fpu/softfloat-specialize.h |   15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)
softfloat-specialize.h +7 -8
index 518f694..83add1a 100644
@@ -934,15 +934,14 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
     commonNaNT z;
 
     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
-    if ( a.low >> 63 ) {
-        z.sign = a.high >> 15;
-        z.low = 0;
-        z.high = a.low << 1;
-    } else {
-        z.sign = floatx80_default_nan_high >> 15;
-        z.low = 0;
-        z.high = floatx80_default_nan_low << 1;
+    /* Replace a Pseudo NaN with a default NaN.  */
+    if (!(a.low >> 63)) {
+        a.low = floatx80_default_nan_low;
+        a.high = floatx80_default_nan_high;
     }
+    z.sign = a.high >> 15;
+    z.low = 0;
+    z.high = a.low << 1;
     return z;
 }
 
Signature · 1 line
1.7.10.4
#1 lore raw
Quoted 21 lines · Thomas Schwinge
---
 fpu/softfloat-specialize.h |   15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)
softfloat-specialize.h +0 -8
index 518f694..83add1a 100644
@@ -934,15 +934,14 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
     commonNaNT z;
 
     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
-    if ( a.low >> 63 ) {
-        z.sign = a.high >> 15;
-        z.low = 0;
-        z.high = a.low << 1;
-    } else {
-        z.sign = floatx80_default_nan_high >> 15;
-        z.low = 0;
-        z.high = floatx80_default_nan_low << 1;

softfloat-specialize.h static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM) · line 946

Quoted 10 lines
softfloat-specialize.h +7 -0
+    /* Replace a Pseudo NaN with a default NaN.  */
+    if (!(a.low >> 63)) {
+        a.low = floatx80_default_nan_low;
+        a.high = floatx80_default_nan_high;
     }
+    z.sign = a.high >> 15;
+    z.low = 0;
+    z.high = a.low << 1;
     return z;
 }

Hmm. And where's the simplification? Here's context diff for the same:

*** fpu/softfloat-specialize.h.orig 2013-05-31 16:02:51.614710351 +0400
--- fpu/softfloat-specialize.h 2013-05-31 16:02:59.838820308 +0400
***************
*** 936,946 ****

      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     if ( a.low >> 63 ) {
!         z.sign = a.high >> 15;
!         z.low = 0;
!         z.high = a.low << 1;
!     } else {
!         z.sign = floatx80_default_nan_high >> 15;
!         z.low = 0;
!         z.high = floatx80_default_nan_low << 1;
      }
      return z;
--- 936,945 ----
      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     /* Replace a Pseudo NaN with a default NaN.  */
!     if (!(a.low >> 63)) {
!         a.low = floatx80_default_nan_low;
!         a.high = floatx80_default_nan_high;
      }
+     z.sign = a.high >> 15;
+     z.low = 0;
+     z.high = a.low << 1;
      return z;

Yes, your version is 3 lines shorter, because it does not have extra else{} (2 lines) and the remaining if() construct is one line shorter too, due to moving z.low=0 construct into common place.

But I don't think your version is more readable, -- before it was easy to understand what is going on, we had two easy case with all right stuff done for each case. Now we do some preparation before, so the common case works.

Generated code should be about the same anyway, but to me (IMHO!), original code is a bit more readable.

Thanks,

/mjt

#2 lore raw

Il 31/05/2013 14:07, Michael Tokarev ha scritto:

Quoted 68 lines
Quoted 21 lines · Thomas Schwinge
---
 fpu/softfloat-specialize.h |   15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)
softfloat-specialize.h +0 -8
index 518f694..83add1a 100644
@@ -934,15 +934,14 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
     commonNaNT z;
 
     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
-    if ( a.low >> 63 ) {
-        z.sign = a.high >> 15;
-        z.low = 0;
-        z.high = a.low << 1;
-    } else {
-        z.sign = floatx80_default_nan_high >> 15;
-        z.low = 0;
-        z.high = floatx80_default_nan_low << 1;

softfloat-specialize.h static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM) · line 946

Quoted 10 lines
softfloat-specialize.h +7 -0
+    /* Replace a Pseudo NaN with a default NaN.  */
+    if (!(a.low >> 63)) {
+        a.low = floatx80_default_nan_low;
+        a.high = floatx80_default_nan_high;
     }
+    z.sign = a.high >> 15;
+    z.low = 0;
+    z.high = a.low << 1;
     return z;
 }

Hmm. And where's the simplification? Here's context diff for the same:

*** fpu/softfloat-specialize.h.orig 2013-05-31 16:02:51.614710351 +0400
--- fpu/softfloat-specialize.h 2013-05-31 16:02:59.838820308 +0400
***************
*** 936,946 ****

      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     if ( a.low >> 63 ) {
!         z.sign = a.high >> 15;
!         z.low = 0;
!         z.high = a.low << 1;
!     } else {
!         z.sign = floatx80_default_nan_high >> 15;
!         z.low = 0;
!         z.high = floatx80_default_nan_low << 1;
      }
      return z;
--- 936,945 ----
      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     /* Replace a Pseudo NaN with a default NaN.  */
!     if (!(a.low >> 63)) {
!         a.low = floatx80_default_nan_low;
!         a.high = floatx80_default_nan_high;
      }
softfloat-specialize.h +3 -0
+     z.sign = a.high >> 15;
+     z.low = 0;
+     z.high = a.low << 1;
      return z;

Yes, your version is 3 lines shorter, because it does not have extra else{} (2 lines) and the remaining if() construct is one line shorter too, due to moving z.low=0 construct into common place.

Quoted 8 lines

But I don't think your version is more readable, -- before it was easy to understand what is going on, we had two easy case with all right stuff done for each case. Now we do some preparation before, so the common case works.

Generated code should be about the same anyway, but to me (IMHO!), original code is a bit more readable.

I agree. It's also not trivial.

Paolo

#3 lore raw
In reply to Michael Tokarev
Quoted 35 lines · Michael Tokarev

Hmm. And where's the simplification? Here's context diff for the same:

*** fpu/softfloat-specialize.h.orig 2013-05-31 16:02:51.614710351 +0400
--- fpu/softfloat-specialize.h 2013-05-31 16:02:59.838820308 +0400
***************
*** 936,946 ****

      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     if ( a.low >> 63 ) {
!         z.sign = a.high >> 15;
!         z.low = 0;
!         z.high = a.low << 1;
!     } else {
!         z.sign = floatx80_default_nan_high >> 15;
!         z.low = 0;
!         z.high = floatx80_default_nan_low << 1;
      }
      return z;
--- 936,945 ----
      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     /* Replace a Pseudo NaN with a default NaN.  */
!     if (!(a.low >> 63)) {
!         a.low = floatx80_default_nan_low;
!         a.high = floatx80_default_nan_high;
      }
softfloat-specialize.h +3 -0
+     z.sign = a.high >> 15;
+     z.low = 0;
+     z.high = a.low << 1;
      return z;

Yes, your version is 3 lines shorter, because it does not have extra else{} (2 lines) and the remaining if() construct is one line shorter too, due to moving z.low=0 construct into common place.

Quoted 5 lines

But I don't think your version is more readable, -- before it was easy to understand what is going on, we had two easy case with all right stuff done for each case. Now we do some preparation before, so the common case works.

I think you could make a reasonable argument for this change being an improvement, because it makes it clear what we're doing: if what we have is an x86 pseudo-NaN, we replace it with the 80-bit default NaN, and then proceed to do 80-bit-to-canonical conversion in the usual way. The comment also explains why this if() exists for the 80 bit case when it doesn't for the equivalent 32 bit and 64 bit functions. As a code change I actually quite like it.

Quoted 1 line

Generated code should be about the same anyway

NaN handling is well out of the fast path, so this isn't particularly important.

That said, I think any new patches to fpu/ need to come with an explicit statement that they can be licensed under the softfloat-2a license or GPLv2 or BSD (etc etc) so they aren't an obstacle to the softfloat-2a-to-2b conversion that is in the works. [cc'd Anthony so he can correct me if I'm wrong.]

thanks
-- PMM

#4 lore raw

Hi!

Quoted 42 lines · Peter Maydell
Quoted 35 lines · Michael Tokarev

Hmm. And where's the simplification? Here's context diff for the same:

*** fpu/softfloat-specialize.h.orig 2013-05-31 16:02:51.614710351 +0400
--- fpu/softfloat-specialize.h 2013-05-31 16:02:59.838820308 +0400
***************
*** 936,946 ****

      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     if ( a.low >> 63 ) {
!         z.sign = a.high >> 15;
!         z.low = 0;
!         z.high = a.low << 1;
!     } else {
!         z.sign = floatx80_default_nan_high >> 15;
!         z.low = 0;
!         z.high = floatx80_default_nan_low << 1;
      }
      return z;
--- 936,945 ----
      if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
!     /* Replace a Pseudo NaN with a default NaN.  */
!     if (!(a.low >> 63)) {
!         a.low = floatx80_default_nan_low;
!         a.high = floatx80_default_nan_high;
      }
softfloat-specialize.h +3 -0
+     z.sign = a.high >> 15;
+     z.low = 0;
+     z.high = a.low << 1;
      return z;

Yes, your version is 3 lines shorter, because it does not have extra else{} (2 lines) and the remaining if() construct is one line shorter too, due to moving z.low=0 construct into common place.

Quoted 5 lines

But I don't think your version is more readable, -- before it was easy to understand what is going on, we had two easy case with all right stuff done for each case. Now we do some preparation before, so the common case works.

Quoted 9 lines

I think you could make a reasonable argument for this change being an improvement, because it makes it clear what we're doing: if what we have is an x86 pseudo-NaN, we replace it with the 80-bit default NaN, and then proceed to do 80-bit-to-canonical conversion in the usual way. The comment also explains why this if() exists for the 80 bit case when it doesn't for the equivalent 32 bit and 64 bit functions. As a code change I actually quite like it.

Yes, this exactly is my reasoning: first, convert a x86 Pseudo NaN into a generic NaN, then do the floating-point type conversion itself). I thought this would be obvious (and hence the patch trivial) -- hey, I even added a comment! -- but apparently what is obvious/trivial to one isn't to the other. :-)

Quoted 6 lines

That said, I think any new patches to fpu/ need to come with an explicit statement that they can be licensed under the softfloat-2a license or GPLv2 or BSD (etc etc) so they aren't an obstacle to the softfloat-2a-to-2b conversion that is in the works. [cc'd Anthony so he can correct me if I'm wrong.]

I hereby place this one contribution (which I think wouldn't constitute a copyrightable change anyway) into the Public Domain, allowing any kind of usage.

Grüße,
Thomas

Reviewed-by
#5 lore raw
Quoted 11 lines · Thomas Schwinge
Quoted 6 lines · Peter Maydell

That said, I think any new patches to fpu/ need to come with an explicit statement that they can be licensed under the softfloat-2a license or GPLv2 or BSD (etc etc) so they aren't an obstacle to the softfloat-2a-to-2b conversion that is in the works. [cc'd Anthony so he can correct me if I'm wrong.]

I hereby place this one contribution (which I think wouldn't constitute a copyrightable change anyway) into the Public Domain, allowing any kind of usage.

I think we'd generally suggest creative commons CC0 as being in less of a legally grey area internationally than "public domain", if you're happy with that.

Either way,

thanks
-- PMM

#6 lore raw

Hi!

Quoted 9 lines · Peter Maydell
Quoted 8 lines · Thomas Schwinge
Quoted 6 lines · Peter Maydell

That said, I think any new patches to fpu/ need to come with an explicit statement that they can be licensed under the softfloat-2a license or GPLv2 or BSD (etc etc) so they aren't an obstacle to the softfloat-2a-to-2b conversion that is in the works. [cc'd Anthony so he can correct me if I'm wrong.]

Quoted 7 lines
Quoted 3 lines

I hereby place this one contribution (which I think wouldn't constitute a copyrightable change anyway) into the Public Domain, allowing any kind of usage.

I think we'd generally suggest creative commons CC0 as being in less of a legally grey area internationally than "public domain", if you're happy with that.

Using Creative Commons' CC0 is likewise fine.

Quoted 3 lines

Either way,

Thanks.

Oh, and as I saw you wondering in the QEMU IRC channel, why I had bothered with this change anyway, the reason is that I have some further SoftFloat changes forthcoming, and in the course of these stumbled over that oddity in the floatx80ToCommonNaN function, and already submitted that one separately asnot related to my other changes.

Grüße,
Thomas