C: Как мне симулировать регистры 8086?

Question

Ой, я сейчас пытаюсь реализовать отладчик ASM 8086 для целей обучения.До сих пор я пытался смоделировать 8- и 16-битные регистры с массивами символов, но этот подход сводит меня с ума при работе с AX, AL и AH.

#define setAL() { int i; for (i = 0; i < 8; i++) AL[i] = AX[i]; }
char AX[16]   = {0, 1, 1, 1, 1 ,1 ,1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
char AL[8]    = {0, 0, 0, 0, 0, 0, 0, 0};

Есть ли у кого-нибудь хорошая идея (иличто-то вроде «лучшей практики») как имитировать эти регистры?

Answer 1

Я не думаю, что есть способ «наилучшей практики» для этого, но один из подходов, который вы можете использовать, который может вас меньше раздражать, - это использование объединения для наложения 8- и 16-битных частей:*

В качестве альтернативы, если вы явно нацеливаетесь только на 8086, вы можете иметь одну структуру, содержащую все 16-битные регистры, и одну, содержащую все байтовые части.например,

struct RegByte {
   unsigned char al, ah, bl, bh, cl, ch, dl, dh;
};

struct RegWord {
   unsigned short ax, bx, cx, dx;
   /* nothing stopping you from continuing with si, di, etc even though
    * they don't have addressable high and low bytes */
};

union Reg {
   struct RegWord word;
   struct RegByte byte;
};

Answer 2

Я бы абстрагировал структуру и использовал бы функции доступа.

struct registry_file_t;
uint16_t get_al(registry_file_t * r);
void set_al(registry_file_t * r, uint16_t value);

При включенном встраивании этот подход будет не менее производительным, чем при использовании объединения.

Answer 3

На случай, если кому-то это пригодится, я поставлю тот, который написал здесь.

typedef struct cpu_8086_s cpu_t;

struct cpu_8086_s
{
    struct
    {
        union
        {
            uint16_t ax;
            struct
            {
                uint8_t al;
                uint8_t ah;
            };
        };
        union
        {
            uint16_t cx;
            struct
            {
                uint8_t cl;
                uint8_t ch;
            };
        };
        union
        {
            uint16_t dx;
            struct
            {
                uint8_t dl;
                uint8_t dh;
            };
        };
        union
        {
            uint16_t bx;
            struct
            {
                uint8_t bl;
                uint8_t bh;
            };
        };
        uint16_t sp;
        uint16_t bp;
        uint16_t si;
        uint16_t di;
    };
    struct
    {
        uint16_t es;
        uint16_t cs;
        uint16_t ss;
        uint16_t ds;
    };
    uint16_t ip;
    union
    {
        uint16_t flags;
        struct
        {
            uint8_t c: 1;
            uint8_t  : 1;
            uint8_t p: 1;
            uint8_t  : 1;
            uint8_t a: 1;
            uint8_t  : 1;
            uint8_t z: 1;
            uint8_t s: 1;
            uint8_t t: 1;
            uint8_t i: 1;
            uint8_t d: 1;
            uint8_t o: 1;
        };
    };
};

Answer 4

Почему бы не использовать structure и union, например:

union AX_R {
    AX_R() {
        AX = 0;
    }
    unsigned __int16 AX;
    struct {
        unsigned __int8 AL;
        unsigned __int8 AH;
    } _AX_R;
};