root/arch/i386/i386/db_disasm.c

DEFINITIONS

1. db_read_address
2. db_print_address
3. db_disasm_esc
4. db_disasm

    1 /*      $OpenBSD: db_disasm.c,v 1.14 2006/09/19 11:06:33 jsg Exp $      */
    2 /*      $NetBSD: db_disasm.c,v 1.11 1996/05/03 19:41:58 christos Exp $  */
    4 /*
    5  * Mach Operating System
    6  * Copyright (c) 1991,1990 Carnegie Mellon University
    7  * All Rights Reserved.
    8  *
    9  * Permission to use, copy, modify and distribute this software and its
   10  * documentation is hereby granted, provided that both the copyright
   11  * notice and this permission notice appear in all copies of the
   12  * software, derivative works or modified versions, and any portions
   13  * thereof, and that both notices appear in supporting documentation.
   14  *
   15  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   16  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
   17  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   18  *
   19  * Carnegie Mellon requests users of this software to return to
   20  *
   21  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   22  *  School of Computer Science
   23  *  Carnegie Mellon University
   24  *  Pittsburgh PA 15213-3890
   25  *
   26  * any improvements or extensions that they make and grant Carnegie Mellon
   27  * the rights to redistribute these changes.
   28  *
   29  *      Id: db_disasm.c,v 2.6  92/01/03  20:05:00  dbg (CMU)
   30  */
   32 /*
   33  * Instruction disassembler.
   34  */
   35 #include <sys/param.h>
   36 #include <sys/proc.h>
   37 #include <machine/db_machdep.h>
   39 #include <ddb/db_access.h>
   40 #include <ddb/db_sym.h>
   41 #include <ddb/db_output.h>
   42 #include <ddb/db_interface.h>
   44 /*
   45  * Size attributes
   46  */
   47 #define BYTE    0
   48 #define WORD    1
   49 #define LONG    2
   50 #define QUAD    3
   51 #define SNGL    4
   52 #define DBLR    5
   53 #define EXTR    6
   54 #define SDEP    7
   55 #define NONE    8
   57 /*
   58  * Addressing modes
   59  */
   60 #define E       1                       /* general effective address */
   61 #define Eind    2                       /* indirect address (jump, call) */
   62 #define Ew      3                       /* address, word size */
   63 #define Eb      4                       /* address, byte size */
   64 #define R       5                       /* register, in 'reg' field */
   65 #define Rw      6                       /* word register, in 'reg' field */
   66 #define Ri      7                       /* register in instruction */
   67 #define S       8                       /* segment reg, in 'reg' field */
   68 #define Si      9                       /* segment reg, in instruction */
   69 #define A       10                      /* accumulator */
   70 #define BX      11                      /* (bx) */
   71 #define CL      12                      /* cl, for shifts */
   72 #define DX      13                      /* dx, for IO */
   73 #define SI      14                      /* si */
   74 #define DI      15                      /* di */
   75 #define CR      16                      /* control register */
   76 #define DR      17                      /* debug register */
   77 #define TR      18                      /* test register */
   78 #define I       19                      /* immediate, unsigned */
   79 #define Is      20                      /* immediate, signed */
   80 #define Ib      21                      /* byte immediate, unsigned */
   81 #define Ibs     22                      /* byte immediate, signed */
   82 #define Iw      23                      /* word immediate, unsigned */
   83 #define O       25                      /* direct address */
   84 #define Db      26                      /* byte displacement from EIP */
   85 #define Dl      27                      /* long displacement from EIP */
   86 #define o1      28                      /* constant 1 */
   87 #define o3      29                      /* constant 3 */
   88 #define OS      30                      /* immediate offset/segment */
   89 #define ST      31                      /* FP stack top */
   90 #define STI     32                      /* FP stack */
   91 #define X       33                      /* extended FP op */
   92 #define XA      34                      /* for 'fstcw %ax' */
   93 #define El      35                      /* address, long size */
   94 #define Ril     36                      /* long register in instruction */
   95 #define Iba     37                      /* byte immediate, don't print if 0xa */
   97 struct inst {
   98         char *  i_name;                 /* name */
   99         short   i_has_modrm;            /* has regmodrm byte */
  100         short   i_size;                 /* operand size */
  101         int     i_mode;                 /* addressing modes */
  102         void *  i_extra;                /* pointer to extra opcode table */
  103 };
  105 #define op1(x)          (x)
  106 #define op2(x,y)        ((x)|((y)<<8))
  107 #define op3(x,y,z)      ((x)|((y)<<8)|((z)<<16))
  109 struct finst {
  110         char *  f_name;                 /* name for memory instruction */
  111         int     f_size;                 /* size for memory instruction */
  112         int     f_rrmode;               /* mode for rr instruction */
  113         void *  f_rrname;               /* name for rr instruction
  114                                            (or pointer to table) */
  115 };
  117 char *  db_Grp6[] = {
  118         "sldt",         "str",          "lldt",         "ltr",
  119         "verr",         "verw",         "",             ""
  120 };
  122 char *  db_Grp7[] = {
  123         "sgdt",         "sidt",         "lgdt",         "lidt",
  124         "smsw",         "",             "lmsw",         "invlpg"
  125 };
  127 char *  db_Grp8[] = {
  128         "",             "",             "",             "",
  129         "bt",           "bts",          "btr",          "btc"
  130 };
  132 char *  db_Grp9[] = {
  133         "fxsave",       "fxrstor",      "",             "",
  134         "",             "",             "",             ""
  135 };
  137 char *  db_GrpA[] = {
  138         "",             "cmpxchg8b",    "",             "",
  139         "",             "",             "",             ""
  140 };
  142 char *  db_GrpB[] = {
  143         "xstore-rng",   "xcrypt-ecb",   "xcrypt-cbc",   "xcrypt-ctr",
  144         "xcrypt-cfb",   "xcrypt-ofb",   "",             ""
  145 };
  147 char *  db_GrpC[] = {
  148         "montmul",      "xsha1",        "xsha256",      "",
  149         "",             "",             "",             ""
  150 };
  152 struct inst db_inst_0f0x[] = {
  153 /*00*/  { "",      TRUE,  NONE,  op1(Ew),     db_Grp6 },
  154 /*01*/  { "",      TRUE,  NONE,  op1(Ew),     db_Grp7 },
  155 /*02*/  { "lar",   TRUE,  LONG,  op2(E,R),    0 },
  156 /*03*/  { "lsl",   TRUE,  LONG,  op2(E,R),    0 },
  157 /*04*/  { "",      FALSE, NONE,  0,           0 },
  158 /*05*/  { "",      FALSE, NONE,  0,           0 },
  159 /*06*/  { "clts",  FALSE, NONE,  0,           0 },
  160 /*07*/  { "",      FALSE, NONE,  0,           0 },
  162 /*08*/  { "invd",  FALSE, NONE,  0,           0 },
  163 /*09*/  { "wbinvd",FALSE, NONE,  0,           0 },
  164 /*0a*/  { "",      FALSE, NONE,  0,           0 },
  165 /*0b*/  { "",      FALSE, NONE,  0,           0 },
  166 /*0c*/  { "",      FALSE, NONE,  0,           0 },
  167 /*0d*/  { "",      FALSE, NONE,  0,           0 },
  168 /*0e*/  { "",      FALSE, NONE,  0,           0 },
  169 /*0f*/  { "",      FALSE, NONE,  0,           0 },
  170 };
  172 struct inst     db_inst_0f2x[] = {
  173 /*20*/  { "mov",   TRUE,  LONG,  op2(CR,E),   0 }, /* use E for reg */
  174 /*21*/  { "mov",   TRUE,  LONG,  op2(DR,E),   0 }, /* since mod == 11 */
  175 /*22*/  { "mov",   TRUE,  LONG,  op2(E,CR),   0 },
  176 /*23*/  { "mov",   TRUE,  LONG,  op2(E,DR),   0 },
  177 /*24*/  { "mov",   TRUE,  LONG,  op2(TR,E),   0 },
  178 /*25*/  { "",      FALSE, NONE,  0,           0 },
  179 /*26*/  { "mov",   TRUE,  LONG,  op2(E,TR),   0 },
  180 /*27*/  { "",      FALSE, NONE,  0,           0 },
  182 /*28*/  { "",      FALSE, NONE,  0,           0 },
  183 /*29*/  { "",      FALSE, NONE,  0,           0 },
  184 /*2a*/  { "",      FALSE, NONE,  0,           0 },
  185 /*2b*/  { "",      FALSE, NONE,  0,           0 },
  186 /*2c*/  { "",      FALSE, NONE,  0,           0 },
  187 /*2d*/  { "",      FALSE, NONE,  0,           0 },
  188 /*2e*/  { "",      FALSE, NONE,  0,           0 },
  189 /*2f*/  { "",      FALSE, NONE,  0,           0 },
  190 };
  192 struct inst     db_inst_0f3x[] = {
  193 /*30*/  { "wrmsr", FALSE, NONE,  0,           0 },
  194 /*31*/  { "rdtsc", FALSE, NONE,  0,           0 },
  195 /*32*/  { "rdmsr", FALSE, NONE,  0,           0 },
  196 /*33*/  { "rdpmc", FALSE, NONE,  0,           0 },
  197 /*34*/  { "",      FALSE, NONE,  0,           0 },
  198 /*35*/  { "",      FALSE, NONE,  0,           0 },
  199 /*36*/  { "",      FALSE, NONE,  0,           0 },
  200 /*37*/  { "",      FALSE, NONE,  0,           0 },
  202 /*38*/  { "",      FALSE, NONE,  0,           0 },
  203 /*39*/  { "",      FALSE, NONE,  0,           0 },
  204 /*3a*/  { "",      FALSE, NONE,  0,           0 },
  205 /*3b*/  { "",      FALSE, NONE,  0,           0 },
  206 /*3c*/  { "",      FALSE, NONE,  0,           0 },
  207 /*3d*/  { "",      FALSE, NONE,  0,           0 },
  208 /*3e*/  { "",      FALSE, NONE,  0,           0 },
  209 /*3f*/  { "",      FALSE, NONE,  0,           0 },
  210 };
  212 struct inst     db_inst_0f8x[] = {
  213 /*80*/  { "jo",    FALSE, NONE,  op1(Dl),     0 },
  214 /*81*/  { "jno",   FALSE, NONE,  op1(Dl),     0 },
  215 /*82*/  { "jb",    FALSE, NONE,  op1(Dl),     0 },
  216 /*83*/  { "jnb",   FALSE, NONE,  op1(Dl),     0 },
  217 /*84*/  { "jz",    FALSE, NONE,  op1(Dl),     0 },
  218 /*85*/  { "jnz",   FALSE, NONE,  op1(Dl),     0 },
  219 /*86*/  { "jbe",   FALSE, NONE,  op1(Dl),     0 },
  220 /*87*/  { "jnbe",  FALSE, NONE,  op1(Dl),     0 },
  222 /*88*/  { "js",    FALSE, NONE,  op1(Dl),     0 },
  223 /*89*/  { "jns",   FALSE, NONE,  op1(Dl),     0 },
  224 /*8a*/  { "jp",    FALSE, NONE,  op1(Dl),     0 },
  225 /*8b*/  { "jnp",   FALSE, NONE,  op1(Dl),     0 },
  226 /*8c*/  { "jl",    FALSE, NONE,  op1(Dl),     0 },
  227 /*8d*/  { "jnl",   FALSE, NONE,  op1(Dl),     0 },
  228 /*8e*/  { "jle",   FALSE, NONE,  op1(Dl),     0 },
  229 /*8f*/  { "jnle",  FALSE, NONE,  op1(Dl),     0 },
  230 };
  232 struct inst     db_inst_0f9x[] = {
  233 /*90*/  { "seto",  TRUE,  NONE,  op1(Eb),     0 },
  234 /*91*/  { "setno", TRUE,  NONE,  op1(Eb),     0 },
  235 /*92*/  { "setb",  TRUE,  NONE,  op1(Eb),     0 },
  236 /*93*/  { "setnb", TRUE,  NONE,  op1(Eb),     0 },
  237 /*94*/  { "setz",  TRUE,  NONE,  op1(Eb),     0 },
  238 /*95*/  { "setnz", TRUE,  NONE,  op1(Eb),     0 },
  239 /*96*/  { "setbe", TRUE,  NONE,  op1(Eb),     0 },
  240 /*97*/  { "setnbe",TRUE,  NONE,  op1(Eb),     0 },
  242 /*98*/  { "sets",  TRUE,  NONE,  op1(Eb),     0 },
  243 /*99*/  { "setns", TRUE,  NONE,  op1(Eb),     0 },
  244 /*9a*/  { "setp",  TRUE,  NONE,  op1(Eb),     0 },
  245 /*9b*/  { "setnp", TRUE,  NONE,  op1(Eb),     0 },
  246 /*9c*/  { "setl",  TRUE,  NONE,  op1(Eb),     0 },
  247 /*9d*/  { "setnl", TRUE,  NONE,  op1(Eb),     0 },
  248 /*9e*/  { "setle", TRUE,  NONE,  op1(Eb),     0 },
  249 /*9f*/  { "setnle",TRUE,  NONE,  op1(Eb),     0 },
  250 };
  252 struct inst     db_inst_0fax[] = {
  253 /*a0*/  { "push",  FALSE, NONE,  op1(Si),     0 },
  254 /*a1*/  { "pop",   FALSE, NONE,  op1(Si),     0 },
  255 /*a2*/  { "cpuid", FALSE, NONE,  0,           0 },
  256 /*a3*/  { "bt",    TRUE,  LONG,  op2(R,E),    0 },
  257 /*a4*/  { "shld",  TRUE,  LONG,  op3(Ib,R,E), 0 },
  258 /*a5*/  { "shld",  TRUE,  LONG,  op3(CL,R,E), 0 },
  259 /*a6*/  { "",      TRUE,  NONE,  0,           db_GrpC },
  260 /*a7*/  { "",      TRUE,  NONE,  0,           db_GrpB },
  262 /*a8*/  { "push",  FALSE, NONE,  op1(Si),     0 },
  263 /*a9*/  { "pop",   FALSE, NONE,  op1(Si),     0 },
  264 /*aa*/  { "",      FALSE, NONE,  0,           0 },
  265 /*ab*/  { "bts",   TRUE,  LONG,  op2(R,E),    0 },
  266 /*ac*/  { "shrd",  TRUE,  LONG,  op3(Ib,E,R), 0 },
  267 /*ad*/  { "shrd",  TRUE,  LONG,  op3(CL,E,R), 0 },
  268 /*ae*/  { "",      TRUE,  NONE,  op1(E),      db_Grp9 },
  269 /*af*/  { "imul",  TRUE,  LONG,  op2(E,R),    0 },
  270 };
  272 struct inst     db_inst_0fbx[] = {
  273 /*b0*/  { "cmpxchg",TRUE, BYTE,  op2(R, E),   0 },
  274 /*b1*/  { "cmpxchg",TRUE, LONG,  op2(R, E),   0 },
  275 /*b2*/  { "lss",   TRUE,  LONG,  op2(E, R),   0 },
  276 /*b3*/  { "btr",   TRUE,  LONG,  op2(R, E),   0 },
  277 /*b4*/  { "lfs",   TRUE,  LONG,  op2(E, R),   0 },
  278 /*b5*/  { "lgs",   TRUE,  LONG,  op2(E, R),   0 },
  279 /*b6*/  { "movzb", TRUE,  LONG,  op2(Eb, R),  0 },
  280 /*b7*/  { "movzw", TRUE,  LONG,  op2(Ew, R),  0 },
  282 /*b8*/  { "",      FALSE, NONE,  0,           0 },
  283 /*b9*/  { "",      FALSE, NONE,  0,           0 },
  284 /*ba*/  { "",      TRUE,  LONG,  op2(Ib, E),  db_Grp8 },
  285 /*bb*/  { "btc",   TRUE,  LONG,  op2(R, E),   0 },
  286 /*bc*/  { "bsf",   TRUE,  LONG,  op2(E, R),   0 },
  287 /*bd*/  { "bsr",   TRUE,  LONG,  op2(E, R),   0 },
  288 /*be*/  { "movsb", TRUE,  LONG,  op2(Eb, R),  0 },
  289 /*bf*/  { "movsw", TRUE,  LONG,  op2(Ew, R),  0 },
  290 };
  292 struct inst     db_inst_0fcx[] = {
  293 /*c0*/  { "xadd",  TRUE,  BYTE,  op2(R, E),   0 },
  294 /*c1*/  { "xadd",  TRUE,  LONG,  op2(R, E),   0 },
  295 /*c2*/  { "",      FALSE, NONE,  0,           0 },
  296 /*c3*/  { "",      FALSE, NONE,  0,           0 },
  297 /*c4*/  { "",      FALSE, NONE,  0,           0 },
  298 /*c5*/  { "",      FALSE, NONE,  0,           0 },
  299 /*c6*/  { "",      FALSE, NONE,  0,           0 },
  300 /*c7*/  { "",      TRUE,  NONE,  op1(E),      db_GrpA },
  302 /*c8*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  303 /*c9*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  304 /*ca*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  305 /*cb*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  306 /*cc*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  307 /*cd*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  308 /*ce*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  309 /*cf*/  { "bswap", FALSE, LONG,  op1(Ril),    0 },
  310 };
  312 struct inst *db_inst_0f[] = {
db_inst_0f0x,
NULL,
db_inst_0f2x,
db_inst_0f3x,
NULL,
NULL,
NULL,
NULL,
db_inst_0f8x,
db_inst_0f9x,
db_inst_0fax,
db_inst_0fbx,
db_inst_0fcx,
NULL,
NULL,
NULL
  329 };
  331 char *  db_Esc92[] = {
  332         "fnop",         "",             "",             "",
  333         "",             "",             "",             ""
  334 };
  335 char *  db_Esc94[] = {
  336         "fchs",         "fabs",         "",             "",
  337         "ftst",         "fxam",         "",             ""
  338 };
  339 char *  db_Esc95[] = {
  340         "fld1",         "fldl2t",       "fldl2e",       "fldpi",
  341         "fldlg2",       "fldln2",       "fldz",         ""
  342 };
  343 char *  db_Esc96[] = {
  344         "f2xm1",        "fyl2x",        "fptan",        "fpatan",
  345         "fxtract",      "fprem1",       "fdecstp",      "fincstp"
  346 };
  347 char *  db_Esc97[] = {
  348         "fprem",        "fyl2xp1",      "fsqrt",        "fsincos",
  349         "frndint",      "fscale",       "fsin",         "fcos"
  350 };
  352 char *  db_Esca5[] = {
  353         "",             "fucompp",      "",             "",
  354         "",             "",             "",             ""
  355 };
  357 char *  db_Escb4[] = {
  358         "fneni",        "fndisi",       "fnclex",       "fninit",
  359         "fsetpm",       "",             "",             ""
  360 };
  362 char *  db_Esce3[] = {
  363         "",             "fcompp",       "",             "",
  364         "",             "",             "",             ""
  365 };
  367 char *  db_Escf4[] = {
  368         "fnstsw",       "",             "",             "",
  369         "",             "",             "",             ""
  370 };
  372 struct finst db_Esc8[] = {
  373 /*0*/   { "fadd",   SNGL,  op2(STI,ST), 0 },
  374 /*1*/   { "fmul",   SNGL,  op2(STI,ST), 0 },
  375 /*2*/   { "fcom",   SNGL,  op2(STI,ST), 0 },
  376 /*3*/   { "fcomp",  SNGL,  op2(STI,ST), 0 },
  377 /*4*/   { "fsub",   SNGL,  op2(STI,ST), 0 },
  378 /*5*/   { "fsubr",  SNGL,  op2(STI,ST), 0 },
  379 /*6*/   { "fdiv",   SNGL,  op2(STI,ST), 0 },
  380 /*7*/   { "fdivr",  SNGL,  op2(STI,ST), 0 },
  381 };
  383 struct finst db_Esc9[] = {
  384 /*0*/   { "fld",    SNGL,  op1(STI),    0 },
  385 /*1*/   { "",       NONE,  op1(STI),    "fxch" },
  386 /*2*/   { "fst",    SNGL,  op1(X),      db_Esc92 },
  387 /*3*/   { "fstp",   SNGL,  op1(X),      0 },
  388 /*4*/   { "fldenv", NONE,  op1(X),      db_Esc94 },
  389 /*5*/   { "fldcw",  NONE,  op1(X),      db_Esc95 },
  390 /*6*/   { "fnstenv",NONE,  op1(X),      db_Esc96 },
  391 /*7*/   { "fnstcw", NONE,  op1(X),      db_Esc97 },
  392 };
  394 struct finst db_Esca[] = {
  395 /*0*/   { "fiadd",  LONG,  0,           0 },
  396 /*1*/   { "fimul",  LONG,  0,           0 },
  397 /*2*/   { "ficom",  LONG,  0,           0 },
  398 /*3*/   { "ficomp", LONG,  0,           0 },
  399 /*4*/   { "fisub",  LONG,  op1(X),      0 },
  400 /*5*/   { "fisubr", LONG,  0,           0 },
  401 /*6*/   { "fidiv",  LONG,  0,           0 },
  402 /*7*/   { "fidivr", LONG,  0,           0 }
  403 };
  405 struct finst db_Escb[] = {
  406 /*0*/   { "fild",   LONG,  0,           0 },
  407 /*1*/   { "",       NONE,  0,           0 },
  408 /*2*/   { "fist",   LONG,  0,           0 },
  409 /*3*/   { "fistp",  LONG,  0,           0 },
  410 /*4*/   { "",       WORD,  op1(X),      db_Escb4 },
  411 /*5*/   { "fld",    EXTR,  0,           0 },
  412 /*6*/   { "",       WORD,  0,           0 },
  413 /*7*/   { "fstp",   EXTR,  0,           0 },
  414 };
  416 struct finst db_Escc[] = {
  417 /*0*/   { "fadd",   DBLR,  op2(ST,STI), 0 },
  418 /*1*/   { "fmul",   DBLR,  op2(ST,STI), 0 },
  419 /*2*/   { "fcom",   DBLR,  0,           0 },
  420 /*3*/   { "fcomp",  DBLR,  0,           0 },
  421 /*4*/   { "fsub",   DBLR,  op2(ST,STI), "fsubr" },
  422 /*5*/   { "fsubr",  DBLR,  op2(ST,STI), "fsub" },
  423 /*6*/   { "fdiv",   DBLR,  op2(ST,STI), "fdivr" },
  424 /*7*/   { "fdivr",  DBLR,  op2(ST,STI), "fdiv" },
  425 };
  427 struct finst db_Escd[] = {
  428 /*0*/   { "fld",    DBLR,  op1(STI),    "ffree" },
  429 /*1*/   { "",       NONE,  0,           0 },
  430 /*2*/   { "fst",    DBLR,  op1(STI),    0 },
  431 /*3*/   { "fstp",   DBLR,  op1(STI),    0 },
  432 /*4*/   { "frstor", NONE,  op1(STI),    "fucom" },
  433 /*5*/   { "",       NONE,  op1(STI),    "fucomp" },
  434 /*6*/   { "fnsave", NONE,  0,           0 },
  435 /*7*/   { "fnstsw", NONE,  0,           0 },
  436 };
  438 struct finst db_Esce[] = {
  439 /*0*/   { "fiadd",  WORD,  op2(ST,STI), "faddp" },
  440 /*1*/   { "fimul",  WORD,  op2(ST,STI), "fmulp" },
  441 /*2*/   { "ficom",  WORD,  0,           0 },
  442 /*3*/   { "ficomp", WORD,  op1(X),      db_Esce3 },
  443 /*4*/   { "fisub",  WORD,  op2(ST,STI), "fsubrp" },
  444 /*5*/   { "fisubr", WORD,  op2(ST,STI), "fsubp" },
  445 /*6*/   { "fidiv",  WORD,  op2(ST,STI), "fdivrp" },
  446 /*7*/   { "fidivr", WORD,  op2(ST,STI), "fdivp" },
  447 };
  449 struct finst db_Escf[] = {
  450 /*0*/   { "fild",   WORD,  0,           0 },
  451 /*1*/   { "",       WORD,  0,           0 },
  452 /*2*/   { "fist",   WORD,  0,           0 },
  453 /*3*/   { "fistp",  WORD,  0,           0 },
  454 /*4*/   { "fbld",   NONE,  op1(XA),     db_Escf4 },
  455 /*5*/   { "fild",   QUAD,  0,           0 },
  456 /*6*/   { "fbstp",  NONE,  0,           0 },
  457 /*7*/   { "fistp",  QUAD,  0,           0 },
  458 };
  460 struct finst *db_Esc_inst[] = {
db_Esc8, db_Esc9, db_Esca, db_Escb,
db_Escc, db_Escd, db_Esce, db_Escf
  463 };
  465 char *  db_Grp1[] = {
  466         "add",
  467         "or",
  468         "adc",
  469         "sbb",
  470         "and",
  471         "sub",
  472         "xor",
  473         "cmp"
  474 };
  476 char *  db_Grp2[] = {
  477         "rol",
  478         "ror",
  479         "rcl",
  480         "rcr",
  481         "shl",
  482         "shr",
  483         "shl",
  484         "sar"
  485 };
  487 struct inst db_Grp3[] = {
  488         { "test",  TRUE, NONE, op2(I,E), 0 },
  489         { "test",  TRUE, NONE, op2(I,E), 0 },
  490         { "not",   TRUE, NONE, op1(E),   0 },
  491         { "neg",   TRUE, NONE, op1(E),   0 },
  492         { "mul",   TRUE, NONE, op2(E,A), 0 },
  493         { "imul",  TRUE, NONE, op2(E,A), 0 },
  494         { "div",   TRUE, NONE, op2(E,A), 0 },
  495         { "idiv",  TRUE, NONE, op2(E,A), 0 },
  496 };
  498 struct inst     db_Grp4[] = {
  499         { "inc",   TRUE, BYTE, op1(E),   0 },
  500         { "dec",   TRUE, BYTE, op1(E),   0 },
  501         { "",      TRUE, NONE, 0,        0 },
  502         { "",      TRUE, NONE, 0,        0 },
  503         { "",      TRUE, NONE, 0,        0 },
  504         { "",      TRUE, NONE, 0,        0 },
  505         { "",      TRUE, NONE, 0,        0 },
  506         { "",      TRUE, NONE, 0,        0 }
  507 };
  509 struct inst     db_Grp5[] = {
  510         { "inc",   TRUE, LONG, op1(E),   0 },
  511         { "dec",   TRUE, LONG, op1(E),   0 },
  512         { "call",  TRUE, NONE, op1(Eind),0 },
  513         { "lcall", TRUE, NONE, op1(Eind),0 },
  514         { "jmp",   TRUE, NONE, op1(Eind),0 },
  515         { "ljmp",  TRUE, NONE, op1(Eind),0 },
  516         { "push",  TRUE, LONG, op1(E),   0 },
  517         { "",      TRUE, NONE, 0,        0 }
  518 };
  520 struct inst db_inst_table[256] = {
  521 /*00*/  { "add",   TRUE,  BYTE,  op2(R, E),  0 },
  522 /*01*/  { "add",   TRUE,  LONG,  op2(R, E),  0 },
  523 /*02*/  { "add",   TRUE,  BYTE,  op2(E, R),  0 },
  524 /*03*/  { "add",   TRUE,  LONG,  op2(E, R),  0 },
  525 /*04*/  { "add",   FALSE, BYTE,  op2(I, A),  0 },
  526 /*05*/  { "add",   FALSE, LONG,  op2(Is, A), 0 },
  527 /*06*/  { "push",  FALSE, NONE,  op1(Si),    0 },
  528 /*07*/  { "pop",   FALSE, NONE,  op1(Si),    0 },
  530 /*08*/  { "or",    TRUE,  BYTE,  op2(R, E),  0 },
  531 /*09*/  { "or",    TRUE,  LONG,  op2(R, E),  0 },
  532 /*0a*/  { "or",    TRUE,  BYTE,  op2(E, R),  0 },
  533 /*0b*/  { "or",    TRUE,  LONG,  op2(E, R),  0 },
  534 /*0c*/  { "or",    FALSE, BYTE,  op2(I, A),  0 },
  535 /*0d*/  { "or",    FALSE, LONG,  op2(I, A),  0 },
  536 /*0e*/  { "push",  FALSE, NONE,  op1(Si),    0 },
  537 /*0f*/  { "",      FALSE, NONE,  0,          0 },
  539 /*10*/  { "adc",   TRUE,  BYTE,  op2(R, E),  0 },
  540 /*11*/  { "adc",   TRUE,  LONG,  op2(R, E),  0 },
  541 /*12*/  { "adc",   TRUE,  BYTE,  op2(E, R),  0 },
  542 /*13*/  { "adc",   TRUE,  LONG,  op2(E, R),  0 },
  543 /*14*/  { "adc",   FALSE, BYTE,  op2(I, A),  0 },
  544 /*15*/  { "adc",   FALSE, LONG,  op2(Is, A), 0 },
  545 /*16*/  { "push",  FALSE, NONE,  op1(Si),    0 },
  546 /*17*/  { "pop",   FALSE, NONE,  op1(Si),    0 },
  548 /*18*/  { "sbb",   TRUE,  BYTE,  op2(R, E),  0 },
  549 /*19*/  { "sbb",   TRUE,  LONG,  op2(R, E),  0 },
  550 /*1a*/  { "sbb",   TRUE,  BYTE,  op2(E, R),  0 },
  551 /*1b*/  { "sbb",   TRUE,  LONG,  op2(E, R),  0 },
  552 /*1c*/  { "sbb",   FALSE, BYTE,  op2(I, A),  0 },
  553 /*1d*/  { "sbb",   FALSE, LONG,  op2(Is, A), 0 },
  554 /*1e*/  { "push",  FALSE, NONE,  op1(Si),    0 },
  555 /*1f*/  { "pop",   FALSE, NONE,  op1(Si),    0 },
  557 /*20*/  { "and",   TRUE,  BYTE,  op2(R, E),  0 },
  558 /*21*/  { "and",   TRUE,  LONG,  op2(R, E),  0 },
  559 /*22*/  { "and",   TRUE,  BYTE,  op2(E, R),  0 },
  560 /*23*/  { "and",   TRUE,  LONG,  op2(E, R),  0 },
  561 /*24*/  { "and",   FALSE, BYTE,  op2(I, A),  0 },
  562 /*25*/  { "and",   FALSE, LONG,  op2(I, A),  0 },
  563 /*26*/  { "",      FALSE, NONE,  0,          0 },
  564 /*27*/  { "daa",   FALSE, NONE,  0,          0 },
  566 /*28*/  { "sub",   TRUE,  BYTE,  op2(R, E),  0 },
  567 /*29*/  { "sub",   TRUE,  LONG,  op2(R, E),  0 },
  568 /*2a*/  { "sub",   TRUE,  BYTE,  op2(E, R),  0 },
  569 /*2b*/  { "sub",   TRUE,  LONG,  op2(E, R),  0 },
  570 /*2c*/  { "sub",   FALSE, BYTE,  op2(I, A),  0 },
  571 /*2d*/  { "sub",   FALSE, LONG,  op2(Is, A), 0 },
  572 /*2e*/  { "",      FALSE, NONE,  0,          0 },
  573 /*2f*/  { "das",   FALSE, NONE,  0,          0 },
  575 /*30*/  { "xor",   TRUE,  BYTE,  op2(R, E),  0 },
  576 /*31*/  { "xor",   TRUE,  LONG,  op2(R, E),  0 },
  577 /*32*/  { "xor",   TRUE,  BYTE,  op2(E, R),  0 },
  578 /*33*/  { "xor",   TRUE,  LONG,  op2(E, R),  0 },
  579 /*34*/  { "xor",   FALSE, BYTE,  op2(I, A),  0 },
  580 /*35*/  { "xor",   FALSE, LONG,  op2(I, A),  0 },
  581 /*36*/  { "",      FALSE, NONE,  0,          0 },
  582 /*37*/  { "aaa",   FALSE, NONE,  0,          0 },
  584 /*38*/  { "cmp",   TRUE,  BYTE,  op2(R, E),  0 },
  585 /*39*/  { "cmp",   TRUE,  LONG,  op2(R, E),  0 },
  586 /*3a*/  { "cmp",   TRUE,  BYTE,  op2(E, R),  0 },
  587 /*3b*/  { "cmp",   TRUE,  LONG,  op2(E, R),  0 },
  588 /*3c*/  { "cmp",   FALSE, BYTE,  op2(I, A),  0 },
  589 /*3d*/  { "cmp",   FALSE, LONG,  op2(Is, A), 0 },
  590 /*3e*/  { "",      FALSE, NONE,  0,          0 },
  591 /*3f*/  { "aas",   FALSE, NONE,  0,          0 },
  593 /*40*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  594 /*41*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  595 /*42*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  596 /*43*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  597 /*44*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  598 /*45*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  599 /*46*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  600 /*47*/  { "inc",   FALSE, LONG,  op1(Ri),    0 },
  602 /*48*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  603 /*49*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  604 /*4a*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  605 /*4b*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  606 /*4c*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  607 /*4d*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  608 /*4e*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  609 /*4f*/  { "dec",   FALSE, LONG,  op1(Ri),    0 },
  611 /*50*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  612 /*51*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  613 /*52*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  614 /*53*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  615 /*54*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  616 /*55*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  617 /*56*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  618 /*57*/  { "push",  FALSE, LONG,  op1(Ri),    0 },
  620 /*58*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  621 /*59*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  622 /*5a*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  623 /*5b*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  624 /*5c*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  625 /*5d*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  626 /*5e*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  627 /*5f*/  { "pop",   FALSE, LONG,  op1(Ri),    0 },
  629 /*60*/  { "pusha", FALSE, LONG,  0,          0 },
  630 /*61*/  { "popa",  FALSE, LONG,  0,          0 },
  631 /*62*/  { "bound", TRUE,  LONG,  op2(E, R),  0 },
  632 /*63*/  { "arpl",  TRUE,  NONE,  op2(Rw,Ew), 0 },
  633 /*64*/  { "",      FALSE, NONE,  0,          0 },
  634 /*65*/  { "",      FALSE, NONE,  0,          0 },
  635 /*66*/  { "",      FALSE, NONE,  0,          0 },
  636 /*67*/  { "",      FALSE, NONE,  0,          0 },
  638 /*68*/  { "push",  FALSE, LONG,  op1(I),     0 },
  639 /*69*/  { "imul",  TRUE,  LONG,  op3(I,E,R), 0 },
  640 /*6a*/  { "push",  FALSE, LONG,  op1(Ibs),   0 },
  641 /*6b*/  { "imul",  TRUE,  LONG,  op3(Ibs,E,R),0 },
  642 /*6c*/  { "ins",   FALSE, BYTE,  op2(DX, DI), 0 },
  643 /*6d*/  { "ins",   FALSE, LONG,  op2(DX, DI), 0 },
  644 /*6e*/  { "outs",  FALSE, BYTE,  op2(SI, DX), 0 },
  645 /*6f*/  { "outs",  FALSE, LONG,  op2(SI, DX), 0 },
  647 /*70*/  { "jo",    FALSE, NONE,  op1(Db),     0 },
  648 /*71*/  { "jno",   FALSE, NONE,  op1(Db),     0 },
  649 /*72*/  { "jb",    FALSE, NONE,  op1(Db),     0 },
  650 /*73*/  { "jnb",   FALSE, NONE,  op1(Db),     0 },
  651 /*74*/  { "jz",    FALSE, NONE,  op1(Db),     0 },
  652 /*75*/  { "jnz",   FALSE, NONE,  op1(Db),     0 },
  653 /*76*/  { "jbe",   FALSE, NONE,  op1(Db),     0 },
  654 /*77*/  { "jnbe",  FALSE, NONE,  op1(Db),     0 },
  656 /*78*/  { "js",    FALSE, NONE,  op1(Db),     0 },
  657 /*79*/  { "jns",   FALSE, NONE,  op1(Db),     0 },
  658 /*7a*/  { "jp",    FALSE, NONE,  op1(Db),     0 },
  659 /*7b*/  { "jnp",   FALSE, NONE,  op1(Db),     0 },
  660 /*7c*/  { "jl",    FALSE, NONE,  op1(Db),     0 },
  661 /*7d*/  { "jnl",   FALSE, NONE,  op1(Db),     0 },
  662 /*7e*/  { "jle",   FALSE, NONE,  op1(Db),     0 },
  663 /*7f*/  { "jnle",  FALSE, NONE,  op1(Db),     0 },
  665 /*80*/  { "",      TRUE,  BYTE,  op2(I, E),   db_Grp1 },
  666 /*81*/  { "",      TRUE,  LONG,  op2(I, E),   db_Grp1 },
  667 /*82*/  { "",      TRUE,  BYTE,  op2(I, E),   db_Grp1 },
  668 /*83*/  { "",      TRUE,  LONG,  op2(Ibs,E),  db_Grp1 },
  669 /*84*/  { "test",  TRUE,  BYTE,  op2(R, E),   0 },
  670 /*85*/  { "test",  TRUE,  LONG,  op2(R, E),   0 },
  671 /*86*/  { "xchg",  TRUE,  BYTE,  op2(R, E),   0 },
  672 /*87*/  { "xchg",  TRUE,  LONG,  op2(R, E),   0 },
  674 /*88*/  { "mov",   TRUE,  BYTE,  op2(R, E),   0 },
  675 /*89*/  { "mov",   TRUE,  LONG,  op2(R, E),   0 },
  676 /*8a*/  { "mov",   TRUE,  BYTE,  op2(E, R),   0 },
  677 /*8b*/  { "mov",   TRUE,  LONG,  op2(E, R),   0 },
  678 /*8c*/  { "mov",   TRUE,  NONE,  op2(S, Ew),  0 },
  679 /*8d*/  { "lea",   TRUE,  LONG,  op2(E, R),   0 },
  680 /*8e*/  { "mov",   TRUE,  NONE,  op2(Ew, S),  0 },
  681 /*8f*/  { "pop",   TRUE,  LONG,  op1(E),      0 },
  683 /*90*/  { "nop",   FALSE, NONE,  0,           0 },
  684 /*91*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  685 /*92*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  686 /*93*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  687 /*94*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  688 /*95*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  689 /*96*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  690 /*97*/  { "xchg",  FALSE, LONG,  op2(A, Ri),  0 },
  692 /*98*/  { "cbw",   FALSE, SDEP,  0,           "cwde" }, /* cbw/cwde */
  693 /*99*/  { "cwd",   FALSE, SDEP,  0,           "cdq"  }, /* cwd/cdq */
  694 /*9a*/  { "lcall", FALSE, NONE,  op1(OS),     0 },
  695 /*9b*/  { "wait",  FALSE, NONE,  0,           0 },
  696 /*9c*/  { "pushf", FALSE, LONG,  0,           0 },
  697 /*9d*/  { "popf",  FALSE, LONG,  0,           0 },
  698 /*9e*/  { "sahf",  FALSE, NONE,  0,           0 },
  699 /*9f*/  { "lahf",  FALSE, NONE,  0,           0 },
  701 /*a0*/  { "mov",   FALSE, BYTE,  op2(O, A),   0 },
  702 /*a1*/  { "mov",   FALSE, LONG,  op2(O, A),   0 },
  703 /*a2*/  { "mov",   FALSE, BYTE,  op2(A, O),   0 },
  704 /*a3*/  { "mov",   FALSE, LONG,  op2(A, O),   0 },
  705 /*a4*/  { "movs",  FALSE, BYTE,  op2(SI,DI),  0 },
  706 /*a5*/  { "movs",  FALSE, LONG,  op2(SI,DI),  0 },
  707 /*a6*/  { "cmps",  FALSE, BYTE,  op2(SI,DI),  0 },
  708 /*a7*/  { "cmps",  FALSE, LONG,  op2(SI,DI),  0 },
  710 /*a8*/  { "test",  FALSE, BYTE,  op2(I, A),   0 },
  711 /*a9*/  { "test",  FALSE, LONG,  op2(I, A),   0 },
  712 /*aa*/  { "stos",  FALSE, BYTE,  op1(DI),     0 },
  713 /*ab*/  { "stos",  FALSE, LONG,  op1(DI),     0 },
  714 /*ac*/  { "lods",  FALSE, BYTE,  op1(SI),     0 },
  715 /*ad*/  { "lods",  FALSE, LONG,  op1(SI),     0 },
  716 /*ae*/  { "scas",  FALSE, BYTE,  op1(SI),     0 },
  717 /*af*/  { "scas",  FALSE, LONG,  op1(SI),     0 },
  719 /*b0*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  720 /*b1*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  721 /*b2*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  722 /*b3*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  723 /*b4*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  724 /*b5*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  725 /*b6*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  726 /*b7*/  { "mov",   FALSE, BYTE,  op2(I, Ri),  0 },
  728 /*b8*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  729 /*b9*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  730 /*ba*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  731 /*bb*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  732 /*bc*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  733 /*bd*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  734 /*be*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  735 /*bf*/  { "mov",   FALSE, LONG,  op2(I, Ri),  0 },
  737 /*c0*/  { "",      TRUE,  BYTE,  op2(Ib, E),  db_Grp2 },
  738 /*c1*/  { "",      TRUE,  LONG,  op2(Ib, E),  db_Grp2 },
  739 /*c2*/  { "ret",   FALSE, NONE,  op1(Iw),     0 },
  740 /*c3*/  { "ret",   FALSE, NONE,  0,           0 },
  741 /*c4*/  { "les",   TRUE,  LONG,  op2(E, R),   0 },
  742 /*c5*/  { "lds",   TRUE,  LONG,  op2(E, R),   0 },
  743 /*c6*/  { "mov",   TRUE,  BYTE,  op2(I, E),   0 },
  744 /*c7*/  { "mov",   TRUE,  LONG,  op2(I, E),   0 },
  746 /*c8*/  { "enter", FALSE, NONE,  op2(Iw, Ib), 0 },
  747 /*c9*/  { "leave", FALSE, NONE,  0,           0 },
  748 /*ca*/  { "lret",  FALSE, NONE,  op1(Iw),     0 },
  749 /*cb*/  { "lret",  FALSE, NONE,  0,           0 },
  750 /*cc*/  { "int",   FALSE, NONE,  op1(o3),     0 },
  751 /*cd*/  { "int",   FALSE, NONE,  op1(Ib),     0 },
  752 /*ce*/  { "into",  FALSE, NONE,  0,           0 },
  753 /*cf*/  { "iret",  FALSE, NONE,  0,           0 },
  755 /*d0*/  { "",      TRUE,  BYTE,  op2(o1, E),  db_Grp2 },
  756 /*d1*/  { "",      TRUE,  LONG,  op2(o1, E),  db_Grp2 },
  757 /*d2*/  { "",      TRUE,  BYTE,  op2(CL, E),  db_Grp2 },
  758 /*d3*/  { "",      TRUE,  LONG,  op2(CL, E),  db_Grp2 },
  759 /*d4*/  { "aam",   TRUE,  NONE,  op1(Iba),    0 },
  760 /*d5*/  { "aad",   TRUE,  NONE,  op1(Iba),    0 },
  761 /*d6*/  { ".byte\t0xd6",FALSE, NONE, 0,       0 },
  762 /*d7*/  { "xlat",  FALSE, BYTE,  op1(BX),     0 },
  764 /*d8*/  { "",      TRUE,  NONE,  0,           db_Esc8 },
  765 /*d9*/  { "",      TRUE,  NONE,  0,           db_Esc9 },
  766 /*da*/  { "",      TRUE,  NONE,  0,           db_Esca },
  767 /*db*/  { "",      TRUE,  NONE,  0,           db_Escb },
  768 /*dc*/  { "",      TRUE,  NONE,  0,           db_Escc },
  769 /*dd*/  { "",      TRUE,  NONE,  0,           db_Escd },
  770 /*de*/  { "",      TRUE,  NONE,  0,           db_Esce },
  771 /*df*/  { "",      TRUE,  NONE,  0,           db_Escf },
  773 /*e0*/  { "loopne",FALSE, NONE,  op1(Db),     0 },
  774 /*e1*/  { "loope", FALSE, NONE,  op1(Db),     0 },
  775 /*e2*/  { "loop",  FALSE, NONE,  op1(Db),     0 },
  776 /*e3*/  { "jcxz",  FALSE, SDEP,  op1(Db),     "jecxz" },
  777 /*e4*/  { "in",    FALSE, BYTE,  op2(Ib, A),  0 },
  778 /*e5*/  { "in",    FALSE, LONG,  op2(Ib, A) , 0 },
  779 /*e6*/  { "out",   FALSE, BYTE,  op2(A, Ib),  0 },
  780 /*e7*/  { "out",   FALSE, LONG,  op2(A, Ib) , 0 },
  782 /*e8*/  { "call",  FALSE, NONE,  op1(Dl),     0 },
  783 /*e9*/  { "jmp",   FALSE, NONE,  op1(Dl),     0 },
  784 /*ea*/  { "ljmp",  FALSE, NONE,  op1(OS),     0 },
  785 /*eb*/  { "jmp",   FALSE, NONE,  op1(Db),     0 },
  786 /*ec*/  { "in",    FALSE, BYTE,  op2(DX, A),  0 },
  787 /*ed*/  { "in",    FALSE, LONG,  op2(DX, A) , 0 },
  788 /*ee*/  { "out",   FALSE, BYTE,  op2(A, DX),  0 },
  789 /*ef*/  { "out",   FALSE, LONG,  op2(A, DX) , 0 },
  791 /*f0*/  { "",      FALSE, NONE,  0,          0 },
  792 /*f1*/  { "",      FALSE, NONE,  0,          0 },
  793 /*f2*/  { "",      FALSE, NONE,  0,          0 },
  794 /*f3*/  { "",      FALSE, NONE,  0,          0 },
  795 /*f4*/  { "hlt",   FALSE, NONE,  0,          0 },
  796 /*f5*/  { "cmc",   FALSE, NONE,  0,          0 },
  797 /*f6*/  { "",      TRUE,  BYTE,  0,          db_Grp3 },
  798 /*f7*/  { "",      TRUE,  LONG,  0,          db_Grp3 },
  800 /*f8*/  { "clc",   FALSE, NONE,  0,          0 },
  801 /*f9*/  { "stc",   FALSE, NONE,  0,          0 },
  802 /*fa*/  { "cli",   FALSE, NONE,  0,          0 },
  803 /*fb*/  { "sti",   FALSE, NONE,  0,          0 },
  804 /*fc*/  { "cld",   FALSE, NONE,  0,          0 },
  805 /*fd*/  { "std",   FALSE, NONE,  0,          0 },
  806 /*fe*/  { "",      TRUE,  NONE,  0,          db_Grp4 },
  807 /*ff*/  { "",      TRUE,  NONE,  0,          db_Grp5 },
  808 };
  810 struct inst     db_bad_inst =
  811         { "???",   FALSE, NONE,  0,           0 }
  812 ;
  814 #define f_mod(byte)     ((byte)>>6)
  815 #define f_reg(byte)     (((byte)>>3)&0x7)
  816 #define f_rm(byte)      ((byte)&0x7)
  818 #define sib_ss(byte)    ((byte)>>6)
  819 #define sib_index(byte) (((byte)>>3)&0x7)
  820 #define sib_base(byte)  ((byte)&0x7)
  822 struct i_addr {
  823         int             is_reg; /* if reg, reg number is in 'disp' */
  824         int             disp;
  825         char *          base;
  826         char *          index;
  827         int             ss;
  828 };
  830 char *  db_index_reg_16[8] = {
  831         "%bx,%si",
  832         "%bx,%di",
  833         "%bp,%si",
  834         "%bp,%di",
  835         "%si",
  836         "%di",
  837         "%bp",
  838         "%bx"
  839 };
  841 char *  db_reg[3][8] = {
  842         { "%al",  "%cl",  "%dl",  "%bl",  "%ah",  "%ch",  "%dh",  "%bh" },
  843         { "%ax",  "%cx",  "%dx",  "%bx",  "%sp",  "%bp",  "%si",  "%di" },
  844         { "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi" }
  845 };
  847 char *  db_seg_reg[8] = {
  848         "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "", ""
  849 };
  851 /*
  852  * lengths for size attributes
  853  */
  854 int db_lengths[] = {
  855         1,      /* BYTE */
  856         2,      /* WORD */
  857         4,      /* LONG */
  858         8,      /* QUAD */
  859         4,      /* SNGL */
  860         8,      /* DBLR */
  861         10,     /* EXTR */
  862 };
  864 #define get_value_inc(result, loc, size, is_signed) \
  865         do { \
result = db_get_value((loc), (size), (is_signed)); \
  867                 (loc) += (size); \
  868         } while (0)
db_addr_t db_read_address(db_addr_t, int, int, struct i_addr *);
  872 void db_print_address(char *, int, struct i_addr *);
db_addr_t db_disasm_esc(db_addr_t, int, int, int, char *);
  875 /*
  876  * Read address at location and return updated location.
  877  */
db_addr_t
db_read_address(db_addr_t loc, int short_addr, int regmodrm,
  880     struct i_addr *addrp)
  881 {
  882         int             mod, rm, sib, index, disp;
mod = f_mod(regmodrm);
rm  = f_rm(regmodrm);
  887         if (mod == 3) {
addrp->is_reg = TRUE;
addrp->disp = rm;
  890                 return (loc);
  891         }
addrp->is_reg = FALSE;
addrp->index = 0;
  895         if (short_addr) {
addrp->index = 0;
addrp->ss = 0;
  898                 switch (mod) {
  899                     case 0:
  900                         if (rm == 6) {
get_value_inc(disp, loc, 2, FALSE);
addrp->disp = disp;
addrp->base = 0;
  904                         } else {
addrp->disp = 0;
addrp->base = db_index_reg_16[rm];
  907                         }
  908                         break;
  909                     case 1:
get_value_inc(disp, loc, 1, TRUE);
disp &= 0xffff;
addrp->disp = disp;
addrp->base = db_index_reg_16[rm];
  914                         break;
  915                     case 2:
get_value_inc(disp, loc, 2, FALSE);
addrp->disp = disp;
addrp->base = db_index_reg_16[rm];
  919                         break;
  920                 }
  921         } else {
  922                 if (rm == 4) {
get_value_inc(sib, loc, 1, FALSE);
rm = sib_base(sib);
index = sib_index(sib);
  926                         if (index != 4)
addrp->index = db_reg[LONG][index];
addrp->ss = sib_ss(sib);
  929                 }
  931                 switch (mod) {
  932                     case 0:
  933                         if (rm == 5) {
get_value_inc(addrp->disp, loc, 4, FALSE);
addrp->base = 0;
  936                         } else {
addrp->disp = 0;
addrp->base = db_reg[LONG][rm];
  939                         }
  940                         break;
  941                     case 1:
get_value_inc(disp, loc, 1, TRUE);
addrp->disp = disp;
addrp->base = db_reg[LONG][rm];
  945                         break;
  946                     case 2:
get_value_inc(disp, loc, 4, FALSE);
addrp->disp = disp;
addrp->base = db_reg[LONG][rm];
  950                         break;
  951                 }
  952         }
  953         return (loc);
  954 }
  956 void
db_print_address(char *seg, int size, struct i_addr *addrp)
  958 {
  959         if (addrp->is_reg) {
db_printf("%s", db_reg[size][addrp->disp]);
  961                 return;
  962         }
  964         if (seg)
db_printf("%s:", seg);
db_printsym((db_addr_t)addrp->disp, DB_STGY_ANY, db_printf);
  968         if (addrp->base != 0 || addrp->index != 0) {
db_printf("(");
  970                 if (addrp->base)
db_printf("%s", addrp->base);
  972                 if (addrp->index)
db_printf(",%s,%d", addrp->index, 1<<addrp->ss);
db_printf(")");
  975         }
  976 }
  978 /*
  979  * Disassemble floating-point ("escape") instruction
  980  * and return updated location.
  981  */
db_addr_t
db_disasm_esc(db_addr_t loc, int inst, int short_addr, int size, char *seg)
  984 {
  985         int             regmodrm;
  986         struct finst    *fp;
  987         int             mod;
  988         struct i_addr   address;
  989         char *          name;
get_value_inc(regmodrm, loc, 1, FALSE);
fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm)];
mod = f_mod(regmodrm);
  994         if (mod != 3) {
  995                 if (*fp->f_name == '\0') {
db_printf("<bad instruction>");
  997                         return (loc);
  998                 }
 1000                 /*
 1001                  * Normal address modes.
 1002                  */
loc = db_read_address(loc, short_addr, regmodrm, &address);
db_printf(fp->f_name);
 1005                 switch(fp->f_size) {
 1006                     case SNGL:
db_printf("s");
 1008                         break;
 1009                     case DBLR:
db_printf("l");
 1011                         break;
 1012                     case EXTR:
db_printf("t");
 1014                         break;
 1015                     case WORD:
db_printf("s");
 1017                         break;
 1018                     case LONG:
db_printf("l");
 1020                         break;
 1021                     case QUAD:
db_printf("q");
 1023                         break;
 1024                     default:
 1025                         break;
 1026                 }
db_printf("\t");
db_print_address(seg, BYTE, &address);
 1029         } else {
 1030                 /*
 1031                  * 'reg-reg' - special formats
 1032                  */
 1033                 switch (fp->f_rrmode) {
 1034                     case op2(ST,STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st,%%st(%d)",name,f_rm(regmodrm));
 1037                         break;
 1038                     case op2(STI,ST):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm));
 1041                         break;
 1042                     case op1(STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
db_printf("%s\t%%st(%d)",name, f_rm(regmodrm));
 1045                         break;
 1046                     case op1(X):
name = ((char * const *)fp->f_rrname)[f_rm(regmodrm)];
 1048                         if (*name == '\0')
 1049                                 goto bad;
db_printf("%s", name);
 1051                         break;
 1052                     case op1(XA):
name = ((char * const *)fp->f_rrname)[f_rm(regmodrm)];
 1054                         if (*name == '\0')
 1055                                 goto bad;
db_printf("%s\t%%ax", name);
 1057                         break;
 1058                     default:
bad:
db_printf("<bad instruction>");
 1061                         break;
 1062                 }
 1063         }
 1065         return (loc);
 1066 }
 1068 /*
 1069  * Disassemble instruction at 'loc'.  'altfmt' specifies an
 1070  * (optional) alternate format.  Return address of start of
 1071  * next instruction.
 1072  */
db_addr_t
db_disasm(db_addr_t loc, boolean_t altfmt)
 1075 {
 1076         int     inst;
 1077         int     size;
 1078         int     short_addr;
 1079         char *  seg;
 1080         struct inst *   ip;
 1081         char *  i_name;
 1082         int     i_size;
 1083         int     i_mode;
 1084         int     regmodrm = 0;
boolean_t       first;
 1086         int     displ;
 1087         int     prefix;
 1088         int     imm;
 1089         int     imm2;
 1090         int     len;
 1091         struct i_addr   address;
get_value_inc(inst, loc, 1, FALSE);
short_addr = FALSE;
size = LONG;
seg = 0;
 1098         /*
 1099          * Get prefixes
 1100          */
prefix = TRUE;
 1102         do {
 1103                 switch (inst) {
 1104                     case 0x66:          /* data16 */
size = WORD;
 1106                         break;
 1107                     case 0x67:
short_addr = TRUE;
 1109                         break;
 1110                     case 0x26:
seg = "%es";
 1112                         break;
 1113                     case 0x36:
seg = "%ss";
 1115                         break;
 1116                     case 0x2e:
seg = "%cs";
 1118                         break;
 1119                     case 0x3e:
seg = "%ds";
 1121                         break;
 1122                     case 0x64:
seg = "%fs";
 1124                         break;
 1125                     case 0x65:
seg = "%gs";
 1127                         break;
 1128                     case 0xf0:
db_printf("lock ");
 1130                         break;
 1131                     case 0xf2:
db_printf("repne ");
 1133                         break;
 1134                     case 0xf3:
db_printf("repe ");     /* XXX repe VS rep */
 1136                         break;
 1137                     default:
prefix = FALSE;
 1139                         break;
 1140                 }
 1141                 if (prefix)
get_value_inc(inst, loc, 1, FALSE);
 1143         } while (prefix);
 1145         if (inst >= 0xd8 && inst <= 0xdf) {
loc = db_disasm_esc(loc, inst, short_addr, size, seg);
db_printf("\n");
 1148                 return (loc);
 1149         }
 1151         if (inst == 0x0f) {
get_value_inc(inst, loc, 1, FALSE);
ip = db_inst_0f[inst>>4];
 1154                 if (ip == 0)
ip = &db_bad_inst;
 1156                 else
ip = &ip[inst&0xf];
 1158         } else {
ip = &db_inst_table[inst];
 1160         }
 1162         if (ip->i_has_modrm) {
get_value_inc(regmodrm, loc, 1, FALSE);
loc = db_read_address(loc, short_addr, regmodrm, &address);
 1165         }
i_name = ip->i_name;
i_size = ip->i_size;
i_mode = ip->i_mode;
 1171         if (ip->i_extra == db_Grp1 || ip->i_extra == db_Grp2 ||
ip->i_extra == db_Grp6 || ip->i_extra == db_Grp7 ||
ip->i_extra == db_Grp8 || ip->i_extra == db_Grp9 ||
ip->i_extra == db_GrpA || ip->i_extra == db_GrpB ||
ip->i_extra == db_GrpC) {
i_name = ((char **)ip->i_extra)[f_reg(regmodrm)];
 1177         } else if (ip->i_extra == db_Grp3) {
ip = (struct inst *)ip->i_extra;
ip = &ip[f_reg(regmodrm)];
i_name = ip->i_name;
i_mode = ip->i_mode;
 1182         } else if (ip->i_extra == db_Grp4 || ip->i_extra == db_Grp5) {
ip = (struct inst *)ip->i_extra;
ip = &ip[f_reg(regmodrm)];
i_name = ip->i_name;
i_mode = ip->i_mode;
i_size = ip->i_size;
 1188         }
 1190         if (i_size == SDEP) {
 1191                 if (size == WORD)
db_printf("%s", i_name);
 1193                 else
db_printf("%s", ip->i_extra);
 1195         } else {
db_printf("%s", i_name);
 1197                 if (i_size != NONE) {
 1198                         if (i_size == BYTE) {
db_printf("b");
size = BYTE;
 1201                         } else if (i_size == WORD) {
db_printf("w");
size = WORD;
 1204                         } else if (size == WORD) {
db_printf("w");
 1206                         } else {
db_printf("l");
 1208                         }
 1209                 }
 1210         }
db_printf("\t");
 1212         for (first = TRUE;
i_mode != 0;
i_mode >>= 8, first = FALSE) {
 1215                 if (!first)
db_printf(",");
 1218                 switch (i_mode & 0xFF) {
 1219                     case E:
db_print_address(seg, size, &address);
 1221                         break;
 1222                     case Eind:
db_printf("*");
db_print_address(seg, size, &address);
 1225                         break;
 1226                     case El:
db_print_address(seg, LONG, &address);
 1228                         break;
 1229                     case Ew:
db_print_address(seg, WORD, &address);
 1231                         break;
 1232                     case Eb:
db_print_address(seg, BYTE, &address);
 1234                         break;
 1235                     case R:
db_printf("%s", db_reg[size][f_reg(regmodrm)]);
 1237                         break;
 1238                     case Rw:
db_printf("%s", db_reg[WORD][f_reg(regmodrm)]);
 1240                         break;
 1241                     case Ri:
db_printf("%s", db_reg[size][f_rm(inst)]);
 1243                         break;
 1244                     case Ril:
db_printf("%s", db_reg[LONG][f_rm(inst)]);
 1246                         break;
 1247                     case S:
db_printf("%s", db_seg_reg[f_reg(regmodrm)]);
 1249                         break;
 1250                     case Si:
db_printf("%s", db_seg_reg[f_reg(inst)]);
 1252                         break;
 1253                     case A:
db_printf("%s", db_reg[size][0]);       /* acc */
 1255                         break;
 1256                     case BX:
 1257                         if (seg)
db_printf("%s:", seg);
db_printf("(%s)", short_addr ? "%bx" : "%ebx");
 1260                         break;
 1261                     case CL:
db_printf("%%cl");
 1263                         break;
 1264                     case DX:
db_printf("%%dx");
 1266                         break;
 1267                     case SI:
 1268                         if (seg)
db_printf("%s:", seg);
db_printf("(%s)", short_addr ? "%si" : "%esi");
 1271                         break;
 1272                     case DI:
db_printf("%%es:(%s)", short_addr ? "%di" : "%edi");
 1274                         break;
 1275                     case CR:
db_printf("%%cr%d", f_reg(regmodrm));
 1277                         break;
 1278                     case DR:
db_printf("%%dr%d", f_reg(regmodrm));
 1280                         break;
 1281                     case TR:
db_printf("%%tr%d", f_reg(regmodrm));
 1283                         break;
 1284                     case I:
len = db_lengths[size];
get_value_inc(imm, loc, len, FALSE);
db_printf("$%#n", imm);
 1288                         break;
 1289                     case Is:
len = db_lengths[size];
get_value_inc(imm, loc, len, TRUE);
db_printf("$%#r", imm);
 1293                         break;
 1294                     case Ib:
get_value_inc(imm, loc, 1, FALSE);
db_printf("$%#n", imm);
 1297                         break;
 1298                     case Iba:
get_value_inc(imm, loc, 1, FALSE);
 1300                         if (imm != 0x0a)
db_printf("$%#n", imm);
 1302                         break;
 1303                     case Ibs:
get_value_inc(imm, loc, 1, TRUE);
 1305                         if (size == WORD)
imm &= 0xFFFF;
db_printf("$%#r", imm);
 1308                         break;
 1309                     case Iw:
get_value_inc(imm, loc, 2, FALSE);
db_printf("$%#n", imm);
 1312                         break;
 1313                     case O:
 1314                         if (short_addr)
get_value_inc(displ, loc, 2, TRUE);
 1316                         else
get_value_inc(displ, loc, 4, TRUE);
 1318                         if (seg)
db_printf("%s:%#r",seg, displ);
 1320                         else
db_printsym((db_addr_t)displ, DB_STGY_ANY,
db_printf);
 1323                         break;
 1324                     case Db:
get_value_inc(displ, loc, 1, TRUE);
displ += loc;
 1327                         if (size == WORD)
displ &= 0xFFFF;
db_printsym((db_addr_t)displ, DB_STGY_XTRN, db_printf);
 1330                         break;
 1331                     case Dl:
len = db_lengths[size];
get_value_inc(displ, loc, len, FALSE);
displ += loc;
 1335                         if (size == WORD)
displ &= 0xFFFF;
db_printsym((db_addr_t)displ, DB_STGY_XTRN, db_printf);
 1338                         break;
 1339                     case o1:
db_printf("$1");
 1341                         break;
 1342                     case o3:
db_printf("$3");
 1344                         break;
 1345                     case OS:
get_value_inc(imm, loc, len, FALSE);    /* offset */
get_value_inc(imm2, loc, 2, FALSE);     /* segment */
db_printf("$%#n,%#n", imm2, imm);
 1349                         break;
 1350                 }
 1351         }
 1353         if (altfmt == 0 && (inst == 0xe9 || inst == 0xeb)) {
 1354                 /*
 1355                  * GAS pads to longword boundary after unconditional jumps.
 1356                  */
loc = (loc + (4-1)) & ~(4-1);
 1358         }
db_printf("\n");
 1360         return (loc);
 1361 }