emu_run_report.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#include "board_net.h"
#include "board_periph.h"
#include "board_periph_sd.h"
#include "board_view.h"
#include "emu_console.h"
#include "emu_cpu1.h"
#include "emu_elf_source_internal.h"
#include "emu_engine.h"
#include "emu_exc.h"
#include "emu_host_io_internal.h"
#include "emu_mmio.h"
#include "emu_prof.h"
#include "emu_run_internal.h"
#include "emu_seams.h"
#include "emu_view.h"

typedef struct {
  uc_err   err;              
  uint32_t run_pc;           
  uint32_t chunks;           
  uint32_t max_chunks;       
  double   wall_s;           
  uint32_t idle_stop_chunks; 
  bool     timed_out;        
  bool     idle_stopped;     
  bool     usb_stopped;      
  bool     stop_sym_hit;     
  bool     prof_stopped;     
} run_stop_t;

RA8_INTERNAL static void internal_run_print_sd_summary(void)
{
  bool        sd_att = false;
  uint64_t    sd_b   = 0U;
  uint8_t     sd_f   = 0U;
  const char* sd_l   = nullptr;
  board_sd_info(&sd_att, &sd_b, &sd_f, &sd_l);
  const uint64_t gib_bytes = (uint64_t)k_size_kib * (uint64_t)k_size_kib * (uint64_t)k_size_kib;
  const uint64_t mib_bytes = (uint64_t)k_size_kib * (uint64_t)k_size_kib;
  const bool     sd_gb     = (sd_b >= gib_bytes);
  const unsigned long sd_sz =
    sd_gb ? (unsigned long)(sd_b / gib_bytes) : (unsigned long)(sd_b / mib_bytes);
  const char* sd_u = sd_gb ? "GB" : "MB";
  if (sd_att && (sd_f != 0U)) {
    (void)priv_emu_io_errf("  SD card       : %lu %s FAT%u '%s' (created by --sd-new)\n",
                           sd_sz,
                           sd_u,
                           (unsigned)sd_f,
                           (sd_l != nullptr) ? sd_l : "");
  } else if (sd_att) {
    (void)priv_emu_io_errf("  SD card       : %lu %s image attached\n", sd_sz, sd_u);
  }
}

RA8_INTERNAL static void internal_run_print_stop_summary(uc_engine* uc, const run_stop_t* st)
{
  (void)priv_emu_io_errf("\nra8_emulator: stopped -- %s%s%s%s%s%s\n",
                         uc_strerror(st->err),
                         st->timed_out ? " (wall-clock budget reached)" : "",
                         st->idle_stopped ? " (idle steady-state)" : "",
                         st->usb_stopped ? " (USB enumerated)" : "",
                         st->stop_sym_hit ? " (--stop-sym threshold reached)" : "",
                         st->prof_stopped ? " (profile: boot complete)" : "");
  (void)priv_emu_io_errf("  final PC      : 0x%08X\n", st->run_pc);
  if (emu_exc_bkpt_hit()) {
    (void)priv_emu_io_errf("  => firmware executed a BKPT @ 0x%08X (deliberate trap: "
                           "Default_Handler / failed assert / fault give-up)\n",
                           emu_exc_bkpt_pc());
  }
  (void)priv_emu_io_errf("  chunks run    : %u   SysTick ticks: %u\n",
                         st->chunks,
                         emu_exc_systick_fires());
  if (emu_mve_emulated_count() > 0U) {
    (void)priv_emu_io_errf("  MVE (Helium)  : %llu instruction(s) emulated "
                           "(M85 vector ops the M33 "
                           "core lacks)\n",
                           (unsigned long long)emu_mve_emulated_count());
  }
  if (emu_lob_emulated_count() > 0U) {
    (void)priv_emu_io_errf("  LOB (loop)    : %llu DLS/LE instruction(s) "
                           "emulated (M85 hardware-loop "
                           "ops)\n",
                           (unsigned long long)emu_lob_emulated_count());
  }
  prof_report();
  (void)priv_emu_io_errf("  exceptions    : %u PendSV  %u SVCall (real Cortex-M entry/return)\n",
                         emu_exc_pendsv_takes(),
                         emu_exc_svc_takes());
  (void)priv_emu_io_errf("  touch clicks  : %u drained via ra8_touch -> I3C -> GT911\n",
                         board_periph_touch_reported());
  /* Emit any console bytes still buffered without a trailing newline. */
  console_flush_line(board_periph_sci_console_channel());
  /* Peripheral-model observability: LED transitions, timer totals, IRQ counts,
   * SCI byte totals. */
  board_periph_report(uc);
  board_net_report();
  emu_mmio_print_counts();
  internal_run_print_sd_summary();
  emu_mmio_print_bgc_and_table();
}

RA8_INTERNAL static void internal_run_print_verdict(const run_stop_t* st)
{
  if (st->timed_out && !st->idle_stopped && !st->usb_stopped && !st->stop_sym_hit &&
      !st->prof_stopped && !emu_exc_bkpt_hit()) {
    /* The wall-clock guard fired (clock() is CPU-time, so a heavily-loaded host
     * burns the budget faster). This is a TRUNCATED run, NOT a completed one --
     * say so plainly, and do NOT print the "EXECUTED to the run budget" line a
     * full-budget run prints. Conflating the two let a load-correlated
     * truncation masquerade as success, dropping a deterministic banner without
     * failing the gate (#168). A caller that wants the run bounded by a
     * deterministic event (not by CPU-time) should pass RA8_EMU_STOP_ON /
     * RA8_EMU_MAX_CHUNKS. */
    (void)priv_emu_io_errf("  => ra8_emulator TRUNCATED by the wall-clock guard at chunk %u of %u "
                           "(%.0fs CPU-time elapsed); this is NOT a full-budget run (host "
                           "overloaded -- see #168).\n",
                           st->chunks,
                           st->max_chunks,
                           st->wall_s);
  } else if (((st->err == UC_ERR_OK) || st->idle_stopped || st->usb_stopped || st->stop_sym_hit ||
              st->prof_stopped) &&
             !emu_exc_bkpt_hit()) {
    if (st->idle_stopped) {
      (void)priv_emu_io_errf("  => firmware EXECUTED to the run budget (idle steady-state: no "
                             "observable change for %u chunks, stopped at chunk %u).\n",
                             st->idle_stop_chunks,
                             st->chunks);
    } else if (st->usb_stopped) {
      (void)priv_emu_io_errf("  => firmware EXECUTED to the run budget (USB enumerated: device "
                             "CONFIGURED, stopped at chunk %u).\n",
                             st->chunks);
    } else {
      (void)priv_emu_io_errf("  => firmware EXECUTED to the run budget (no "
                             "invalid opcode / fault).\n");
    }
  }
}

RA8_INTERNAL static void internal_run_print_dump_syms(uc_engine* uc, const emu_run_cfg_t* cfg)
{
  /* --dump-sym: read each resolved global from Unicorn memory and print its
   * 32-bit value (and the address), so a test can probe firmware state (e.g. an
   * init-step or mismatch counter) after the run without a debugger. */
  for (uint32_t d = 0U; d < cfg->dump_sym_n; d++) {
    if (cfg->dump_sym_addrs[d] == 0U) {
      (void)priv_emu_io_errf("  dump-sym      : %s = <unresolved>\n", cfg->dump_sym_names[d]);
      continue;
    }
    uint32_t v = 0U;
    if (emu_mem_read(uc, (uint64_t)cfg->dump_sym_addrs[d], &v, sizeof(v)) == UC_ERR_OK) {
      (void)priv_emu_io_errf("  dump-sym      : %s @0x%08X = %u (0x%08X)\n",
                             cfg->dump_sym_names[d],
                             cfg->dump_sym_addrs[d],
                             v,
                             v);
    } else {
      (void)priv_emu_io_errf("  dump-sym      : %s @0x%08X = <unreadable>\n",
                             cfg->dump_sym_names[d],
                             cfg->dump_sym_addrs[d]);
    }
  }
}
 
void priv_run_report(const run_loop_t* st)
{
  emu_view_mark_stopped(st->run_pc); /* final / held frame shows "parked". */
  const run_stop_t stop = {
    .err              = st->err,
    .run_pc           = st->run_pc,
    .chunks           = st->chunks,
    .max_chunks       = st->guards.max_chunks,
    .wall_s           = st->guards.wall_s,
    .idle_stop_chunks = st->guards.idle_stop_chunks,
    .timed_out        = st->timed_out,
    .idle_stopped     = st->idle_stopped,
    .usb_stopped      = st->usb_stopped,
    .stop_sym_hit     = st->stop_sym_hit,
    .prof_stopped     = st->prof_stopped,
  };
  internal_run_print_stop_summary(st->cfg->uc, &stop);
  internal_run_print_verdict(&stop);
  internal_run_print_dump_syms(st->cfg->uc, st->cfg);
}
 
void priv_run_write_outputs(const run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  if ((cfg->ppm_path != nullptr) && (st->presentation->fd >= 0)) {
    const bool built = build_composite(cfg->uc, st->presentation, cfg->win_title);
    if (built && (write_ppm(cfg->ppm_path, st->presentation) == 0)) {
      (void)priv_emu_io_errf("  wrote %s (%ux%u)\n",
                             cfg->ppm_path,
                             (unsigned)st->comp_w,
                             (unsigned)st->comp_h);
    } else {
      (void)priv_emu_io_errf("  could not write %s\n", cfg->ppm_path);
    }
  }
  if (cfg->record_dir != nullptr) {
    (void)priv_emu_io_errf("  recorded %u frame(s) to %s (%ux%u, ~%u fps)\n",
                           st->rec_frames,
                           cfg->record_dir,
                           (unsigned)st->comp_w,
                           (unsigned)st->comp_h,
                           (unsigned)k_record_fps);
  }
}
 
void priv_run_hold_view(const run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  if (st->view == nullptr) {
    return;
  }
  if (!st->closed) { /* run ended on its own -- keep the last frame up until
                        closed */
    if (build_composite(cfg->uc, st->presentation, cfg->win_title)) {
      board_view_present(st->view, st->presentation);
    }
    (void)priv_emu_io_errf("ra8_emulator: run ended; close the window to exit\n");
    while (!board_view_pump(st->view)) {
      (void)usleep((useconds_t)k_view_idle_us);
    }
  }
  board_view_close(st->view);
}
 
int priv_run_cleanup(const run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  if (cfg->save_sd_path != nullptr) {
    (void)board_sd_save(cfg->save_sd_path);
  }
  (void)emu_presentation_close(cfg->presentation);
  (void)priv_emu_elf_source_close(cfg->elf); /* warm reboot source lifetime ends here. */
  emu_cpu1_close(cfg->memory);
  (void)emu_memmap_detach(cfg->memory, cfg->uc);
  (void)uc_close(cfg->uc);
  (void)emu_memmap_close(cfg->memory);
 
  emu_exit_t exit_code = k_emu_exit_ok;
  if (emu_exc_bkpt_hit()) {
    exit_code = k_emu_exit_bkpt;
  } else if (st->err != UC_ERR_OK) {
    exit_code = k_emu_exit_fault;
  } else if (st->timed_out) {
    exit_code = k_emu_exit_timeout;
  }
  return (int)exit_code;
}