kvisc/vm/pc/regs.c

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

#include <pc/device.h>

reg_t arch_r[] =
{
    { "inv", RES },
    { "flg", GPR },
    { "rip", GPR },
    { "rpc", GPR },
    { "px0", RES },
    { "px1", RES },
    { "fc1", RES },
    { "fc2", RES },
    { "sa0", SYS },
    { "sa1", SYS },
    { "sa2", SYS },
    { "sa3", SYS },
    { "sa4", SYS },
    { "sa5", SYS },
    { "sa6", SYS },
    { "sa7", SYS },
    { "dr0", SYS },
    { "dr1", SYS },
    { "dr2", SYS },
    { "dr3", SYS },
    { "dr4", SYS },
    { "dr5", SYS },
    { "dr6", SYS },
    { "dr7", SYS },
    { "cr0", CTL },
    { "cr1", CTL },
    { "cr2", CTL },
    { "cr3", CTL },
    { "cr4", CTL },
    { "cr5", CTL },
    { "cr6", CTL },
    { "cr7", CTL },

    { "rax", GPR },
    { "rbx", GPR },
    { "rcx", GPR },
    { "rdx", GPR },
    { "rsi", GPR },
    { "rdi", GPR },
    { "rbp", GPR },
    { "rsp", GPR },
    { "rx8", GPR },
    { "rx9", GPR },
    { "r10", GPR },
    { "r11", GPR },
    { "r12", GPR },
    { "r13", GPR },
    { "r14", GPR },
    { "r15", GPR },
    { "r16", GPR },
    { "r17", GPR },
    { "r18", GPR },
    { "r19", GPR },
    { "r20", GPR },
    { "r21", GPR },
    { "r22", GPR },
    { "r23", GPR },
    { "r24", GPR },
    { "r25", GPR },
    { "r26", GPR },
    { "r27", GPR },
    { "r28", GPR },
    { "r29", GPR },
    { "r30", GPR },
    { "r31", GPR },

    { "ax0", GPR },
    { "ax1", GPR },
    { "ax2", GPR },
    { "ax3", GPR },
    { "ax4", GPR },
    { "ax5", GPR },
    { "ax6", GPR },
    { "ax7", GPR },
    { "ax8", GPR },
    { "ax9", GPR },
    { "a10", GPR },
    { "a11", GPR },
    { "a12", GPR },
    { "a13", GPR },
    { "a14", GPR },
    { "a15", GPR },
    { "a16", GPR },
    { "a17", GPR },
    { "a18", GPR },
    { "a19", GPR },
    { "a20", GPR },
    { "a21", GPR },
    { "a22", GPR },
    { "a23", GPR },
    { "a24", GPR },
    { "a25", GPR },
    { "a26", GPR },
    { "a27", GPR },
    { "a28", GPR },
    { "a29", GPR },
    { "a30", GPR },
    { "a31", GPR },

    { "nx0", GPR },
    { "nx1", GPR },
    { "nx2", GPR },
    { "nx3", GPR },
    { "nx4", GPR },
    { "nx5", GPR },
    { "nx6", GPR },
    { "nx7", GPR },
    { "nx8", GPR },
    { "nx9", GPR },
    { "n10", GPR },
    { "n11", GPR },
    { "n12", GPR },
    { "n13", GPR },
    { "n14", GPR },
    { "n15", GPR },
    { "n16", GPR },
    { "n17", GPR },
    { "n18", GPR },
    { "n19", GPR },
    { "n20", GPR },
    { "n21", GPR },
    { "n22", GPR },
    { "n23", GPR },
    { "n24", GPR },
    { "n25", GPR },
    { "n26", GPR },
    { "n27", GPR },
    { "n28", GPR },
    { "n29", GPR },
    { "n30", GPR },
    { "n31", GPR },
};

static_assert(NREGS <= 256, "");
static_assert(sizeof(arch_r)/sizeof(reg_t) == NREGS, "");

#define DUMPREGS(down, up)                                                  \
    for (i = down; i <= up; i++) {                                          \
        if (i % 4 == 0)                                                     \
            trace("\n");                                                    \
        r = &ctx->r[i];                                                     \
        trace("%s=0x%-16lX ", r->name, R(i));                               \
    }                                                                       \

void dumpregs(ctx_t *ctx)
{
    int i;
    reg_t *r;

    trace("Current RFRAME index: #%lu\n", rfs_current_idx);

    DUMPREGS(RAX, R15);

    trace("\n");
    DUMPREGS(AX0, A15);

    trace("\n");
    DUMPREGS(NX0, N15);

    trace("\n");
    DUMPREGS(SA0, SA7);
    DUMPREGS(CR0, CR7);


    trace("\n\nrip=0x%-16lX rpc=0x%-16lX rsp=0x%-16lX rbp=0x%-16lX",
          rip, rpc, rsp, rbp);

    trace("\nfc0=0d%-16lu fc1=0d%-16lu fc2=0d%-16lu flg=0x%-16lX",
          rx0, rx1, rx2, flg);

    trace("\n\nCF=%x OF=%x\n"
         "ZF=%x SF=%x\n"
         "PF=%x DF=%x\n"
         "IF=%x UF=%x\n",
         !!(flg&CF), !!(flg&OF),
         !!(flg&ZF), !!(flg&SF),
         !!(flg&PF), !!(flg&DF),
         !!(cr0&IF), !!(cr0&UF));

    assert(inv == 0);
}