emu_idle.c

Go to the documentation of this file.

 
#include "emu_exc.h"
#include "emu_run.h"

RA8_INTERNAL static bool
internal_idle_back_edge(uc_engine* uc, uint32_t at, uint16_t hw, uint32_t aligned, bool* done)
{
  *done = false;
  if ((hw & (uint16_t)k_op_bn_mask) != (uint16_t)k_op_bn_base) {
    return false; /* not an unconditional b.n -- still inside the loop body */
  }
  *done = true;
  /* Unconditional b.n: target = at + 4 + sign_extend(imm11) * 2. */
  const uint32_t imm11 = (uint32_t)(hw & (uint16_t)k_op_bn_imm);
  const int32_t off = (int32_t)(imm11 << (uint32_t)k_bn_imm_sext_shl) >> (int32_t)k_bn_imm_sext_shr;
  if (off >= 0) {
    return false; /* forward branch -- not a spin-in-place back-edge */
  }
  const uint32_t target = at + (uint32_t)k_thumb2_insn_bytes + (uint32_t)off;
  if ((target > aligned) || ((aligned - target) > (uint32_t)k_idle_loop_max)) {
    return false; /* back-edge does not bracket pc in a tight loop */
  }
  /* pc is enclosed by [target, at]: require a wait (cpsie/wfi) in the body. */
  for (uint32_t k = target; k <= at; k += (uint32_t)k_thumb_hw_bytes) {
    uint16_t bhw = 0U;
    if (emu_mem_read(uc, (uint64_t)k, &bhw, sizeof(bhw)) != UC_ERR_OK) {
      return false;
    }
    if ((bhw == (uint16_t)k_op_cpsie_i) || (bhw == (uint16_t)k_op_wfi)) {
      return true;
    }
  }
  return false; /* tight loop but no wait signature -- a busy loop, not idle */
}

bool idle_spin_at(uc_engine* uc, uint32_t pc)
{
  const uint32_t aligned = pc & ~1U;
  uint16_t       hw0     = 0U;
  if (emu_mem_read(uc, (uint64_t)aligned, &hw0, sizeof(hw0)) != UC_ERR_OK) {
    return false;
  }
  /* Case 1: the core is literally on a halt instruction. */
  if ((hw0 == (uint16_t)k_op_branch_self) || (hw0 == (uint16_t)k_op_wfi)) {
    return true;
  }
 
  /* Case 2: scan forward for the loop's unconditional backward back-edge. */
  for (uint32_t j = 0U; j < (uint32_t)k_idle_scan_fwd; j++) {
    const uint32_t at = aligned + (j * (uint32_t)k_thumb_hw_bytes);
    uint16_t       hw = 0U;
    if (emu_mem_read(uc, (uint64_t)at, &hw, sizeof(hw)) != UC_ERR_OK) {
      return false;
    }
    bool       done    = false;
    const bool verdict = internal_idle_back_edge(uc, at, hw, aligned, &done);
    if (done) {
      return verdict;
    }
  }
  return false;
}