Added issignaling and optimized some softfloat routines

Author: ZERICO2005

src/libc/include/__math_def.h

@@ -44,19 +44,21 @@ extern "C" {
 int _fpclassifyf(float) __NOEXCEPT_CONST;
 int _fpclassifyl(long double) __NOEXCEPT_CONST;
 
-bool _isinff(float) __NOEXCEPT_CONST;
+bool _issignalingf(float) __NOEXCEPT_CONST;
 bool _isnanf(float) __NOEXCEPT_CONST;
-bool _isnormalf(float) __NOEXCEPT_CONST;
+bool _isinff(float) __NOEXCEPT_CONST;
 bool _isfinitef(float) __NOEXCEPT_CONST;
-bool _iszerof(float) __NOEXCEPT_CONST;
+bool _isnormalf(float) __NOEXCEPT_CONST;
 bool _issubnormalf(float) __NOEXCEPT_CONST;
+bool _iszerof(float) __NOEXCEPT_CONST;
 
-bool _isinfl(long double) __NOEXCEPT_CONST;
+bool _issignalingl(long double) __NOEXCEPT_CONST;
 bool _isnanl(long double) __NOEXCEPT_CONST;
-bool _isnormall(long double) __NOEXCEPT_CONST;
+bool _isinfl(long double) __NOEXCEPT_CONST;
 bool _isfinitel(long double) __NOEXCEPT_CONST;
-bool _iszerol(long double) __NOEXCEPT_CONST;
+bool _isnormall(long double) __NOEXCEPT_CONST;
 bool _issubnormall(long double) __NOEXCEPT_CONST;
+bool _iszerol(long double) __NOEXCEPT_CONST;
 
 #if 0
 /* disabled until builtin is optimized */

src/libc/include/math.h

@@ -21,10 +21,10 @@
     float: _signbitf \
 )(x))
 
-#define isinf(x) ((int)_Generic(__math_promote(x), \
-    long double: _isinfl, \
-    default: _isinff, \
-    float: _isinff \
+#define issignaling(x) ((int)_Generic(__math_promote(x), \
+    long double: _issignalingl, \
+    default: _issignalingf, \
+    float: _issignalingf \
 )(x))
 
 #define isnan(x) ((int)_Generic(__math_promote(x), \
@@ -33,10 +33,11 @@
     float: _isnanf \
 )(x))
 
-#define isnormal(x) ((int)_Generic(__math_promote(x), \
-    long double: _isnormall, \
-    default: _isnormalf, \
-    float: _isnormalf \
+
+#define isinf(x) ((int)_Generic(__math_promote(x), \
+    long double: _isinfl, \
+    default: _isinff, \
+    float: _isinff \
 )(x))
 
 #define isfinite(x) ((int)_Generic(__math_promote(x), \
@@ -45,10 +46,10 @@
     float: _isfinitef \
 )(x))
 
-#define iszero(x) ((int)_Generic(__math_promote(x), \
-    long double: _iszerol, \
-    default: _iszerof, \
-    float: _iszerof \
+#define isnormal(x) ((int)_Generic(__math_promote(x), \
+    long double: _isnormall, \
+    default: _isnormalf, \
+    float: _isnormalf \
 )(x))
 
 #define issubnormal(x) ((int)_Generic(__math_promote(x), \
@@ -57,6 +58,12 @@
     float: _issubnormalf \
 )(x))
 
+#define iszero(x) ((int)_Generic(__math_promote(x), \
+    long double: _iszerol, \
+    default: _iszerof, \
+    float: _iszerof \
+)(x))
+
 #define fpclassify(x) ((int)_Generic(__math_promote(x), \
     long double: _fpclassifyl, \
     default: _fpclassifyf, \

src/libc/issignalingf.src

@@ -0,0 +1,30 @@
+	assume	adl=1
+
+	section	.text
+
+	public	__issignalingf
+
+; assumes quiet NaN is 0x7FC00000 or 0xFFC00000
+; bool _issignalingf(float)
+__issignalingf:
+	; based off __isnanf, unoptimized
+	xor	a, a
+	ld	iy, 0
+	add	iy, sp
+	ld	hl, (iy + 3)
+	adc	hl, hl
+	ret	z	; infinity
+	ld	a, (iy + 6)
+	rla
+
+	or	a, a
+	adc	hl, hl
+	jr	z, .quiet_nan
+
+	add	a, 1	; attempt to overflow the exponent
+	sbc	a, a
+	ret
+
+.quiet_nan:
+	xor	a, a
+	ret

src/libc/issignalingl.src

@@ -0,0 +1,34 @@
+	assume	adl=1
+
+	section	.text
+
+	public	__issignalingl
+
+; assumes quiet NaN is 0x7FF8000000000000 or 0xFFF8000000000000
+; bool _issignalingl(long double)
+__issignalingl:
+	; based off __isnanl, unoptimized
+	pop	bc, hl, de
+	xor	a, a
+	adc	hl, de
+	pop	de
+	push	bc, bc, bc, bc
+	ld	a, e
+	jr	nz, .mant_nonzero	; normal, subnormal, or NaN
+	jr	c, .mant_nonzero	; normal, subnormal, or NaN
+	; common NaN, inf, normal, or subnormal
+	; quiet NaN will be along this path
+	xor	a, $F8
+	ret	z	; quiet NaN
+	xor	a, $F8
+	ret	z
+	dec	a
+.mant_nonzero:
+	add	a, 16	; overflows 0xF0
+	sbc	a, a
+	ret	z
+	ld	a, d
+	add	a, a
+	add	a, 2
+	sbc	a, a
+	ret

src/libcxx/include/cmath

@@ -34,27 +34,18 @@ template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
 signbit(_Tp __x) { return (__x < 0); }
 
-inline constexpr bool isinf(float __x) {
-    if (__builtin_constant_p(__x)) {
-        return __builtin_isinf(__x);
-    }
-    return _isinff(__x);
+inline constexpr bool issignaling(float __x) {
+    return _issignalingf(__x);
 }
-inline constexpr bool isinf(double __x) {
-    if (__builtin_constant_p(__x)) {
-        return __builtin_isinf(__x);
-    }
-    return _isinff(__x);
+inline constexpr bool issignaling(double __x) {
+    return _issignalingf(__x);
 }
-inline constexpr bool isinf(long double __x) {
-    if (__builtin_constant_p(__x)) {
-        return __builtin_isinf(__x);
-    }
-    return _isinfl(__x);
+inline constexpr bool issignaling(long double __x) {
+    return _issignalingl(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
-isinf(_Tp __x) { return false; }
+issignaling(_Tp __x) { return false; }
 
 inline constexpr bool isnan(float __x) {
     if (__builtin_constant_p(__x)) {
@@ -78,27 +69,27 @@ template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
 isnan(_Tp __x) { return false; }
 
-inline constexpr bool isnormal(float __x) {
+inline constexpr bool isinf(float __x) {
     if (__builtin_constant_p(__x)) {
-        return __builtin_isnormal(__x);
+        return __builtin_isinf(__x);
     }
-    return _isnormalf(__x);
+    return _isinff(__x);
 }
-inline constexpr bool isnormal(double __x) {
+inline constexpr bool isinf(double __x) {
     if (__builtin_constant_p(__x)) {
-        return __builtin_isnormal(__x);
+        return __builtin_isinf(__x);
     }
-    return _isnormalf(__x);
+    return _isinff(__x);
 }
-inline constexpr bool isnormal(long double __x) {
+inline constexpr bool isinf(long double __x) {
     if (__builtin_constant_p(__x)) {
-        return __builtin_isnormal(__x);
+        return __builtin_isinf(__x);
     }
-    return _isnormall(__x);
+    return _isinfl(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
-isnormal(_Tp __x) { return (__x != 0); }
+isinf(_Tp __x) { return false; }
 
 inline constexpr bool isfinite(float __x) {
     if (__builtin_constant_p(__x)) {
@@ -122,27 +113,27 @@ template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
 isfinite(_Tp __x) { return true; }
 
-inline constexpr bool iszero(float __x) {
+inline constexpr bool isnormal(float __x) {
     if (__builtin_constant_p(__x)) {
-        return (__x == 0.0f);
+        return __builtin_isnormal(__x);
     }
-    return _iszerof(__x);
+    return _isnormalf(__x);
 }
-inline constexpr bool iszero(double __x) {
+inline constexpr bool isnormal(double __x) {
     if (__builtin_constant_p(__x)) {
-        return (__x == 0.0);
+        return __builtin_isnormal(__x);
     }
-    return _iszerof(__x);
+    return _isnormalf(__x);
 }
-inline constexpr bool iszero(long double __x) {
+inline constexpr bool isnormal(long double __x) {
     if (__builtin_constant_p(__x)) {
-        return (__x == 0.0L);
+        return __builtin_isnormal(__x);
     }
-    return _iszerol(__x);
+    return _isnormall(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
-iszero(_Tp __x) { return (__x == 0); }
+isnormal(_Tp __x) { return (__x != 0); }
 
 inline constexpr bool issubnormal(float __x) {
     if (__builtin_constant_p(__x)) {
@@ -166,6 +157,28 @@ template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
 issubnormal(_Tp __x) { return false; }
 
+inline constexpr bool iszero(float __x) {
+    if (__builtin_constant_p(__x)) {
+        return (__x == 0.0f);
+    }
+    return _iszerof(__x);
+}
+inline constexpr bool iszero(double __x) {
+    if (__builtin_constant_p(__x)) {
+        return (__x == 0.0);
+    }
+    return _iszerof(__x);
+}
+inline constexpr bool iszero(long double __x) {
+    if (__builtin_constant_p(__x)) {
+        return (__x == 0.0L);
+    }
+    return _iszerol(__x);
+}
+template<typename _Tp> inline constexpr
+__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
+iszero(_Tp __x) { return (__x == 0); }
+
 inline constexpr int fpclassify(float __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
@@ -801,12 +814,13 @@ trunc(_Tp __x) { return trunc(__x); }
 } // namespace std
 
 using std::signbit;
-using std::isinf;
+using std::issignaling;
 using std::isnan;
-using std::isnormal;
+using std::isinf;
 using std::isfinite;
-using std::iszero;
+using std::isnormal;
 using std::issubnormal;
+using std::iszero;
 using std::fpclassify;
 
 using std::isgreater;