Support basic testing of more Zca instructions

By using Zca-friendly registers, we can reuse the existing tests to get
quick-and-dirty coverage of Zca, when the assembler is told to use Zca.
(This doesn't break non-Zca targets.)

1 files changed, 76 insertions, 76 deletions

diff --git a/isa/macros/scalar/test_macros.h b/isa/macros/scalar/test_macros.h
index 6c901d0..88049ea 100644
--- a/isa/macros/scalar/test_macros.h
+++ b/isa/macros/scalar/test_macros.h
@@ -45,14 +45,14 @@ test_ ## testnum: \
 
 #define TEST_IMM_OP( testnum, inst, result, val1, imm ) \
     TEST_CASE( testnum, x14, result, \
-      li  x1, MASK_XLEN(val1); \
-      inst x14, x1, SEXT_IMM(imm); \
+      li  x13, MASK_XLEN(val1); \
+      inst x14, x13, SEXT_IMM(imm); \
     )
 
 #define TEST_IMM_SRC1_EQ_DEST( testnum, inst, result, val1, imm ) \
-    TEST_CASE( testnum, x1, result, \
-      li  x1, MASK_XLEN(val1); \
-      inst x1, x1, SEXT_IMM(imm); \
+    TEST_CASE( testnum, x11, result, \
+      li  x11, MASK_XLEN(val1); \
+      inst x11, x11, SEXT_IMM(imm); \
     )
 
 #define TEST_IMM_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, imm ) \
@@ -123,29 +123,29 @@ test_ ## testnum: \
 
 #define TEST_RR_OP( testnum, inst, result, val1, val2 ) \
     TEST_CASE( testnum, x14, result, \
-      li  x1, MASK_XLEN(val1); \
-      li  x2, MASK_XLEN(val2); \
-      inst x14, x1, x2; \
+      li  x11, MASK_XLEN(val1); \
+      li  x12, MASK_XLEN(val2); \
+      inst x14, x11, x12; \
     )
 
 #define TEST_RR_SRC1_EQ_DEST( testnum, inst, result, val1, val2 ) \
-    TEST_CASE( testnum, x1, result, \
-      li  x1, MASK_XLEN(val1); \
-      li  x2, MASK_XLEN(val2); \
-      inst x1, x1, x2; \
+    TEST_CASE( testnum, x11, result, \
+      li  x11, MASK_XLEN(val1); \
+      li  x12, MASK_XLEN(val2); \
+      inst x11, x11, x12; \
     )
 
 #define TEST_RR_SRC2_EQ_DEST( testnum, inst, result, val1, val2 ) \
-    TEST_CASE( testnum, x2, result, \
-      li  x1, MASK_XLEN(val1); \
-      li  x2, MASK_XLEN(val2); \
-      inst x2, x1, x2; \
+    TEST_CASE( testnum, x12, result, \
+      li  x11, MASK_XLEN(val1); \
+      li  x12, MASK_XLEN(val2); \
+      inst x12, x11, x12; \
     )
 
 #define TEST_RR_SRC12_EQ_DEST( testnum, inst, result, val1 ) \
-    TEST_CASE( testnum, x1, result, \
-      li  x1, MASK_XLEN(val1); \
-      inst x1, x1, x1; \
+    TEST_CASE( testnum, x11, result, \
+      li  x11, MASK_XLEN(val1); \
+      inst x11, x11, x11; \
     )
 
 #define TEST_RR_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, val2 ) \
@@ -218,8 +218,8 @@ test_ ## testnum: \
 #define TEST_LD_OP( testnum, inst, result, offset, base ) \
     TEST_CASE( testnum, x14, result, \
       li  x15, result; /* Tell the exception handler the expected result. */ \
-      la  x1, base; \
-      inst x14, offset(x1); \
+      la  x2, base; \
+      inst x14, offset(x2); \
     )
 
 #define TEST_ST_OP( testnum, load_inst, store_inst, result, offset, base ) \
@@ -392,9 +392,9 @@ test_ ## testnum: \
 test_ ## testnum: \
   li  TESTNUM, testnum; \
   la  a0, test_ ## testnum ## _data ;\
-  flh f0, 0(a0); \
-  flh f1, 2(a0); \
-  flh f2, 4(a0); \
+  flh f10, 0(a0); \
+  flh f11, 2(a0); \
+  flh f12, 4(a0); \
   lh  a3, 6(a0); \
   code; \
   fsflags a1, x0; \
@@ -414,9 +414,9 @@ test_ ## testnum: \
 test_ ## testnum: \
   li  TESTNUM, testnum; \
   la  a0, test_ ## testnum ## _data ;\
-  flw f0, 0(a0); \
-  flw f1, 4(a0); \
-  flw f2, 8(a0); \
+  flw f10, 0(a0); \
+  flw f11, 4(a0); \
+  flw f12, 8(a0); \
   lw  a3, 12(a0); \
   code; \
   fsflags a1, x0; \
@@ -436,9 +436,9 @@ test_ ## testnum: \
 test_ ## testnum: \
   li  TESTNUM, testnum; \
   la  a0, test_ ## testnum ## _data ;\
-  fld f0, 0(a0); \
-  fld f1, 8(a0); \
-  fld f2, 16(a0); \
+  fld f10, 0(a0); \
+  fld f11, 8(a0); \
+  fld f12, 16(a0); \
   ld  a3, 24(a0); \
   code; \
   fsflags a1, x0; \
@@ -459,9 +459,9 @@ test_ ## testnum: \
 test_ ## testnum: \
   li  TESTNUM, testnum; \
   la  a0, test_ ## testnum ## _data ;\
-  fld f0, 0(a0); \
-  fld f1, 8(a0); \
-  fld f2, 16(a0); \
+  fld f10, 0(a0); \
+  fld f11, 8(a0); \
+  fld f12, 16(a0); \
   lw  a3, 24(a0); \
   lw  t1, 28(a0); \
   code; \
@@ -481,134 +481,134 @@ test_ ## testnum: \
 
 #define TEST_FCVT_S_D32( testnum, result, val1 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, 0, double result, val1, 0.0, 0.0, \
-                    fcvt.s.d f3, f0; fcvt.d.s f3, f3; fsd f3, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
+                    fcvt.s.d f13, f10; fcvt.d.s f13, f13; fsd f13, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
 
 #define TEST_FCVT_S_D( testnum, result, val1 ) \
   TEST_FP_OP_D_INTERNAL( testnum, 0, double result, val1, 0.0, 0.0, \
-                    fcvt.s.d f3, f0; fcvt.d.s f3, f3; fmv.x.d a0, f3)
+                    fcvt.s.d f13, f10; fcvt.d.s f13, f13; fmv.x.d a0, f13)
 
 #define TEST_FCVT_D_S( testnum, result, val1 ) \
   TEST_FP_OP_S_INTERNAL( testnum, 0, float result, val1, 0.0, 0.0, \
-                    fcvt.d.s f3, f0; fcvt.s.d f3, f3; fmv.x.s a0, f3)
+                    fcvt.d.s f13, f10; fcvt.s.d f13, f13; fmv.x.s a0, f13)
 
 #define TEST_FCVT_H_S( testnum, result, val1 ) \
   TEST_FP_OP_H_INTERNAL( testnum, 0, float16 result, val1, 0.0, 0.0, \
-                    fcvt.s.h f3, f0; fcvt.h.s f3, f3; fmv.x.h a0, f3)
+                    fcvt.s.h f13, f10; fcvt.h.s f13, f13; fmv.x.h a0, f13)
 
 #define TEST_FCVT_H_D( testnum, result, val1 ) \
   TEST_FP_OP_H_INTERNAL( testnum, 0, float16 result, val1, 0.0, 0.0, \
-                    fcvt.d.h f3, f0; fcvt.h.d f3, f3; fmv.x.h a0, f3)
+                    fcvt.d.h f13, f10; fcvt.h.d f13, f13; fmv.x.h a0, f13)
 
 
 #define TEST_FP_OP1_H( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, float16 result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.h a0, f3;)
+                    inst f13, f10; fmv.x.h a0, f13;)
 
 #define TEST_FP_OP1_S( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.s a0, f3)
+                    inst f13, f10; fmv.x.s a0, f13)
 
 #define TEST_FP_OP1_D32( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, double result, val1, 0.0, 0.0, \
-                    inst f3, f0; fsd f3, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
+                    inst f13, f10; fsd f13, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
 // ^: store computation result in address from a0, load high-word into t2
 
 #define TEST_FP_OP1_D( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.d a0, f3)
+                    inst f13, f10; fmv.x.d a0, f13)
 
 #define TEST_FP_OP1_S_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.s a0, f3)
+                    inst f13, f10; fmv.x.s a0, f13)
 
 #define TEST_FP_OP1_H_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, word result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.h a0, f3)
+                    inst f13, f10; fmv.x.h a0, f13)
 
 #define TEST_FP_OP1_D32_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
-                    inst f3, f0; fsd f3, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
+                    inst f13, f10; fsd f13, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
 // ^: store computation result in address from a0, load high-word into t2
 
 #define TEST_FP_OP1_D_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
-                    inst f3, f0; fmv.x.d a0, f3)
+                    inst f13, f10; fmv.x.d a0, f13)
 
 #define TEST_FP_OP2_S( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, val2, 0.0, \
-                    inst f3, f0, f1; fmv.x.s a0, f3)
+                    inst f13, f10, f11; fmv.x.s a0, f13)
 
 #define TEST_FP_OP2_H( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, float16 result, val1, val2, 0.0, \
-                    inst f3, f0, f1; fmv.x.h a0, f3)
+                    inst f13, f10, f11; fmv.x.h a0, f13)
 
 #define TEST_FP_OP2_D32( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, double result, val1, val2, 0.0, \
-                    inst f3, f0, f1; fsd f3, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
+                    inst f13, f10, f11; fsd f13, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
 // ^: store computation result in address from a0, load high-word into t2
 
 #define TEST_FP_OP2_D( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, val2, 0.0, \
-                    inst f3, f0, f1; fmv.x.d a0, f3)
+                    inst f13, f10, f11; fmv.x.d a0, f13)
 
 #define TEST_FP_OP3_S( testnum, inst, flags, result, val1, val2, val3 ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, val2, val3, \
-                    inst f3, f0, f1, f2; fmv.x.s a0, f3)
+                    inst f13, f10, f11, f12; fmv.x.s a0, f13)
 
 #define TEST_FP_OP3_H( testnum, inst, flags, result, val1, val2, val3 ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, float16 result, val1, val2, val3, \
-                    inst f3, f0, f1, f2; fmv.x.h a0, f3)
+                    inst f13, f10, f11, f12; fmv.x.h a0, f13)
 
 #define TEST_FP_OP3_D32( testnum, inst, flags, result, val1, val2, val3 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, double result, val1, val2, val3, \
-                    inst f3, f0, f1, f2; fsd f3, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
+                    inst f13, f10, f11, f12; fsd f13, 0(a0); lw t2, 4(a0); lw a0, 0(a0))
 // ^: store computation result in address from a0, load high-word into t2
 
 #define TEST_FP_OP3_D( testnum, inst, flags, result, val1, val2, val3 ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, val2, val3, \
-                    inst f3, f0, f1, f2; fmv.x.d a0, f3)
+                    inst f13, f10, f11, f12; fmv.x.d a0, f13)
 
 #define TEST_FP_INT_OP_S( testnum, inst, flags, result, val1, rm ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, word result, val1, 0.0, 0.0, \
-                    inst a0, f0, rm)
+                    inst a0, f10, rm)
 
 #define TEST_FP_INT_OP_H( testnum, inst, flags, result, val1, rm ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, word result, val1, 0.0, 0.0, \
-                    inst a0, f0, rm)
+                    inst a0, f10, rm)
 
 #define TEST_FP_INT_OP_D32( testnum, inst, flags, result, val1, rm ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
-                    inst a0, f0, f1; li t2, 0)
+                    inst a0, f10, f11; li t2, 0)
 
 #define TEST_FP_INT_OP_D( testnum, inst, flags, result, val1, rm ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
-                    inst a0, f0, rm)
+                    inst a0, f10, rm)
 
 #define TEST_FP_CMP_OP_S( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_S_INTERNAL( testnum, flags, word result, val1, val2, 0.0, \
-                    inst a0, f0, f1)
+                    inst a0, f10, f11)
 
 #define TEST_FP_CMP_OP_H( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_H_INTERNAL( testnum, flags, hword result, val1, val2, 0.0, \
-                    inst a0, f0, f1)
+                    inst a0, f10, f11)
 
 #define TEST_FP_CMP_OP_D32( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_D32_INTERNAL( testnum, flags, dword result, val1, val2, 0.0, \
-                    inst a0, f0, f1; li t2, 0)
+                    inst a0, f10, f11; li t2, 0)
 
 #define TEST_FP_CMP_OP_D( testnum, inst, flags, result, val1, val2 ) \
   TEST_FP_OP_D_INTERNAL( testnum, flags, dword result, val1, val2, 0.0, \
-                    inst a0, f0, f1)
+                    inst a0, f10, f11)
 
 #define TEST_FCLASS_S(testnum, correct, input) \
-  TEST_CASE(testnum, a0, correct, li a0, input; fmv.s.x fa0, a0; \
-                    fclass.s a0, fa0)
+  TEST_CASE(testnum, a0, correct, li a0, input; fmv.s.x f10, a0; \
+                    fclass.s a0, f10)
 
 #define TEST_FCLASS_D32(testnum, correct, input) \
   TEST_CASE(testnum, a0, correct, \
             la a0, test_ ## testnum ## _data ;\
-            fld fa0, 0(a0); \
-            fclass.d a0, fa0) \
+            fld f10, 0(a0); \
+            fclass.d a0, f10) \
     .pushsection .data; \
     .align 3; \
     test_ ## testnum ## _data: \
@@ -616,8 +616,8 @@ test_ ## testnum: \
     .popsection
 
 #define TEST_FCLASS_D(testnum, correct, input) \
-  TEST_CASE(testnum, a0, correct, li a0, input; fmv.d.x fa0, a0; \
-                    fclass.d a0, fa0)
+  TEST_CASE(testnum, a0, correct, li a0, input; fmv.d.x f10, a0; \
+                    fclass.d a0, f10)
 
 #define TEST_INT_FP_OP_S( testnum, inst, result, val1 ) \
 test_ ## testnum: \
@@ -625,9 +625,9 @@ test_ ## testnum: \
   la  a0, test_ ## testnum ## _data ;\
   lw  a3, 0(a0); \
   li  a0, val1; \
-  inst f0, a0; \
+  inst f10, a0; \
   fsflags x0; \
-  fmv.x.s a0, f0; \
+  fmv.x.s a0, f10; \
   bne a0, a3, fail; \
   .pushsection .data; \
   .align 2; \
@@ -641,9 +641,9 @@ test_ ## testnum: \
   la  a0, test_ ## testnum ## _data ;\
   lh  a3, 0(a0); \
   li  a0, val1; \
-  inst f0, a0; \
+  inst f10, a0; \
   fsflags x0; \
-  fmv.x.h a0, f0; \
+  fmv.x.h a0, f10; \
   bne a0, a3, fail; \
   .pushsection .data; \
   .align 1; \
@@ -658,9 +658,9 @@ test_ ## testnum: \
   lw  a3, 0(a0); \
   lw  a4, 4(a0); \
   li  a1, val1; \
-  inst f0, a1; \
+  inst f10, a1; \
   \
-  fsd f0, 0(a0); \
+  fsd f10, 0(a0); \
   lw a1, 4(a0); \
   lw a0, 0(a0); \
   \
@@ -679,9 +679,9 @@ test_ ## testnum: \
   la  a0, test_ ## testnum ## _data ;\
   ld  a3, 0(a0); \
   li  a0, val1; \
-  inst f0, a0; \
+  inst f10, a0; \
   fsflags x0; \
-  fmv.x.d a0, f0; \
+  fmv.x.d a0, f10; \
   bne a0, a3, fail; \
   .pushsection .data; \
   .align 3; \