emu_run_inner.c

Go to the documentation of this file.

 
#include "emu_engine.h"
#include "emu_exc.h"
#include "emu_mpu.h"
#include "emu_prof.h"
#include "emu_run_internal.h"
#include "emu_seams.h"
#include "emu_view.h"

typedef enum : uint8_t {
  k_inner_continue = 0, 
  k_inner_break    = 1, 
} inner_action_t;

RA8_INTERNAL static size_t internal_run_inner_budget(uc_engine* uc, uint32_t run_pc)
{
  size_t busy_budget = (size_t)k_run_chunk_insns;
  if (emu_low_power()) {
    busy_budget = (size_t)k_run_chunk_insns / (size_t)k_low_power_div;
  }
  return idle_spin_at(uc, run_pc) ? (size_t)k_idle_spin_insns : busy_budget;
}

RA8_INTERNAL static bool
internal_run_inner_check_stops(uc_engine* uc, bool* faulted, inner_action_t* act)
{
  (void)uc;
  if (emu_seam_take_relaunch()) {
    /* A --fast-sd byte-exchange returned to its caller. This consumed no
     * modelled time, so relaunch from the returned PC without advancing the
     * SysTick or charging a chunk (the inner-loop cap still bounds the run). */
    *act = k_inner_continue;
    return true;
  }
  if (emu_prof_stop_hit()) {
    *act = k_inner_break; /* RA8_EMU_STOP_PC reached (prof_insn_hook) -- end the run. */
    return true;
  }
  if (emu_exc_reboot_requested()) {
    *act = k_inner_break; /* AIRCR.SYSRESETREQ -- the outer wrapper performs the reboot. */
    return true;
  }
  if (emu_exc_bkpt_hit()) {
    *faulted = true; /* firmware trapped on a BKPT -- end the run, report it. */
    *act     = k_inner_break;
    return true;
  }
  return false;
}

RA8_INTERNAL static inner_action_t internal_run_inner_take_exception(uc_engine* uc,
                                                                     uint32_t   vtor_base,
                                                                     uint32_t*  run_pc,
                                                                     uc_err     err,
                                                                     bool*      faulted)
{
  uint64_t exc_ret_pc = 0U;
  if (emu_exc_take_exc_return(&exc_ret_pc)) {
    exc_return(uc, (uint32_t)exc_ret_pc);
    /* Tail-chain the next pend, but do NOT advance the SysTick: an exception
     * return consumes no modelled time, so time advances only on a full
     * instruction budget (below). This keeps a deferred tick from firing the
     * instant a PendSV context switch unstacks into the new thread. */
    (void)exc_take_pending(uc, vtor_base, false);
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  if (emu_mve_nocp_take()) {
    /* MVE NoCP fault: the seam already did the access + advanced PC; resume, synchronous. */
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  if (err != UC_ERR_OK) {
    *faulted = true;
    return k_inner_break;
  }
  if (emu_mpu_fault_pending()) {
    /* A store hit a read-only MPU region (on_mpu_ro_write stopped us).
     * Synthesise MemManage at this boundary -- no time advances (a fault is
     * synchronous), and the stacked PC is the faulting store. */
    emu_mpu_clear_fault();
    mpu_synth_memmanage(uc, vtor_base);
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  if (emu_div0_fault_pending()) {
    /* A UDIV/SDIV by zero with CCR.DIV_0_TRP set (emulate_div0_patched stopped
     * us). Synthesise UsageFault at this boundary -- synchronous, no time
     * advances, and the stacked PC is the trapping divide. */
    emu_div0_clear_fault();
    div0_synth_usagefault(uc, vtor_base);
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  if (emu_exc_pendsv_stop()) {
    /* Context-switch stop: a thread wrote PENDSVSET to yield. Take PendSV but do
     * NOT advance the SysTick -- a context switch consumes no modelled time, so a
     * thread that just suspended on a tick wait keeps waiting and the scheduler
     * runs the highest-priority READY thread. This is what lets a low-priority
     * worker (e.g. the NetX echo thread) run to completion before a higher-
     * priority sleeper's tick expires. */
    (void)exc_take_pending(uc, vtor_base, false);
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  /* Full instruction budget elapsed: a tick's worth of genuine execution (or an
   * idle spin) has passed, so advance time -- take the highest-priority pending
   * exception (SysTick this period, and/or PendSV) and resolve it in this same
   * chunk so a context switch does not cost a scheduling quantum. */
  if (exc_take_pending(uc, vtor_base, true)) {
    (void)uc_reg_read(uc, UC_ARM_REG_PC, run_pc);
    return k_inner_continue;
  }
  return k_inner_break;
}
 
bool priv_run_inner(uc_engine* uc, uint32_t vtor_base, uint32_t* run_pc_io, uc_err* err_out)
{
  uint32_t run_pc  = *run_pc_io;
  uc_err   err     = UC_ERR_OK;
  bool     faulted = false;
  for (uint32_t inner = 0U; inner < (uint32_t)k_run_inner_max; inner++) {
    emu_exc_clear_pendsv_stop(); /* set by on_icsr_write iff this run ends on PENDSVSET */
    const size_t run_budget = internal_run_inner_budget(uc, run_pc);
    err                     = uc_emu_start(uc, (uint64_t)run_pc | 1U, 0, 0, run_budget);
    (void)uc_reg_read(uc, UC_ARM_REG_PC, &run_pc);
    inner_action_t act = k_inner_continue;
    if (internal_run_inner_check_stops(uc, &faulted, &act)) {
      if (act == k_inner_break) {
        break;
      }
      continue;
    }
    if (internal_run_inner_take_exception(uc, vtor_base, &run_pc, err, &faulted) == k_inner_break) {
      break;
    }
  }
  *run_pc_io = run_pc;
  *err_out   = err;
  return faulted;
}