Optimized the remaining long double classification routines to return bool

ZERICO2005 · ZERICO2005 · commit d8dabdcf3557 · 2025-03-25T19:41:17.000-06:00
diff --git a/src/libc/include/__math_def.h b/src/libc/include/__math_def.h
@@ -51,12 +51,12 @@ bool _isfinitef(float) __NOEXCEPT_CONST;
 bool _iszerof(float) __NOEXCEPT_CONST;
 bool _issubnormalf(float) __NOEXCEPT_CONST;
 
-int _isinfl(long double) __NOEXCEPT_CONST;
-int _isnanl(long double) __NOEXCEPT_CONST;
+bool _isinfl(long double) __NOEXCEPT_CONST;
+bool _isnanl(long double) __NOEXCEPT_CONST;
 bool _isnormall(long double) __NOEXCEPT_CONST;
 bool _isfinitel(long double) __NOEXCEPT_CONST;
-int _iszerol(long double) __NOEXCEPT_CONST;
-int _issubnormall(long double) __NOEXCEPT_CONST;
+bool _iszerol(long double) __NOEXCEPT_CONST;
+bool _issubnormall(long double) __NOEXCEPT_CONST;
 
 #if 0
 /* disabled until builtin is optimized */
diff --git a/src/libc/isinfl.src b/src/libc/isinfl.src
@@ -7,24 +7,17 @@
 ; int _isinfl(long double)
 __isinfl:
 	pop	bc, hl, de
-	or	a, a
+	xor	a, a
 	adc	hl, de
 	pop	de
 	push	bc, bc, bc, bc
-	jr	nz, .mant_nonzero
-	jr	c, .mant_carry
+	ret	nz	; mant_nonzero
+	ret	c	; mant_carry
 	ld	a, e
-	xor	a, $F0
-	ret	nz	; mantissa is non-zero
-	; A is zero here
+	xor	a, $F0	; sets A to zero if the bit pattern matches infinity
 	set	7, d
-	inc	d
-	ret	nz
-	inc	hl
-	ret
-	
-.mant_nonzero:
-.mant_carry:
-	or	a, a
-	sbc	hl, hl
+	inc	d	; set d to zero if it matches infinity
+	or	a, d
+	sub	a, 1
+	sbc	a, a
 	ret
diff --git a/src/libc/isnanl.src b/src/libc/isnanl.src
@@ -15,19 +15,15 @@ __isnanl:
 	jr	nz, .mant_nonzero	; normal, subnormal, or NaN
 	jr	c, .mant_nonzero	; normal, subnormal, or NaN
 	; common NaN, inf, normal, or subnormal
-	add	a, 15	; overflows 0xF1
-	jr	c, .skip_exp_check
-	ret
-.mant_nonzero:
 	or	a, a
-	sbc	hl, hl
+	ret	z
+	dec	a
+.mant_nonzero:
 	add	a, 16	; overflows 0xF0
-	ret	nc
-.skip_exp_check:
-	; carry is set here
+	sbc	a, a
+	ret	z
 	ld	a, d
-	rla	; A should be all ones if D was all ones
-	inc	a
-	ret	nz
-	inc	hl
+	add	a, a
+	add	a, 2
+	sbc	a, a
 	ret
diff --git a/src/libc/issubnormall.src b/src/libc/issubnormall.src
@@ -21,10 +21,8 @@ __issubnormall:
 .mant_carry:
 	ld	a, e
 	and	a, $F0
-	sbc	hl, hl
-	rra
 	res	7, d
-	add	a, d
-	ret	nz
-	inc	hl
+	or	a, d
+	sub	a, 1
+	sbc	a, a
 	ret
diff --git a/src/libc/iszerol.src b/src/libc/iszerol.src
@@ -7,23 +7,16 @@
 ; int iszerol(long double)
 __iszerol:
 	pop	bc, hl, de
-	or	a, a
+	xor	a, a
 	adc	hl, de
 	pop	de
 	push	bc, bc, bc, bc
 	; return if mantissa is non-zero
-	jr	nz, .mant_nonzero
-	jr	c, .mant_carry
+	ret	nz	; mant_nonzero
+	ret	c	; mant_carry
 	ld	a, d
 	rla	; clear the signbit
 	or	a, e
-	inc	hl
-	ret	z
-	; upper 16 bits non-zero
-;	dec	hl
-;	ret
-.mant_nonzero:
-.mant_carry:
-	or	a, a
-	sbc	hl, hl
+	sub	a, 1
+	sbc	a, a
 	ret
diff --git a/src/libcxx/include/cmath b/src/libcxx/include/cmath
@@ -16,19 +16,19 @@ inline constexpr bool signbit(float __x) {
     if (__builtin_constant_p(__x)) {
         return (__builtin_copysign(1.0f, __x) < 0.0f);
     }
-    return static_cast<bool>(_signbitf(__x));
+    return _signbitf(__x);
 }
 inline constexpr bool signbit(double __x) {
     if (__builtin_constant_p(__x)) {
         return (__builtin_copysign(1.0, __x)  < 0.0);
     }
-    return static_cast<bool>(_signbitf(__x));
+    return _signbitf(__x);
 }
 inline constexpr bool signbit(long double __x) {
     if (__builtin_constant_p(__x)) {
         return (__builtin_copysign(1.0L, __x) < 0.0L);
     }
-    return static_cast<bool>(_signbitl(__x));
+    return _signbitl(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -38,19 +38,19 @@ inline constexpr bool isinf(float __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isinf(__x);
     }
-    return static_cast<bool>(_isinff(__x));
+    return _isinff(__x);
 }
 inline constexpr bool isinf(double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isinf(__x);
     }
-    return static_cast<bool>(_isinff(__x));
+    return _isinff(__x);
 }
 inline constexpr bool isinf(long double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isinf(__x);
     }
-    return static_cast<bool>(_isinfl(__x));
+    return _isinfl(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -60,19 +60,19 @@ inline constexpr bool isnan(float __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnan(__x);
     }
-    return static_cast<bool>(_isnanf(__x));
+    return _isnanf(__x);
 }
 inline constexpr bool isnan(double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnan(__x);
     }
-    return static_cast<bool>(_isnanf(__x));
+    return _isnanf(__x);
 }
 inline constexpr bool isnan(long double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnan(__x);
     }
-    return static_cast<bool>(_isnanl(__x));
+    return _isnanl(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -82,19 +82,19 @@ inline constexpr bool isnormal(float __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnormal(__x);
     }
-    return static_cast<bool>(_isnormalf(__x));
+    return _isnormalf(__x);
 }
 inline constexpr bool isnormal(double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnormal(__x);
     }
-    return static_cast<bool>(_isnormalf(__x));
+    return _isnormalf(__x);
 }
 inline constexpr bool isnormal(long double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isnormal(__x);
     }
-    return static_cast<bool>(_isnormall(__x));
+    return _isnormall(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -104,19 +104,19 @@ inline constexpr bool isfinite(float __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isfinite(__x);
     }
-    return static_cast<bool>(_isfinitef(__x));
+    return _isfinitef(__x);
 }
 inline constexpr bool isfinite(double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isfinite(__x);
     }
-    return static_cast<bool>(_isfinitef(__x));
+    return _isfinitef(__x);
 }
 inline constexpr bool isfinite(long double __x) {
     if (__builtin_constant_p(__x)) {
         return __builtin_isfinite(__x);
     }
-    return static_cast<bool>(_isfinitel(__x));
+    return _isfinitel(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -126,19 +126,19 @@ inline constexpr bool iszero(float __x) {
     if (__builtin_constant_p(__x)) {
         return (__x == 0.0f);
     }
-    return static_cast<bool>(_iszerof(__x));
+    return _iszerof(__x);
 }
 inline constexpr bool iszero(double __x) {
     if (__builtin_constant_p(__x)) {
         return (__x == 0.0);
     }
-    return static_cast<bool>(_iszerof(__x));
+    return _iszerof(__x);
 }
 inline constexpr bool iszero(long double __x) {
     if (__builtin_constant_p(__x)) {
         return (__x == 0.0L);
     }
-    return static_cast<bool>(_iszerol(__x));
+    return _iszerol(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
@@ -148,19 +148,19 @@ inline constexpr bool issubnormal(float __x) {
     if (__builtin_constant_p(__x)) {
         return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));
     }
-    return static_cast<bool>(_issubnormalf(__x));
+    return _issubnormalf(__x);
 }
 inline constexpr bool issubnormal(double __x) {
     if (__builtin_constant_p(__x)) {
         return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));
     }
-    return static_cast<bool>(_issubnormalf(__x));
+    return _issubnormalf(__x);
 }
 inline constexpr bool issubnormal(long double __x) {
     if (__builtin_constant_p(__x)) {
         return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));
     }
-    return static_cast<bool>(_issubnormall(__x));
+    return _issubnormall(__x);
 }
 template<typename _Tp> inline constexpr
 __cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>
diff --git a/test/floating_point/float32_classification/src/main.c b/test/floating_point/float32_classification/src/main.c
@@ -137,7 +137,7 @@ int main(void) {
     } else {
         printf(
             "Failed test:\n0x%08lX\nTruth: %06X_%d\nGuess: %06X_%d",
-            ret.failed_index, ret.guess, ret.guess_fp, ret.truth, ret.truth_fp
+            ret.failed_index, ret.truth, ret.truth_fp, ret.guess, ret.guess_fp
         );
     }
 
diff --git a/test/floating_point/float64_classification/src/main.c b/test/floating_point/float64_classification/src/main.c
@@ -139,7 +139,7 @@ int main(void) {
         const uint32_t* failed_index_split = (const uint32_t*)((const void*)&(ret.failed_index));
         printf(
             "Failed test:\n0x%08lX%08lX\nTruth: %06X_%d\nGuess: %06X_%d",
-            failed_index_split[1], failed_index_split[0], ret.guess, ret.guess_fp, ret.truth, ret.truth_fp
+            failed_index_split[1], failed_index_split[0], ret.truth, ret.truth_fp, ret.guess, ret.guess_fp
         );
     }
 

Original file line number	Diff line number	Diff line change
`@@ -16,19 +16,19 @@ inline constexpr bool signbit(float __x) {`
`16`	`16`	`if (__builtin_constant_p(__x)) {`
`17`	`17`	`return (__builtin_copysign(1.0f, __x) < 0.0f);`
`18`	`18`	`}`
`19`		`- return static_cast<bool>(_signbitf(__x));`
	`19`	`+ return _signbitf(__x);`
`20`	`20`	`}`
`21`	`21`	`inline constexpr bool signbit(double __x) {`
`22`	`22`	`if (__builtin_constant_p(__x)) {`
`23`	`23`	`return (__builtin_copysign(1.0, __x) < 0.0);`
`24`	`24`	`}`
`25`		`- return static_cast<bool>(_signbitf(__x));`
	`25`	`+ return _signbitf(__x);`
`26`	`26`	`}`
`27`	`27`	`inline constexpr bool signbit(long double __x) {`
`28`	`28`	`if (__builtin_constant_p(__x)) {`
`29`	`29`	`return (__builtin_copysign(1.0L, __x) < 0.0L);`
`30`	`30`	`}`
`31`		`- return static_cast<bool>(_signbitl(__x));`
	`31`	`+ return _signbitl(__x);`
`32`	`32`	`}`
`33`	`33`	`template<typename _Tp> inline constexpr`
`34`	`34`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -38,19 +38,19 @@ inline constexpr bool isinf(float __x) {`
`38`	`38`	`if (__builtin_constant_p(__x)) {`
`39`	`39`	`return __builtin_isinf(__x);`
`40`	`40`	`}`
`41`		`- return static_cast<bool>(_isinff(__x));`
	`41`	`+ return _isinff(__x);`
`42`	`42`	`}`
`43`	`43`	`inline constexpr bool isinf(double __x) {`
`44`	`44`	`if (__builtin_constant_p(__x)) {`
`45`	`45`	`return __builtin_isinf(__x);`
`46`	`46`	`}`
`47`		`- return static_cast<bool>(_isinff(__x));`
	`47`	`+ return _isinff(__x);`
`48`	`48`	`}`
`49`	`49`	`inline constexpr bool isinf(long double __x) {`
`50`	`50`	`if (__builtin_constant_p(__x)) {`
`51`	`51`	`return __builtin_isinf(__x);`
`52`	`52`	`}`
`53`		`- return static_cast<bool>(_isinfl(__x));`
	`53`	`+ return _isinfl(__x);`
`54`	`54`	`}`
`55`	`55`	`template<typename _Tp> inline constexpr`
`56`	`56`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -60,19 +60,19 @@ inline constexpr bool isnan(float __x) {`
`60`	`60`	`if (__builtin_constant_p(__x)) {`
`61`	`61`	`return __builtin_isnan(__x);`
`62`	`62`	`}`
`63`		`- return static_cast<bool>(_isnanf(__x));`
	`63`	`+ return _isnanf(__x);`
`64`	`64`	`}`
`65`	`65`	`inline constexpr bool isnan(double __x) {`
`66`	`66`	`if (__builtin_constant_p(__x)) {`
`67`	`67`	`return __builtin_isnan(__x);`
`68`	`68`	`}`
`69`		`- return static_cast<bool>(_isnanf(__x));`
	`69`	`+ return _isnanf(__x);`
`70`	`70`	`}`
`71`	`71`	`inline constexpr bool isnan(long double __x) {`
`72`	`72`	`if (__builtin_constant_p(__x)) {`
`73`	`73`	`return __builtin_isnan(__x);`
`74`	`74`	`}`
`75`		`- return static_cast<bool>(_isnanl(__x));`
	`75`	`+ return _isnanl(__x);`
`76`	`76`	`}`
`77`	`77`	`template<typename _Tp> inline constexpr`
`78`	`78`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -82,19 +82,19 @@ inline constexpr bool isnormal(float __x) {`
`82`	`82`	`if (__builtin_constant_p(__x)) {`
`83`	`83`	`return __builtin_isnormal(__x);`
`84`	`84`	`}`
`85`		`- return static_cast<bool>(_isnormalf(__x));`
	`85`	`+ return _isnormalf(__x);`
`86`	`86`	`}`
`87`	`87`	`inline constexpr bool isnormal(double __x) {`
`88`	`88`	`if (__builtin_constant_p(__x)) {`
`89`	`89`	`return __builtin_isnormal(__x);`
`90`	`90`	`}`
`91`		`- return static_cast<bool>(_isnormalf(__x));`
	`91`	`+ return _isnormalf(__x);`
`92`	`92`	`}`
`93`	`93`	`inline constexpr bool isnormal(long double __x) {`
`94`	`94`	`if (__builtin_constant_p(__x)) {`
`95`	`95`	`return __builtin_isnormal(__x);`
`96`	`96`	`}`
`97`		`- return static_cast<bool>(_isnormall(__x));`
	`97`	`+ return _isnormall(__x);`
`98`	`98`	`}`
`99`	`99`	`template<typename _Tp> inline constexpr`
`100`	`100`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -104,19 +104,19 @@ inline constexpr bool isfinite(float __x) {`
`104`	`104`	`if (__builtin_constant_p(__x)) {`
`105`	`105`	`return __builtin_isfinite(__x);`
`106`	`106`	`}`
`107`		`- return static_cast<bool>(_isfinitef(__x));`
	`107`	`+ return _isfinitef(__x);`
`108`	`108`	`}`
`109`	`109`	`inline constexpr bool isfinite(double __x) {`
`110`	`110`	`if (__builtin_constant_p(__x)) {`
`111`	`111`	`return __builtin_isfinite(__x);`
`112`	`112`	`}`
`113`		`- return static_cast<bool>(_isfinitef(__x));`
	`113`	`+ return _isfinitef(__x);`
`114`	`114`	`}`
`115`	`115`	`inline constexpr bool isfinite(long double __x) {`
`116`	`116`	`if (__builtin_constant_p(__x)) {`
`117`	`117`	`return __builtin_isfinite(__x);`
`118`	`118`	`}`
`119`		`- return static_cast<bool>(_isfinitel(__x));`
	`119`	`+ return _isfinitel(__x);`
`120`	`120`	`}`
`121`	`121`	`template<typename _Tp> inline constexpr`
`122`	`122`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -126,19 +126,19 @@ inline constexpr bool iszero(float __x) {`
`126`	`126`	`if (__builtin_constant_p(__x)) {`
`127`	`127`	`return (__x == 0.0f);`
`128`	`128`	`}`
`129`		`- return static_cast<bool>(_iszerof(__x));`
	`129`	`+ return _iszerof(__x);`
`130`	`130`	`}`
`131`	`131`	`inline constexpr bool iszero(double __x) {`
`132`	`132`	`if (__builtin_constant_p(__x)) {`
`133`	`133`	`return (__x == 0.0);`
`134`	`134`	`}`
`135`		`- return static_cast<bool>(_iszerof(__x));`
	`135`	`+ return _iszerof(__x);`
`136`	`136`	`}`
`137`	`137`	`inline constexpr bool iszero(long double __x) {`
`138`	`138`	`if (__builtin_constant_p(__x)) {`
`139`	`139`	`return (__x == 0.0L);`
`140`	`140`	`}`
`141`		`- return static_cast<bool>(_iszerol(__x));`
	`141`	`+ return _iszerol(__x);`
`142`	`142`	`}`
`143`	`143`	`template<typename _Tp> inline constexpr`
`144`	`144`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
`@@ -148,19 +148,19 @@ inline constexpr bool issubnormal(float __x) {`
`148`	`148`	`if (__builtin_constant_p(__x)) {`
`149`	`149`	`return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));`
`150`	`150`	`}`
`151`		`- return static_cast<bool>(_issubnormalf(__x));`
	`151`	`+ return _issubnormalf(__x);`
`152`	`152`	`}`
`153`	`153`	`inline constexpr bool issubnormal(double __x) {`
`154`	`154`	`if (__builtin_constant_p(__x)) {`
`155`	`155`	`return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));`
`156`	`156`	`}`
`157`		`- return static_cast<bool>(_issubnormalf(__x));`
	`157`	`+ return _issubnormalf(__x);`
`158`	`158`	`}`
`159`	`159`	`inline constexpr bool issubnormal(long double __x) {`
`160`	`160`	`if (__builtin_constant_p(__x)) {`
`161`	`161`	`return (FP_SUBNORMAL == __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x));`
`162`	`162`	`}`
`163`		`- return static_cast<bool>(_issubnormall(__x));`
	`163`	`+ return _issubnormall(__x);`
`164`	`164`	`}`
`165`	`165`	`template<typename _Tp> inline constexpr`
`166`	`166`	`__cmath_enable_if_t<__cmath_is_integral_v<_Tp>, bool>`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ int main(void) {`
`137`	`137`	`} else {`
`138`	`138`	`printf(`
`139`	`139`	`"Failed test:\n0x%08lX\nTruth: %06X_%d\nGuess: %06X_%d",`
`140`		`- ret.failed_index, ret.guess, ret.guess_fp, ret.truth, ret.truth_fp`
	`140`	`+ ret.failed_index, ret.truth, ret.truth_fp, ret.guess, ret.guess_fp`
`141`	`141`	`);`
`142`	`142`	`}`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ int main(void) {`
`139`	`139`	`const uint32_t* failed_index_split = (const uint32_t)((const void)&(ret.failed_index));`
`140`	`140`	`printf(`
`141`	`141`	`"Failed test:\n0x%08lX%08lX\nTruth: %06X_%d\nGuess: %06X_%d",`
`142`		`- failed_index_split[1], failed_index_split[0], ret.guess, ret.guess_fp, ret.truth, ret.truth_fp`
	`142`	`+ failed_index_split[1], failed_index_split[0], ret.truth, ret.truth_fp, ret.guess, ret.guess_fp`
`143`	`143`	`);`
`144`	`144`	`}`
`145`	`145`