minix/commands/mdb/mdbdis86.c
Ben Gras 5e3b213f05 import of mdb (minix debugger), some ptrace and signals unbreaking
seem to have made it work (runtime debugging and core reading).
2005-08-04 08:44:16 +00:00

1564 lines
27 KiB
C

/*
* mdbdis86.c for mdb.c - 8086-386 and 8087 disassembler
* From Bruce Evans db
*/
#include "mdb.h"
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include "proto.h"
struct address_s
{
off_t off;
off_t base;
};
PRIVATE int bits32;
PRIVATE struct address_s uptr;
FORWARD _PROTOTYPE( u8_t get8, (void) );
FORWARD _PROTOTYPE( u16_t get16, (void) );
FORWARD _PROTOTYPE( u32_t get32, (void) );
FORWARD _PROTOTYPE( u8_t peek_byte, (off_t addr) );
FORWARD _PROTOTYPE( u16_t peek_word, (off_t addr) );
FORWARD _PROTOTYPE( int puti, (void) );
FORWARD _PROTOTYPE( int outsegaddr, (struct address_s *addr) );
FORWARD _PROTOTYPE( int outssegaddr, (struct address_s *addr) );
FORWARD _PROTOTYPE( int show1instruction , (void));
/************************* UNASM ******************************/
#define LINDIRECT '['
#define RINDIRECT ']'
#define BASE_MASK 0x07
#define INDEX_MASK 0x38
#define INDEX_SHIFT 3
#define MOD_MASK 0xC0 /* mod reg r/m is mmrrrRRR */
#define REG_MOD 0xC0
#define MEM0_MOD 0x00
#define MEM1_MOD 0x40
#define MEM2_MOD 0x80
#define REG_MASK 0x38
#define REG_SHIFT 3
#define RM_MASK 0x07
#define RM_SHIFT 0
#define SS_MASK 0xC0
#define SS_SHIFT 6
#define SIGNBIT 0x02 /* opcode bits xxxxxxsw for immediates */
#define WORDBIT 0x01
#define TOREGBIT 0x02 /* opcode bit for non-immediates */
#define MAX_SIGNED_CHAR 0x7F /* will assume 2's complement */
#define MAX_UNSIGNED_CHAR 0xFF
typedef unsigned opcode_pt; /* promote to unsigned and not int */
typedef int reg_pt;
typedef int su16_t;
typedef int su8_pt;
FORWARD _PROTOTYPE( su8_pt get8s , (void));
FORWARD _PROTOTYPE( void getmodregrm , (void));
FORWARD _PROTOTYPE( void i_00_to_3f , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_40_to_5f , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_60_to_6f , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_70_to_7f , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_80 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_88 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_90 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_98 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_a0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_a8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_b0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_b8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_c0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_c8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_d0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_d8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_e0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_e8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_f0 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void i_f8 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void outad , (opcode_pt opc ));
FORWARD _PROTOTYPE( void outad1 , (opcode_pt opc ));
FORWARD _PROTOTYPE( void outalorx , (opcode_pt opc ));
FORWARD _PROTOTYPE( void outax , (void));
FORWARD _PROTOTYPE( void outbptr , (void));
FORWARD _PROTOTYPE( void outbwptr , (opcode_pt opc ));
FORWARD _PROTOTYPE( void outea , (opcode_pt wordflags ));
FORWARD _PROTOTYPE( void outf1 , (void));
FORWARD _PROTOTYPE( void out32offset , (void));
FORWARD _PROTOTYPE( void outfishy , (void));
FORWARD _PROTOTYPE( void outgetaddr , (void));
FORWARD _PROTOTYPE( void outimmed , (opcode_pt signwordflag ));
FORWARD _PROTOTYPE( void outpc , (off_t pc ));
FORWARD _PROTOTYPE( void outsegpc , (void));
FORWARD _PROTOTYPE( void oututstr , (char *s ));
FORWARD _PROTOTYPE( void outword , (void));
FORWARD _PROTOTYPE( void outwptr , (void));
FORWARD _PROTOTYPE( void outwsize , (void));
FORWARD _PROTOTYPE( void pagef , (void));
FORWARD _PROTOTYPE( void shift , (opcode_pt opc ));
FORWARD _PROTOTYPE( void checkmemory , (void));
FORWARD _PROTOTYPE( void CL , (void));
FORWARD _PROTOTYPE( void Eb , (void));
FORWARD _PROTOTYPE( void Ev , (void));
FORWARD _PROTOTYPE( void EvGv , (void));
FORWARD _PROTOTYPE( void EvIb , (void));
FORWARD _PROTOTYPE( void Ew , (void));
FORWARD _PROTOTYPE( void EwRw , (void));
FORWARD _PROTOTYPE( void Gv , (void));
FORWARD _PROTOTYPE( void Gv1 , (void));
FORWARD _PROTOTYPE( void GvEv , (void));
FORWARD _PROTOTYPE( void GvEw , (void));
FORWARD _PROTOTYPE( void GvM , (void));
FORWARD _PROTOTYPE( void GvMa , (void));
FORWARD _PROTOTYPE( void GvMp , (void));
FORWARD _PROTOTYPE( void Ib , (void));
FORWARD _PROTOTYPE( void Iw , (void));
FORWARD _PROTOTYPE( void Iv , (void));
FORWARD _PROTOTYPE( void Jb , (void));
FORWARD _PROTOTYPE( void Jv , (void));
FORWARD _PROTOTYPE( void Ms , (void));
_PROTOTYPE( typedef void (*pfv_t),(opcode_pt opc ));
PRIVATE pfv_t optable[] =
{
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_00_to_3f,
i_40_to_5f,
i_40_to_5f,
i_40_to_5f,
i_40_to_5f,
i_60_to_6f,
i_60_to_6f,
i_70_to_7f,
i_70_to_7f,
i_80,
i_88,
i_90,
i_98,
i_a0,
i_a8,
i_b0,
i_b8,
i_c0,
i_c8,
i_d0,
i_d8,
i_e0,
i_e8,
i_f0,
i_f8,
};
PRIVATE char fishy[] = "???";
PRIVATE char movtab[] = "mov\t";
PRIVATE char *genreg[] =
{
"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
"ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
};
PRIVATE char *segreg[] =
{
"es", "cs", "ss", "ds", "fs", "gs", "?s", "?s",
};
PRIVATE char *indreg[] =
{
"bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx",
};
PRIVATE char *str_00_to_3f[] =
{
/* index by (opcode >> 3) & 7 */
"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp",
};
PRIVATE char *sstr_00_to_3f[] =
{
/* index ((opc>>2) & 0x0E) + (opc & 7) - 6 */
"push\tes", "pop\tes", "push\tcs", "pop\tcs",
"push\tss", "pop\tss", "push\tds", "pop\tds",
"es:", "daa", "cs:", "das", "ss:", "aaa", "ds:", "aas",
};
PRIVATE char *sstr_0f[] =
{
"push\tfs", "pop\tfs", fishy, "bt\t", "shld\t", "shld\t", fishy, fishy,
"push\tgs", "pop\tgs", fishy, "bts\t", "shrd\t", "shrd\t", fishy, "imul\t",
fishy, fishy, "lss\t", "btr\t", "lfs\t", "lgs\t", "movzx\t", "movzx\t",
fishy, fishy, "", "btc\t", "bsf\t", "bsr\t", "movsx\t", "movsx\t",
};
PRIVATE char *ssstr_0f[] =
{
"sldt\t", "str\t", "lldt\t", "ltr\t", "verr\t", "verw\t", fishy, fishy,
"sgdt\t", "sidt\t", "lgdt\t", "lidt\t", "smsw\t", fishy, "lmsw\t", fishy,
fishy, fishy, fishy, fishy, "bt\t", "bts\t", "btr\t", "btc\t",
};
PRIVATE char *str_40_to_5f[] =
{
/* index by (opcode >> 3) & 3 */
"inc\t", "dec\t", "push\t", "pop\t",
};
PRIVATE char *str_60_to_6f[] =
{
"pusha", "popa", "bound\t", "arpl\t", "fs:", "gs:", "os:", "as:",
"push\t", "imul\t", "push\t", "imul\t", "insb", "ins", "outsb", "outs",
};
PRIVATE char *str_flags[] =
{
/* opcodes 0x70 to 0x7F, and 0x0F80 to 0x0F9F */
"o", "no", "b", "nb", "z", "nz", "be", "a",
"s", "ns", "pe", "po", "l", "ge", "le", "g",
};
PRIVATE char *str_98[] =
{
"cbw", "cwd", "call\t", "wait", "pushf", "popf", "sahf", "lahf",
"cwde", "cdq", "call\t", "wait", "pushfd", "popfd", "sahf", "lahf",
};
PRIVATE char *str_a0[] =
{
movtab, movtab, movtab, movtab, "movsb", "movs", "cmpsb", "cmps",
};
PRIVATE char *str_a8[] =
{
"test\t", "test\t", "stosb", "stos", "lodsb", "lods", "scasb", "scas",
};
PRIVATE char *str_c0[] =
{
"", "", "ret\t", "ret", "les\t", "lds\t", movtab, movtab,
};
PRIVATE char *str_c8[] =
{
"enter\t", "leave", "retf\t", "retf", "int\t3", "int\t", "into", "iret",
};
PRIVATE char *str_d0[] =
{
"aam", "aad", "db\td6", "xlat",
};
PRIVATE char *sstr_d0[] =
{
"rol", "ror", "rcl", "rcr", "shl", "shr", fishy, "sar",
};
PRIVATE char *str_d8[] =
{
"fadd", "fmul", "fcom", "fcomp", "fsub", "fsubr", "fdiv", "fdivr",
"fld", NULL, "fst", "fstp", "fldenv", "fldcw", "fstenv", "fstcw",
"fiadd", "fimul", "ficom", "ficomp", "fisub", "fisubr", "fidiv", "fidivr",
"fild", NULL, "fist", "fistp", NULL, "fld", NULL, "fstp",
"fadd", "fmul", "fcom", "fcomp", "fsub", "fsubr", "fdiv", "fdivr",
"fld", NULL, "fst", "fstp", "frstor", NULL, "fsave", "fstsw",
"fiadd", "fimul", "ficom", "ficomp", "fisub", "fisubr", "fidiv", "fidivr",
"fild", NULL, "fist", "fistp", "fbld", "fild", "fbstp", "fistp",
};
PRIVATE char *str1_d8[] =
{
"fadd", "fmul", "fcom", "fcomp", "fsub", "fsubr", "fdiv", "fdivr",
"fld", "fxch", "\0\0", NULL, "\0\10", "\0\20", "\0\30", "\0\40",
NULL, NULL, NULL, NULL, NULL, "\0\50", NULL, NULL,
NULL, NULL, NULL, NULL, "\0\60", NULL, NULL, NULL,
"fadd", "fmul", NULL, NULL, "fsubr", "fsub", "fdivr", "fdiv",
"ffree", NULL, "fst", "fstp", "fucom", "fucomp", NULL, NULL,
"faddp", "fmulp", NULL, "\0\70", "fsubrp", "fsubp", "fdivrp", "fdivp",
NULL, NULL, NULL, NULL, "\0\100", NULL, NULL, NULL,
};
PRIVATE unsigned char size_d8[] =
{
4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 14-28, 2, 14-28, 2,
4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 0, 10, 0, 10,
8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 94-108, 0, 94-108, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 10, 8, 10, 8,
};
PRIVATE char *sstr_d8[] =
{
"fnop", NULL, NULL, NULL, /* D9D0 */
NULL, NULL, NULL, NULL,
"fchs", "fabs", NULL, NULL, /* D9E0 */
"ftst", "fxam", NULL, NULL,
"fld1", "fldl2t", "fldl2e", "fldpi", /* D9E8 */
"fldlg2", "fldln2", "fldz", NULL,
"f2xm1", "fyl2x", "fptan", "fpatan", /* D9F0 */
"fxtract", "fprem1", "fdecstp", "fincstp",
"fprem", "fyl2xp1", "fsqrt", "fsincos", /* D9F8 */
"frndint", "fscale", "fsin", "fcos",
NULL, "fucompp", NULL, NULL, /* DAE8 */
NULL, NULL, NULL, NULL,
"feni", "fdisi", "fclex", "finit", /* DBE0 */
"fsetpm", NULL, NULL, NULL,
NULL, "fcompp", NULL, NULL, /* DED8 */
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, /* DFE0 */
"fstsw\tax", NULL, NULL, NULL,
};
PRIVATE char *str_e0[] =
{
"loopnz\t", "loopz\t", "loop\t", "jcxz\t",
"in\t", "in\t", "out\t", "out\t",
};
PRIVATE char *str_e8[] =
{
"call\t", "jmp\t", "jmp\t", "jmp\t",
"in\t", "in\t", "out\t", "out\t",
};
PRIVATE char *str_f0[] =
{
"lock\t", "db\tf1", "repnz\t", "repz\t",
"hlt", "cmc",
/* other 2 from sstr_f0 */
};
PRIVATE char *sstr_f0[] =
{
"test\t", fishy, "not\t", "neg\t",
"mul\t", "imul\t", "div\t", "idiv\t",
};
PRIVATE char *str_f8[] =
{
"clc", "stc", "cli", "sti",
"cld", "std",
/* other 2 from sstr_f8 */
};
PRIVATE char *sstr_f8[] =
{
"inc\t", "dec\t", "call\t", "call\tfar ",
"jmp\t", "jmp\tfar ", "push\t", "???\t",
};
PRIVATE int data_seg; /* data segment (munged name for asld) */
PRIVATE unsigned hasize; /* half address size in bits */
PRIVATE unsigned hdefsize;
PRIVATE unsigned hosize; /* half operand size in bits */
/* for easy index into reg tables */
PRIVATE opcode_pt mod;
PRIVATE off_t offtable[2];
PRIVATE off_t *offptr;
PRIVATE off_t *off1ptr;
PRIVATE opcode_pt reg;
PRIVATE opcode_pt rm;
PRIVATE su8_pt get8s()
{
u8_t got;
if ((got = get8()) > MAX_SIGNED_CHAR)
got -= (MAX_UNSIGNED_CHAR + 1);
return got;
}
PRIVATE void getmodregrm()
{
opcode_pt modregrm;
modregrm = get8();
mod = modregrm & MOD_MASK;
reg = (modregrm & REG_MASK) >> REG_SHIFT;
rm = (modregrm & RM_MASK) >> RM_SHIFT;
}
PRIVATE void i_00_to_3f(opc)
opcode_pt opc;
{
opcode_pt sub;
if (opc == 15)
pagef();
else if ((sub = opc & 7) >= 6)
{
outustr((sstr_00_to_3f - 6)[((opc >> 2) & 0x0E) + sub]);
if (!(opc & 1))
data_seg = opc;
}
else
{
oututstr(str_00_to_3f[(opc >> 3) & 7]);
if (sub == 4)
{
outustr(genreg[0]);
outcomma();
Ib();
}
else if (sub == 5)
{
outax();
outcomma();
Iv();
}
else
outad(sub);
}
}
PRIVATE void i_40_to_5f(opc)
opcode_pt opc;
{
outustr(str_40_to_5f[(opc >> 3) & 3]);
outustr(genreg[hosize + (opc & 7)]);
}
PRIVATE void i_60_to_6f(opc)
opcode_pt opc;
{
/* most for 386, some for 286 */
outustr((str_60_to_6f - 0x60)[opc]);
switch (opc)
{
case 0x60:
case 0x61:
if (hosize == 16)
outwsize();
break;
case 0x62:
GvMa();
break;
case 0x63:
EwRw();
break;
case 0x64:
case 0x65:
data_seg = opc;
break;
case 0x66:
hosize = (16 + 8) - hdefsize;
break;
case 0x67:
hasize = (16 + 8) - hdefsize;
break;
case 0x68:
outword();
Iv();
break;
case 0x6A:
outword();
outimmed(SIGNBIT | WORDBIT);
break;
case 0x69:
GvEv();
outcomma();
Iv();
break;
case 0x6B:
GvEv();
outcomma();
outimmed(SIGNBIT | WORDBIT);
break;
case 0x6D:
case 0x6F:
outwsize();
break;
}
}
PRIVATE void i_70_to_7f(opc)
opcode_pt opc;
{
outustr("j");
oututstr((str_flags - 0x70)[opc]);
Jb();
}
PRIVATE void i_80(opc)
opcode_pt opc;
{
if (opc >= 4)
{
outustr(opc >= 6 ? "xchg\t" : "test\t");
outad(opc);
}
else
{
getmodregrm();
oututstr(str_00_to_3f[reg]);
outbwptr(opc);
outea(opc);
outcomma();
outimmed(opc);
#ifdef SIGNED_LOGICALS
if (opc & SIGNBIT && (reg == 1 || reg == 4 || reg == 6))
/* and, or and xor with signe extension are not documented in some
* 8086 and 80286 manuals, but make sense and work
*/
outfishy();
#endif
}
}
PRIVATE void i_88(opc)
opcode_pt opc;
{
if (opc < 4)
{
outustr(movtab);
outad(opc);
}
else if (opc == 5)
{
oututstr("lea");
GvM();
}
else if (opc == 7)
{
oututstr("pop");
getmodregrm();
outwptr();
Ev();
if (reg != 0)
outfishy();
}
else
{
getmodregrm();
outustr(movtab);
if (!(opc & TOREGBIT))
{
Ev();
outcomma();
}
outustr(segreg[reg]);
if (opc & TOREGBIT)
{
outcomma();
Ev();
}
}
}
PRIVATE void i_90(opc)
opcode_pt opc;
{
if (opc == 0)
outustr("nop");
else
{
outustr("xchg\t");
outax();
outcomma();
outustr(genreg[hosize + opc]);
}
}
PRIVATE void i_98(opc)
opcode_pt opc;
{
outustr((str_98 - 8)[opc + hosize]);
if (opc == 2)
outsegpc();
}
PRIVATE void i_a0(opc)
opcode_pt opc;
{
outustr(str_a0[opc]);
if (opc < 4)
{
mod = MEM0_MOD; /* fake */
reg = 0; /* fake ax */
if (hasize == 16)
rm = 5; /* fake [d16] */
else
rm = 6; /* fake [d32] */
outad1(opc ^ TOREGBIT);
}
else if (opc & 1)
outwsize();
}
PRIVATE void i_a8(opc)
opcode_pt opc;
{
outustr(str_a8[opc]);
if (opc < 2)
{
outalorx(opc);
outcomma();
outimmed(opc);
}
else if (opc & 1)
outwsize();
}
PRIVATE void i_b0(opc)
opcode_pt opc;
{
outustr(movtab);
outustr(genreg[opc]);
outcomma();
Ib();
}
PRIVATE void i_b8(opc)
opcode_pt opc;
{
outustr(movtab);
outustr(genreg[hosize + opc]);
outcomma();
Iv();
}
PRIVATE void i_c0(opc)
opcode_pt opc;
{
outustr(str_c0[opc]);
if (opc >= 6)
{
getmodregrm();
outbwptr(opc);
outea(opc);
outcomma();
outimmed(opc & WORDBIT);
if (reg != 0)
/* not completely decoded (like DEBUG) */
outfishy();
}
else if (opc >= 4)
GvMp();
else if (opc == 2)
Iv();
else if (opc < 2)
shift(opc);
}
PRIVATE void i_c8(opc)
opcode_pt opc;
{
outustr(str_c8[opc]);
if (opc == 0)
{
Iw();
outcomma();
Ib();
}
if (opc == 2)
Iv();
else if (opc == 5)
Ib();
else if (opc == 7 && hosize == 16)
outwsize();
}
PRIVATE void i_d0(opc)
opcode_pt opc;
{
opcode_pt aabyte;
if (opc < 4)
shift(opc | 0xD0);
else
{
outustr((str_d0 - 4)[opc]);
if (opc < 6 && (aabyte = get8()) != 0x0A)
{
outtab();
outh8(aabyte);
outfishy();
}
}
}
PRIVATE void i_d8(opc)
opcode_pt opc;
{
opcode_pt esc;
char *str;
getmodregrm();
esc = (opc << 3) | reg;
if ((str = (mod == REG_MOD ? str1_d8 : str_d8)[esc]) == NULL)
{
escape:
oututstr("esc");
outh8(esc);
outcomma();
outea(0);
return;
}
if (*str == 0)
{
str = sstr_d8[str[1] + rm];
if (str == NULL)
goto escape;
outustr(str);
return;
}
outustr(str);
outtab();
if (mod == REG_MOD)
{
if (opc == 0 && reg != 2 && reg != 3)
outustr("st,");
outf1();
if (opc == 4 || opc == 6)
outustr(",st");
return;
}
switch(size_d8[esc])
{
case 4:
outustr("d");
case 2:
outwptr();
break;
case 8:
outustr("q");
outwptr();
break;
case 10:
outustr("t");
outbptr();
break;
}
outea(opc);
}
PRIVATE void i_e0(opc)
opcode_pt opc;
{
outustr(str_e0[opc]);
if (opc < 4)
Jb();
else if (opc < 6)
{
outalorx(opc);
outcomma();
Ib();
}
else
{
Ib();
outcomma();
outalorx(opc);
}
}
PRIVATE void i_e8(opc)
opcode_pt opc;
{
outustr(str_e8[opc]);
if (opc < 2)
Jv();
else if (opc == 2)
outsegpc();
else if (opc == 3)
Jb();
else
{
if (opc & TOREGBIT)
{
outustr(genreg[10]);
outcomma();
outalorx(opc);
}
else
{
outalorx(opc);
outcomma();
outustr(genreg[10]);
}
}
}
PRIVATE void i_f0(opc)
opcode_pt opc;
{
if (opc < 6)
outustr(str_f0[opc]);
else
{
getmodregrm();
outustr(sstr_f0[reg]);
outbwptr(opc);
outea(opc);
if (reg == 0)
{
outcomma();
outimmed(opc & WORDBIT);
}
}
}
PRIVATE void i_f8(opc)
opcode_pt opc;
{
if (opc < 6)
outustr(str_f8[opc]);
else
{
getmodregrm();
if (opc == 6 && reg >= 2)
outustr("fishy\t");
else
outustr(sstr_f8[reg]);
outbwptr(opc);
outea(opc);
}
}
PRIVATE void outad(opc)
opcode_pt opc;
{
getmodregrm();
outad1(opc);
}
PRIVATE void outad1(opc)
opcode_pt opc;
{
if (!(opc & TOREGBIT))
{
outea(opc);
outcomma();
}
if (opc & WORDBIT)
Gv1();
else
outustr(genreg[reg]);
if (opc & TOREGBIT)
{
outcomma();
outea(opc);
}
}
PRIVATE void outalorx(opc)
opcode_pt opc;
{
if (opc & WORDBIT)
outax();
else
outustr(genreg[0]);
}
PRIVATE void outax()
{
outustr(genreg[hosize]);
}
PRIVATE void outbptr()
{
outustr("byte ptr ");
}
PRIVATE void outbwptr(opc)
opcode_pt opc;
{
if (mod != REG_MOD)
{
if (opc & WORDBIT)
outwptr();
else
outbptr();
}
}
PRIVATE void outea(wordflags)
opcode_pt wordflags;
{
reg_pt base;
reg_pt index;
opcode_pt ss;
opcode_pt ssindexbase;
if (mod == REG_MOD)
outustr(genreg[hosize * (wordflags & WORDBIT) + rm]);
else
{
outbyte(LINDIRECT);
if (hasize == 16)
{
if (rm == 4)
{
base = (ssindexbase = get8()) & BASE_MASK;
if (mod == MEM0_MOD && base == 5)
outgetaddr();
else
outustr((genreg + 16)[base]);
ss = (ssindexbase & SS_MASK) >> SS_SHIFT;
if ((index = (ssindexbase & INDEX_MASK) >> INDEX_SHIFT) != 4)
{
outbyte('+');
outustr((genreg + 16)[index]);
outstr("\0\0\0*2\0*4\0*8\0" + (3 * ss));
}
}
else if (mod == MEM0_MOD && rm == 5)
outgetaddr();
else
outustr((genreg + 16)[rm]);
}
else if (mod == MEM0_MOD && rm == 6)
outgetaddr();
else
outustr(indreg[rm]);
if (mod == MEM1_MOD)
/* fake sign extension to get +- */
outimmed(SIGNBIT | WORDBIT);
else if (mod == MEM2_MOD)
{
outbyte('+');
#if (_WORD_SIZE == 4)
out32offset();
#else
outgetaddr();
#endif
}
outbyte(RINDIRECT);
if (hasize == 16 && rm == 4 && index == 4 && ss != 0)
outfishy();
}
}
PRIVATE void outf1()
{
outustr("st(");
outbyte((int) (rm + '0'));
outbyte(')');
}
#if (_WORD_SIZE == 4)
PRIVATE void out32offset()
{
off_t off;
if (hasize == 16)
off = get32();
else
outfishy();
outh32(off);
}
#endif
PRIVATE void outfishy()
{
outustr("\t???");
}
PRIVATE void outgetaddr()
{
off_t off;
if (hasize == 16)
off = get32();
else
off = get16();
if ( finds_data(off,data_seg) )
*offptr++ = off;
else if (hasize == 16)
outh32(off);
else
outh16((u16_t) off);
}
PRIVATE void outimmed(signwordflag)
opcode_pt signwordflag;
{
su8_pt byte;
if (signwordflag & WORDBIT)
{
if (signwordflag & SIGNBIT)
{
if ((byte = get8s()) < 0)
{
outbyte('-');
byte = -byte;
}
else
outbyte('+');
outh8((u8_t) byte);
}
else
Iv();
}
else
Ib();
}
PRIVATE void outpc(pc)
off_t pc;
{
if (hosize == 8)
pc = (u16_t) pc;
if ( finds_pc(pc) )
*offptr++ = pc;
else if (hosize == 16)
outh32(pc);
else
outh16((u16_t) pc);
}
PRIVATE void outsegpc()
{
off_t oldbase;
off_t pc;
if (hosize == 16)
pc = get32();
else
pc = get16();
oldbase = uptr.base;
outh16((u16_t) (uptr.base = get16())); /* fake seg for lookup of pc */
/* TODO - convert to offset in protected mode */
outbyte(':');
outpc(pc);
uptr.base = oldbase;
}
PRIVATE void oututstr(s)
char *s;
{
outustr(s);
outtab();
}
PRIVATE void outword()
{
outustr("dword " + ((16 - hosize) >> 3));
}
PRIVATE void outwptr()
{
outword();
outustr("ptr ");
}
PRIVATE void outwsize()
{
if (hosize == 16)
outustr("d");
else
outustr("w");
}
PRIVATE void pagef()
{
opcode_pt opc;
int regbad;
if ((opc = get8()) <= 1 || opc == 0xBA)
{
if (opc == 0xBA)
opc = 16;
else
opc *= 8;
getmodregrm();
outustr(ssstr_0f[opc += reg]);
if (opc < 6 || opc == 12 || opc == 14)
Ew();
else if (opc >= 8 && opc < 13)
Ms();
else if (opc >= 20)
{
outbwptr(WORDBIT);
EvIb();
}
}
else if (opc < 4)
{
oututstr("lar\0lsl" + 4 * (opc - 2));
GvEw();
}
else if (opc == 5)
{
outustr("loadall");
outfishy();
}
else if (opc == 6)
outustr("clts");
else if (opc < 0x20)
outstr(fishy);
else if (opc < 0x27 && opc != 0x25)
{
outustr(movtab);
getmodregrm();
hosize = 16;
if (!(opc & TOREGBIT))
{
Ev(); /* Rd() since hosize is 16 */
outcomma();
}
regbad = FALSE;
if (opc & 1)
{
outustr("dr");
if (reg == 4 || reg == 5)
regbad = TRUE;
}
else if (opc < 0x24)
{
outustr("cr");
if (reg >= 4 || reg == 1)
regbad = TRUE;
}
else
{
outustr("tr");
if (reg < 6)
regbad = TRUE;
}
outbyte((int) (reg + '0'));
if (opc & TOREGBIT)
{
outcomma();
Ev();
}
if (regbad || mod != REG_MOD)
outfishy();
}
else if (opc < 0x80)
outstr(fishy);
else if (opc < 0x90)
{
outustr("j");
oututstr((str_flags - 0x80)[opc]);
Jv();
}
else if (opc < 0xA0)
{
outustr("set");
oututstr((str_flags - 0x90)[opc]);
getmodregrm();
outbwptr(0);
Eb();
}
else if (opc < 0xC0)
{
outustr((sstr_0f - 0xA0)[opc]);
switch (opc)
{
case 0xA3:
case 0xAB:
case 0xB3:
case 0xBB:
EvGv();
break;
case 0xA4:
case 0xAC:
EvGv();
outcomma();
Ib();
break;
case 0xA5:
case 0xAD:
EvGv();
outcomma();
CL();
break;
case 0xAF:
case 0xBC:
case 0xBD:
GvEv();
break;
case 0xB2:
case 0xB4:
case 0xB5:
GvMp();
break;
case 0xB6:
case 0xBE:
Gv();
outcomma();
outbwptr(opc);
Eb();
break;
case 0xB7:
case 0xBF:
Gv();
outcomma();
hosize = 8; /* done in Ew(), but too late */
outbwptr(opc);
Ew();
break;
}
}
else
outstr(fishy);
}
PRIVATE int puti()
{
static int hadprefix;
opcode_pt opcode;
more:
offptr = offtable;
opcode = get8();
if (!hadprefix)
{
data_seg = DSEG;
hdefsize = 8;
if (bits32)
hdefsize = 16;
hosize =
hasize = hdefsize;
}
(*optable[opcode >> 3])(opcode < 0x80 ? opcode : opcode & 7);
if (offptr > offtable)
{
if (stringtab() >= 31)
{
outspace();
outspace();
}
else
while (stringtab() < 32)
outtab();
outbyte(';');
for (off1ptr = offtable; off1ptr < offptr; ++off1ptr)
{
outspace();
if (*off1ptr < 0x10000)
outh16((u16_t) *off1ptr);
else
outh32(*off1ptr);
}
offptr = offtable;
}
if ((opcode & 0xE7) == 0x26 ||
opcode >= 0x64 && opcode < 0x68 ||
opcode == 0xF0 || opcode == 0xF2 || opcode == 0xF3)
/* not finished instruction for 0x26, 0x2E, 0x36, 0x3E seg overrides
* and 0x64, 0x65 386 seg overrides
* and 0x66, 0x67 386 size prefixes
* and 0xF0 lock, 0xF2 repne, 0xF3 rep
*/
{
hadprefix = TRUE;
goto more; /* TODO - print prefixes better */
return FALSE;
}
hadprefix = FALSE;
return TRUE;
}
PRIVATE void shift(opc)
opcode_pt opc;
{
getmodregrm();
oututstr(sstr_d0[reg]);
outbwptr(opc);
outea(opc);
outcomma();
if (opc < 0xD0)
Ib();
else if (opc & 2)
CL();
else
outbyte('1');
}
PRIVATE void checkmemory()
{
if (mod == REG_MOD)
outfishy();
}
PRIVATE void CL()
{
outustr(genreg[1]);
}
PRIVATE void Eb()
{
outea(0);
}
PRIVATE void Ev()
{
outea(WORDBIT);
}
PRIVATE void EvGv()
{
getmodregrm();
Ev();
outcomma();
Gv1();
}
PRIVATE void EvIb()
{
Ev();
outcomma();
Ib();
}
PRIVATE void Ew()
{
hosize = 8;
Ev();
}
PRIVATE void EwRw()
{
hosize = 8;
EvGv();
}
PRIVATE void Gv()
{
getmodregrm();
Gv1();
}
PRIVATE void Gv1()
{
outustr(genreg[hosize + reg]);
}
PRIVATE void GvEv()
{
Gv();
outcomma();
Ev();
}
PRIVATE void GvEw()
{
Gv();
outcomma();
Ew();
}
PRIVATE void GvM()
{
GvEv();
checkmemory();
}
PRIVATE void GvMa()
{
GvM();
}
PRIVATE void GvMp()
{
GvM();
}
PRIVATE void Ib()
{
outh8(get8());
}
PRIVATE void Iw()
{
outh16(get16());
}
PRIVATE void Iv()
{
if (hosize == 16)
outh32(get32());
else
Iw();
}
PRIVATE void Jb()
{
off_t pcjump;
pcjump = get8s();
outpc(pcjump + uptr.off);
}
PRIVATE void Jv()
{
off_t pcjump;
if (hosize == 16)
pcjump = get32();
else
pcjump = (su16_t) get16();
outpc(pcjump + uptr.off);
}
PRIVATE void Ms()
{
Ev();
checkmemory();
}
/********************* DASM ******************************/
PUBLIC long dasm( addr, count, symflg )
long addr;
int count;
int symflg;
{
#if (_WORD_SIZE == 4)
bits32 = TRUE; /* Set mode */
#else
bits32 = FALSE;
#endif
uptr.off = addr;
uptr.base = 0; /* not known */
while ( count-- != 0 && show1instruction() )
;
}
PRIVATE int show1instruction()
{
register int column;
int idone;
static char line[81];
int maxcol;
struct address_s newuptr;
struct address_s olduptr;
outbyte('\r');
do
{
if ( text_symbol(uptr.off) ) {
outbyte(':');
outbyte('\n');
}
olduptr = uptr;
openstring(line);
idone = puti();
line[stringpos()] = 0;
closestring();
newuptr = uptr;
uptr = olduptr;
column = outssegaddr(&uptr);
while (uptr.off != newuptr.off)
{
outh8(get8());
column += 2;
}
maxcol = bits32 ? 24 : 16;
while (column < maxcol)
{
outtab();
column += 8;
}
outtab();
outstr(line);
outbyte('\n');
}
while (!idone); /* eat all prefixes */
return TRUE;
}
PRIVATE u8_t get8()
{
/* get 8 bits current instruction pointer and advance pointer */
u8_t temp;
temp = peek_byte(uptr.off + uptr.base);
++uptr.off;
return temp;
}
PRIVATE u16_t get16()
{
/* get 16 bits from current instruction pointer and advance pointer */
u16_t temp;
temp = peek_word(uptr.off + uptr.base);
uptr.off += 2;
return temp;
}
PRIVATE u32_t get32()
{
/* get 32 bits from current instruction pointer and advance pointer */
u32_t temp;
temp = peek_dword(uptr.off + uptr.base);
uptr.off += 4;
return temp;
}
PRIVATE int outsegaddr(addr)
struct address_s *addr;
{
/* print segmented address */
int bytes_printed;
bytes_printed = 2;
bytes_printed = outsegreg(addr->base);
if (bytes_printed > 4)
outbyte('+');
else
outbyte(':');
++bytes_printed;
if (addr->off >= 0x10000)
{
outh32(addr->off);
return bytes_printed + 8;
}
outh16((u16_t) addr->off);
return bytes_printed + 4;
}
PRIVATE int outssegaddr(addr)
struct address_s *addr;
{
/* print 32 bit segmented address and 2 spaces */
int bytes_printed;
bytes_printed = outsegaddr(addr);
outspace();
outspace();
return bytes_printed + 2;
}
PRIVATE u8_t peek_byte(addr)
off_t addr;
{
return (u8_t) peek_dword(addr) & 0xFF; /* 8 bits only */
}
PRIVATE u16_t peek_word(addr)
off_t addr;
{
return (u16_t) peek_dword(addr);
}