cd7d21d1385c262e4ade9e7dc4cff37b3022d72f
1 // See LICENSE for license details.
3 #ifndef __TEST_MACROS_SCALAR_H
4 #define __TEST_MACROS_SCALAR_H
7 #-----------------------------------------------------------------------
9 #-----------------------------------------------------------------------
11 #define MASK_XLEN(x) ((x) & ((1 << (__riscv_xlen - 1) << 1) - 1))
13 #define TEST_CASE( testnum, testreg, correctval, code... ) \
16 li x29, MASK_XLEN(correctval); \
17 li TESTNUM, testnum; \
18 bne testreg, x29, fail;
20 # We use a macro hack to simpify code generation for various numbers
23 #define TEST_INSERT_NOPS_0
24 #define TEST_INSERT_NOPS_1 nop; TEST_INSERT_NOPS_0
25 #define TEST_INSERT_NOPS_2 nop; TEST_INSERT_NOPS_1
26 #define TEST_INSERT_NOPS_3 nop; TEST_INSERT_NOPS_2
27 #define TEST_INSERT_NOPS_4 nop; TEST_INSERT_NOPS_3
28 #define TEST_INSERT_NOPS_5 nop; TEST_INSERT_NOPS_4
29 #define TEST_INSERT_NOPS_6 nop; TEST_INSERT_NOPS_5
30 #define TEST_INSERT_NOPS_7 nop; TEST_INSERT_NOPS_6
31 #define TEST_INSERT_NOPS_8 nop; TEST_INSERT_NOPS_7
32 #define TEST_INSERT_NOPS_9 nop; TEST_INSERT_NOPS_8
33 #define TEST_INSERT_NOPS_10 nop; TEST_INSERT_NOPS_9
36 #-----------------------------------------------------------------------
38 #-----------------------------------------------------------------------
40 #-----------------------------------------------------------------------
41 # Tests for instructions with immediate operand
42 #-----------------------------------------------------------------------
44 #define SEXT_IMM(x) ((x) | (-(((x) >> 11) & 1) << 11))
46 #define TEST_IMM_OP( testnum, inst, result, val1, imm ) \
47 TEST_CASE( testnum, x3, result, \
48 li x1, MASK_XLEN(val1); \
49 inst x3, x1, SEXT_IMM(imm); \
52 #define TEST_IMM_SRC1_EQ_DEST( testnum, inst, result, val1, imm ) \
53 TEST_CASE( testnum, x1, result, \
54 li x1, MASK_XLEN(val1); \
55 inst x1, x1, SEXT_IMM(imm); \
58 #define TEST_IMM_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, imm ) \
59 TEST_CASE( testnum, x6, result, \
61 1: li x1, MASK_XLEN(val1); \
62 inst x3, x1, SEXT_IMM(imm); \
63 TEST_INSERT_NOPS_ ## nop_cycles \
70 #define TEST_IMM_SRC1_BYPASS( testnum, nop_cycles, inst, result, val1, imm ) \
71 TEST_CASE( testnum, x3, result, \
73 1: li x1, MASK_XLEN(val1); \
74 TEST_INSERT_NOPS_ ## nop_cycles \
75 inst x3, x1, SEXT_IMM(imm); \
81 #define TEST_IMM_ZEROSRC1( testnum, inst, result, imm ) \
82 TEST_CASE( testnum, x1, result, \
83 inst x1, x0, SEXT_IMM(imm); \
86 #define TEST_IMM_ZERODEST( testnum, inst, val1, imm ) \
87 TEST_CASE( testnum, x0, 0, \
88 li x1, MASK_XLEN(val1); \
89 inst x0, x1, SEXT_IMM(imm); \
92 #-----------------------------------------------------------------------
93 # Tests for vector config instructions
94 #-----------------------------------------------------------------------
96 #define TEST_VSETCFGIVL( testnum, nxpr, nfpr, bank, vl, result ) \
97 TEST_CASE( testnum, x1, result, \
98 li x1, (bank << 12); \
99 vsetcfg x1,nxpr,nfpr; \
104 #define TEST_VVCFG( testnum, nxpr, nfpr, bank, vl, result ) \
105 TEST_CASE( testnum, x1, result, \
106 li x1, (bank << 12) | (nfpr << 6) | nxpr; \
112 #define TEST_VSETVL( testnum, nxpr, nfpr, bank, vl, result ) \
113 TEST_CASE( testnum, x1, result, \
114 li x1, (bank << 12); \
115 vsetcfg x1,nxpr,nfpr; \
120 #-----------------------------------------------------------------------
121 # Tests for an instruction with register operands
122 #-----------------------------------------------------------------------
124 #define TEST_R_OP( testnum, inst, result, val1 ) \
125 TEST_CASE( testnum, x3, result, \
130 #define TEST_R_SRC1_EQ_DEST( testnum, inst, result, val1 ) \
131 TEST_CASE( testnum, x1, result, \
136 #define TEST_R_DEST_BYPASS( testnum, nop_cycles, inst, result, val1 ) \
137 TEST_CASE( testnum, x6, result, \
141 TEST_INSERT_NOPS_ ## nop_cycles \
148 #-----------------------------------------------------------------------
149 # Tests for an instruction with register-register operands
150 #-----------------------------------------------------------------------
152 #define TEST_RR_OP( testnum, inst, result, val1, val2 ) \
153 TEST_CASE( testnum, x3, result, \
154 li x1, MASK_XLEN(val1); \
155 li x2, MASK_XLEN(val2); \
159 #define TEST_RR_SRC1_EQ_DEST( testnum, inst, result, val1, val2 ) \
160 TEST_CASE( testnum, x1, result, \
161 li x1, MASK_XLEN(val1); \
162 li x2, MASK_XLEN(val2); \
166 #define TEST_RR_SRC2_EQ_DEST( testnum, inst, result, val1, val2 ) \
167 TEST_CASE( testnum, x2, result, \
168 li x1, MASK_XLEN(val1); \
169 li x2, MASK_XLEN(val2); \
173 #define TEST_RR_SRC12_EQ_DEST( testnum, inst, result, val1 ) \
174 TEST_CASE( testnum, x1, result, \
175 li x1, MASK_XLEN(val1); \
179 #define TEST_RR_DEST_BYPASS( testnum, nop_cycles, inst, result, val1, val2 ) \
180 TEST_CASE( testnum, x6, result, \
182 1: li x1, MASK_XLEN(val1); \
183 li x2, MASK_XLEN(val2); \
185 TEST_INSERT_NOPS_ ## nop_cycles \
192 #define TEST_RR_SRC12_BYPASS( testnum, src1_nops, src2_nops, inst, result, val1, val2 ) \
193 TEST_CASE( testnum, x3, result, \
195 1: li x1, MASK_XLEN(val1); \
196 TEST_INSERT_NOPS_ ## src1_nops \
197 li x2, MASK_XLEN(val2); \
198 TEST_INSERT_NOPS_ ## src2_nops \
205 #define TEST_RR_SRC21_BYPASS( testnum, src1_nops, src2_nops, inst, result, val1, val2 ) \
206 TEST_CASE( testnum, x3, result, \
208 1: li x2, MASK_XLEN(val2); \
209 TEST_INSERT_NOPS_ ## src1_nops \
210 li x1, MASK_XLEN(val1); \
211 TEST_INSERT_NOPS_ ## src2_nops \
218 #define TEST_RR_ZEROSRC1( testnum, inst, result, val ) \
219 TEST_CASE( testnum, x2, result, \
220 li x1, MASK_XLEN(val); \
224 #define TEST_RR_ZEROSRC2( testnum, inst, result, val ) \
225 TEST_CASE( testnum, x2, result, \
226 li x1, MASK_XLEN(val); \
230 #define TEST_RR_ZEROSRC12( testnum, inst, result ) \
231 TEST_CASE( testnum, x1, result, \
235 #define TEST_RR_ZERODEST( testnum, inst, val1, val2 ) \
236 TEST_CASE( testnum, x0, 0, \
237 li x1, MASK_XLEN(val1); \
238 li x2, MASK_XLEN(val2); \
242 #-----------------------------------------------------------------------
243 # Test memory instructions
244 #-----------------------------------------------------------------------
246 #define TEST_LD_OP( testnum, inst, result, offset, base ) \
247 TEST_CASE( testnum, x3, result, \
249 inst x3, offset(x1); \
252 #define TEST_ST_OP( testnum, load_inst, store_inst, result, offset, base ) \
253 TEST_CASE( testnum, x3, result, \
256 store_inst x2, offset(x1); \
257 load_inst x3, offset(x1); \
260 #define TEST_LD_DEST_BYPASS( testnum, nop_cycles, inst, result, offset, base ) \
262 li TESTNUM, testnum; \
265 inst x3, offset(x1); \
266 TEST_INSERT_NOPS_ ## nop_cycles \
274 #define TEST_LD_SRC1_BYPASS( testnum, nop_cycles, inst, result, offset, base ) \
276 li TESTNUM, testnum; \
279 TEST_INSERT_NOPS_ ## nop_cycles \
280 inst x3, offset(x1); \
287 #define TEST_ST_SRC12_BYPASS( testnum, src1_nops, src2_nops, load_inst, store_inst, result, offset, base ) \
289 li TESTNUM, testnum; \
292 TEST_INSERT_NOPS_ ## src1_nops \
294 TEST_INSERT_NOPS_ ## src2_nops \
295 store_inst x1, offset(x2); \
296 load_inst x3, offset(x2); \
303 #define TEST_ST_SRC21_BYPASS( testnum, src1_nops, src2_nops, load_inst, store_inst, result, offset, base ) \
305 li TESTNUM, testnum; \
308 TEST_INSERT_NOPS_ ## src1_nops \
310 TEST_INSERT_NOPS_ ## src2_nops \
311 store_inst x1, offset(x2); \
312 load_inst x3, offset(x2); \
319 #define TEST_BR2_OP_TAKEN( testnum, inst, val1, val2 ) \
321 li TESTNUM, testnum; \
325 bne x0, TESTNUM, fail; \
326 1: bne x0, TESTNUM, 3f; \
327 2: inst x1, x2, 1b; \
328 bne x0, TESTNUM, fail; \
331 #define TEST_BR2_OP_NOTTAKEN( testnum, inst, val1, val2 ) \
333 li TESTNUM, testnum; \
337 bne x0, TESTNUM, 2f; \
338 1: bne x0, TESTNUM, fail; \
339 2: inst x1, x2, 1b; \
342 #define TEST_BR2_SRC12_BYPASS( testnum, src1_nops, src2_nops, inst, val1, val2 ) \
344 li TESTNUM, testnum; \
347 TEST_INSERT_NOPS_ ## src1_nops \
349 TEST_INSERT_NOPS_ ## src2_nops \
355 #define TEST_BR2_SRC21_BYPASS( testnum, src1_nops, src2_nops, inst, val1, val2 ) \
357 li TESTNUM, testnum; \
360 TEST_INSERT_NOPS_ ## src1_nops \
362 TEST_INSERT_NOPS_ ## src2_nops \
368 #-----------------------------------------------------------------------
369 # Test jump instructions
370 #-----------------------------------------------------------------------
372 #define TEST_JR_SRC1_BYPASS( testnum, nop_cycles, inst ) \
374 li TESTNUM, testnum; \
377 TEST_INSERT_NOPS_ ## nop_cycles \
379 bne x0, TESTNUM, fail; \
384 #define TEST_JALR_SRC1_BYPASS( testnum, nop_cycles, inst ) \
386 li TESTNUM, testnum; \
389 TEST_INSERT_NOPS_ ## nop_cycles \
391 bne x0, TESTNUM, fail; \
397 #-----------------------------------------------------------------------
399 #-----------------------------------------------------------------------
401 #-----------------------------------------------------------------------
402 # Tests floating-point instructions
403 #-----------------------------------------------------------------------
405 #define TEST_FP_OP_S_INTERNAL( testnum, flags, result, val1, val2, val3, code... ) \
407 li TESTNUM, testnum; \
408 la a0, test_ ## testnum ## _data ;\
418 .pushsection .data; \
420 test_ ## testnum ## _data: \
427 #define TEST_FP_OP_D_INTERNAL( testnum, flags, result, val1, val2, val3, code... ) \
429 li TESTNUM, testnum; \
430 la a0, test_ ## testnum ## _data ;\
440 .pushsection .data; \
442 test_ ## testnum ## _data: \
449 #define TEST_FCVT_S_D( testnum, result, val1 ) \
450 TEST_FP_OP_D_INTERNAL( testnum, 0, double result, val1, 0.0, 0.0, \
451 fcvt.s.d f3, f0; fcvt.d.s f3, f3; fmv.x.d a0, f3)
453 #define TEST_FCVT_D_S( testnum, result, val1 ) \
454 TEST_FP_OP_S_INTERNAL( testnum, 0, float result, val1, 0.0, 0.0, \
455 fcvt.d.s f3, f0; fcvt.s.d f3, f3; fmv.x.s a0, f3)
457 #define TEST_FP_OP1_S( testnum, inst, flags, result, val1 ) \
458 TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, 0.0, 0.0, \
459 inst f3, f0; fmv.x.s a0, f3)
461 #define TEST_FP_OP1_D( testnum, inst, flags, result, val1 ) \
462 TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, 0.0, 0.0, \
463 inst f3, f0; fmv.x.d a0, f3)
465 #define TEST_FP_OP1_S_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
466 TEST_FP_OP_S_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
467 inst f3, f0; fmv.x.s a0, f3)
469 #define TEST_FP_OP1_D_DWORD_RESULT( testnum, inst, flags, result, val1 ) \
470 TEST_FP_OP_D_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
471 inst f3, f0; fmv.x.d a0, f3)
473 #define TEST_FP_OP2_S( testnum, inst, flags, result, val1, val2 ) \
474 TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, val2, 0.0, \
475 inst f3, f0, f1; fmv.x.s a0, f3)
477 #define TEST_FP_OP2_D( testnum, inst, flags, result, val1, val2 ) \
478 TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, val2, 0.0, \
479 inst f3, f0, f1; fmv.x.d a0, f3)
481 #define TEST_FP_OP3_S( testnum, inst, flags, result, val1, val2, val3 ) \
482 TEST_FP_OP_S_INTERNAL( testnum, flags, float result, val1, val2, val3, \
483 inst f3, f0, f1, f2; fmv.x.s a0, f3)
485 #define TEST_FP_OP3_D( testnum, inst, flags, result, val1, val2, val3 ) \
486 TEST_FP_OP_D_INTERNAL( testnum, flags, double result, val1, val2, val3, \
487 inst f3, f0, f1, f2; fmv.x.d a0, f3)
489 #define TEST_FP_INT_OP_S( testnum, inst, flags, result, val1, rm ) \
490 TEST_FP_OP_S_INTERNAL( testnum, flags, word result, val1, 0.0, 0.0, \
493 #define TEST_FP_INT_OP_D( testnum, inst, flags, result, val1, rm ) \
494 TEST_FP_OP_D_INTERNAL( testnum, flags, dword result, val1, 0.0, 0.0, \
497 #define TEST_FP_CMP_OP_S( testnum, inst, result, val1, val2 ) \
498 TEST_FP_OP_S_INTERNAL( testnum, 0, word result, val1, val2, 0.0, \
501 #define TEST_FP_CMP_OP_D( testnum, inst, result, val1, val2 ) \
502 TEST_FP_OP_D_INTERNAL( testnum, 0, dword result, val1, val2, 0.0, \
505 #define TEST_FCLASS_S(testnum, correct, input) \
506 TEST_CASE(testnum, a0, correct, li a0, input; fmv.s.x fa0, a0; \
509 #define TEST_FCLASS_D(testnum, correct, input) \
510 TEST_CASE(testnum, a0, correct, li a0, input; fmv.d.x fa0, a0; \
513 #define TEST_INT_FP_OP_S( testnum, inst, result, val1 ) \
515 li TESTNUM, testnum; \
516 la a0, test_ ## testnum ## _data ;\
523 .pushsection .data; \
525 test_ ## testnum ## _data: \
529 #define TEST_INT_FP_OP_D( testnum, inst, result, val1 ) \
531 li TESTNUM, testnum; \
532 la a0, test_ ## testnum ## _data ;\
539 .pushsection .data; \
541 test_ ## testnum ## _data: \
545 #-----------------------------------------------------------------------
546 # Pass and fail code (assumes test num is in TESTNUM)
547 #-----------------------------------------------------------------------
549 #define TEST_PASSFAIL \
550 bne x0, TESTNUM, pass; \
557 #-----------------------------------------------------------------------
559 #-----------------------------------------------------------------------