1  #include <catch/catch.hpp>
  2  
  3  #include <array>
  4  #include <biscuit/assembler.hpp>
  5  
  6  #include "assembler_test_utils.hpp"
  7  
  8  using namespace biscuit;
  9  
 10  TEST_CASE("ADD", "[rv32i]") {
 11      uint32_t value = 0;
 12      auto as = MakeAssembler32(value);
 13  
 14      as.ADD(x7, x15, x31);
 15      REQUIRE(value == 0x01F783B3);
 16  
 17      as.RewindBuffer();
 18  
 19      as.ADD(x31, x31, x31);
 20      REQUIRE(value == 0x01FF8FB3);
 21  
 22      as.RewindBuffer();
 23  
 24      as.ADD(x0, x0, x0);
 25      REQUIRE(value == 0x00000033);
 26  }
 27  
 28  TEST_CASE("ADDI", "[rv32i]") {
 29      uint32_t value = 0;
 30      auto as = MakeAssembler32(value);
 31  
 32      as.ADDI(x15, x31, 1024);
 33      REQUIRE(value == 0x400F8793);
 34  
 35      as.RewindBuffer();
 36  
 37      as.ADDI(x15, x31, 2048);
 38      REQUIRE(value == 0x800F8793);
 39  
 40      as.RewindBuffer();
 41  
 42      as.ADDI(x15, x31, 4095);
 43      REQUIRE(value == 0xFFFF8793);
 44  }
 45  
 46  TEST_CASE("AND", "[rv32i]") {
 47      uint32_t value = 0;
 48      auto as = MakeAssembler32(value);
 49  
 50      as.AND(x7, x15, x31);
 51      REQUIRE(value == 0x01F7F3B3);
 52  
 53      as.RewindBuffer();
 54  
 55      as.AND(x31, x31, x31);
 56      REQUIRE(value == 0x01FFFFB3);
 57  
 58      as.RewindBuffer();
 59  
 60      as.AND(x0, x0, x0);
 61      REQUIRE(value == 0x00007033);
 62  }
 63  
 64  TEST_CASE("ANDI", "[rv32i]") {
 65      uint32_t value = 0;
 66      auto as = MakeAssembler32(value);
 67  
 68      as.ANDI(x15, x31, 1024);
 69      REQUIRE(value == 0x400FF793);
 70  
 71      as.RewindBuffer();
 72  
 73      as.ANDI(x15, x31, 2048);
 74      REQUIRE(value == 0x800FF793);
 75  
 76      as.RewindBuffer();
 77  
 78      as.ANDI(x15, x31, 4095);
 79      REQUIRE(value == 0xFFFFF793);
 80  }
 81  
 82  TEST_CASE("AUIPC", "[rv32i]") {
 83      uint32_t value = 0;
 84      auto as = MakeAssembler32(value);
 85  
 86      as.AUIPC(x31, -1);
 87      REQUIRE(value == 0xFFFFFF97);
 88  
 89      as.RewindBuffer();
 90  
 91      as.AUIPC(x31, 0);
 92      REQUIRE(value == 0x00000F97);
 93  
 94      as.RewindBuffer();
 95  
 96      as.AUIPC(x31, 0x00FF00FF);
 97      REQUIRE(value == 0xF00FFF97);
 98  }
 99  
100  TEST_CASE("BEQ", "[rv32i]") {
101      uint32_t value = 0;
102      auto as = MakeAssembler32(value);
103  
104      as.BEQ(x15, x31, 2000);
105      REQUIRE(value == 0x7DF78863);
106  
107      as.RewindBuffer();
108  
109      as.BEQ(x15, x31, -2);
110      REQUIRE(value == 0xFFF78FE3);
111  }
112  
113  TEST_CASE("BGE", "[rv32i]") {
114      uint32_t value = 0;
115      auto as = MakeAssembler32(value);
116  
117      as.BGE(x15, x31, 2000);
118      REQUIRE(value == 0x7DF7D863);
119  
120      as.RewindBuffer();
121  
122      as.BGE(x15, x31, -2);
123      REQUIRE(value == 0xFFF7DFE3);
124  }
125  
126  TEST_CASE("BGEU", "[rv32i]") {
127      uint32_t value = 0;
128      auto as = MakeAssembler32(value);
129  
130      as.BGEU(x15, x31, 2000);
131      REQUIRE(value == 0x7DF7F863);
132  
133      as.RewindBuffer();
134  
135      as.BGEU(x15, x31, -2);
136      REQUIRE(value == 0xFFF7FFE3);
137  }
138  
139  TEST_CASE("BNE", "[rv32i]") {
140      uint32_t value = 0;
141      auto as = MakeAssembler32(value);
142  
143      as.BNE(x15, x31, 2000);
144      REQUIRE(value == 0x7DF79863);
145  
146      as.RewindBuffer();
147  
148      as.BNE(x15, x31, -2);
149      REQUIRE(value == 0xFFF79FE3);
150  }
151  
152  TEST_CASE("BLT", "[rv32i]") {
153      uint32_t value = 0;
154      auto as = MakeAssembler32(value);
155  
156      as.BLT(x15, x31, 2000);
157      REQUIRE(value == 0x7DF7C863);
158  
159      as.RewindBuffer();
160  
161      as.BLT(x15, x31, -2);
162      REQUIRE(value == 0xFFF7CFE3);
163  }
164  
165  TEST_CASE("BLTU", "[rv32i]") {
166      uint32_t value = 0;
167      auto as = MakeAssembler32(value);
168  
169      as.BLTU(x15, x31, 2000);
170      REQUIRE(value == 0x7DF7E863);
171  
172      as.RewindBuffer();
173  
174      as.BLTU(x15, x31, -2);
175      REQUIRE(value == 0xFFF7EFE3);
176  }
177  
178  TEST_CASE("CALL", "[rv32i]") {
179      std::array<uint32_t, 2> vals{};
180      auto as = MakeAssembler32(vals);
181  
182      const auto compare_vals = [&vals](uint32_t val_1, uint32_t val_2) {
183          REQUIRE(vals[0] == val_1);
184          REQUIRE(vals[1] == val_2);
185      };
186  
187      as.CALL(-1);
188      compare_vals(0x00000097, 0xFFF080E7);
189  }
190  
191  TEST_CASE("EBREAK", "[rv32i]") {
192      uint32_t value = 0;
193      auto as = MakeAssembler32(value);
194  
195      as.EBREAK();
196      REQUIRE(value == 0x00100073);
197  }
198  
199  TEST_CASE("ECALL", "[rv32i]") {
200      uint32_t value = 0;
201      auto as = MakeAssembler32(value);
202  
203      as.ECALL();
204      REQUIRE(value == 0x00000073);
205  }
206  
207  TEST_CASE("FENCE", "[rv32i]") {
208      uint32_t value = 0;
209      auto as = MakeAssembler32(value);
210  
211      as.FENCE(FenceOrder::IORW, FenceOrder::IORW);
212      REQUIRE(value == 0x0FF0000F);
213  
214      as.RewindBuffer();
215  
216      as.FENCETSO();
217      REQUIRE(value == 0x8330000F);
218  
219      as.RewindBuffer();
220  
221      as.FENCEI();
222      REQUIRE(value == 0x0000100F);
223  }
224  
225  TEST_CASE("JAL", "[rv32i]") {
226      uint32_t value = 0;
227      auto as = MakeAssembler32(value);
228  
229      as.JAL(x31, 0xFFFFFFFF);
230      REQUIRE(value == 0xFFFFFFEF);
231  
232      as.RewindBuffer();
233  
234      as.JAL(x31, 2000);
235      REQUIRE(value == 0x7D000FEF);
236  
237      as.RewindBuffer();
238  
239      as.JAL(x31, 100000);
240      REQUIRE(value == 0x6A018FEF);
241  }
242  
243  TEST_CASE("JALR", "[rv32i]") {
244      uint32_t value = 0;
245      auto as = MakeAssembler32(value);
246  
247      as.JALR(x15, 1024, x31);
248      REQUIRE(value == 0x400F87E7);
249  
250      as.RewindBuffer();
251  
252      as.JALR(x15, 1536, x31);
253      REQUIRE(value == 0x600F87E7);
254  
255      as.RewindBuffer();
256  
257      as.JALR(x15, -1, x31);
258      REQUIRE(value == 0xFFFF87E7);
259  }
260  
261  TEST_CASE("LB", "[rv32i]") {
262      uint32_t value = 0;
263      auto as = MakeAssembler32(value);
264  
265      as.LB(x15, 1024, x31);
266      REQUIRE(value == 0x400F8783);
267  
268      as.RewindBuffer();
269  
270      as.LB(x15, 1536, x31);
271      REQUIRE(value == 0x600F8783);
272  
273      as.RewindBuffer();
274  
275      as.LB(x15, -1, x31);
276      REQUIRE(value == 0xFFFF8783);
277  }
278  
279  TEST_CASE("LBU", "[rv32i]") {
280      uint32_t value = 0;
281      auto as = MakeAssembler32(value);
282  
283      as.LBU(x15, 1024, x31);
284      REQUIRE(value == 0x400FC783);
285  
286      as.RewindBuffer();
287  
288      as.LBU(x15, 1536, x31);
289      REQUIRE(value == 0x600FC783);
290  
291      as.RewindBuffer();
292  
293      as.LBU(x15, -1, x31);
294      REQUIRE(value == 0xFFFFC783);
295  }
296  
297  TEST_CASE("LH", "[rv32i]") {
298      uint32_t value = 0;
299      auto as = MakeAssembler32(value);
300  
301      as.LH(x15, 1024, x31);
302      REQUIRE(value == 0x400F9783);
303  
304      as.RewindBuffer();
305  
306      as.LH(x15, 1536, x31);
307      REQUIRE(value == 0x600F9783);
308  
309      as.RewindBuffer();
310  
311      as.LH(x15, -1, x31);
312      REQUIRE(value == 0xFFFF9783);
313  }
314  
315  TEST_CASE("LHU", "[rv32i]") {
316      uint32_t value = 0;
317      auto as = MakeAssembler32(value);
318  
319      as.LHU(x15, 1024, x31);
320      REQUIRE(value == 0x400FD783);
321  
322      as.RewindBuffer();
323  
324      as.LHU(x15, 1536, x31);
325      REQUIRE(value == 0x600FD783);
326  
327      as.RewindBuffer();
328  
329      as.LHU(x15, -1, x31);
330      REQUIRE(value == 0xFFFFD783);
331  }
332  
333  TEST_CASE("LI", "[rv32i]") {
334      std::array<uint32_t, 2> vals{};
335      auto as = MakeAssembler32(vals);
336  
337      const auto compare_vals = [&vals](uint32_t val_1, uint32_t val_2) {
338          REQUIRE(vals[0] == val_1);
339          REQUIRE(vals[1] == val_2);
340      };
341  
342      ///////// Single ADDI cases
343  
344      as.LI(x1, 0);
345      // addi x1, x0, 0
346      compare_vals(0x00000093, 0x00000000);
347      as.RewindBuffer();
348      vals = {};
349  
350      as.LI(x1, -1);
351      // addi x1, x0, -1
352      compare_vals(0xFFF00093, 0x00000000);
353      as.RewindBuffer();
354      vals = {};
355  
356      as.LI(x1, 42);
357      // addi x1, x0, 42
358      compare_vals(0x02A00093, 0x000000000);
359      as.RewindBuffer();
360      vals = {};
361  
362      as.LI(x1, 0x7ff);
363      // addi x1, x0, 2047
364      compare_vals(0x7FF00093, 0x00000000);
365      as.RewindBuffer();
366      vals = {};
367  
368      ///////// Single LUI cases
369  
370      as.LI(x1, 0x2A000);
371      // lui x1, 42
372      compare_vals(0x0002A0B7, 0x00000000);
373      as.RewindBuffer();
374      vals = {};
375  
376      as.LI(x1, ~0xFFF);
377      // lui x1, -1
378      compare_vals(0xFFFFF0B7, 0x00000000);
379      as.RewindBuffer();
380      vals = {};
381  
382      as.LI(x1, INT32_MIN);
383      // lui x1, -524288
384      compare_vals(0x800000B7, 0x00000000);
385      as.RewindBuffer();
386      vals = {};
387  
388      ///////// Full LUI+ADDI cases
389  
390      as.LI(x1, 0x11111111);
391      // lui x1, 69905
392      // addi x1, x1, 273
393      compare_vals(0x111110B7, 0x11108093);
394      as.RewindBuffer();
395      vals = {};
396  
397      as.LI(x1, INT32_MAX);
398      // lui x1, -524288
399      // addi x1, x1, -1
400      compare_vals(0x800000B7, 0xFFF08093);
401  }
402  
403  TEST_CASE("LUI", "[rv32i]") {
404      uint32_t value = 0;
405      auto as = MakeAssembler32(value);
406  
407      as.LUI(x10, 0xFFFFFFFF);
408      REQUIRE(value == 0xFFFFF537);
409  
410      as.RewindBuffer();
411  
412      as.LUI(x10, 0xFFF7FFFF);
413      REQUIRE(value == 0x7FFFF537);
414  
415      as.RewindBuffer();
416  
417      as.LUI(x31, 0xFFFFFFFF);
418      REQUIRE(value == 0xFFFFFFB7);
419  }
420  
421  TEST_CASE("LW", "[rv32i]") {
422      uint32_t value = 0;
423      auto as = MakeAssembler32(value);
424  
425      as.LW(x15, 1024, x31);
426      REQUIRE(value == 0x400FA783);
427  
428      as.RewindBuffer();
429  
430      as.LW(x15, 1536, x31);
431      REQUIRE(value == 0x600FA783);
432  
433      as.RewindBuffer();
434  
435      as.LW(x15, -1, x31);
436      REQUIRE(value == 0xFFFFA783);
437  }
438  
439  TEST_CASE("OR", "[rv32i]") {
440      uint32_t value = 0;
441      auto as = MakeAssembler32(value);
442  
443      as.OR(x7, x15, x31);
444      REQUIRE(value == 0x01F7E3B3);
445  
446      as.RewindBuffer();
447  
448      as.OR(x31, x31, x31);
449      REQUIRE(value == 0x01FFEFB3);
450  
451      as.RewindBuffer();
452  
453      as.OR(x0, x0, x0);
454      REQUIRE(value == 0x00006033);
455  }
456  
457  TEST_CASE("ORI", "[rv32i]") {
458      uint32_t value = 0;
459      auto as = MakeAssembler32(value);
460  
461      as.ORI(x15, x31, 1024);
462      REQUIRE(value == 0x400FE793);
463  
464      as.RewindBuffer();
465  
466      as.ORI(x15, x31, 2048);
467      REQUIRE(value == 0x800FE793);
468  
469      as.RewindBuffer();
470  
471      as.ORI(x15, x31, 4095);
472      REQUIRE(value == 0xFFFFE793);
473  }
474  
475  TEST_CASE("PAUSE", "[rv32i]") {
476      uint32_t value = 0;
477      auto as = MakeAssembler32(value);
478  
479      as.PAUSE();
480      REQUIRE(value == 0x0100000F);
481  }
482  
483  TEST_CASE("SB", "[rv32i]") {
484      uint32_t value = 0;
485      auto as = MakeAssembler32(value);
486  
487      as.SB(x31, 1024, x15);
488      REQUIRE(value == 0x41F78023);
489  
490      as.RewindBuffer();
491  
492      as.SB(x31, 1536, x15);
493      REQUIRE(value == 0x61F78023);
494  
495      as.RewindBuffer();
496  
497      as.SB(x31, -1, x15);
498      REQUIRE(value == 0xFFF78FA3);
499  }
500  
501  TEST_CASE("SH", "[rv32i]") {
502      uint32_t value = 0;
503      auto as = MakeAssembler32(value);
504  
505      as.SH(x31, 1024, x15);
506      REQUIRE(value == 0x41F79023);
507  
508      as.RewindBuffer();
509  
510      as.SH(x31, 1536, x15);
511      REQUIRE(value == 0x61F79023);
512  
513      as.RewindBuffer();
514  
515      as.SH(x31, -1, x15);
516      REQUIRE(value == 0xFFF79FA3);
517  }
518  
519  TEST_CASE("SLL", "[rv32i]") {
520      uint32_t value = 0;
521      auto as = MakeAssembler32(value);
522  
523      as.SLL(x7, x15, x31);
524      REQUIRE(value == 0x01F793B3);
525  
526      as.RewindBuffer();
527  
528      as.SLL(x31, x31, x31);
529      REQUIRE(value == 0x01FF9FB3);
530  
531      as.RewindBuffer();
532  
533      as.SLL(x0, x0, x0);
534      REQUIRE(value == 0x00001033);
535  }
536  
537  TEST_CASE("SLLI", "[rv32i]") {
538      uint32_t value = 0;
539      auto as = MakeAssembler32(value);
540  
541      as.SLLI(x31, x15, 10);
542      REQUIRE(value == 0x00A79F93);
543  
544      as.RewindBuffer();
545  
546      as.SLLI(x31, x15, 20);
547      REQUIRE(value == 0x01479F93);
548  
549      as.RewindBuffer();
550  
551      as.SLLI(x31, x15, 31);
552      REQUIRE(value == 0x01F79F93);
553  }
554  
555  TEST_CASE("SLT", "[rv32i]") {
556      uint32_t value = 0;
557      auto as = MakeAssembler32(value);
558  
559      as.SLT(x7, x15, x31);
560      REQUIRE(value == 0x01F7A3B3);
561  
562      as.RewindBuffer();
563  
564      as.SLT(x31, x31, x31);
565      REQUIRE(value == 0x01FFAFB3);
566  
567      as.RewindBuffer();
568  
569      as.SLT(x0, x0, x0);
570      REQUIRE(value == 0x00002033);
571  }
572  
573  TEST_CASE("SLTI", "[rv32i]") {
574      uint32_t value = 0;
575      auto as = MakeAssembler32(value);
576  
577      as.SLTI(x15, x31, 1024);
578      REQUIRE(value == 0x400FA793);
579  
580      as.RewindBuffer();
581  
582      as.SLTI(x15, x31, -2048);
583      REQUIRE(value == 0x800FA793);
584  
585      as.RewindBuffer();
586  
587      as.SLTI(x15, x31, -1);
588      REQUIRE(value == 0xFFFFA793);
589  }
590  
591  TEST_CASE("SLTIU", "[rv32i]") {
592      uint32_t value = 0;
593      auto as = MakeAssembler32(value);
594  
595      as.SLTIU(x15, x31, 1024);
596      REQUIRE(value == 0x400FB793);
597  
598      as.RewindBuffer();
599  
600      as.SLTIU(x15, x31, -2048);
601      REQUIRE(value == 0x800FB793);
602  
603      as.RewindBuffer();
604  
605      as.SLTIU(x15, x31, -1);
606      REQUIRE(value == 0xFFFFB793);
607  }
608  
609  TEST_CASE("SLTU", "[rv32i]") {
610      uint32_t value = 0;
611      auto as = MakeAssembler32(value);
612  
613      as.SLTU(x7, x15, x31);
614      REQUIRE(value == 0x01F7B3B3);
615  
616      as.RewindBuffer();
617  
618      as.SLTU(x31, x31, x31);
619      REQUIRE(value == 0x01FFBFB3);
620  
621      as.RewindBuffer();
622  
623      as.SLTU(x0, x0, x0);
624      REQUIRE(value == 0x00003033);
625  }
626  
627  TEST_CASE("SRA", "[rv32i]") {
628      uint32_t value = 0;
629      auto as = MakeAssembler32(value);
630  
631      as.SRA(x7, x15, x31);
632      REQUIRE(value == 0x41F7D3B3);
633  
634      as.RewindBuffer();
635  
636      as.SRA(x31, x31, x31);
637      REQUIRE(value == 0x41FFDFB3);
638  
639      as.RewindBuffer();
640  
641      as.SRA(x0, x0, x0);
642      REQUIRE(value == 0x40005033);
643  }
644  
645  TEST_CASE("SRAI", "[rv32i]") {
646      uint32_t value = 0;
647      auto as = MakeAssembler32(value);
648  
649      as.SRAI(x31, x15, 10);
650      REQUIRE(value == 0x40A7DF93);
651  
652      as.RewindBuffer();
653  
654      as.SRAI(x31, x15, 20);
655      REQUIRE(value == 0x4147DF93);
656  
657      as.RewindBuffer();
658  
659      as.SRAI(x31, x15, 31);
660      REQUIRE(value == 0x41F7DF93);
661  }
662  
663  TEST_CASE("SRL", "[rv32i]") {
664      uint32_t value = 0;
665      auto as = MakeAssembler32(value);
666  
667      as.SRL(x7, x15, x31);
668      REQUIRE(value == 0x01F7D3B3);
669  
670      as.RewindBuffer();
671  
672      as.SRL(x31, x31, x31);
673      REQUIRE(value == 0x01FFDFB3);
674  
675      as.RewindBuffer();
676  
677      as.SRL(x0, x0, x0);
678      REQUIRE(value == 0x00005033);
679  }
680  
681  TEST_CASE("SRLI", "[rv32i]") {
682      uint32_t value = 0;
683      auto as = MakeAssembler32(value);
684  
685      as.SRLI(x31, x15, 10);
686      REQUIRE(value == 0x00A7DF93);
687  
688      as.RewindBuffer();
689  
690      as.SRLI(x31, x15, 20);
691      REQUIRE(value == 0x0147DF93);
692  
693      as.RewindBuffer();
694  
695      as.SRLI(x31, x15, 31);
696      REQUIRE(value == 0x01F7DF93);
697  }
698  
699  TEST_CASE("SUB", "[rv32i]") {
700      uint32_t value = 0;
701      auto as = MakeAssembler32(value);
702  
703      as.SUB(x7, x15, x31);
704      REQUIRE(value == 0x41F783B3);
705  
706      as.RewindBuffer();
707  
708      as.SUB(x31, x31, x31);
709      REQUIRE(value == 0x41FF8FB3);
710  
711      as.RewindBuffer();
712  
713      as.SUB(x0, x0, x0);
714      REQUIRE(value == 0x40000033);
715  }
716  
717  TEST_CASE("SW", "[rv32i]") {
718      uint32_t value = 0;
719      auto as = MakeAssembler32(value);
720  
721      as.SW(x31, 1024, x15);
722      REQUIRE(value == 0x41F7A023);
723  
724      as.RewindBuffer();
725  
726      as.SW(x31, 1536, x15);
727      REQUIRE(value == 0x61F7A023);
728  
729      as.RewindBuffer();
730  
731      as.SW(x31, -1, x15);
732      REQUIRE(value == 0xFFF7AFA3);
733  }
734  
735  TEST_CASE("XOR", "[rv32i]") {
736      uint32_t value = 0;
737      auto as = MakeAssembler32(value);
738  
739      as.XOR(x7, x15, x31);
740      REQUIRE(value == 0x01F7C3B3);
741  
742      as.RewindBuffer();
743  
744      as.XOR(x31, x31, x31);
745      REQUIRE(value == 0x01FFCFB3);
746  
747      as.RewindBuffer();
748  
749      as.XOR(x0, x0, x0);
750      REQUIRE(value == 0x00004033);
751  }
752  
753  TEST_CASE("XORI", "[rv32i]") {
754      uint32_t value = 0;
755      auto as = MakeAssembler32(value);
756  
757      as.XORI(x15, x31, 1024);
758      REQUIRE(value == 0x400FC793);
759  
760      as.RewindBuffer();
761  
762      as.XORI(x15, x31, 2048);
763      REQUIRE(value == 0x800FC793);
764  
765      as.RewindBuffer();
766  
767      as.XORI(x15, x31, 4095);
768      REQUIRE(value == 0xFFFFC793);
769  }