qemu-e2k/target/e2k/helper.c

#include "qemu/osdep.h"
#include "qemu/log.h"
#include "cpu.h"
#include "exec/exec-all.h"
#include "qemu/host-utils.h"
#include "exec/helper-proto.h"
#include "translate.h"

static inline void reset_ctprs(CPUE2KState *env)
{
    unsigned int i;

    for (i = 0; i < 3; i++) {
        env->ctprs[i] = SET_FIELD(env->ctprs[i], CTPR_TAG_NONE,
            CTPR_TAG_OFF, CTPR_TAG_LEN);
    }
}

static inline void save_br_state(CPUE2KState *env)
{
    int rbs, rsz, rcur;

    rbs = env->boff / 2;
    rsz = (env->bsize - 2) / 2;
    rcur = env->bcur / 2;

    env->br = SET_FIELD(env->br, rbs, BR_RBS_OFF, BR_RBS_LEN);
    env->br = SET_FIELD(env->br, rsz, BR_RSZ_OFF, BR_RSZ_LEN);
    env->br = SET_FIELD(env->br, rcur, BR_RCUR_OFF, BR_RCUR_LEN);
    env->br = SET_FIELD(env->br, env->psize, BR_PSZ_OFF, BR_PSZ_LEN);
    env->br = SET_FIELD(env->br, env->pcur, BR_PCUR_OFF, BR_PCUR_LEN);

    e2k_state_cr1_br_set(env, env->br);
}

static inline void restore_br_state(CPUE2KState *env)
{
    int rbs, rsz, rcur;

    env->br = e2k_state_cr1_br_get(env);
    rbs = GET_FIELD(env->br, BR_RBS_OFF, BR_RBS_LEN);
    rsz = GET_FIELD(env->br, BR_RSZ_OFF, BR_RSZ_LEN);
    rcur = GET_FIELD(env->br, BR_RCUR_OFF, BR_RCUR_LEN);

    env->boff = rbs * 2;
    env->bsize = rsz * 2 + 2;
    env->bcur = rcur * 2;
    env->psize = GET_FIELD(env->br, BR_PSZ_OFF, BR_PSZ_LEN);
    env->pcur = GET_FIELD(env->br, BR_PCUR_OFF, BR_PCUR_LEN);
}

static void pcs_push(CPUE2KState *env, int wbs)
{
    size_t size = e2k_state_pcs_size_get(env);
    size_t offset = e2k_state_pcs_index_get(env);
    void *pcsp = (void*) e2k_state_pcs_base_get(env) + offset;

    if (offset + 32 > size) {
        /* TODO: allocate more memory */
        abort();
    }

    save_br_state(env);
    e2k_state_cr1_wpsz_set(env, env->wd_psize / 2);
    memcpy(pcsp, &env->proc_chain[0], 32);
    e2k_state_cr1_wbs_set(env, wbs);

    e2k_state_pcs_index_set(env, offset + 32);
}

static void pcs_pop(CPUE2KState *env)
{
    size_t offset = e2k_state_pcs_index_get(env);
    void *pcsp = (void*) e2k_state_pcs_base_get(env) + offset - 32;

    if (offset < 32) {
        /* TODO: SIGKILL */
        abort();
    }

    memcpy(&env->proc_chain[0], pcsp, 32);

    // TODO: restore wbs (after pshtp implemented)
    env->wd_psize = e2k_state_cr1_wpsz_get(env) * 2;
    restore_br_state(env);

    e2k_state_pcs_index_set(env, offset - 32);
}

static void ps_push(CPUE2KState *env, unsigned int wd_base, size_t len)
{
    unsigned int i;
    size_t index = e2k_state_ps_ind_get(env);
    uint64_t *p = (uint64_t*) (e2k_state_ps_base_get(env) + index);

    /* TODO: push FX registers */
    /* TODO: stack overflow */

    for (i = 0; i < len; i++) {
        uint64_t reg = env->wregs[(wd_base + i) % WREGS_SIZE];
        memcpy(p + i, &reg, sizeof(uint64_t));
    }

    e2k_state_ps_ind_set(env, index + len * sizeof(uint64_t));
}

static void ps_pop(CPUE2KState *env, unsigned int wd_base, size_t len)
{
    unsigned int i;
    size_t index = e2k_state_ps_ind_get(env) - len * sizeof(uint64_t);
    uint64_t *p = (uint64_t*) (e2k_state_ps_base_get(env) + index);

    /* TODO: pop FX registers */
    /* TODO: stack overflow */

    for (i = 0; i < len; i++) {
        uint64_t *reg = &env->wregs[(wd_base + i) % WREGS_SIZE];
        memcpy(reg, p + i, sizeof(uint64_t));
    }

    e2k_state_ps_ind_set(env, index);
}

static inline void do_call(CPUE2KState *env, int call_wbs)
{
    int call_wpsz = env->wd_size / 2 - call_wbs;

    env->ip = env->nip;
    pcs_push(env, call_wbs);
    ps_push(env, env->wd_base, call_wbs * 2);

    env->wd_base = (env->wd_base + call_wbs * 2) % WREGS_SIZE;
    env->wd_size = env->wd_psize = call_wpsz * 2;

    reset_ctprs(env);
}

void helper_return(CPUE2KState *env)
{
    uint32_t new_wd_size, new_wd_base, wbs;

    wbs = e2k_state_cr1_wbs_get(env);
    new_wd_size = env->wd_psize + wbs * 2;
    new_wd_base = (env->wd_base - wbs * 2) % WREGS_SIZE;

    if (env->wd_base < new_wd_base) {
        env->wd_base += WREGS_SIZE;
    }

    ps_pop(env, new_wd_base, env->wd_base - new_wd_base);
    pcs_pop(env);

    env->wd_base = new_wd_base;
    env->wd_size = new_wd_size;

    reset_ctprs(env);
}

static inline void do_syscall(CPUE2KState *env, int call_wbs)
{
    env->syscall_wbs = call_wbs;
    reset_ctprs(env);
    helper_raise_exception(env, E2K_EXCP_SYSCALL);
}

target_ulong helper_call(CPUE2KState *env, uint64_t ctpr,
    int call_wbs)
{
    int ctpr_tag = GET_FIELD(ctpr, CTPR_TAG_OFF, CTPR_TAG_LEN);

    switch (ctpr_tag) {
    case CTPR_TAG_DISP:
        do_call(env, call_wbs);
        return GET_FIELD(ctpr, CTPR_BASE_OFF, CTPR_BASE_LEN);
    case CTPR_TAG_SDISP:
        do_syscall(env, call_wbs);
        return env->ip;
    default:
        abort();
        break;
    }

    return 0;
}

void helper_raise_exception(CPUE2KState *env, int tt)
{
    CPUState *cs = env_cpu(env);
    save_br_state(env);
    cs->exception_index = tt;
    cpu_loop_exit(cs);
}

static void break_save_ps(CPUE2KState *env)
{
    unsigned int i;
    unsigned int wd_base = env->wd_base;
    unsigned int len = env->wd_size;
    size_t index = e2k_state_ps_ind_get(env);
    uint64_t *p = (uint64_t*) (e2k_state_ps_base_get(env) + index);

    /* TODO: stack overflow */

    for (i = 0; i < len; i += 2) {
        uint64_t t[2] = { 0 };
        uint64_t *reg = &env->wregs[(wd_base + i) % WREGS_SIZE];
        memcpy(p + i * 2, reg, 2 * sizeof(uint64_t));
        memcpy(p + i * 2 + 2, t, 2 * sizeof(uint64_t)); // TODO: fx part
    }

    e2k_state_ps_ind_set(env, index + len * 2 * sizeof(uint64_t));
}

static void break_save_state(CPUE2KState *env)
{
    break_save_ps(env);
    pcs_push(env, env->wd_size / 2);

    env->wd_base = (env->wd_base + env->wd_size) % WREGS_SIZE;
    env->wd_size = 0;
    env->wd_psize = 0;

    env->is_bp = true;
}

void helper_break_restore_state(CPUE2KState *env)
{
    size_t index;
    int wbs;

    wbs = e2k_state_cr1_wbs_get(env);
    pcs_pop(env);
    env->wd_size = wbs * 2;
    env->wd_base = (env->wd_base - env->wd_size) % WREGS_SIZE;

    index = e2k_state_ps_ind_get(env);
    e2k_state_ps_ind_set(env, index - env->wd_size * 2 * sizeof(uint64_t));

    env->is_bp = false;
}

uint64_t helper_sxt(uint64_t x, uint64_t y)
{
    int size;

    switch (x & 3) {
    case 0:
        size = 8;
        break;
    case 1:
        size = 16;
        break;
    default:
        size = 32;
        break;
    }

    if (x & 4) {
        return y & GEN_MASK(0, size);
    } else {
        return (((int64_t) y) << (64 - size) >> (64 - size));
    }
}

void helper_debug_i32(uint32_t x)
{
    qemu_log_mask(LOG_UNIMP, "log %#x\n", x);
}

void helper_debug_i64(uint64_t x)
{
    qemu_log_mask(LOG_UNIMP, "log %#lx\n", x);
}

uint64_t helper_state_reg_get(CPUE2KState *env, int reg)
{
    switch (reg) {
    case 0x2c: /* %usd.hi */
        return env->usd_hi;
    case 0x2d: /* %usd.lo */
        return env->usd_lo;
    case 0x80: /* %upsr */
        return env->upsr;
    case 0x81: /* %ip */
        return env->ip;
    case 0x83: /* %lsr */
        return env->lsr;
    case 0x8a: /* %idr */
        return env->idr;
    case 0x90: /* %clkr */
        return cpu_get_host_ticks();
    default:
        /* TODO: exception */
        qemu_log_mask(LOG_UNIMP, "unknown register 0x%x\n", reg);
        abort();
        return 0; /* unreachable */
    }
}

void helper_state_reg_set(CPUE2KState *env, int reg, uint64_t val)
{
    switch (reg) {
    case 0x2c: /* %usd.hi */
        /* FIXME: user cannot write */
        env->usd_hi = val;
        break;
    case 0x2d: /* %usd.lo */
        /* FIXME: user cannot write */
        env->usd_lo = val;
        break;
    case 0x80: /* %upsr */
        env->upsr = val;
        break;
    case 0x83: /* %lsr */
        env->lsr = val;
        break;
    default:
        qemu_log_mask(LOG_UNIMP, "unknown register 0x%x\n", reg);
        helper_raise_exception(env, E2K_EXCP_ILLOPC);
        break;
    }
}

uint64_t helper_getsp(CPUE2KState *env, uint64_t src2) {
    uint64_t base = GET_FIELD(env->usd_lo, USD_LO_BASE_OFF, USD_LO_BASE_LEN);

    base += src2;

    /* TODO: stack overflow */
    env->usd_lo = SET_FIELD(env->usd_lo, base, USD_LO_BASE_OFF,
        USD_LO_BASE_LEN);

    return base;
}