1 #ifndef __TEST_MACROS_SCALAR_H
2 #define __TEST_MACROS_SCALAR_H
6 #-----------------------------------------------------------------------
8 #-----------------------------------------------------------------------
10 #define TEST_CASE( testnum, testreg, correctval, code... ) \
15 bne testreg, x29, fail;
17 #define TEST_CASE_JUMP( testnum, testreg, correctval, code... ) \
22 beq testreg, x29, pass_ ## testnum; \
26 # We use a macro hack to simpify code generation for various numbers
29 #define TEST_INSERT_NOPS_0
30 #define TEST_INSERT_NOPS_1 nop; TEST_INSERT_NOPS_0
31 #define TEST_INSERT_NOPS_2 nop; TEST_INSERT_NOPS_1
32 #define TEST_INSERT_NOPS_3 nop; TEST_INSERT_NOPS_2
33 #define TEST_INSERT_NOPS_4 nop; TEST_INSERT_NOPS_3
34 #define TEST_INSERT_NOPS_5 nop; TEST_INSERT_NOPS_4
35 #define TEST_INSERT_NOPS_6 nop; TEST_INSERT_NOPS_5
36 #define TEST_INSERT_NOPS_7 nop; TEST_INSERT_NOPS_6
37 #define TEST_INSERT_NOPS_8 nop; TEST_INSERT_NOPS_7
38 #define TEST_INSERT_NOPS_9 nop; TEST_INSERT_NOPS_8
39 #define TEST_INSERT_NOPS_10 nop; TEST_INSERT_NOPS_9
41 #-----------------------------------------------------------------------
42 # Tests for instructions with immediate operand
43 #-----------------------------------------------------------------------
45 #define TEST_IMM_OP( testnum, inst, result, val1, imm ) \
46 TEST_CASE( testnum, x3, result, \
51 #define TEST_IMM_SRC1_EQ_DEST( testnum, inst, result, val1, imm ) \
52 TEST_CASE( testnum, x1, result, \
57 #define TEST_IMM_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, imm ) \
58 TEST_CASE( testnum, x6, result, \
62 TEST_INSERT_NOPS_ ## nop_cycles \
69 #define TEST_IMM_SRC1_BYPASS( testnum, nop_cycles, inst, result, val1, imm ) \
70 TEST_CASE( testnum, x3, result, \
73 TEST_INSERT_NOPS_ ## nop_cycles \
80 #define TEST_IMM_ZEROSRC1( testnum, inst, result, imm ) \
81 TEST_CASE( testnum, x1, result, \
85 #define TEST_IMM_ZERODEST( testnum, inst, val1, imm ) \
86 TEST_CASE( testnum, x0, 0, \
91 #-----------------------------------------------------------------------
92 # Tests for vector config instructions
93 #-----------------------------------------------------------------------
95 #define TEST_VVCFGIVL( testnum, nxpr, nfpr, bank, vl, result ) \
96 TEST_CASE_JUMP( testnum, x1, result, \
100 vvcfgivl x1,x1,nxpr,nfpr; \
103 #define TEST_VVCFG( testnum, nxpr, nfpr, bank, vl, result ) \
104 TEST_CASE_JUMP( testnum, x1, result, \
114 #define TEST_VSETVL( testnum, nxpr, nfpr, bank, vl, result ) \
115 TEST_CASE_JUMP( testnum, x1, result, \
118 vvcfgivl x0,x0,nxpr,nfpr; \
123 #-----------------------------------------------------------------------
124 # Tests for an instruction with register operands
125 #-----------------------------------------------------------------------
127 #define TEST_R_OP( testnum, inst, result, val1 ) \
128 TEST_CASE( testnum, x3, result, \
133 #define TEST_R_SRC1_EQ_DEST( testnum, inst, result, val1 ) \
134 TEST_CASE( testnum, x1, result, \
139 #define TEST_R_DEST_BYPASS( testnum, nop_cycles, inst, result, val1 ) \
140 TEST_CASE( testnum, x6, result, \
144 TEST_INSERT_NOPS_ ## nop_cycles \
151 #-----------------------------------------------------------------------
152 # Tests for an instruction with register-register operands
153 #-----------------------------------------------------------------------
155 #define TEST_RR_OP( testnum, inst, result, val1, val2 ) \
156 TEST_CASE( testnum, x3, result, \
162 #define TEST_RR_SRC1_EQ_DEST( testnum, inst, result, val1, val2 ) \
163 TEST_CASE( testnum, x1, result, \
169 #define TEST_RR_SRC2_EQ_DEST( testnum, inst, result, val1, val2 ) \
170 TEST_CASE( testnum, x2, result, \
176 #define TEST_RR_SRC12_EQ_DEST( testnum, inst, result, val1 ) \
177 TEST_CASE( testnum, x1, result, \
182 #define TEST_RR_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, val2 ) \
183 TEST_CASE( testnum, x6, result, \
188 TEST_INSERT_NOPS_ ## nop_cycles \
195 #define TEST_RR_SRC12_BYPASS( testnum, src1_nops, src2_nops, inst, result, val1, val2 ) \
196 TEST_CASE( testnum, x3, result, \
199 TEST_INSERT_NOPS_ ## src1_nops \
201 TEST_INSERT_NOPS_ ## src2_nops \
208 #define TEST_RR_SRC21_BYPASS( testnum, src1_nops, src2_nops, inst, result, val1, val2 ) \
209 TEST_CASE( testnum, x3, result, \
212 TEST_INSERT_NOPS_ ## src1_nops \
214 TEST_INSERT_NOPS_ ## src2_nops \
221 #define TEST_RR_ZEROSRC1( testnum, inst, result, val ) \
222 TEST_CASE( testnum, x2, result, \
227 #define TEST_RR_ZEROSRC2( testnum, inst, result, val ) \
228 TEST_CASE( testnum, x2, result, \
233 #define TEST_RR_ZEROSRC12( testnum, inst, result ) \
234 TEST_CASE( testnum, x1, result, \
238 #define TEST_RR_ZERODEST( testnum, inst, val1, val2 ) \
239 TEST_CASE( testnum, x0, 0, \
245 #-----------------------------------------------------------------------
246 # Test memory instructions
247 #-----------------------------------------------------------------------
249 #define TEST_LD_OP( testnum, inst, result, offset, base ) \
250 TEST_CASE( testnum, x3, result, \
252 inst x3, offset(x1); \
255 #define TEST_ST_OP( testnum, load_inst, store_inst, result, offset, base ) \
256 TEST_CASE( testnum, x3, result, \
259 store_inst x2, offset(x1); \
260 load_inst x3, offset(x1); \
263 #define TEST_LD_DEST_BYPASS( testnum, nop_cycles, inst, result, offset, base ) \
268 inst x3, offset(x1); \
269 TEST_INSERT_NOPS_ ## nop_cycles \
277 #define TEST_LD_SRC1_BYPASS( testnum, nop_cycles, inst, result, offset, base ) \
282 TEST_INSERT_NOPS_ ## nop_cycles \
283 inst x3, offset(x1); \
290 #define TEST_ST_SRC12_BYPASS( testnum, src1_nops, src2_nops, load_inst, store_inst, result, offset, base ) \
295 TEST_INSERT_NOPS_ ## src1_nops \
297 TEST_INSERT_NOPS_ ## src2_nops \
298 store_inst x1, offset(x2); \
299 load_inst x3, offset(x2); \
306 #define TEST_ST_SRC21_BYPASS( testnum, src1_nops, src2_nops, load_inst, store_inst, result, offset, base ) \
311 TEST_INSERT_NOPS_ ## src1_nops \
313 TEST_INSERT_NOPS_ ## src2_nops \
314 store_inst x1, offset(x2); \
315 load_inst x3, offset(x2); \
322 #-----------------------------------------------------------------------
323 # Test branch instructions
324 #-----------------------------------------------------------------------
326 #define TEST_BR1_OP_TAKEN( testnum, inst, val1 ) \
332 1: bne x0, x28, 3f; \
337 #define TEST_BR1_OP_NOTTAKEN( testnum, inst, val1 ) \
343 1: bne x0, x28, fail; \
347 #define TEST_BR1_SRC1_BYPASS( testnum, nop_cycles, inst, val1 ) \
352 TEST_INSERT_NOPS_ ## nop_cycles \
358 #define TEST_BR2_OP_TAKEN( testnum, inst, val1, val2 ) \
365 1: bne x0, x28, 3f; \
366 2: inst x1, x2, 1b; \
370 #define TEST_BR2_OP_NOTTAKEN( testnum, inst, val1, val2 ) \
377 1: bne x0, x28, fail; \
378 2: inst x1, x2, 1b; \
381 #define TEST_BR2_SRC12_BYPASS( testnum, src1_nops, src2_nops, inst, val1, val2 ) \
386 TEST_INSERT_NOPS_ ## src1_nops \
388 TEST_INSERT_NOPS_ ## src2_nops \
394 #define TEST_BR2_SRC21_BYPASS( testnum, src1_nops, src2_nops, inst, val1, val2 ) \
399 TEST_INSERT_NOPS_ ## src1_nops \
401 TEST_INSERT_NOPS_ ## src2_nops \
407 #-----------------------------------------------------------------------
408 # Test jump instructions
409 #-----------------------------------------------------------------------
411 #define TEST_JR_SRC1_BYPASS( testnum, nop_cycles, inst ) \
416 TEST_INSERT_NOPS_ ## nop_cycles \
423 #define TEST_JALR_SRC1_BYPASS( testnum, nop_cycles, inst ) \
428 TEST_INSERT_NOPS_ ## nop_cycles \
435 #-----------------------------------------------------------------------
436 # Tests floating-point instructions
437 #-----------------------------------------------------------------------
439 #define TEST_FP_OP_S_INTERNAL( testnum, result, val1, val2, val3, code... ) \
442 la a0, test_ ## testnum ## _data ;\
451 test_ ## testnum ## _data: \
458 #define TEST_FP_OP_D_INTERNAL( testnum, result, val1, val2, val3, code... ) \
461 la a0, test_ ## testnum ## _data ;\
470 test_ ## testnum ## _data: \
477 #define TEST_FCVT_S_D( testnum, result, val1 ) \
478 TEST_FP_OP_D_INTERNAL( testnum, double result, val1, 0.0, 0.0, \
479 fcvt.s.d f3, f0; fcvt.d.s f3, f3; mftx.d a0, f3)
481 #define TEST_FCVT_D_S( testnum, result, val1 ) \
482 TEST_FP_OP_S_INTERNAL( testnum, float result, val1, 0.0, 0.0, \
483 fcvt.d.s f3, f0; fcvt.s.d f3, f3; mftx.s a0, f3)
485 #define TEST_FP_OP1_S( testnum, inst, result, val1 ) \
486 TEST_FP_OP_S_INTERNAL( testnum, float result, val1, 0.0, 0.0, \
487 inst f3, f0; mftx.s a0, f3)
489 #define TEST_FP_OP1_D( testnum, inst, result, val1 ) \
490 TEST_FP_OP_D_INTERNAL( testnum, double result, val1, 0.0, 0.0, \
491 inst f3, f0; mftx.d a0, f3)
493 #define TEST_FP_OP2_S( testnum, inst, result, val1, val2 ) \
494 TEST_FP_OP_S_INTERNAL( testnum, float result, val1, val2, 0.0, \
495 inst f3, f0, f1; mftx.s a0, f3)
497 #define TEST_FP_OP2_D( testnum, inst, result, val1, val2 ) \
498 TEST_FP_OP_D_INTERNAL( testnum, double result, val1, val2, 0.0, \
499 inst f3, f0, f1; mftx.d a0, f3)
501 #define TEST_FP_OP3_S( testnum, inst, result, val1, val2, val3 ) \
502 TEST_FP_OP_S_INTERNAL( testnum, float result, val1, val2, val3, \
503 inst f3, f0, f1, f2; mftx.s a0, f3)
505 #define TEST_FP_OP3_D( testnum, inst, result, val1, val2, val3 ) \
506 TEST_FP_OP_D_INTERNAL( testnum, double result, val1, val2, val3, \
507 inst f3, f0, f1, f2; mftx.d a0, f3)
509 #define TEST_FP_INT_OP_S( testnum, inst, result, val1, rm ) \
510 TEST_FP_OP_S_INTERNAL( testnum, word result, val1, 0.0, 0.0, \
513 #define TEST_FP_INT_OP_D( testnum, inst, result, val1, rm ) \
514 TEST_FP_OP_D_INTERNAL( testnum, dword result, val1, 0.0, 0.0, \
517 #define TEST_FP_CMP_OP_S( testnum, inst, result, val1, val2 ) \
518 TEST_FP_OP_S_INTERNAL( testnum, word result, val1, val2, 0.0, \
521 #define TEST_FP_CMP_OP_D( testnum, inst, result, val1, val2 ) \
522 TEST_FP_OP_D_INTERNAL( testnum, dword result, val1, val2, 0.0, \
525 #define TEST_INT_FP_OP_S( testnum, inst, result, val1 ) \
528 la a0, test_ ## testnum ## _data ;\
536 test_ ## testnum ## _data: \
540 #define TEST_INT_FP_OP_D( testnum, inst, result, val1 ) \
543 la a0, test_ ## testnum ## _data ;\
551 test_ ## testnum ## _data: \
555 #define TEST_ILLEGAL_VT_REGID( testnum, nxreg, nfreg, inst, reg1, reg2, reg3) \
561 la a0, handler ## testnum; \
564 vvcfgivl a0, a0, nxreg, nfreg; \
569 lui a0,%hi(vtcode1 ## testnum); \
570 vf %lo(vtcode1 ## testnum)(a0); \
574 vtcode1 ## testnum: \
576 illegal ## testnum: \
577 inst reg1, reg2, reg3; \
579 vtcode2 ## testnum: \
582 handler ## testnum: \
589 la a1,illegal ## testnum; \
592 vvcfgivl a0,a0,32,0; \
597 lui a0,%hi(vtcode2 ## testnum); \
598 vf %lo(vtcode2 ## testnum)(a0); \
616 #define TEST_ILLEGAL_TVEC_REGID( testnum, nxreg, nfreg, inst, reg1, reg2, aux) \
622 la a0, handler ## testnum; \
625 vvcfgivl a0, a0, nxreg, nfreg; \
630 lui a0,%hi(vtcode1 ## testnum); \
631 vf %lo(vtcode1 ## testnum)(a0); \
633 illegal ## testnum: \
638 vtcode1 ## testnum: \
641 vtcode2 ## testnum: \
644 handler ## testnum: \
654 vvcfgivl a0,a0,32,0; \
659 lui a0,%hi(vtcode2 ## testnum); \
660 vf %lo(vtcode2 ## testnum)(a0); \
678 #-----------------------------------------------------------------------
679 # Pass and fail code (assumes test num is in x28)
680 #-----------------------------------------------------------------------
683 #define TEST_PASSFAIL \