1565 lines
27 KiB
C
1565 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);
|
|
}
|