Optimized f64 comparisons and integer conversions

Author: ZERICO2005

src/crt/dcmp.c

@@ -12,23 +12,31 @@ typedef union F64_pun {
 #define F64_CMP_GREATER    1 /* doesn't trigger flags */
 #define F64_CMP_UNORDERED  1 /* doesn't trigger flags */
 
+typedef struct f64_cmp_arg {
+    long double x;
+    bool x_sign; /* <-- unimplemented */
+    unsigned int const return_address;
+    long double y;
+    bool y_sign; /* <-- unimplemented */
+} f64_cmp_arg;
+
 // assumes no NaN
-int _dcmp_c(const long double *__restrict x, const long double *__restrict y) {
-    F64_pun arg_x, arg_y;
-    arg_x.flt = *x;
-    arg_y.flt = *y;
+int _dcmp_c(f64_cmp_arg *__restrict const arg) {
+    F64_pun x, y;
+    x.flt = arg->x;
+    y.flt = arg->y;
 
-    bool x_sign = signbit(arg_x.flt);
-    bool y_sign = signbit(arg_y.flt);
+    bool x_sign = signbit(x.flt);
+    bool y_sign = signbit(y.flt);
     if (x_sign != y_sign) {
-        if (iszero(arg_x.flt) && iszero(arg_y.flt)) {
+        if (iszero(x.flt) && iszero(y.flt)) {
             return F64_CMP_EQUAL;
         }
         return (x_sign ? F64_CMP_LESS : F64_CMP_GREATER);
     }
 
-    if (arg_x.bin == arg_y.bin) {
+    if (x.bin == y.bin) {
         return F64_CMP_EQUAL;
     }
-    return ((arg_x.bin < arg_y.bin) != x_sign) ? F64_CMP_LESS : F64_CMP_GREATER;
+    return ((x.bin < y.bin) != x_sign) ? F64_CMP_LESS : F64_CMP_GREATER;
 }

src/crt/dcmp.src

@@ -4,16 +4,18 @@
 
 	public	__dcmp
 
-; int _dcmp_c(const long double *__restrict x, const long double *__restrict y)
+; int _dcmp_c(f64_cmp_arg const *__restrict const arg)
 __dcmp:
-	; f64*_f64*_ret_i24
-	push	bc, de, hl, af, iy
-	ld	iy, 6
-	add	iy, sp
-	pea	iy + 12
-	push	iy
+	; f64_cmp_arg*_ret_i24
+	push	bc, de, hl
+	or	a, a
+	sbc	hl, hl
+	add	hl, sp
+	push	iy, af
+	push	hl	; f64_cmp_arg*
 	call	__dcmp_c
-	pop	af, af, iy, af
+	pop	af
+	pop	af, iy
 	; Set the comparison flags
 	add	hl, de
 	or	a, a

src/crt/dtol.src

@@ -6,9 +6,17 @@
 
 __dtol:
 	; f64_ret_i32
-	push	af, iy, bc, de, hl
+	push	af, iy
+	ld	a, b
+	push	bc, de, hl
+	ld	hl, 7
+	add	hl, sp
+	res	7, (hl)	; fabsl(x)
+	inc	hl
+	rlca
+	ld	(hl), a	; store the sign of x in the padding byte
 	call	__dtol_c
-	pop	af, af, af, iy, af
+	pop	af, af, bc, iy, af
 	ret
 
 	extern	__dtol_c

src/crt/dtoll.src

@@ -6,7 +6,14 @@
 
 __dtoll:
 	; f64_ret_i64
-	push	af, iy, bc, de, hl
+	push	af, iy
+	ld	a, b
+	res	7, b	; fabsl(x)
+	push	bc, de, hl
+	ld	hl, 8
+	add	hl, sp
+	rlca
+	ld	(hl), a	; store the sign of x in the padding byte
 	call	__dtoll_c
 	pop	af, af, af, iy, af
 	ret

src/crt/dtoul.src

@@ -8,7 +8,7 @@ __dtoul:
 	; f64_ret_u32
 	push	af, iy, bc, de, hl
 	call	__dtoul_c
-	pop	af, af, af, iy, af
+	pop	af, af, bc, iy, af
 	ret
 
 	extern	__dtoul_c

src/crt/float64_to_int.c

@@ -74,6 +74,11 @@ uint64_t _dtoull_c(long double x) {
  */
 #define HANDLE_INT_MIN 1
 
+typedef struct f64_sign {
+    long double flt;
+    bool sign;
+} f64_sign;
+
 /**
  * @note val must have the signbit cleared
  */
@@ -123,10 +128,10 @@ uint32_t _dtoul_c(long double x) {
     return (uint32_t)f64_to_unsigned(val);
 }
 
-int64_t _dtoll_c(long double x) {
+int64_t _dtoll_c(f64_sign arg) {
     F64_pun val;
-    bool x_sign = signbit(x);
-    val.flt = fabsl(x);
+    bool x_sign = arg.sign;
+    val.flt = arg.flt;
 
     /* overflow || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_i64_max_exp) << Float64_exp_BC_shift)) {
@@ -145,10 +150,10 @@ int64_t _dtoll_c(long double x) {
     return ret;
 }
 
-int32_t _dtol_c(long double x) {
+int32_t _dtol_c(f64_sign arg) {
     F64_pun val;
-    bool x_sign = signbit(x);
-    val.flt = fabsl(x);
+    bool x_sign = arg.sign;
+    val.flt = arg.flt;
 
     /* overflow || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_i32_max_exp) << Float64_exp_BC_shift)) {

src/softfloat/include/softfloat.h

@@ -116,7 +116,13 @@ enum {
 /*----------------------------------------------------------------------------
 | Routine to raise any or all of the software floating-point exception flags.
 *----------------------------------------------------------------------------*/
+#if 0
 void softfloat_raiseFlags( uint_fast8_t );
+#else
+inline void softfloat_raiseFlags( uint_fast8_t flags ) {
+    softfloat_exceptionFlags |= flags;
+}
+#endif
 
 /*----------------------------------------------------------------------------
 | Integer-to-floating-point conversion routines.

src/softfloat/softfloat_raiseFlags.c

@@ -34,6 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 =============================================================================*/
 
+#if 0
+
 #include "platform.h"
 #include "softfloat.h"
 #include <fenv.h>
@@ -49,3 +51,4 @@ void softfloat_raiseFlags( uint_fast8_t flags )
     softfloat_exceptionFlags |= flags;
 }
 
+#endif

test/floating_point/float64_arithmetic/src/data.asm

@@ -0,0 +1,27 @@
+	assume	adl=1
+
+	section	.text
+
+	public	_f64_pos_zero
+_f64_pos_zero:
+	db $00, $00, $00, $00, $00, $00, $00, $00
+
+	public	_f64_neg_zero
+_f64_neg_zero:
+	db $00, $00, $00, $00, $00, $00, $00, $80
+
+	public	_f64_pos_one
+_f64_pos_one:
+	db $00, $00, $00, $00, $00, $00, $F0, $3F
+
+	public	_f64_neg_one
+_f64_neg_one:
+	db $00, $00, $00, $00, $00, $00, $F0, $BF
+
+	public	_f64_pos_pi
+_f64_pos_pi:
+	db $18, $2D, $44, $54, $FB, $21, $09, $40
+
+	public	_f64_neg_pi
+_f64_neg_pi:
+	db $18, $2D, $44, $54, $FB, $21, $09, $C0

test/floating_point/float64_arithmetic/src/main.cpp

@@ -61,16 +61,54 @@ static size_t run_test(int64_t* fail_ulp) {
     return SIZE_MAX;
 }
 
+#define C(expr) if (!(expr)) { return __LINE__; }
+
+extern volatile long double f64_pos_zero;
+extern volatile long double f64_neg_zero;
+extern volatile long double f64_pos_one;
+extern volatile long double f64_neg_one;
+extern volatile long double f64_pos_pi;
+extern volatile long double f64_neg_pi;
+
+int comparison_test(void) {
+    C(f64_pos_one  == f64_pos_one );
+    C(f64_neg_one  <  f64_pos_one );
+    C(f64_pos_one  >= f64_neg_one );
+    C(f64_pos_one  != f64_neg_one );
+    C(f64_pos_zero <  f64_pos_one );
+    C(f64_neg_zero >  f64_neg_one );
+
+    C(f64_pos_zero == f64_pos_zero);
+    C(f64_neg_zero == f64_neg_zero);
+    C(f64_pos_zero >= f64_neg_zero);
+    C(f64_neg_zero == f64_pos_zero);
+
+    C(f64_pos_pi   == f64_pos_pi  );
+    C(f64_pos_pi   >  f64_pos_one );
+    C(f64_neg_pi   <  f64_neg_one );
+    C(f64_pos_pi   >  f64_pos_zero);
+    C(f64_neg_pi   <= f64_neg_zero);
+    C(f64_neg_pi   != f64_neg_zero);
+    C(f64_pos_pi   != f64_neg_pi  );
+    C(f64_pos_pi   >= f64_neg_pi  );
+    
+    return 0;
+}
+
 int main(void) {
     os_ClrHome();
-    int64_t fail_ulp = 0;
-    size_t fail_index = run_test(&fail_ulp);
-    if (fail_index == SIZE_MAX) {
-        printf("All tests passed");
+    int comparison_result = comparison_test();
+    if (comparison_result != 0) {
+        printf("Failed test L%d\n", comparison_result);
     } else {
-        printf("Failed test: %zu\nULP: %lld", fail_index, fail_ulp);
+        int64_t fail_ulp = 0;
+        size_t fail_index = run_test(&fail_ulp);
+        if (fail_index == SIZE_MAX) {
+            printf("All tests passed");
+        } else {
+            printf("Failed test: %zu\nULP: %lld", fail_index, fail_ulp);
+        }
     }
-
     while (!os_GetCSC());
 
     return 0;