Needed on s390x, to test for the data class of a number. So it will
gain soon a user.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/fpu/softfloat.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
index 38a5e99cf3..10c31557b4 100644
--- a/include/fpu/softfloat.h
+++ b/include/fpu/softfloat.h
@@ -940,6 +940,16 @@ static inline int float128_is_zero_or_denormal(float128 a)
     return (a.high & 0x7fff000000000000LL) == 0;
 }
 
+static inline bool float128_is_normal(float128 a)
+{
+    return ((a.high + (1ULL << 47)) & -1ULL >> 1) >= 1ULL << 48;
+}
+
+static inline bool float128_is_denormal(float128 a)
+{
+    return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
+}
+
 static inline int float128_is_any_nan(float128 a)
 {
     return ((a.high >> 48) & 0x7fff) == 0x7fff &&
-- 
2.17.2

On 2/5/19 4:22 PM, David Hildenbrand wrote:
> +static inline bool float128_is_normal(float128 a)
> +{
> +    return ((a.high + (1ULL << 47)) & -1ULL >> 1) >= 1ULL << 48;

I believe this is off by one: 1 << 48 and >= 1 << 49.

The exponent is at [62:48].  The trick is adding 1, letting Inf+NaN overflow
into the sign, masking out the sign, and checking that the result >= 2 to
eliminate Inf+NaN (0) and Zero+Denormal (1).

I think this is clearer as

  (((a.high >> 48) + 1) & 0x7fff) >= 2.

It might be worth applying this to the other formats for clarity...


r~

On 06.02.19 04:08, Richard Henderson wrote:
> On 2/5/19 4:22 PM, David Hildenbrand wrote:
>> +static inline bool float128_is_normal(float128 a)
>> +{
>> +    return ((a.high + (1ULL << 47)) & -1ULL >> 1) >= 1ULL << 48;
> 
> I believe this is off by one: 1 << 48 and >= 1 << 49.
> 
> The exponent is at [62:48].  The trick is adding 1, letting Inf+NaN overflow
> into the sign, masking out the sign, and checking that the result >= 2 to
> eliminate Inf+NaN (0) and Zero+Denormal (1).

Right, the exponent must not be 0 or all 1's. so after adding 1, it must
be >=2.

Yesterday it all made sense on my sheet of paper :) Let's verify against
float64

float64 has an exponent of 11:

return ((float64_val(a) + (1ULL << 52)) & -1ULL >> 1) >= 1ULL << 53;

float128 has an exponent of 15, the difference is 4. So 52 -> 48, 53 -> 49.

So you're right.

> 
> I think this is clearer as
> 
>   (((a.high >> 48) + 1) & 0x7fff) >= 2.>
> It might be worth applying this to the other formats for clarity...
> 

Yes, this makes it much clearer, will send a patch for the others as
well, thanks!

> 
> r~
> 


-- 

Thanks,

David / dhildenb