kvisc/pc/instrs/instrs.h

// The OS/K Team licences this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#include "../arch.h"

#define IMPL_START_0(name)                                                  \
void i_##name(ctx_t *ctx, acc_t *p1, acc_t *p2)                             \
{                                                                           \

#define IMPL_START_1(name)                                                  \
void i_##name(ctx_t *ctx, acc_t *p1, acc_t *p2)                             \
{                                                                           \
    ulong v1 = (p1->type == A_REG ? ctx->r[p1->val].val : p1->val);         \
    if (p1->mem) v1 = readmem(ctx, v1 + p1->off, p1->mlen);                 \

#define IMPL_START_2(name)                                                  \
void i_##name(ctx_t *ctx, acc_t *p1, acc_t *p2)                             \
{                                                                           \
    ulong v1 = (p1->type == A_REG ? ctx->r[p1->val].val : p1->val);         \
    ulong v2 = (p2->type == A_REG ? ctx->r[p2->val].val : p2->val);         \
    if (p1->mem) v1 = readmem(ctx, v1 + p1->off, p1->mlen);                 \
    if (p2->mem) v2 = readmem(ctx, v2 + p2->off, p2->mlen);                 \

#define IMPL_START_3(name)                                                  \
void i_##name(ctx_t *ctx, acc_t *p1, acc_t *p2)                             \
{                                                                           \
    ulong v2 = (p2->type == A_REG ? ctx->r[p2->val].val : p2->val);         \
    if (p2->mem) v2 = readmem(ctx, v2 + p2->off, p2->mlen);                 \

#define IMPL_OUT                                                            \
    assert(p1->type == A_REG || p1->mem);                                   \
    if (p1->mem) {                                                          \
        ulong addr = p1->type == A_REG ? ctx->r[p1->val].val : p1->val;     \
        writemem(ctx, v1, addr, p1->mlen);                                  \
    }                                                                       \
    else ctx->r[p1->val].val = v1;                                          \
}                                                                           \

#define IMPL_END                                                            \
}

#define CHK_SUPERV()                                                        \
    do {                                                                    \
        if ((ctx->r[CR0].val & UF) == 1) {                                  \
            _except(ctx, E_SYS, "Supervisor-only INSTR");                   \
        }                                                                   \
    } while (0)

#define CHK_STACK(op)                                                       \
    if (ctx->r[RSP].val % 8 > 0 || ctx->r[RBP].val % 8 > 0) {               \
       _except(ctx, E_STK, "Misaligned stack REGS");                        \
    }                                                                       \
    if (ctx->r[RBP].val op ctx->r[RSP].val) {                               \
        _except(ctx, E_STK, "RSP above RBP");                               \
    }

#define PUSH(v)                                                             \
    writemem64(ctx, v, ctx->r[RSP].val);                                    \
    ctx->r[RSP].val -= 8;                                                   \

#define POP(v)                                                              \
    ctx->r[RSP].val += 8;                                                   \
    v = readmem64(ctx, ctx->r[RSP].val);

#define JUMP(v)                                                             \
    ctx->r[RIP].val = v + ctx->r[CR1].val