Add an option to dump registers as JSON (sysprog21#128)

Author: long-long-float

README.md

@@ -153,6 +153,20 @@ $ riscv32-unknown-elf-gdb
 Congratulate yourself if `riscv-gdb` does not produce an error message. Now that the GDB
 command line is available, you can communicate with `rv32emu`.
 
+## Command line options
+
+### Dump registers as JSON
+
+If an option `--dump-registers [filename]` is specified, the emulator outputs registers as JSON format.
+This can be used for tests using the emulator, such as compiler tests.
+
+You can use the option with `--quiet` to use the output directly.
+
+```
+# Read the register x10 (a0).
+$ build/rv32emu --dump-registers - out.elf --quiet | jq .x10
+```
+
 ## Contributing
 See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
 

src/emulate.c

@@ -5,6 +5,7 @@
 
 #include <assert.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -1588,3 +1589,25 @@ void ecall_handler(riscv_t *rv)
     rv_except_ecall_M(rv, 0);
     syscall_handler(rv);
 }
+
+void dump_registers(riscv_t *rv, char *out_file_path)
+{
+    FILE *f;
+    if (strncmp(out_file_path, "-", 1) == 0) {
+        f = stdout;
+    } else {
+        f = fopen(out_file_path, "w");
+    }
+
+    if (!f) {
+        fprintf(stderr, "Cannot open registers output file.\n");
+        return;
+    }
+
+    fprintf(f, "{\n");
+    for (unsigned i = 0; i < RV_N_REGS; i++) {
+        char *comma = i < RV_N_REGS - 1 ? "," : "";
+        fprintf(f, "  \"x%d\": %u%s\n", i, rv->X[i], comma);
+    }
+    fprintf(f, "}\n");
+}

src/main.c

@@ -18,10 +18,17 @@ static bool opt_trace = false;
 static bool opt_gdbstub = false;
 #endif
 
+/* dump registers as JSON */
+static bool opt_dump_regs = false;
+static char *registers_out_file;
+
 /* RISC-V arch-test */
 static bool opt_arch_test = false;
 static char *signature_out_file;
 
+/* Quiet outputs */
+static bool opt_quiet_outputs = false;
+
 /* target executable */
 static const char *opt_prog_name = "a.out";
 
@@ -91,6 +98,9 @@ static void print_usage(const char *filename)
 #if RV32_HAS(GDBSTUB)
             "  --gdbstub : allow remote GDB connections (as gdbstub)\n"
 #endif
+            "  --dump-registers [filename]: dump registers as JSON to the "
+            "given file or `-` (STDOUT)\n"
+            "  --quiet : Suppress outputs other than `dump-registers`\n"
             "  --arch-test [filename] : dump signature to the given file, "
             "required by arch-test test\n",
             filename);
@@ -115,6 +125,23 @@ static bool parse_args(int argc, char **args)
                 continue;
             }
 #endif
+            if (!strcmp(arg, "--dump-registers")) {
+                opt_dump_regs = true;
+                if (i + 1 >= argc) {
+                    fprintf(stderr,
+                            "Filename for registers output required by "
+                            "dump-registers.\n");
+                    return false;
+                }
+                registers_out_file = args[++i];
+                continue;
+            }
+
+            if (!strcmp(arg, "--quiet")) {
+                opt_quiet_outputs = true;
+                continue;
+            }
+
             if (!strcmp(arg, "--arch-test")) {
                 opt_arch_test = true;
                 if (i + 1 >= argc) {
@@ -212,7 +239,7 @@ int main(int argc, char **args)
         state->break_addr = end->st_value;
 
     /* create the RISC-V runtime */
-    riscv_t *rv = rv_create(&io, state);
+    riscv_t *rv = rv_create(&io, state, !opt_quiet_outputs);
     if (!rv) {
         fprintf(stderr, "Unable to create riscv emulator\n");
         return 1;
@@ -237,6 +264,10 @@ int main(int argc, char **args)
         run(rv);
     }
 
+    /* dump registers as JSON */
+    if (opt_dump_regs)
+        dump_registers(rv, registers_out_file);
+
     /* dump test result in test mode */
     if (opt_arch_test)
         dump_test_signature(rv, elf);

src/riscv.c

@@ -76,7 +76,9 @@ riscv_word_t rv_get_reg(riscv_t *rv, uint32_t reg)
     return ~0U;
 }
 
-riscv_t *rv_create(const riscv_io_t *io, riscv_user_t userdata)
+riscv_t *rv_create(const riscv_io_t *io,
+                   riscv_user_t userdata,
+                   bool output_exit_code)
 {
     assert(io);
 
@@ -88,6 +90,8 @@ riscv_t *rv_create(const riscv_io_t *io, riscv_user_t userdata)
     /* copy over the userdata */
     rv->userdata = userdata;
 
+    rv->output_exit_code = output_exit_code;
+
     /* initialize the block map */
     block_map_init(&rv->block_map, 10);
 
@@ -107,6 +111,11 @@ bool rv_has_halted(riscv_t *rv)
     return rv->halt;
 }
 
+bool rv_enables_to_output_exit_code(riscv_t *rv)
+{
+    return rv->output_exit_code;
+}
+
 void rv_delete(riscv_t *rv)
 {
     assert(rv);

src/riscv.h

@@ -113,7 +113,9 @@ typedef struct {
 } riscv_io_t;
 
 /* create a RISC-V emulator */
-riscv_t *rv_create(const riscv_io_t *io, riscv_user_t user_data);
+riscv_t *rv_create(const riscv_io_t *io,
+                   riscv_user_t user_data,
+                   bool output_exit_code);
 
 /* delete a RISC-V emulator */
 void rv_delete(riscv_t *rv);
@@ -150,6 +152,9 @@ void syscall_handler(riscv_t *rv);
 /* environment call handler */
 void ecall_handler(riscv_t *rv);
 
+/* dump registers as JSON to out_file_path */
+void dump_registers(riscv_t *rv, char *out_file_path);
+
 /* breakpoint exception handler */
 void ebreak_handler(riscv_t *rv);
 
@@ -159,6 +164,9 @@ void rv_halt(riscv_t *rv);
 /* return the halt state */
 bool rv_has_halted(riscv_t *rv);
 
+/* return the flag of outputting exit code */
+bool rv_enables_to_output_exit_code(riscv_t *rv);
+
 #ifdef __cplusplus
 };
 #endif

src/riscv_private.h

@@ -121,6 +121,9 @@ struct riscv_internal {
 
     bool compressed;       /**< current instruction is compressed or not */
     block_map_t block_map; /**< basic block map */
+
+    /* print exit code on syscall_exit */
+    bool output_exit_code;
 };
 
 /* sign extend a 16 bit value */

src/syscall.c

@@ -107,9 +107,11 @@ static void syscall_exit(riscv_t *rv)
 {
     rv_halt(rv);
 
-    riscv_word_t code = rv_get_reg(rv, rv_reg_a0);
-    /* FIXME: add an option to show/hide this message */
-    fprintf(stdout, "inferior exit code %d\n", (int) code);
+    /* To avoid mixing with JSON output */
+    if (rv_enables_to_output_exit_code(rv)) {
+        riscv_word_t code = rv_get_reg(rv, rv_reg_a0);
+        fprintf(stdout, "inferior exit code %d\n", (int) code);
+    }
 }
 
 /* brk(increment)