Finish the test for rv32i comformance tests

I have modified the emu-rv32i for supporting riscv-compliance
test-suite. However, it is needed to copy the makefile.include to the
specified directory which is explained in README.md.

Author: [email protected]

.gitignore

@@ -3,7 +3,7 @@ test1
 sig.txt
 rom.v
 debug.txt
-CSR.h
 # ignore generated files
 work
 *.mem
+*.signature.output

README.md

@@ -24,15 +24,19 @@ Passed RV32IC compliance tests from https://github.com/riscv/riscv-compliance
 Assume `emu-rv32i` in `$PATH` environment variable.
 ```shell
 $ git clone https://github.com/riscv/riscv-compliance
-$ cd riscv-compliance
+$ cd rv32emu
+$ cp rv32emu ../riscv-compliance/riscv-target
+$ cd ../riscv-compliance
 $ make RISCV_PREFIX=riscv-none-embed- RISCV_DEVICE=rv32i TARGET_SIM=emu-rv32i variant
 ```
 - Run RV32IMC compliance tests.
 Assume `emu-rv32i` in `$PATH` environment variable.
 ```shell
 $ git clone https://github.com/riscv/riscv-compliance
+$ cd rv32emu
+$ cp rv32emu ../riscv-compliance/riscv-target # If having copied the makefile.include to riscv-compliance, it can be ignored.
 $ cd riscv-compliance
-$ make RISCV_PREFIX=riscv-none-embed- RISCV_DEVICE=rv32imc TARGET_SIM=emu-rv32i variant
+$ make RISCV_PREFIX=riscv-none-embed- RISCV_DEVICE=rv32imc TARGET_SIM=/abs/path/to/emu-rv32i variant
 ```
 
 Compiling and running simple code:

emu-rv32i.c

@@ -21,8 +21,8 @@
 #include <unistd.h>
 
 /* uncomment this for an instruction trace and other debug outputs */
-// #define DEBUG_OUTPUT
-// #define DEBUG_EXTRA
+#define DEBUG_OUTPUT
+#define DEBUG_EXTRA
 
 #define STRICT_RV32I
 #define FALSE (0)
@@ -655,20 +655,20 @@ void raise_exception(uint32_t cause, uint32_t tval)
         return;
     }
 
-    switch (cause) {
-    case CAUSE_MACHINE_ECALL:
-        printf("Unimplement Machine ecall!\n");
-        return;
-    case CAUSE_USER_ECALL:
-        printf("Unimplement User ecall!\n");
-        return;
-    case CAUSE_SUPERVISOR_ECALL:
-        printf("Unimplement Supervisor ecall!\n");
-        return;
-    case CAUSE_HYPERVISOR_ECALL:
-        printf("Unimplement Hypervisor ecall!\n");
-        return;
-    }
+    // switch (cause) {
+    // case CAUSE_MACHINE_ECALL:
+    //     printf("Unimplement Machine ecall!\n");
+    //     return;
+    // case CAUSE_USER_ECALL:
+    //     printf("Unimplement User ecall!\n");
+    //     return;
+    // case CAUSE_SUPERVISOR_ECALL:
+    //     printf("Unimplement Supervisor ecall!\n");
+    //     return;
+    // case CAUSE_HYPERVISOR_ECALL:
+    //     printf("Unimplement Hypervisor ecall!\n");
+    //     return;
+    // }
 
     if (priv <= PRV_S) {
         /* delegate the exception to the supervisor priviledge */
@@ -2785,9 +2785,15 @@ void riscv_cpu_interp_x32()
 
         /* test for misaligned fetches , in order to match the compressed
          * instruction. */
+#ifdef RV32C
         if (next_pc & 0x1) {
             raise_exception(CAUSE_MISALIGNED_FETCH, next_pc);
         }
+#else
+        if (next_pc & 0x3) {
+            raise_exception(CAUSE_MISALIGNED_FETCH, next_pc);
+        }
+#endif
 
         /* update current PC */
         pc = next_pc;
@@ -2808,23 +2814,33 @@ int main(int argc, char **argv)
     setvbuf(stdout, NULL, _IONBF, 0);
     /* parse command line */
     const char *elf_file = NULL;
-    const char *signature_file = NULL;
+    int output_flag = 0;
     const char *output_file = NULL;
+    const char *elf_name = NULL;
+    const char* signature_file = NULL;
     int cmd_opt = 0;
     struct option opts[] = {{"elf", 1, NULL, 'e'},
-                            {"signature", 1, NULL, 's'},
-                            {"output", 1, NULL, 'o'}};
+                            {"verify", 1, NULL, 'v'},
+                            {"signaturedump", 0, NULL, 's'}};
     const char *optstring = "e:s:o:";
     while ((cmd_opt = getopt_long(argc, argv, optstring, opts, NULL)) != -1) {
         switch (cmd_opt) {
         case 'e':
             elf_file = optarg;
+            elf_name = strtok(strdup(elf_file), ".");
+            printf("%s\n", elf_name);
+            output_file = malloc(strlen(elf_name) + 30);
+            memset(output_file, '\0', strlen(elf_name) + 30);
+            strcat(output_file, elf_name);
+            strcat(output_file, ".signature.output");
+            printf("signature.output : %s\n", output_file);
             break;
-        case 's':
-            signature_file = optarg;
+        case 'v':
+            //signature_file = optarg;
             break;
-        case 'o':
-            output_file = optarg;
+        case 's':
+            //output_file = optarg;
+            output_flag = 1;
             break;
         default:
             printf("Unknow argument: %s\n", optarg);
@@ -2900,11 +2916,15 @@ int main(int argc, char **argv)
     while ((scn = elf_nextscn(elf, scn)) != NULL) {
         gelf_getshdr(scn, &shdr);
         const char *name = elf_strptr(elf, shstrndx, shdr.sh_name);
-
+        printf("section name: %s\n", name);
+        printf("Type: %d\n", shdr.sh_type);
         if (shdr.sh_type == SHT_PROGBITS) {
             if (strcmp(name, ".text") == 0) {
                 ram_start = shdr.sh_addr;
                 break;
+            }else if(strcmp(name, ".text.init") == 0){
+                ram_start = shdr.sh_addr;
+                break;
             }
         }
     }
@@ -3051,6 +3071,7 @@ int main(int argc, char **argv)
         fclose(sf);
     }
     if (output_file) {
+
         FILE *of = fopen(output_file, "w");
         int size = end_signature - begin_signature;
         for (int i = 0; i < size / 4; i++) {

rv32emu/compliance_io.h

@@ -0,0 +1,240 @@
+// RISC-V Compliance IO Test Header File
+
+/*
+ * Copyright (c) 2005-2018 Imperas Software Ltd., www.imperas.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+//
+// In general the following registers are reserved
+// ra, a0, t0, t1
+// x1, x10 x5, x6
+// new reserve x31
+//
+
+#ifndef _COMPLIANCE_IO_H
+#define _COMPLIANCE_IO_H
+
+#define RVTEST_IO_QUIET
+
+//-----------------------------------------------------------------------
+// RV IO Macros (Character transfer by custom instruction)
+//-----------------------------------------------------------------------
+#define STRINGIFY(x) #x
+#define TOSTRING(x)  STRINGIFY(x)
+
+#define RVTEST_CUSTOM1 0x0005200B
+
+#ifdef RVTEST_IO_QUIET
+
+#define RVTEST_IO_INIT
+#define RVTEST_IO_WRITE_STR(_SP, _STR)
+#define RVTEST_IO_CHECK()
+#define RVTEST_IO_ASSERT_GPR_EQ(_SP, _R, _I)
+#define RVTEST_IO_ASSERT_SFPR_EQ(_F, _R, _I)
+#define RVTEST_IO_ASSERT_DFPR_EQ(_D, _R, _I)
+
+#else
+
+#define RSIZE 4
+// _SP = (volatile register)
+#define LOCAL_IO_PUSH(_SP)                                              \
+    la      _SP,  begin_regstate;                                       \
+    sw      x1,   (1*RSIZE)(_SP);                                       \
+    sw      x5,   (5*RSIZE)(_SP);                                       \
+    sw      x6,   (6*RSIZE)(_SP);                                       \
+    sw      x8,   (8*RSIZE)(_SP);                                       \
+    sw      x10,  (10*RSIZE)(_SP);
+
+// _SP = (volatile register)
+#define LOCAL_IO_POP(_SP)                                               \
+    la      _SP,   begin_regstate;                                      \
+    lw      x1,   (1*RSIZE)(_SP);                                       \
+    lw      x5,   (5*RSIZE)(_SP);                                       \
+    lw      x6,   (6*RSIZE)(_SP);                                       \
+    lw      x8,   (8*RSIZE)(_SP);                                       \
+    lw      x10,  (10*RSIZE)(_SP);
+
+#define LOCAL_IO_WRITE_GPR(_R)                                          \
+    mv          a0, _R;                                                 \
+    jal         FN_WriteA0;
+
+#define LOCAL_IO_WRITE_FPR(_F)                                          \
+    fmv.x.s     a0, _F;                                                 \
+    jal         FN_WriteA0;
+
+#define LOCAL_IO_WRITE_DFPR(_V1, _V2)                                   \
+    mv          a0, _V1;                                                \
+    jal         FN_WriteA0; \
+    mv          a0, _V2; \
+    jal         FN_WriteA0; \
+
+#define LOCAL_IO_PUTC(_R)                                               \
+    .word RVTEST_CUSTOM1;                                               \
+
+#define RVTEST_IO_INIT
+
+// Assertion violation: file file.c, line 1234: (expr)
+// _SP = (volatile register)
+// _R = GPR
+// _I = Immediate
+#define RVTEST_IO_ASSERT_GPR_EQ(_SP, _R, _I)                            \
+    LOCAL_IO_PUSH(_SP)                                                  \
+    mv          s0, _R;                                                 \
+    li          t0, _I;                                                 \
+    beq         s0, t0, 20002f;                                         \
+    LOCAL_IO_WRITE_STR("Assertion violation: file ");                   \
+    LOCAL_IO_WRITE_STR(__FILE__);                                       \
+    LOCAL_IO_WRITE_STR(", line ");                                      \
+    LOCAL_IO_WRITE_STR(TOSTRING(__LINE__));                             \
+    LOCAL_IO_WRITE_STR(": ");                                           \
+    LOCAL_IO_WRITE_STR(# _R);                                           \
+    LOCAL_IO_WRITE_STR("(");                                            \
+    LOCAL_IO_WRITE_GPR(s0);                                             \
+    LOCAL_IO_WRITE_STR(") != ");                                        \
+    LOCAL_IO_WRITE_STR(# _I);                                           \
+    LOCAL_IO_WRITE_STR("\n");                                           \
+    li TESTNUM, 100;                                                    \
+    RVTEST_FAIL;                                                        \
+20002:                                                                  \
+    LOCAL_IO_POP(_SP)
+
+// _F = FPR
+// _C = GPR
+// _I = Immediate
+#define RVTEST_IO_ASSERT_SFPR_EQ(_F, _C, _I)                            \
+    fmv.x.s     t0, _F;                                                 \
+    beq         _C, t0, 20003f;                                         \
+    LOCAL_IO_WRITE_STR("Assertion violation: file ");                   \
+    LOCAL_IO_WRITE_STR(__FILE__);                                       \
+    LOCAL_IO_WRITE_STR(", line ");                                      \
+    LOCAL_IO_WRITE_STR(TOSTRING(__LINE__));                             \
+    LOCAL_IO_WRITE_STR(": ");                                           \
+    LOCAL_IO_WRITE_STR(# _F);                                           \
+    LOCAL_IO_WRITE_STR("(");                                            \
+    LOCAL_IO_WRITE_FPR(_F);                                             \
+    LOCAL_IO_WRITE_STR(") != ");                                        \
+    LOCAL_IO_WRITE_STR(# _I);                                           \
+    LOCAL_IO_WRITE_STR("\n");                                           \
+    li TESTNUM, 100;                                                    \
+    RVTEST_FAIL;                                                        \
+20003:
+
+// _D = DFPR
+// _R = GPR
+// _I = Immediate
+#define RVTEST_IO_ASSERT_DFPR_EQ(_D, _R, _I)                            \
+    fmv.x.d     t0, _D;                                                 \
+    beq         _R, t0, 20005f;                                         \
+    LOCAL_IO_WRITE_STR("Assertion violation: file ");                   \
+    LOCAL_IO_WRITE_STR(__FILE__);                                       \
+    LOCAL_IO_WRITE_STR(", line ");                                      \
+    LOCAL_IO_WRITE_STR(TOSTRING(__LINE__));                             \
+    LOCAL_IO_WRITE_STR(": ");                                           \
+    LOCAL_IO_WRITE_STR(# _D);                                           \
+    LOCAL_IO_WRITE_STR("(");                                            \
+    LOCAL_IO_WRITE_DFPR(_D);                                            \
+    LOCAL_IO_WRITE_STR(") != ");                                        \
+    LOCAL_IO_WRITE_STR(# _I);                                           \
+    LOCAL_IO_WRITE_STR("\n");                                           \
+    li TESTNUM, 100;                                                    \
+    RVTEST_FAIL;                                                        \
+20005:
+
+// _SP = (volatile register)
+#define LOCAL_IO_WRITE_STR(_STR) RVTEST_IO_WRITE_STR(x31, _STR)
+#define RVTEST_IO_WRITE_STR(_SP, _STR)                                  \
+    LOCAL_IO_PUSH(_SP)                                                  \
+    .section .data.string;                                              \
+20001:                                                                  \
+    .string _STR;                                                       \
+    .section .text.init;                                                \
+    la a0, 20001b;                                                      \
+    jal FN_WriteStr;                                                    \
+    LOCAL_IO_POP(_SP)
+
+// generate assertion listing
+#define LOCAL_CHECK() RVTEST_IO_CHECK()
+#define RVTEST_IO_CHECK()                                               \
+    li zero, -1;                                                        \
+
+//
+// FN_WriteStr: Uses a0, t0
+//
+FN_WriteStr:
+    mv          t0, a0;
+10000:
+    lbu         a0, (t0);
+    addi        t0, t0, 1;
+    beq         a0, zero, 10000f;
+    LOCAL_IO_PUTC(a0);
+    j           10000b;
+10000:
+    ret;
+
+//
+// FN_WriteA0: write register a0(x10) (destroys a0(x10), t0-t2(x5-x7))
+//
+FN_WriteA0:
+        mv          t0, a0
+        // determine architectural register width
+        li          a0, -1
+        srli        a0, a0, 31
+        srli        a0, a0, 1
+        bnez        a0, FN_WriteA0_64
+
+FN_WriteA0_32:
+        // reverse register when xlen is 32
+        li          t1, 8
+10000:  slli        t2, t2, 4
+        andi        a0, t0, 0xf
+        srli        t0, t0, 4
+        or          t2, t2, a0
+        addi        t1, t1, -1
+        bnez        t1, 10000b
+        li          t1, 8
+        j           FN_WriteA0_common
+
+FN_WriteA0_64:
+        // reverse register when xlen is 64
+        li          t1, 16
+10000:  slli        t2, t2, 4
+        andi        a0, t0, 0xf
+        srli        t0, t0, 4
+        or          t2, t2, a0
+        addi        t1, t1, -1
+        bnez        t1, 10000b
+        li          t1, 16
+
+FN_WriteA0_common:
+        // write reversed characters
+        li          t0, 10
+10000:  andi        a0, t2, 0xf
+        blt         a0, t0, 10001f
+        addi        a0, a0, 'a'-10
+        j           10002f
+10001:  addi        a0, a0, '0'
+10002:  LOCAL_IO_PUTC(a0)
+        srli        t2, t2, 4
+        addi        t1, t1, -1
+        bnez        t1, 10000b
+        ret
+
+#endif // RVTEST_IO_QUIET
+
+#endif // _COMPLIANCE_IO_H