Replace floating magic constant by macro (#623)

aswaterman · web-flow · commit 7b7074aed2db · 2025-06-12T15:57:08.000-07:00
* macro: define [sq]NaN[dfh] and [n]Inf[dfh]

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply sNaNf

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply sNaNd

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply qNaNd

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply qNaNf

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply sNaNh

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply Infh

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply nInfh

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply Infd

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply nInfd

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply Inff

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

* apply nInff

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;

---------

Signed-off-by: Chih-Min Chao &lt;chihmin.chao@sifive.com&gt;
diff --git a/isa/macros/scalar/test_macros.h b/isa/macros/scalar/test_macros.h
@@ -417,6 +417,24 @@ test_ ## testnum: \
 # Tests floating-point instructions
 #-----------------------------------------------------------------------
 
+# 16-bit half precision (float16)
+#define qNaNh     0x7e00
+#define sNaNh     0x7c01
+#define Infh      0x7c00
+#define nInfh     0xfc00
+
+# 32-bit single precision (float)
+#define qNaNf     0x7fc00000
+#define sNaNf     0x7f800001
+#define Inff      0x7f800000
+#define nInff     0xff800000
+
+# 64-bit double precision (double)
+#define qNaNd     0x7ff8000000000000
+#define sNaNd     0x7ff0000000000001
+#define Infd      0x7ff0000000000000
+#define nInfd     0xfff0000000000000
+
 #define TEST_FP_OP_H_INTERNAL( testnum, flags, result, val1, val2, val3, code... ) \
 test_ ## testnum: \
   li  TESTNUM, testnum; \
diff --git a/isa/rv64ud/fadd.S b/isa/rv64ud/fadd.S
@@ -38,7 +38,7 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_D(10,  fmul.d, 1,      3.14159265e-8, 3.14159265, 0.00000001 );
 
   # Is the canonical NaN generated for Inf - Inf?
-  TEST_FP_OP2_D_HEX(11,  fsub.d, 0x10, 0x7ff8000000000000, 0x7ff0000000000000, 0x7ff0000000000000);
+  TEST_FP_OP2_D_HEX(11,  fsub.d, 0x10, qNaNd, Infd, Infd);
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64ud/fclass.S b/isa/rv64ud/fclass.S
@@ -23,16 +23,16 @@ RVTEST_CODE_BEGIN
   # Arithmetic tests
   #-------------------------------------------------------------
 
-  TEST_FCLASS_D( 2, 1 << 0, 0xfff0000000000000 )
+  TEST_FCLASS_D( 2, 1 << 0, nInfd )
   TEST_FCLASS_D( 3, 1 << 1, 0xbff0000000000000 )
   TEST_FCLASS_D( 4, 1 << 2, 0x800fffffffffffff )
   TEST_FCLASS_D( 5, 1 << 3, 0x8000000000000000 )
   TEST_FCLASS_D( 6, 1 << 4, 0x0000000000000000 )
   TEST_FCLASS_D( 7, 1 << 5, 0x000fffffffffffff )
   TEST_FCLASS_D( 8, 1 << 6, 0x3ff0000000000000 )
-  TEST_FCLASS_D( 9, 1 << 7, 0x7ff0000000000000 )
-  TEST_FCLASS_D(10, 1 << 8, 0x7ff0000000000001 )
-  TEST_FCLASS_D(11, 1 << 9, 0x7ff8000000000000 )
+  TEST_FCLASS_D( 9, 1 << 7, Infd )
+  TEST_FCLASS_D(10, 1 << 8, sNaNd )
+  TEST_FCLASS_D(11, 1 << 9, qNaNd )
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64ud/fcmp.S b/isa/rv64ud/fcmp.S
@@ -36,15 +36,15 @@ RVTEST_CODE_BEGIN
   # Only sNaN should signal invalid for feq.
   TEST_FP_CMP_OP_D( 8, feq.d, 0x00, 0, NaN, 0)
   TEST_FP_CMP_OP_D( 9, feq.d, 0x00, 0, NaN, NaN)
-  TEST_FP_CMP_OP_D_HEX(10, feq.d, 0x10, 0, 0x7ff0000000000001, 0)
+  TEST_FP_CMP_OP_D_HEX(10, feq.d, 0x10, 0, sNaNd, 0)
 
   # qNaN should signal invalid for fle/flt.
   TEST_FP_CMP_OP_D(11, flt.d, 0x10, 0, NaN, 0)
   TEST_FP_CMP_OP_D(12, flt.d, 0x10, 0, NaN, NaN)
-  TEST_FP_CMP_OP_D_HEX(13, flt.d, 0x10, 0, 0x7ff0000000000001, 0)
+  TEST_FP_CMP_OP_D_HEX(13, flt.d, 0x10, 0, sNaNd, 0)
   TEST_FP_CMP_OP_D(14, fle.d, 0x10, 0, NaN, 0)
   TEST_FP_CMP_OP_D(15, fle.d, 0x10, 0, NaN, NaN)
-  TEST_FP_CMP_OP_D_HEX(16, fle.d, 0x10, 0, 0x7ff0000000000001, 0)
+  TEST_FP_CMP_OP_D_HEX(16, fle.d, 0x10, 0, sNaNd, 0)
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64ud/fcvt.S b/isa/rv64ud/fcvt.S
@@ -44,7 +44,7 @@ RVTEST_CODE_BEGIN
   TEST_FCVT_D_S(11, -1.5, -1.5)
 
 #if __riscv_xlen >= 64
-  TEST_CASE(12, a0, 0x7ff8000000000000,
+  TEST_CASE(12, a0, qNaNd,
     la a1, test_data_22;
     ld a2, 0(a1);
     fmv.d.x f2, a2;
@@ -53,7 +53,7 @@ RVTEST_CODE_BEGIN
     fmv.x.d a0, f2;
   )
 #else
-  TEST_CASE_D32(12, a0, a1, 0x7ff8000000000000,
+  TEST_CASE_D32(12, a0, a1, qNaNd,
     la a1, test_data_22;
     fld f2, 0(a1);
     fcvt.s.d f2, f2;
diff --git a/isa/rv64ud/fcvt_w.S b/isa/rv64ud/fcvt_w.S
@@ -102,13 +102,13 @@ RVTEST_DATA_BEGIN
 tdat:
 .word 0xffffffff
 .word 0x7fffffff
-.word 0xff800000
-.word 0x7f800000
+.word nInff
+.word Inff
 
 tdat_d:
 .dword 0xffffffffffffffff
 .dword 0x7fffffffffffffff
-.dword 0xfff0000000000000
-.dword 0x7ff0000000000000
+.dword nInfd
+.dword Infd
 
 RVTEST_DATA_END
diff --git a/isa/rv64ud/fmin.S b/isa/rv64ud/fmin.S
@@ -40,9 +40,9 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_D(17,  fmax.d, 0,       -1.0,       -1.0,       -2.0 );
 
   # FMAX(sNaN, x) = x
-  TEST_FP_OP2_D_HEX(20,  fmax.d, 0x10, 0x3ff0000000000000, 0x7ff0000000000001, 0x3ff0000000000000);
+  TEST_FP_OP2_D_HEX(20,  fmax.d, 0x10, 0x3ff0000000000000, sNaNd, 0x3ff0000000000000);
   # FMAX(qNaN, qNaN) = canonical NaN
-  TEST_FP_OP2_D_HEX(21,  fmax.d, 0x00, 0x7ff8000000000000, 0x7fffffffffffffff, 0x7fffffffffffffff);
+  TEST_FP_OP2_D_HEX(21,  fmax.d, 0x00, qNaNd, 0x7fffffffffffffff, 0x7fffffffffffffff);
 
   # -0.0 < +0.0
   TEST_FP_OP2_D(30,  fmin.d, 0,       -0.0,       -0.0,        0.0 );
diff --git a/isa/rv64ud/move.S b/isa/rv64ud/move.S
@@ -55,14 +55,14 @@ RVTEST_CODE_BEGIN
     fsgnj.s f0, f1, f2; \
     fmv.x.d a0, f0)
 
-  TEST_FSGNJS(40, 0x7fc00000, 0x7ffffffe12345678, 0)
-  TEST_FSGNJS(41, 0x7fc00000, 0xfffffffe12345678, 0)
-  TEST_FSGNJS(42, 0x7fc00000, 0x7fffffff12345678, 0)
+  TEST_FSGNJS(40, qNaNf, 0x7ffffffe12345678, 0)
+  TEST_FSGNJS(41, qNaNf, 0xfffffffe12345678, 0)
+  TEST_FSGNJS(42, qNaNf, 0x7fffffff12345678, 0)
   TEST_FSGNJS(43, 0x12345678, 0xffffffff12345678, 0)
 
-  TEST_FSGNJS(50, 0x7fc00000, 0x7ffffffe12345678, 0x80000000)
-  TEST_FSGNJS(51, 0x7fc00000, 0xfffffffe12345678, 0x80000000)
-  TEST_FSGNJS(52, 0x7fc00000, 0x7fffffff12345678, 0x80000000)
+  TEST_FSGNJS(50, qNaNf, 0x7ffffffe12345678, 0x80000000)
+  TEST_FSGNJS(51, qNaNf, 0xfffffffe12345678, 0x80000000)
+  TEST_FSGNJS(52, qNaNf, 0x7fffffff12345678, 0x80000000)
   TEST_FSGNJS(53, 0x12345678, 0xffffffff12345678, 0x80000000)
 
   TEST_FSGNJS(60, 0xffc00000, 0x7ffffffe12345678, 0xffffffff80000000)
diff --git a/isa/rv64uf/fadd.S b/isa/rv64uf/fadd.S
@@ -30,7 +30,7 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_S(10,  fmul.s, 1,      3.14159265e-8, 3.14159265, 0.00000001 );
 
   # Is the canonical NaN generated for Inf - Inf?
-  TEST_FP_OP2_S_HEX(11,  fsub.s, 0x10, 0x7fc00000, 0x7f800000, 0x7f800000);
+  TEST_FP_OP2_S_HEX(11,  fsub.s, 0x10, qNaNf, Inff, Inff);
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64uf/fclass.S b/isa/rv64uf/fclass.S
@@ -17,16 +17,16 @@ RVTEST_CODE_BEGIN
   # Arithmetic tests
   #-------------------------------------------------------------
 
-  TEST_FCLASS_S( 2, 1 << 0, 0xff800000 )
+  TEST_FCLASS_S( 2, 1 << 0, nInff )
   TEST_FCLASS_S( 3, 1 << 1, 0xbf800000 )
   TEST_FCLASS_S( 4, 1 << 2, 0x807fffff )
   TEST_FCLASS_S( 5, 1 << 3, 0x80000000 )
   TEST_FCLASS_S( 6, 1 << 4, 0x00000000 )
   TEST_FCLASS_S( 7, 1 << 5, 0x007fffff )
   TEST_FCLASS_S( 8, 1 << 6, 0x3f800000 )
-  TEST_FCLASS_S( 9, 1 << 7, 0x7f800000 )
-  TEST_FCLASS_S(10, 1 << 8, 0x7f800001 )
-  TEST_FCLASS_S(11, 1 << 9, 0x7fc00000 )
+  TEST_FCLASS_S( 9, 1 << 7, Inff )
+  TEST_FCLASS_S(10, 1 << 8, sNaNf )
+  TEST_FCLASS_S(11, 1 << 9, qNaNf )
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64uf/fcmp.S b/isa/rv64uf/fcmp.S
@@ -28,15 +28,15 @@ RVTEST_CODE_BEGIN
   # Only sNaN should signal invalid for feq.
   TEST_FP_CMP_OP_S( 8, feq.s, 0x00, 0, NaN, 0)
   TEST_FP_CMP_OP_S( 9, feq.s, 0x00, 0, NaN, NaN)
-  TEST_FP_CMP_OP_S_HEX(10, feq.s, 0x10, 0, 0x7f800001, 0)
+  TEST_FP_CMP_OP_S_HEX(10, feq.s, 0x10, 0, sNaNf, 0)
 
   # qNaN should signal invalid for fle/flt.
   TEST_FP_CMP_OP_S(11, flt.s, 0x10, 0, NaN, 0)
   TEST_FP_CMP_OP_S(12, flt.s, 0x10, 0, NaN, NaN)
-  TEST_FP_CMP_OP_S_HEX(13, flt.s, 0x10, 0, 0x7f800001, 0)
+  TEST_FP_CMP_OP_S_HEX(13, flt.s, 0x10, 0, sNaNf, 0)
   TEST_FP_CMP_OP_S(14, fle.s, 0x10, 0, NaN, 0)
   TEST_FP_CMP_OP_S(15, fle.s, 0x10, 0, NaN, NaN)
-  TEST_FP_CMP_OP_S_HEX(16, fle.s, 0x10, 0, 0x7f800001, 0)
+  TEST_FP_CMP_OP_S_HEX(16, fle.s, 0x10, 0, sNaNf, 0)
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64uf/fcvt_w.S b/isa/rv64uf/fcvt_w.S
@@ -93,13 +93,13 @@ RVTEST_DATA_BEGIN
 tdat:
 .word 0xffffffff
 .word 0x7fffffff
-.word 0xff800000
-.word 0x7f800000
+.word nInff
+.word Inff
 
 tdat_d:
 .dword 0xffffffffffffffff
 .dword 0x7fffffffffffffff
-.dword 0xfff0000000000000
-.dword 0x7ff0000000000000
+.dword nInfd
+.dword Infd
 
 RVTEST_DATA_END
diff --git a/isa/rv64uf/fmin.S b/isa/rv64uf/fmin.S
@@ -32,9 +32,9 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_S(17,  fmax.s, 0,       -1.0,       -1.0,       -2.0 );
 
   # FMAX(sNaN, x) = x
-  TEST_FP_OP2_S_HEX(20,  fmax.s, 0x10, 0x3f800000, 0x7f800001, 0x3f800000);
+  TEST_FP_OP2_S_HEX(20,  fmax.s, 0x10, 0x3f800000, sNaNf, 0x3f800000);
   # FMAX(qNaN, qNaN) = canonical NaN
-  TEST_FP_OP2_S_HEX(21,  fmax.s, 0x00, 0x7fc00000, 0x7fffffff, 0x7fffffff);
+  TEST_FP_OP2_S_HEX(21,  fmax.s, 0x00, qNaNf, 0x7fffffff, 0x7fffffff);
 
   # -0.0 < +0.0
   TEST_FP_OP2_S(30,  fmin.s, 0,       -0.0,       -0.0,        0.0 );
diff --git a/isa/rv64uzfh/fadd.S b/isa/rv64uzfh/fadd.S
@@ -30,7 +30,7 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_H(10,  fmul.h, 1,                 1.1,      11.0,        0.1 );
 
   # Is the canonical NaN generated for Inf - Inf?
-  TEST_FP_OP2_H_HEX(11,  fsub.h, 0x10, 0x7e00, 0x7c00, 0x7c00);
+  TEST_FP_OP2_H_HEX(11,  fsub.h, 0x10, 0x7e00, Infh, Infh);
 
   TEST_PASSFAIL
 
diff --git a/isa/rv64uzfh/fclass.S b/isa/rv64uzfh/fclass.S
@@ -21,15 +21,15 @@ RVTEST_CODE_BEGIN
     TEST_CASE(testnum, a0, correct, li a0, input; fmv.h.x fa0, a0; \
                                     fclass.h a0, fa0)
 
-  TEST_FCLASS_H( 2, 1 << 0, 0xfc00 )
+  TEST_FCLASS_H( 2, 1 << 0, nInfh )
   TEST_FCLASS_H( 3, 1 << 1, 0xbc00 )
   TEST_FCLASS_H( 4, 1 << 2, 0x83ff )
   TEST_FCLASS_H( 5, 1 << 3, 0x8000 )
   TEST_FCLASS_H( 6, 1 << 4, 0x0000 )
   TEST_FCLASS_H( 7, 1 << 5, 0x03ff )
   TEST_FCLASS_H( 8, 1 << 6, 0x3c00 )
-  TEST_FCLASS_H( 9, 1 << 7, 0x7c00 )
-  TEST_FCLASS_H(10, 1 << 8, 0x7c01 )
+  TEST_FCLASS_H( 9, 1 << 7, Infh )
+  TEST_FCLASS_H(10, 1 << 8, sNaNh )
   TEST_FCLASS_H(11, 1 << 9, 0x7e00 )
 
   TEST_PASSFAIL
diff --git a/isa/rv64uzfh/fcvt_w.S b/isa/rv64uzfh/fcvt_w.S
@@ -92,8 +92,8 @@ RVTEST_DATA_BEGIN
 #tdat:
 #.word 0xffffffff
 #.word 0x7fffffff
-#.word 0xff800000
-#.word 0x7f800000
+#.word nInff
+#.word Inff
 
 tdat:
 .word 0xffffffff
diff --git a/isa/rv64uzfh/fmin.S b/isa/rv64uzfh/fmin.S
@@ -32,7 +32,7 @@ RVTEST_CODE_BEGIN
   TEST_FP_OP2_H(17,  fmax.h, 0,       -1.0,       -1.0,       -2.0 );
 
   # FMIN(sNaN, x) = x
-  TEST_FP_OP2_H_HEX(20,  fmax.h, 0x10, 0x3c00, 0x7c01, 0x3c00);
+  TEST_FP_OP2_H_HEX(20,  fmax.h, 0x10, 0x3c00, sNaNh, 0x3c00);
   # FMIN(hNaN, hNaN) = canonical NaN
   TEST_FP_OP2_H_HEX(21,  fmax.h, 0x00, 0x7e00, 0x7fff, 0x7fff);
 
