kvisc/vm/pc/arch.h

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

#ifndef _ARCH_H
#define _ARCH_H

#define dev_t stddev_t

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>
#include <limits.h>

#undef dev_t
#define packed __attribute__ ((__packed__))
#define static_assert _Static_assert
#define alignof _Alignof

typedef unsigned int        bool;
typedef unsigned char       uchar;
typedef unsigned short      ushort;
typedef unsigned int        uint;
typedef unsigned long       ulong;

typedef struct reg_t        reg_t;
typedef struct ctx_t        ctx_t;
typedef struct instr_t      instr_t;
typedef struct acc_t        acc_t;
typedef struct arch_t       arch_t;
typedef struct dev_t        dev_t;

void log(const char *, ...);
void vlog(const char *, va_list);

// A_REG is implicit
// A_MEM denotes a memory access
// A_OFF is A_MEM but a 16-bit offset is expected immediatly next
enum
{
    A_REG = 0,

    A_MEM8  = 0x7001,
    A_MEM16 = 0x7002,
    A_MEM32 = 0x7004,
    A_MEM64 = 0x7008,

    A_OFF8  = 0x7701,
    A_OFF16 = 0x7702,
    A_OFF32 = 0x7704,
    A_OFF64 = 0x7708,

    A_IMM16 = 0x7772,
    A_IMM32 = 0x7774,
    A_IMM64 = 0x7778
};

#define A_IS_MEM(x) ((x) >= A_MEM8 && (x) <= A_MEM64)
#define A_IS_OFF(x) ((x) >= A_OFF8 && (x) <= A_OFF64)
#define A_IS_IMM(x) ((x) >= A_IMM16)

#define A_IS_8(x) ((x) & 0xF == 1)
#define A_IS_16(x) ((x) & 0xF == 2)
#define A_IS_32(x) ((x) & 0xF == 3)
#define A_IS_64(x) ((x) & 0xF == 4)

struct acc_t
{
    bool mem;
    uint mlen;
    short off;
    uint offreg;

    uint type;
    uint ilen;
    ulong val;
};

enum { NOPREF, PREF_REP=0x8000, PREF_LOCK, NPREFS };

#define ISPREF(x) ((x) & 0x8000 && (x)<NPREFS)
#define ISINSTR(x)  ((x) < NINSTRS)

enum { NOPRM, P_REG, P_IMM, P_MEM=4 };

struct instr_t
{
    char   *name;
    char   *full;

    uint    prm1;
    uint    prm2;

    void  (*func)(ctx_t *, acc_t *, acc_t *);
};

struct ctx_t
{
    reg_t   *r;
    instr_t *i;

    // Memory and memory size
    ushort *mp;
    ulong   mz;

    // Read next instruction
    ushort (*get)(ctx_t *ctx);

    // For disassembly
    FILE *disf;

    // Step by step
    int step;

    // Devices list head
    dev_t *dh;
};

#define R(X) ctx->r[X].val

static inline ushort bswap16(ushort u)
{ return ((u<<8) | (u>>8)); }

static inline char getmempref(ushort len)
{ return (len==1?'b':(len==2?'w':(len==4?'l':(len==8?'q':'x')))); }

enum
{
    E_SHT,          // Shutdown instruction
    E_IMP,          // Not implemented
    E_ILL,          // Ill-formed
    E_ACC,          // Invalid access
    E_SYS,          // Supervisor only
    E_ALI,          // Alignment error
    E_STK,          // Stack error
    NEXCPTS
};

void dumpregs(ctx_t *);
void dumpinstr(ctx_t *, ulong, uint, ushort, acc_t *, acc_t *);
void dumpmem(ctx_t *, ulong, ulong);
void dumpfwstack(ctx_t *);

void _except(ctx_t *, int, char *, ...);

void disasm(ctx_t *ctx);
void decode(ctx_t *ctx);

#define MEMOFF (1 * 1024 * 1024)
#define MEMSIZE (16 * 1024 * 1024)  // 16MB

#define addr2real(p) (((p) - MEMOFF) / 2)
#define real2addr(p) (((p) + MEMOFF) / 2)

// Address of boot firmware stack
#define FWSTACK (MEMOFF * 2)        // 2MB

ulong readmem8(ctx_t *, ulong addr);
ulong readmem16(ctx_t *, ulong addr);
ulong readmem32(ctx_t *, ulong addr);
ulong readmem64(ctx_t *, ulong addr);
ulong readmem(ctx_t *c, ulong addr, uint len);

void writemem8(ctx_t *, ulong val, ulong addr);
void writemem16(ctx_t *, ulong val, ulong addr);
void writemem32(ctx_t *, ulong val, ulong addr);
void writemem64(ctx_t *, ulong val, ulong addr);
void writemem(ctx_t *, ulong val, ulong addr, uint len);

#include <pc/regs.h>
#include <in/arch_i.h>

extern reg_t arch_r[NREGS];
extern instr_t arch_i[NINSTRS];

#endif