db_disasm.c revision 798
14Srgrimes/* 24Srgrimes * Mach Operating System 34Srgrimes * Copyright (c) 1991,1990 Carnegie Mellon University 44Srgrimes * All Rights Reserved. 54Srgrimes * 64Srgrimes * Permission to use, copy, modify and distribute this software and its 74Srgrimes * documentation is hereby granted, provided that both the copyright 84Srgrimes * notice and this permission notice appear in all copies of the 94Srgrimes * software, derivative works or modified versions, and any portions 104Srgrimes * thereof, and that both notices appear in supporting documentation. 114Srgrimes * 124Srgrimes * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS 134Srgrimes * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR 144Srgrimes * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 154Srgrimes * 164Srgrimes * Carnegie Mellon requests users of this software to return to 174Srgrimes * 184Srgrimes * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 194Srgrimes * School of Computer Science 204Srgrimes * Carnegie Mellon University 214Srgrimes * Pittsburgh PA 15213-3890 224Srgrimes * 234Srgrimes * any improvements or extensions that they make and grant Carnegie the 244Srgrimes * rights to redistribute these changes. 25118Srgrimes * 26798Swollman * $Id: db_disasm.c,v 1.3 1993/10/16 14:14:52 rgrimes Exp $ 274Srgrimes */ 284Srgrimes 294Srgrimes/* 304Srgrimes * Instruction disassembler. 314Srgrimes */ 324Srgrimes#include "param.h" 334Srgrimes#include "proc.h" 344Srgrimes#include <machine/db_machdep.h> 354Srgrimes 364Srgrimes#include <ddb/db_access.h> 374Srgrimes#include <ddb/db_sym.h> 384Srgrimes 394Srgrimes/* 404Srgrimes * Size attributes 414Srgrimes */ 424Srgrimes#define BYTE 0 434Srgrimes#define WORD 1 444Srgrimes#define LONG 2 454Srgrimes#define QUAD 3 464Srgrimes#define SNGL 4 474Srgrimes#define DBLR 5 484Srgrimes#define EXTR 6 494Srgrimes#define SDEP 7 504Srgrimes#define NONE 8 514Srgrimes 524Srgrimes/* 534Srgrimes * Addressing modes 544Srgrimes */ 554Srgrimes#define E 1 /* general effective address */ 564Srgrimes#define Eind 2 /* indirect address (jump, call) */ 574Srgrimes#define Ew 3 /* address, word size */ 584Srgrimes#define Eb 4 /* address, byte size */ 594Srgrimes#define R 5 /* register, in 'reg' field */ 604Srgrimes#define Rw 6 /* word register, in 'reg' field */ 614Srgrimes#define Ri 7 /* register in instruction */ 624Srgrimes#define S 8 /* segment reg, in 'reg' field */ 634Srgrimes#define Si 9 /* segment reg, in instruction */ 644Srgrimes#define A 10 /* accumulator */ 654Srgrimes#define BX 11 /* (bx) */ 664Srgrimes#define CL 12 /* cl, for shifts */ 674Srgrimes#define DX 13 /* dx, for IO */ 684Srgrimes#define SI 14 /* si */ 694Srgrimes#define DI 15 /* di */ 704Srgrimes#define CR 16 /* control register */ 714Srgrimes#define DR 17 /* debug register */ 724Srgrimes#define TR 18 /* test register */ 734Srgrimes#define I 19 /* immediate, unsigned */ 744Srgrimes#define Is 20 /* immediate, signed */ 754Srgrimes#define Ib 21 /* byte immediate, unsigned */ 764Srgrimes#define Ibs 22 /* byte immediate, signed */ 774Srgrimes#define Iw 23 /* word immediate, unsigned */ 784Srgrimes#define Il 24 /* long immediate */ 794Srgrimes#define O 25 /* direct address */ 804Srgrimes#define Db 26 /* byte displacement from EIP */ 814Srgrimes#define Dl 27 /* long displacement from EIP */ 824Srgrimes#define o1 28 /* constant 1 */ 834Srgrimes#define o3 29 /* constant 3 */ 844Srgrimes#define OS 30 /* immediate offset/segment */ 854Srgrimes#define ST 31 /* FP stack top */ 864Srgrimes#define STI 32 /* FP stack */ 874Srgrimes#define X 33 /* extended FP op */ 884Srgrimes#define XA 34 /* for 'fstcw %ax' */ 894Srgrimes 904Srgrimesstruct inst { 914Srgrimes char * i_name; /* name */ 924Srgrimes short i_has_modrm; /* has regmodrm byte */ 934Srgrimes short i_size; /* operand size */ 944Srgrimes int i_mode; /* addressing modes */ 954Srgrimes char * i_extra; /* pointer to extra opcode table */ 964Srgrimes}; 974Srgrimes 984Srgrimes#define op1(x) (x) 994Srgrimes#define op2(x,y) ((x)|((y)<<8)) 1004Srgrimes#define op3(x,y,z) ((x)|((y)<<8)|((z)<<16)) 1014Srgrimes 1024Srgrimesstruct finst { 1034Srgrimes char * f_name; /* name for memory instruction */ 1044Srgrimes int f_size; /* size for memory instruction */ 1054Srgrimes int f_rrmode; /* mode for rr instruction */ 1064Srgrimes char * f_rrname; /* name for rr instruction 1074Srgrimes (or pointer to table) */ 1084Srgrimes}; 1094Srgrimes 1104Srgrimeschar * db_Grp6[] = { 1114Srgrimes "sldt", 1124Srgrimes "str", 1134Srgrimes "lldt", 1144Srgrimes "ltr", 1154Srgrimes "verr", 1164Srgrimes "verw", 1174Srgrimes "", 1184Srgrimes "" 1194Srgrimes}; 1204Srgrimes 1214Srgrimeschar * db_Grp7[] = { 1224Srgrimes "sgdt", 1234Srgrimes "sidt", 1244Srgrimes "lgdt", 1254Srgrimes "lidt", 1264Srgrimes "smsw", 1274Srgrimes "", 1284Srgrimes "lmsw", 1294Srgrimes "invlpg" 1304Srgrimes}; 1314Srgrimes 1324Srgrimeschar * db_Grp8[] = { 1334Srgrimes "", 1344Srgrimes "", 1354Srgrimes "", 1364Srgrimes "", 1374Srgrimes "bt", 1384Srgrimes "bts", 1394Srgrimes "btr", 1404Srgrimes "btc" 1414Srgrimes}; 1424Srgrimes 1434Srgrimesstruct inst db_inst_0f0x[] = { 1444Srgrimes/*00*/ { "", TRUE, NONE, op1(Ew), (char *)db_Grp6 }, 1454Srgrimes/*01*/ { "", TRUE, NONE, op1(Ew), (char *)db_Grp7 }, 1464Srgrimes/*02*/ { "lar", TRUE, LONG, op2(E,R), 0 }, 1474Srgrimes/*03*/ { "lsl", TRUE, LONG, op2(E,R), 0 }, 1484Srgrimes/*04*/ { "", FALSE, NONE, 0, 0 }, 1494Srgrimes/*05*/ { "", FALSE, NONE, 0, 0 }, 1504Srgrimes/*06*/ { "clts", FALSE, NONE, 0, 0 }, 1514Srgrimes/*07*/ { "", FALSE, NONE, 0, 0 }, 1524Srgrimes 1534Srgrimes/*08*/ { "invd", FALSE, NONE, 0, 0 }, 1544Srgrimes/*09*/ { "wbinvd",FALSE, NONE, 0, 0 }, 1554Srgrimes/*0a*/ { "", FALSE, NONE, 0, 0 }, 1564Srgrimes/*0b*/ { "", FALSE, NONE, 0, 0 }, 1574Srgrimes/*0c*/ { "", FALSE, NONE, 0, 0 }, 1584Srgrimes/*0d*/ { "", FALSE, NONE, 0, 0 }, 1594Srgrimes/*0e*/ { "", FALSE, NONE, 0, 0 }, 1604Srgrimes/*0f*/ { "", FALSE, NONE, 0, 0 }, 1614Srgrimes}; 1624Srgrimes 1634Srgrimesstruct inst db_inst_0f2x[] = { 1644Srgrimes/*20*/ { "mov", TRUE, LONG, op2(CR,E), 0 }, /* use E for reg */ 1654Srgrimes/*21*/ { "mov", TRUE, LONG, op2(DR,E), 0 }, /* since mod == 11 */ 1664Srgrimes/*22*/ { "mov", TRUE, LONG, op2(E,CR), 0 }, 1674Srgrimes/*23*/ { "mov", TRUE, LONG, op2(E,DR), 0 }, 1684Srgrimes/*24*/ { "mov", TRUE, LONG, op2(TR,E), 0 }, 1694Srgrimes/*25*/ { "", FALSE, NONE, 0, 0 }, 1704Srgrimes/*26*/ { "mov", TRUE, LONG, op2(E,TR), 0 }, 1714Srgrimes/*27*/ { "", FALSE, NONE, 0, 0 }, 1724Srgrimes 1734Srgrimes/*28*/ { "", FALSE, NONE, 0, 0 }, 1744Srgrimes/*29*/ { "", FALSE, NONE, 0, 0 }, 1754Srgrimes/*2a*/ { "", FALSE, NONE, 0, 0 }, 1764Srgrimes/*2b*/ { "", FALSE, NONE, 0, 0 }, 1774Srgrimes/*2c*/ { "", FALSE, NONE, 0, 0 }, 1784Srgrimes/*2d*/ { "", FALSE, NONE, 0, 0 }, 1794Srgrimes/*2e*/ { "", FALSE, NONE, 0, 0 }, 1804Srgrimes/*2f*/ { "", FALSE, NONE, 0, 0 }, 1814Srgrimes}; 1824Srgrimes 1834Srgrimesstruct inst db_inst_0f8x[] = { 1844Srgrimes/*80*/ { "jo", FALSE, NONE, op1(Dl), 0 }, 1854Srgrimes/*81*/ { "jno", FALSE, NONE, op1(Dl), 0 }, 1864Srgrimes/*82*/ { "jb", FALSE, NONE, op1(Dl), 0 }, 1874Srgrimes/*83*/ { "jnb", FALSE, NONE, op1(Dl), 0 }, 1884Srgrimes/*84*/ { "jz", FALSE, NONE, op1(Dl), 0 }, 1894Srgrimes/*85*/ { "jnz", FALSE, NONE, op1(Dl), 0 }, 1904Srgrimes/*86*/ { "jbe", FALSE, NONE, op1(Dl), 0 }, 1914Srgrimes/*87*/ { "jnbe", FALSE, NONE, op1(Dl), 0 }, 1924Srgrimes 1934Srgrimes/*88*/ { "js", FALSE, NONE, op1(Dl), 0 }, 1944Srgrimes/*89*/ { "jns", FALSE, NONE, op1(Dl), 0 }, 1954Srgrimes/*8a*/ { "jp", FALSE, NONE, op1(Dl), 0 }, 1964Srgrimes/*8b*/ { "jnp", FALSE, NONE, op1(Dl), 0 }, 1974Srgrimes/*8c*/ { "jl", FALSE, NONE, op1(Dl), 0 }, 1984Srgrimes/*8d*/ { "jnl", FALSE, NONE, op1(Dl), 0 }, 1994Srgrimes/*8e*/ { "jle", FALSE, NONE, op1(Dl), 0 }, 2004Srgrimes/*8f*/ { "jnle", FALSE, NONE, op1(Dl), 0 }, 2014Srgrimes}; 2024Srgrimes 2034Srgrimesstruct inst db_inst_0f9x[] = { 2044Srgrimes/*90*/ { "seto", TRUE, NONE, op1(Eb), 0 }, 2054Srgrimes/*91*/ { "setno", TRUE, NONE, op1(Eb), 0 }, 2064Srgrimes/*92*/ { "setb", TRUE, NONE, op1(Eb), 0 }, 2074Srgrimes/*93*/ { "setnb", TRUE, NONE, op1(Eb), 0 }, 2084Srgrimes/*94*/ { "setz", TRUE, NONE, op1(Eb), 0 }, 2094Srgrimes/*95*/ { "setnz", TRUE, NONE, op1(Eb), 0 }, 2104Srgrimes/*96*/ { "setbe", TRUE, NONE, op1(Eb), 0 }, 2114Srgrimes/*97*/ { "setnbe",TRUE, NONE, op1(Eb), 0 }, 2124Srgrimes 2134Srgrimes/*98*/ { "sets", TRUE, NONE, op1(Eb), 0 }, 2144Srgrimes/*99*/ { "setns", TRUE, NONE, op1(Eb), 0 }, 2154Srgrimes/*9a*/ { "setp", TRUE, NONE, op1(Eb), 0 }, 2164Srgrimes/*9b*/ { "setnp", TRUE, NONE, op1(Eb), 0 }, 2174Srgrimes/*9c*/ { "setl", TRUE, NONE, op1(Eb), 0 }, 2184Srgrimes/*9d*/ { "setnl", TRUE, NONE, op1(Eb), 0 }, 2194Srgrimes/*9e*/ { "setle", TRUE, NONE, op1(Eb), 0 }, 2204Srgrimes/*9f*/ { "setnle",TRUE, NONE, op1(Eb), 0 }, 2214Srgrimes}; 2224Srgrimes 2234Srgrimesstruct inst db_inst_0fax[] = { 2244Srgrimes/*a0*/ { "push", FALSE, NONE, op1(Si), 0 }, 2254Srgrimes/*a1*/ { "pop", FALSE, NONE, op1(Si), 0 }, 2264Srgrimes/*a2*/ { "", FALSE, NONE, 0, 0 }, 2274Srgrimes/*a3*/ { "bt", TRUE, LONG, op2(E,R), 0 }, 2284Srgrimes/*a4*/ { "shld", TRUE, LONG, op3(Ib,E,R), 0 }, 2294Srgrimes/*a5*/ { "shld", TRUE, LONG, op3(CL,E,R), 0 }, 2304Srgrimes/*a6*/ { "", FALSE, NONE, 0, 0 }, 2314Srgrimes/*a7*/ { "", FALSE, NONE, 0, 0 }, 2324Srgrimes 2334Srgrimes/*a8*/ { "push", FALSE, NONE, op1(Si), 0 }, 2344Srgrimes/*a9*/ { "pop", FALSE, NONE, op1(Si), 0 }, 2354Srgrimes/*aa*/ { "", FALSE, NONE, 0, 0 }, 2364Srgrimes/*ab*/ { "bts", TRUE, LONG, op2(E,R), 0 }, 2374Srgrimes/*ac*/ { "shrd", TRUE, LONG, op3(Ib,E,R), 0 }, 2384Srgrimes/*ad*/ { "shrd", TRUE, LONG, op3(CL,E,R), 0 }, 2394Srgrimes/*a6*/ { "", FALSE, NONE, 0, 0 }, 2404Srgrimes/*a7*/ { "imul", TRUE, LONG, op2(E,R), 0 }, 2414Srgrimes}; 2424Srgrimes 2434Srgrimesstruct inst db_inst_0fbx[] = { 2444Srgrimes/*b0*/ { "", FALSE, NONE, 0, 0 }, 2454Srgrimes/*b1*/ { "", FALSE, NONE, 0, 0 }, 2464Srgrimes/*b2*/ { "lss", TRUE, LONG, op2(E, R), 0 }, 2474Srgrimes/*b3*/ { "bts", TRUE, LONG, op2(R, E), 0 }, 2484Srgrimes/*b4*/ { "lfs", TRUE, LONG, op2(E, R), 0 }, 2494Srgrimes/*b5*/ { "lgs", TRUE, LONG, op2(E, R), 0 }, 2504Srgrimes/*b6*/ { "movzb", TRUE, LONG, op2(E, R), 0 }, 2514Srgrimes/*b7*/ { "movzw", TRUE, LONG, op2(E, R), 0 }, 2524Srgrimes 2534Srgrimes/*b8*/ { "", FALSE, NONE, 0, 0 }, 2544Srgrimes/*b9*/ { "", FALSE, NONE, 0, 0 }, 2554Srgrimes/*ba*/ { "", TRUE, LONG, op2(Is, E), (char *)db_Grp8 }, 2564Srgrimes/*bb*/ { "btc", TRUE, LONG, op2(R, E), 0 }, 2574Srgrimes/*bc*/ { "bsf", TRUE, LONG, op2(E, R), 0 }, 2584Srgrimes/*bd*/ { "bsr", TRUE, LONG, op2(E, R), 0 }, 2594Srgrimes/*be*/ { "movsb", TRUE, LONG, op2(E, R), 0 }, 2604Srgrimes/*bf*/ { "movsw", TRUE, LONG, op2(E, R), 0 }, 2614Srgrimes}; 2624Srgrimes 2634Srgrimesstruct inst db_inst_0fcx[] = { 2644Srgrimes/*c0*/ { "xadd", TRUE, BYTE, op2(R, E), 0 }, 2654Srgrimes/*c1*/ { "xadd", TRUE, LONG, op2(R, E), 0 }, 2664Srgrimes/*c2*/ { "", FALSE, NONE, 0, 0 }, 2674Srgrimes/*c3*/ { "", FALSE, NONE, 0, 0 }, 2684Srgrimes/*c4*/ { "", FALSE, NONE, 0, 0 }, 2694Srgrimes/*c5*/ { "", FALSE, NONE, 0, 0 }, 2704Srgrimes/*c6*/ { "", FALSE, NONE, 0, 0 }, 2714Srgrimes/*c7*/ { "", FALSE, NONE, 0, 0 }, 2724Srgrimes/*c8*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2734Srgrimes/*c9*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2744Srgrimes/*ca*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2754Srgrimes/*cb*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2764Srgrimes/*cc*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2774Srgrimes/*cd*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2784Srgrimes/*ce*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2794Srgrimes/*cf*/ { "bswap", FALSE, LONG, op1(Ri), 0 }, 2804Srgrimes}; 2814Srgrimes 2824Srgrimesstruct inst db_inst_0fdx[] = { 2834Srgrimes/*c0*/ { "cmpxchg",TRUE, BYTE, op2(R, E), 0 }, 2844Srgrimes/*c1*/ { "cmpxchg",TRUE, LONG, op2(R, E), 0 }, 2854Srgrimes/*c2*/ { "", FALSE, NONE, 0, 0 }, 2864Srgrimes/*c3*/ { "", FALSE, NONE, 0, 0 }, 2874Srgrimes/*c4*/ { "", FALSE, NONE, 0, 0 }, 2884Srgrimes/*c5*/ { "", FALSE, NONE, 0, 0 }, 2894Srgrimes/*c6*/ { "", FALSE, NONE, 0, 0 }, 2904Srgrimes/*c7*/ { "", FALSE, NONE, 0, 0 }, 2914Srgrimes/*c8*/ { "", FALSE, NONE, 0, 0 }, 2924Srgrimes/*c9*/ { "", FALSE, NONE, 0, 0 }, 2934Srgrimes/*ca*/ { "", FALSE, NONE, 0, 0 }, 2944Srgrimes/*cb*/ { "", FALSE, NONE, 0, 0 }, 2954Srgrimes/*cc*/ { "", FALSE, NONE, 0, 0 }, 2964Srgrimes/*cd*/ { "", FALSE, NONE, 0, 0 }, 2974Srgrimes/*ce*/ { "", FALSE, NONE, 0, 0 }, 2984Srgrimes/*cf*/ { "", FALSE, NONE, 0, 0 }, 2994Srgrimes}; 3004Srgrimes 3014Srgrimesstruct inst *db_inst_0f[] = { 3024Srgrimes db_inst_0f0x, 3034Srgrimes 0, 3044Srgrimes db_inst_0f2x, 3054Srgrimes 0, 3064Srgrimes 0, 3074Srgrimes 0, 3084Srgrimes 0, 3094Srgrimes 0, 3104Srgrimes db_inst_0f8x, 3114Srgrimes db_inst_0f9x, 3124Srgrimes db_inst_0fax, 3134Srgrimes db_inst_0fbx, 3144Srgrimes db_inst_0fcx, 3154Srgrimes db_inst_0fdx, 3164Srgrimes 0, 3174Srgrimes 0 3184Srgrimes}; 3194Srgrimes 3204Srgrimeschar * db_Esc92[] = { 3214Srgrimes "fnop", "", "", "", "", "", "", "" 3224Srgrimes}; 3234Srgrimeschar * db_Esc93[] = { 3244Srgrimes "", "", "", "", "", "", "", "" 3254Srgrimes}; 3264Srgrimeschar * db_Esc94[] = { 3274Srgrimes "fchs", "fabs", "", "", "ftst", "fxam", "", "" 3284Srgrimes}; 3294Srgrimeschar * db_Esc95[] = { 3304Srgrimes "fld1", "fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","" 3314Srgrimes}; 3324Srgrimeschar * db_Esc96[] = { 3334Srgrimes "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp", 3344Srgrimes "fincstp" 3354Srgrimes}; 3364Srgrimeschar * db_Esc97[] = { 3374Srgrimes "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos" 3384Srgrimes}; 3394Srgrimes 3404Srgrimeschar * db_Esca4[] = { 3414Srgrimes "", "fucompp","", "", "", "", "", "" 3424Srgrimes}; 3434Srgrimes 3444Srgrimeschar * db_Escb4[] = { 3454Srgrimes "", "", "fnclex","fninit","", "", "", "" 3464Srgrimes}; 3474Srgrimes 3484Srgrimeschar * db_Esce3[] = { 3494Srgrimes "", "fcompp","", "", "", "", "", "" 3504Srgrimes}; 3514Srgrimes 3524Srgrimeschar * db_Escf4[] = { 3534Srgrimes "fnstsw","", "", "", "", "", "", "" 3544Srgrimes}; 3554Srgrimes 3564Srgrimesstruct finst db_Esc8[] = { 3574Srgrimes/*0*/ { "fadd", SNGL, op2(STI,ST), 0 }, 3584Srgrimes/*1*/ { "fmul", SNGL, op2(STI,ST), 0 }, 3594Srgrimes/*2*/ { "fcom", SNGL, op2(STI,ST), 0 }, 3604Srgrimes/*3*/ { "fcomp", SNGL, op2(STI,ST), 0 }, 3614Srgrimes/*4*/ { "fsub", SNGL, op2(STI,ST), 0 }, 3624Srgrimes/*5*/ { "fsubr", SNGL, op2(STI,ST), 0 }, 3634Srgrimes/*6*/ { "fdiv", SNGL, op2(STI,ST), 0 }, 3644Srgrimes/*7*/ { "fdivr", SNGL, op2(STI,ST), 0 }, 3654Srgrimes}; 3664Srgrimes 3674Srgrimesstruct finst db_Esc9[] = { 3684Srgrimes/*0*/ { "fld", SNGL, op1(STI), 0 }, 3694Srgrimes/*1*/ { "", NONE, op1(STI), "fxch" }, 3704Srgrimes/*2*/ { "fst", SNGL, op1(X), (char *)db_Esc92 }, 3714Srgrimes/*3*/ { "fstp", SNGL, op1(X), (char *)db_Esc93 }, 3724Srgrimes/*4*/ { "fldenv", NONE, op1(X), (char *)db_Esc94 }, 3734Srgrimes/*5*/ { "fldcw", NONE, op1(X), (char *)db_Esc95 }, 3744Srgrimes/*6*/ { "fnstenv",NONE, op1(X), (char *)db_Esc96 }, 3754Srgrimes/*7*/ { "fnstcw", NONE, op1(X), (char *)db_Esc97 }, 3764Srgrimes}; 3774Srgrimes 3784Srgrimesstruct finst db_Esca[] = { 3794Srgrimes/*0*/ { "fiadd", WORD, 0, 0 }, 3804Srgrimes/*1*/ { "fimul", WORD, 0, 0 }, 3814Srgrimes/*2*/ { "ficom", WORD, 0, 0 }, 3824Srgrimes/*3*/ { "ficomp", WORD, 0, 0 }, 3834Srgrimes/*4*/ { "fisub", WORD, op1(X), (char *)db_Esca4 }, 3844Srgrimes/*5*/ { "fisubr", WORD, 0, 0 }, 3854Srgrimes/*6*/ { "fidiv", WORD, 0, 0 }, 3864Srgrimes/*7*/ { "fidivr", WORD, 0, 0 } 3874Srgrimes}; 3884Srgrimes 3894Srgrimesstruct finst db_Escb[] = { 3904Srgrimes/*0*/ { "fild", WORD, 0, 0 }, 3914Srgrimes/*1*/ { "", NONE, 0, 0 }, 3924Srgrimes/*2*/ { "fist", WORD, 0, 0 }, 3934Srgrimes/*3*/ { "fistp", WORD, 0, 0 }, 3944Srgrimes/*4*/ { "", WORD, op1(X), (char *)db_Escb4 }, 3954Srgrimes/*5*/ { "fld", EXTR, 0, 0 }, 3964Srgrimes/*6*/ { "", WORD, 0, 0 }, 3974Srgrimes/*7*/ { "fstp", EXTR, 0, 0 }, 3984Srgrimes}; 3994Srgrimes 4004Srgrimesstruct finst db_Escc[] = { 4014Srgrimes/*0*/ { "fadd", DBLR, op2(ST,STI), 0 }, 4024Srgrimes/*1*/ { "fmul", DBLR, op2(ST,STI), 0 }, 4034Srgrimes/*2*/ { "fcom", DBLR, op2(ST,STI), 0 }, 4044Srgrimes/*3*/ { "fcomp", DBLR, op2(ST,STI), 0 }, 4054Srgrimes/*4*/ { "fsub", DBLR, op2(ST,STI), "fsubr" }, 4064Srgrimes/*5*/ { "fsubr", DBLR, op2(ST,STI), "fsub" }, 4074Srgrimes/*6*/ { "fdiv", DBLR, op2(ST,STI), "fdivr" }, 4084Srgrimes/*7*/ { "fdivr", DBLR, op2(ST,STI), "fdiv" }, 4094Srgrimes}; 4104Srgrimes 4114Srgrimesstruct finst db_Escd[] = { 4124Srgrimes/*0*/ { "fld", DBLR, op1(STI), "ffree" }, 4134Srgrimes/*1*/ { "", NONE, 0, 0 }, 4144Srgrimes/*2*/ { "fst", DBLR, op1(STI), 0 }, 4154Srgrimes/*3*/ { "fstp", DBLR, op1(STI), 0 }, 4164Srgrimes/*4*/ { "frstor", NONE, op1(STI), "fucom" }, 4174Srgrimes/*5*/ { "", NONE, op1(STI), "fucomp" }, 4184Srgrimes/*6*/ { "fnsave", NONE, 0, 0 }, 4194Srgrimes/*7*/ { "fnstsw", NONE, 0, 0 }, 4204Srgrimes}; 4214Srgrimes 4224Srgrimesstruct finst db_Esce[] = { 4234Srgrimes/*0*/ { "fiadd", LONG, op2(ST,STI), "faddp" }, 4244Srgrimes/*1*/ { "fimul", LONG, op2(ST,STI), "fmulp" }, 4254Srgrimes/*2*/ { "ficom", LONG, 0, 0 }, 4264Srgrimes/*3*/ { "ficomp", LONG, op1(X), (char *)db_Esce3 }, 4274Srgrimes/*4*/ { "fisub", LONG, op2(ST,STI), "fsubrp" }, 4284Srgrimes/*5*/ { "fisubr", LONG, op2(ST,STI), "fsubp" }, 4294Srgrimes/*6*/ { "fidiv", LONG, op2(ST,STI), "fdivrp" }, 4304Srgrimes/*7*/ { "fidivr", LONG, op2(ST,STI), "fdivp" }, 4314Srgrimes}; 4324Srgrimes 4334Srgrimesstruct finst db_Escf[] = { 4344Srgrimes/*0*/ { "fild", LONG, 0, 0 }, 4354Srgrimes/*1*/ { "", LONG, 0, 0 }, 4364Srgrimes/*2*/ { "fist", LONG, 0, 0 }, 4374Srgrimes/*3*/ { "fistp", LONG, 0, 0 }, 4384Srgrimes/*4*/ { "fbld", NONE, op1(XA), (char *)db_Escf4 }, 4394Srgrimes/*5*/ { "fld", QUAD, 0, 0 }, 4404Srgrimes/*6*/ { "fbstp", NONE, 0, 0 }, 4414Srgrimes/*7*/ { "fstp", QUAD, 0, 0 }, 4424Srgrimes}; 4434Srgrimes 4444Srgrimesstruct finst *db_Esc_inst[] = { 4454Srgrimes db_Esc8, db_Esc9, db_Esca, db_Escb, 4464Srgrimes db_Escc, db_Escd, db_Esce, db_Escf 4474Srgrimes}; 4484Srgrimes 4494Srgrimeschar * db_Grp1[] = { 4504Srgrimes "add", 4514Srgrimes "or", 4524Srgrimes "adc", 4534Srgrimes "sbb", 4544Srgrimes "and", 4554Srgrimes "sub", 4564Srgrimes "xor", 4574Srgrimes "cmp" 4584Srgrimes}; 4594Srgrimes 4604Srgrimeschar * db_Grp2[] = { 4614Srgrimes "rol", 4624Srgrimes "ror", 4634Srgrimes "rcl", 4644Srgrimes "rcr", 4654Srgrimes "shl", 4664Srgrimes "shr", 4674Srgrimes "shl", 4684Srgrimes "sar" 4694Srgrimes}; 4704Srgrimes 4714Srgrimesstruct inst db_Grp3[] = { 4724Srgrimes { "test", TRUE, NONE, op2(I,E), 0 }, 4734Srgrimes { "test", TRUE, NONE, op2(I,E), 0 }, 4744Srgrimes { "not", TRUE, NONE, op1(E), 0 }, 4754Srgrimes { "neg", TRUE, NONE, op1(E), 0 }, 4764Srgrimes { "mul", TRUE, NONE, op2(E,A), 0 }, 4774Srgrimes { "imul", TRUE, NONE, op2(E,A), 0 }, 4784Srgrimes { "div", TRUE, NONE, op2(E,A), 0 }, 4794Srgrimes { "idiv", TRUE, NONE, op2(E,A), 0 }, 4804Srgrimes}; 4814Srgrimes 4824Srgrimesstruct inst db_Grp4[] = { 4834Srgrimes { "inc", TRUE, BYTE, op1(E), 0 }, 4844Srgrimes { "dec", TRUE, BYTE, op1(E), 0 }, 4854Srgrimes { "", TRUE, NONE, 0, 0 }, 4864Srgrimes { "", TRUE, NONE, 0, 0 }, 4874Srgrimes { "", TRUE, NONE, 0, 0 }, 4884Srgrimes { "", TRUE, NONE, 0, 0 }, 4894Srgrimes { "", TRUE, NONE, 0, 0 }, 4904Srgrimes { "", TRUE, NONE, 0, 0 } 4914Srgrimes}; 4924Srgrimes 4934Srgrimesstruct inst db_Grp5[] = { 4944Srgrimes { "inc", TRUE, LONG, op1(E), 0 }, 4954Srgrimes { "dec", TRUE, LONG, op1(E), 0 }, 4964Srgrimes { "call", TRUE, NONE, op1(Eind),0 }, 4974Srgrimes { "lcall", TRUE, NONE, op1(Eind),0 }, 4984Srgrimes { "jmp", TRUE, NONE, op1(Eind),0 }, 4994Srgrimes { "ljmp", TRUE, NONE, op1(Eind),0 }, 5004Srgrimes { "push", TRUE, LONG, op1(E), 0 }, 5014Srgrimes { "", TRUE, NONE, 0, 0 } 5024Srgrimes}; 5034Srgrimes 5044Srgrimesstruct inst db_inst_table[256] = { 5054Srgrimes/*00*/ { "add", TRUE, BYTE, op2(R, E), 0 }, 5064Srgrimes/*01*/ { "add", TRUE, LONG, op2(R, E), 0 }, 5074Srgrimes/*02*/ { "add", TRUE, BYTE, op2(E, R), 0 }, 5084Srgrimes/*03*/ { "add", TRUE, LONG, op2(E, R), 0 }, 5094Srgrimes/*04*/ { "add", FALSE, BYTE, op2(Is, A), 0 }, 5104Srgrimes/*05*/ { "add", FALSE, LONG, op2(Is, A), 0 }, 5114Srgrimes/*06*/ { "push", FALSE, NONE, op1(Si), 0 }, 5124Srgrimes/*07*/ { "pop", FALSE, NONE, op1(Si), 0 }, 5134Srgrimes 5144Srgrimes/*08*/ { "or", TRUE, BYTE, op2(R, E), 0 }, 5154Srgrimes/*09*/ { "or", TRUE, LONG, op2(R, E), 0 }, 5164Srgrimes/*0a*/ { "or", TRUE, BYTE, op2(E, R), 0 }, 5174Srgrimes/*0b*/ { "or", TRUE, LONG, op2(E, R), 0 }, 5184Srgrimes/*0c*/ { "or", FALSE, BYTE, op2(I, A), 0 }, 5194Srgrimes/*0d*/ { "or", FALSE, LONG, op2(I, A), 0 }, 5204Srgrimes/*0e*/ { "push", FALSE, NONE, op1(Si), 0 }, 5214Srgrimes/*0f*/ { "", FALSE, NONE, 0, 0 }, 5224Srgrimes 5234Srgrimes/*10*/ { "adc", TRUE, BYTE, op2(R, E), 0 }, 5244Srgrimes/*11*/ { "adc", TRUE, LONG, op2(R, E), 0 }, 5254Srgrimes/*12*/ { "adc", TRUE, BYTE, op2(E, R), 0 }, 5264Srgrimes/*13*/ { "adc", TRUE, LONG, op2(E, R), 0 }, 5274Srgrimes/*14*/ { "adc", FALSE, BYTE, op2(Is, A), 0 }, 5284Srgrimes/*15*/ { "adc", FALSE, LONG, op2(Is, A), 0 }, 5294Srgrimes/*16*/ { "push", FALSE, NONE, op1(Si), 0 }, 5304Srgrimes/*17*/ { "pop", FALSE, NONE, op1(Si), 0 }, 5314Srgrimes 5324Srgrimes/*18*/ { "sbb", TRUE, BYTE, op2(R, E), 0 }, 5334Srgrimes/*19*/ { "sbb", TRUE, LONG, op2(R, E), 0 }, 5344Srgrimes/*1a*/ { "sbb", TRUE, BYTE, op2(E, R), 0 }, 5354Srgrimes/*1b*/ { "sbb", TRUE, LONG, op2(E, R), 0 }, 5364Srgrimes/*1c*/ { "sbb", FALSE, BYTE, op2(Is, A), 0 }, 5374Srgrimes/*1d*/ { "sbb", FALSE, LONG, op2(Is, A), 0 }, 5384Srgrimes/*1e*/ { "push", FALSE, NONE, op1(Si), 0 }, 5394Srgrimes/*1f*/ { "pop", FALSE, NONE, op1(Si), 0 }, 5404Srgrimes 5414Srgrimes/*20*/ { "and", TRUE, BYTE, op2(R, E), 0 }, 5424Srgrimes/*21*/ { "and", TRUE, LONG, op2(R, E), 0 }, 5434Srgrimes/*22*/ { "and", TRUE, BYTE, op2(E, R), 0 }, 5444Srgrimes/*23*/ { "and", TRUE, LONG, op2(E, R), 0 }, 5454Srgrimes/*24*/ { "and", FALSE, BYTE, op2(I, A), 0 }, 5464Srgrimes/*25*/ { "and", FALSE, LONG, op2(I, A), 0 }, 5474Srgrimes/*26*/ { "", FALSE, NONE, 0, 0 }, 5484Srgrimes/*27*/ { "aaa", FALSE, NONE, 0, 0 }, 5494Srgrimes 5504Srgrimes/*28*/ { "sub", TRUE, BYTE, op2(R, E), 0 }, 5514Srgrimes/*29*/ { "sub", TRUE, LONG, op2(R, E), 0 }, 5524Srgrimes/*2a*/ { "sub", TRUE, BYTE, op2(E, R), 0 }, 5534Srgrimes/*2b*/ { "sub", TRUE, LONG, op2(E, R), 0 }, 5544Srgrimes/*2c*/ { "sub", FALSE, BYTE, op2(Is, A), 0 }, 5554Srgrimes/*2d*/ { "sub", FALSE, LONG, op2(Is, A), 0 }, 5564Srgrimes/*2e*/ { "", FALSE, NONE, 0, 0 }, 5574Srgrimes/*2f*/ { "das", FALSE, NONE, 0, 0 }, 5584Srgrimes 5594Srgrimes/*30*/ { "xor", TRUE, BYTE, op2(R, E), 0 }, 5604Srgrimes/*31*/ { "xor", TRUE, LONG, op2(R, E), 0 }, 5614Srgrimes/*32*/ { "xor", TRUE, BYTE, op2(E, R), 0 }, 5624Srgrimes/*33*/ { "xor", TRUE, LONG, op2(E, R), 0 }, 5634Srgrimes/*34*/ { "xor", FALSE, BYTE, op2(I, A), 0 }, 5644Srgrimes/*35*/ { "xor", FALSE, LONG, op2(I, A), 0 }, 5654Srgrimes/*36*/ { "", FALSE, NONE, 0, 0 }, 5664Srgrimes/*37*/ { "daa", FALSE, NONE, 0, 0 }, 5674Srgrimes 5684Srgrimes/*38*/ { "cmp", TRUE, BYTE, op2(R, E), 0 }, 5694Srgrimes/*39*/ { "cmp", TRUE, LONG, op2(R, E), 0 }, 5704Srgrimes/*3a*/ { "cmp", TRUE, BYTE, op2(E, R), 0 }, 5714Srgrimes/*3b*/ { "cmp", TRUE, LONG, op2(E, R), 0 }, 5724Srgrimes/*3c*/ { "cmp", FALSE, BYTE, op2(Is, A), 0 }, 5734Srgrimes/*3d*/ { "cmp", FALSE, LONG, op2(Is, A), 0 }, 5744Srgrimes/*3e*/ { "", FALSE, NONE, 0, 0 }, 5754Srgrimes/*3f*/ { "aas", FALSE, NONE, 0, 0 }, 5764Srgrimes 5774Srgrimes/*40*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5784Srgrimes/*41*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5794Srgrimes/*42*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5804Srgrimes/*43*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5814Srgrimes/*44*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5824Srgrimes/*45*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5834Srgrimes/*46*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5844Srgrimes/*47*/ { "inc", FALSE, LONG, op1(Ri), 0 }, 5854Srgrimes 5864Srgrimes/*48*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5874Srgrimes/*49*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5884Srgrimes/*4a*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5894Srgrimes/*4b*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5904Srgrimes/*4c*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5914Srgrimes/*4d*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5924Srgrimes/*4e*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5934Srgrimes/*4f*/ { "dec", FALSE, LONG, op1(Ri), 0 }, 5944Srgrimes 5954Srgrimes/*50*/ { "push", FALSE, LONG, op1(Ri), 0 }, 5964Srgrimes/*51*/ { "push", FALSE, LONG, op1(Ri), 0 }, 5974Srgrimes/*52*/ { "push", FALSE, LONG, op1(Ri), 0 }, 5984Srgrimes/*53*/ { "push", FALSE, LONG, op1(Ri), 0 }, 5994Srgrimes/*54*/ { "push", FALSE, LONG, op1(Ri), 0 }, 6004Srgrimes/*55*/ { "push", FALSE, LONG, op1(Ri), 0 }, 6014Srgrimes/*56*/ { "push", FALSE, LONG, op1(Ri), 0 }, 6024Srgrimes/*57*/ { "push", FALSE, LONG, op1(Ri), 0 }, 6034Srgrimes 6044Srgrimes/*58*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6054Srgrimes/*59*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6064Srgrimes/*5a*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6074Srgrimes/*5b*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6084Srgrimes/*5c*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6094Srgrimes/*5d*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6104Srgrimes/*5e*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6114Srgrimes/*5f*/ { "pop", FALSE, LONG, op1(Ri), 0 }, 6124Srgrimes 6134Srgrimes/*60*/ { "pusha", FALSE, LONG, 0, 0 }, 6144Srgrimes/*61*/ { "popa", FALSE, LONG, 0, 0 }, 6154Srgrimes/*62*/ { "bound", TRUE, LONG, op2(E, R), 0 }, 6164Srgrimes/*63*/ { "arpl", TRUE, NONE, op2(Ew,Rw), 0 }, 6174Srgrimes 6184Srgrimes/*64*/ { "", FALSE, NONE, 0, 0 }, 6194Srgrimes/*65*/ { "", FALSE, NONE, 0, 0 }, 6204Srgrimes/*66*/ { "", FALSE, NONE, 0, 0 }, 6214Srgrimes/*67*/ { "", FALSE, NONE, 0, 0 }, 6224Srgrimes 6234Srgrimes/*68*/ { "push", FALSE, LONG, op1(I), 0 }, 6244Srgrimes/*69*/ { "imul", TRUE, LONG, op3(I,E,R), 0 }, 6254Srgrimes/*6a*/ { "push", FALSE, LONG, op1(Ib), 0 }, 6264Srgrimes/*6b*/ { "imul", TRUE, LONG, op3(Ibs,E,R),0 }, 6274Srgrimes/*6c*/ { "ins", FALSE, BYTE, op2(DX, DI), 0 }, 6284Srgrimes/*6d*/ { "ins", FALSE, LONG, op2(DX, DI), 0 }, 6294Srgrimes/*6e*/ { "outs", FALSE, BYTE, op2(SI, DX), 0 }, 6304Srgrimes/*6f*/ { "outs", FALSE, LONG, op2(SI, DX), 0 }, 6314Srgrimes 6324Srgrimes/*70*/ { "jo", FALSE, NONE, op1(Db), 0 }, 6334Srgrimes/*71*/ { "jno", FALSE, NONE, op1(Db), 0 }, 6344Srgrimes/*72*/ { "jb", FALSE, NONE, op1(Db), 0 }, 6354Srgrimes/*73*/ { "jnb", FALSE, NONE, op1(Db), 0 }, 6364Srgrimes/*74*/ { "jz", FALSE, NONE, op1(Db), 0 }, 6374Srgrimes/*75*/ { "jnz", FALSE, NONE, op1(Db), 0 }, 6384Srgrimes/*76*/ { "jbe", FALSE, NONE, op1(Db), 0 }, 6394Srgrimes/*77*/ { "jnbe", FALSE, NONE, op1(Db), 0 }, 6404Srgrimes 6414Srgrimes/*78*/ { "js", FALSE, NONE, op1(Db), 0 }, 6424Srgrimes/*79*/ { "jns", FALSE, NONE, op1(Db), 0 }, 6434Srgrimes/*7a*/ { "jp", FALSE, NONE, op1(Db), 0 }, 6444Srgrimes/*7b*/ { "jnp", FALSE, NONE, op1(Db), 0 }, 6454Srgrimes/*7c*/ { "jl", FALSE, NONE, op1(Db), 0 }, 6464Srgrimes/*7d*/ { "jnl", FALSE, NONE, op1(Db), 0 }, 6474Srgrimes/*7e*/ { "jle", FALSE, NONE, op1(Db), 0 }, 6484Srgrimes/*7f*/ { "jnle", FALSE, NONE, op1(Db), 0 }, 6494Srgrimes 6504Srgrimes/*80*/ { "", TRUE, BYTE, op2(I, E), (char *)db_Grp1 }, 6514Srgrimes/*81*/ { "", TRUE, LONG, op2(I, E), (char *)db_Grp1 }, 6524Srgrimes/*82*/ { "", TRUE, BYTE, op2(Is,E), (char *)db_Grp1 }, 6534Srgrimes/*83*/ { "", TRUE, LONG, op2(Ibs,E), (char *)db_Grp1 }, 6544Srgrimes/*84*/ { "test", TRUE, BYTE, op2(R, E), 0 }, 6554Srgrimes/*85*/ { "test", TRUE, LONG, op2(R, E), 0 }, 6564Srgrimes/*86*/ { "xchg", TRUE, BYTE, op2(R, E), 0 }, 6574Srgrimes/*87*/ { "xchg", TRUE, LONG, op2(R, E), 0 }, 6584Srgrimes 6594Srgrimes/*88*/ { "mov", TRUE, BYTE, op2(R, E), 0 }, 6604Srgrimes/*89*/ { "mov", TRUE, LONG, op2(R, E), 0 }, 6614Srgrimes/*8a*/ { "mov", TRUE, BYTE, op2(E, R), 0 }, 6624Srgrimes/*8b*/ { "mov", TRUE, LONG, op2(E, R), 0 }, 6634Srgrimes/*8c*/ { "mov", TRUE, NONE, op2(S, Ew), 0 }, 6644Srgrimes/*8d*/ { "lea", TRUE, LONG, op2(E, R), 0 }, 6654Srgrimes/*8e*/ { "mov", TRUE, NONE, op2(Ew, S), 0 }, 6664Srgrimes/*8f*/ { "pop", TRUE, LONG, op1(E), 0 }, 6674Srgrimes 6684Srgrimes/*90*/ { "nop", FALSE, NONE, 0, 0 }, 6694Srgrimes/*91*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6704Srgrimes/*92*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6714Srgrimes/*93*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6724Srgrimes/*94*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6734Srgrimes/*95*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6744Srgrimes/*96*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6754Srgrimes/*97*/ { "xchg", FALSE, LONG, op2(A, Ri), 0 }, 6764Srgrimes 6774Srgrimes/*98*/ { "cbw", FALSE, SDEP, 0, "cwde" }, /* cbw/cwde */ 6784Srgrimes/*99*/ { "cwd", FALSE, SDEP, 0, "cdq" }, /* cwd/cdq */ 6794Srgrimes/*9a*/ { "lcall", FALSE, NONE, op1(OS), 0 }, 6804Srgrimes/*9b*/ { "wait", FALSE, NONE, 0, 0 }, 6814Srgrimes/*9c*/ { "pushf", FALSE, LONG, 0, 0 }, 6824Srgrimes/*9d*/ { "popf", FALSE, LONG, 0, 0 }, 6834Srgrimes/*9e*/ { "sahf", FALSE, NONE, 0, 0 }, 6844Srgrimes/*9f*/ { "lahf", FALSE, NONE, 0, 0 }, 6854Srgrimes 6864Srgrimes/*a0*/ { "mov", FALSE, BYTE, op2(O, A), 0 }, 6874Srgrimes/*a1*/ { "mov", FALSE, LONG, op2(O, A), 0 }, 6884Srgrimes/*a2*/ { "mov", FALSE, BYTE, op2(A, O), 0 }, 6894Srgrimes/*a3*/ { "mov", FALSE, LONG, op2(A, O), 0 }, 6904Srgrimes/*a4*/ { "movs", FALSE, BYTE, op2(SI,DI), 0 }, 6914Srgrimes/*a5*/ { "movs", FALSE, LONG, op2(SI,DI), 0 }, 6924Srgrimes/*a6*/ { "cmps", FALSE, BYTE, op2(SI,DI), 0 }, 6934Srgrimes/*a7*/ { "cmps", FALSE, LONG, op2(SI,DI), 0 }, 6944Srgrimes 6954Srgrimes/*a8*/ { "test", FALSE, BYTE, op2(I, A), 0 }, 6964Srgrimes/*a9*/ { "test", FALSE, LONG, op2(I, A), 0 }, 6974Srgrimes/*aa*/ { "stos", FALSE, BYTE, op1(DI), 0 }, 6984Srgrimes/*ab*/ { "stos", FALSE, LONG, op1(DI), 0 }, 699118Srgrimes/*ac*/ { "lods", FALSE, BYTE, op1(SI), 0 }, 700118Srgrimes/*ad*/ { "lods", FALSE, LONG, op1(SI), 0 }, 7014Srgrimes/*ae*/ { "scas", FALSE, BYTE, op1(SI), 0 }, 7024Srgrimes/*af*/ { "scas", FALSE, LONG, op1(SI), 0 }, 7034Srgrimes 7044Srgrimes/*b0*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7054Srgrimes/*b1*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7064Srgrimes/*b2*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7074Srgrimes/*b3*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7084Srgrimes/*b4*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7094Srgrimes/*b5*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7104Srgrimes/*b6*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7114Srgrimes/*b7*/ { "mov", FALSE, BYTE, op2(I, Ri), 0 }, 7124Srgrimes 7134Srgrimes/*b8*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7144Srgrimes/*b9*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7154Srgrimes/*ba*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7164Srgrimes/*bb*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7174Srgrimes/*bc*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7184Srgrimes/*bd*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7194Srgrimes/*be*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7204Srgrimes/*bf*/ { "mov", FALSE, LONG, op2(I, Ri), 0 }, 7214Srgrimes 7224Srgrimes/*c0*/ { "", TRUE, BYTE, op2(Ib, E), (char *)db_Grp2 }, 7234Srgrimes/*c1*/ { "", TRUE, LONG, op2(Ib, E), (char *)db_Grp2 }, 7244Srgrimes/*c2*/ { "ret", FALSE, NONE, op1(Iw), 0 }, 7254Srgrimes/*c3*/ { "ret", FALSE, NONE, 0, 0 }, 7264Srgrimes/*c4*/ { "les", TRUE, LONG, op2(E, R), 0 }, 7274Srgrimes/*c5*/ { "lds", TRUE, LONG, op2(E, R), 0 }, 7284Srgrimes/*c6*/ { "mov", TRUE, BYTE, op2(I, E), 0 }, 7294Srgrimes/*c7*/ { "mov", TRUE, LONG, op2(I, E), 0 }, 7304Srgrimes 7314Srgrimes/*c8*/ { "enter", FALSE, NONE, op2(Ib, Iw), 0 }, 7324Srgrimes/*c9*/ { "leave", FALSE, NONE, 0, 0 }, 7334Srgrimes/*ca*/ { "lret", FALSE, NONE, op1(Iw), 0 }, 7344Srgrimes/*cb*/ { "lret", FALSE, NONE, 0, 0 }, 7354Srgrimes/*cc*/ { "int", FALSE, NONE, op1(o3), 0 }, 7364Srgrimes/*cd*/ { "int", FALSE, NONE, op1(Ib), 0 }, 7374Srgrimes/*ce*/ { "into", FALSE, NONE, 0, 0 }, 7384Srgrimes/*cf*/ { "iret", FALSE, NONE, 0, 0 }, 7394Srgrimes 7404Srgrimes/*d0*/ { "", TRUE, BYTE, op2(o1, E), (char *)db_Grp2 }, 7414Srgrimes/*d1*/ { "", TRUE, LONG, op2(o1, E), (char *)db_Grp2 }, 7424Srgrimes/*d2*/ { "", TRUE, BYTE, op2(CL, E), (char *)db_Grp2 }, 7434Srgrimes/*d3*/ { "", TRUE, LONG, op2(CL, E), (char *)db_Grp2 }, 7444Srgrimes/*d4*/ { "aam", TRUE, NONE, 0, 0 }, 7454Srgrimes/*d5*/ { "aad", TRUE, NONE, 0, 0 }, 7464Srgrimes/*d6*/ { "", FALSE, NONE, 0, 0 }, 7474Srgrimes/*d7*/ { "xlat", FALSE, BYTE, op1(BX), 0 }, 7484Srgrimes 7494Srgrimes/*d8*/ { "", TRUE, NONE, 0, (char *)db_Esc8 }, 7504Srgrimes/*d9*/ { "", TRUE, NONE, 0, (char *)db_Esc9 }, 7514Srgrimes/*da*/ { "", TRUE, NONE, 0, (char *)db_Esca }, 7524Srgrimes/*db*/ { "", TRUE, NONE, 0, (char *)db_Escb }, 7534Srgrimes/*dc*/ { "", TRUE, NONE, 0, (char *)db_Escc }, 7544Srgrimes/*dd*/ { "", TRUE, NONE, 0, (char *)db_Escd }, 7554Srgrimes/*de*/ { "", TRUE, NONE, 0, (char *)db_Esce }, 7564Srgrimes/*df*/ { "", TRUE, NONE, 0, (char *)db_Escf }, 7574Srgrimes 7584Srgrimes/*e0*/ { "loopne",FALSE, NONE, op1(Db), 0 }, 7594Srgrimes/*e1*/ { "loope", FALSE, NONE, op1(Db), 0 }, 7604Srgrimes/*e2*/ { "loop", FALSE, NONE, op1(Db), 0 }, 7614Srgrimes/*e3*/ { "jcxz", FALSE, SDEP, op1(Db), "jecxz" }, 7624Srgrimes/*e4*/ { "in", FALSE, BYTE, op2(Ib, A), 0 }, 7634Srgrimes/*e5*/ { "in", FALSE, LONG, op2(Ib, A) , 0 }, 7644Srgrimes/*e6*/ { "out", FALSE, BYTE, op2(A, Ib), 0 }, 7654Srgrimes/*e7*/ { "out", FALSE, LONG, op2(A, Ib) , 0 }, 7664Srgrimes 7674Srgrimes/*e8*/ { "call", FALSE, NONE, op1(Dl), 0 }, 7684Srgrimes/*e9*/ { "jmp", FALSE, NONE, op1(Dl), 0 }, 7694Srgrimes/*ea*/ { "ljmp", FALSE, NONE, op1(OS), 0 }, 7704Srgrimes/*eb*/ { "jmp", FALSE, NONE, op1(Db), 0 }, 7714Srgrimes/*ec*/ { "in", FALSE, BYTE, op2(DX, A), 0 }, 7724Srgrimes/*ed*/ { "in", FALSE, LONG, op2(DX, A) , 0 }, 7734Srgrimes/*ee*/ { "out", FALSE, BYTE, op2(A, DX), 0 }, 7744Srgrimes/*ef*/ { "out", FALSE, LONG, op2(A, DX) , 0 }, 7754Srgrimes 7764Srgrimes/*f0*/ { "", FALSE, NONE, 0, 0 }, 7774Srgrimes/*f1*/ { "", FALSE, NONE, 0, 0 }, 7784Srgrimes/*f2*/ { "", FALSE, NONE, 0, 0 }, 7794Srgrimes/*f3*/ { "", FALSE, NONE, 0, 0 }, 7804Srgrimes/*f4*/ { "hlt", FALSE, NONE, 0, 0 }, 7814Srgrimes/*f5*/ { "cmc", FALSE, NONE, 0, 0 }, 7824Srgrimes/*f6*/ { "", TRUE, BYTE, 0, (char *)db_Grp3 }, 7834Srgrimes/*f7*/ { "", TRUE, LONG, 0, (char *)db_Grp3 }, 7844Srgrimes 7854Srgrimes/*f8*/ { "clc", FALSE, NONE, 0, 0 }, 7864Srgrimes/*f9*/ { "stc", FALSE, NONE, 0, 0 }, 7874Srgrimes/*fa*/ { "cli", FALSE, NONE, 0, 0 }, 7884Srgrimes/*fb*/ { "sti", FALSE, NONE, 0, 0 }, 7894Srgrimes/*fc*/ { "cld", FALSE, NONE, 0, 0 }, 7904Srgrimes/*fd*/ { "std", FALSE, NONE, 0, 0 }, 7914Srgrimes/*fe*/ { "", TRUE, NONE, 0, (char *)db_Grp4 }, 7924Srgrimes/*ff*/ { "", TRUE, NONE, 0, (char *)db_Grp5 }, 7934Srgrimes}; 7944Srgrimes 7954Srgrimesstruct inst db_bad_inst = 7964Srgrimes { "???", FALSE, NONE, 0, 0 } 7974Srgrimes; 7984Srgrimes 7994Srgrimes#define f_mod(byte) ((byte)>>6) 8004Srgrimes#define f_reg(byte) (((byte)>>3)&0x7) 8014Srgrimes#define f_rm(byte) ((byte)&0x7) 8024Srgrimes 8034Srgrimes#define sib_ss(byte) ((byte)>>6) 8044Srgrimes#define sib_index(byte) (((byte)>>3)&0x7) 8054Srgrimes#define sib_base(byte) ((byte)&0x7) 8064Srgrimes 8074Srgrimesstruct i_addr { 8084Srgrimes int is_reg; /* if reg, reg number is in 'disp' */ 8094Srgrimes int disp; 8104Srgrimes char * base; 8114Srgrimes char * index; 8124Srgrimes int ss; 8134Srgrimes}; 8144Srgrimes 8154Srgrimeschar * db_index_reg_16[8] = { 8164Srgrimes "%bx,%si", 8174Srgrimes "%bx,%di", 8184Srgrimes "%bp,%si", 8194Srgrimes "%bp,%di", 8204Srgrimes "%si", 8214Srgrimes "%di", 8224Srgrimes "%bp", 8234Srgrimes "%bx" 8244Srgrimes}; 8254Srgrimes 8264Srgrimeschar * db_reg[3][8] = { 8274Srgrimes "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", 8284Srgrimes "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", 8294Srgrimes "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi" 8304Srgrimes}; 8314Srgrimes 8324Srgrimeschar * db_seg_reg[8] = { 8334Srgrimes "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "", "" 8344Srgrimes}; 8354Srgrimes 8364Srgrimes/* 8374Srgrimes * lengths for size attributes 8384Srgrimes */ 8394Srgrimesint db_lengths[] = { 8404Srgrimes 1, /* BYTE */ 8414Srgrimes 2, /* WORD */ 8424Srgrimes 4, /* LONG */ 8434Srgrimes 8, /* QUAD */ 8444Srgrimes 4, /* SNGL */ 8454Srgrimes 8, /* DBLR */ 8464Srgrimes 10, /* EXTR */ 8474Srgrimes}; 8484Srgrimes 8494Srgrimes#define get_value_inc(result, loc, size, is_signed) \ 8504Srgrimes result = db_get_value((loc), (size), (is_signed)); \ 8514Srgrimes (loc) += (size); 8524Srgrimes 8534Srgrimes/* 8544Srgrimes * Read address at location and return updated location. 8554Srgrimes */ 8564Srgrimesdb_addr_t 8574Srgrimesdb_read_address(loc, short_addr, regmodrm, addrp) 8584Srgrimes db_addr_t loc; 8594Srgrimes int short_addr; 8604Srgrimes int regmodrm; 8614Srgrimes struct i_addr *addrp; /* out */ 8624Srgrimes{ 8634Srgrimes int mod, rm, sib, index, ss, disp; 8644Srgrimes 8654Srgrimes mod = f_mod(regmodrm); 8664Srgrimes rm = f_rm(regmodrm); 8674Srgrimes 8684Srgrimes if (mod == 3) { 8694Srgrimes addrp->is_reg = TRUE; 8704Srgrimes addrp->disp = rm; 8714Srgrimes return (loc); 8724Srgrimes } 8734Srgrimes addrp->is_reg = FALSE; 8744Srgrimes addrp->index = 0; 8754Srgrimes 8764Srgrimes if (short_addr) { 8774Srgrimes addrp->index = 0; 8784Srgrimes addrp->ss = 0; 8794Srgrimes switch (mod) { 8804Srgrimes case 0: 8814Srgrimes if (rm == 6) { 8824Srgrimes get_value_inc(disp, loc, 2, TRUE); 8834Srgrimes addrp->disp = disp; 8844Srgrimes addrp->base = 0; 8854Srgrimes } 8864Srgrimes else { 8874Srgrimes addrp->disp = 0; 8884Srgrimes addrp->base = db_index_reg_16[rm]; 8894Srgrimes } 8904Srgrimes break; 8914Srgrimes case 1: 8924Srgrimes get_value_inc(disp, loc, 1, TRUE); 8934Srgrimes addrp->disp = disp; 8944Srgrimes addrp->base = db_index_reg_16[rm]; 8954Srgrimes break; 8964Srgrimes case 2: 8974Srgrimes get_value_inc(disp, loc, 2, TRUE); 8984Srgrimes addrp->disp = disp; 8994Srgrimes addrp->base = db_index_reg_16[rm]; 9004Srgrimes break; 9014Srgrimes } 9024Srgrimes } 9034Srgrimes else { 9044Srgrimes if (mod != 3 && rm == 4) { 9054Srgrimes get_value_inc(sib, loc, 1, FALSE); 9064Srgrimes rm = sib_base(sib); 9074Srgrimes index = sib_index(sib); 9084Srgrimes if (index != 4) 9094Srgrimes addrp->index = db_reg[LONG][index]; 9104Srgrimes addrp->ss = sib_ss(sib); 9114Srgrimes } 9124Srgrimes 9134Srgrimes switch (mod) { 9144Srgrimes case 0: 9154Srgrimes if (rm == 5) { 9164Srgrimes get_value_inc(addrp->disp, loc, 4, FALSE); 9174Srgrimes addrp->base = 0; 9184Srgrimes } 9194Srgrimes else { 9204Srgrimes addrp->disp = 0; 9214Srgrimes addrp->base = db_reg[LONG][rm]; 9224Srgrimes } 9234Srgrimes break; 9244Srgrimes 9254Srgrimes case 1: 9264Srgrimes get_value_inc(disp, loc, 1, TRUE); 9274Srgrimes addrp->disp = disp; 9284Srgrimes addrp->base = db_reg[LONG][rm]; 9294Srgrimes break; 9304Srgrimes 9314Srgrimes case 2: 9324Srgrimes get_value_inc(disp, loc, 4, FALSE); 9334Srgrimes addrp->disp = disp; 9344Srgrimes addrp->base = db_reg[LONG][rm]; 9354Srgrimes break; 9364Srgrimes } 9374Srgrimes } 9384Srgrimes return (loc); 9394Srgrimes} 9404Srgrimes 9414Srgrimesvoid 9424Srgrimesdb_print_address(seg, size, addrp) 9434Srgrimes char * seg; 9444Srgrimes int size; 9454Srgrimes struct i_addr *addrp; 9464Srgrimes{ 9474Srgrimes if (addrp->is_reg) { 9484Srgrimes db_printf("%s", db_reg[size][addrp->disp]); 9494Srgrimes return; 9504Srgrimes } 9514Srgrimes 9524Srgrimes if (seg) { 9534Srgrimes db_printf("%s:", seg); 9544Srgrimes } 9554Srgrimes 9564Srgrimes db_printsym((db_addr_t)addrp->disp, DB_STGY_ANY); 9574Srgrimes if (addrp->base != 0 || addrp->index != 0) { 9584Srgrimes db_printf("("); 9594Srgrimes if (addrp->base) 9604Srgrimes db_printf("%s", addrp->base); 9614Srgrimes if (addrp->index) 9624Srgrimes db_printf(",%s,%d", addrp->index, 1<<addrp->ss); 9634Srgrimes db_printf(")"); 9644Srgrimes } 9654Srgrimes} 9664Srgrimes 9674Srgrimes/* 9684Srgrimes * Disassemble floating-point ("escape") instruction 9694Srgrimes * and return updated location. 9704Srgrimes */ 9714Srgrimesdb_addr_t 9724Srgrimesdb_disasm_esc(loc, inst, short_addr, size, seg) 9734Srgrimes db_addr_t loc; 9744Srgrimes int inst; 9754Srgrimes int short_addr; 9764Srgrimes int size; 9774Srgrimes char * seg; 9784Srgrimes{ 9794Srgrimes int regmodrm; 9804Srgrimes struct finst *fp; 9814Srgrimes int mod; 9824Srgrimes struct i_addr address; 9834Srgrimes char * name; 9844Srgrimes 9854Srgrimes get_value_inc(regmodrm, loc, 1, FALSE); 9864Srgrimes fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm)]; 9874Srgrimes mod = f_mod(regmodrm); 9884Srgrimes if (mod != 3) { 9894Srgrimes /* 9904Srgrimes * Normal address modes. 9914Srgrimes */ 9924Srgrimes loc = db_read_address(loc, short_addr, regmodrm, &address); 9934Srgrimes db_printf(fp->f_name); 9944Srgrimes switch(fp->f_size) { 9954Srgrimes case SNGL: 9964Srgrimes db_printf("s"); 9974Srgrimes break; 9984Srgrimes case DBLR: 9994Srgrimes db_printf("l"); 10004Srgrimes break; 10014Srgrimes case EXTR: 10024Srgrimes db_printf("t"); 10034Srgrimes break; 10044Srgrimes case WORD: 10054Srgrimes db_printf("s"); 10064Srgrimes break; 10074Srgrimes case LONG: 10084Srgrimes db_printf("l"); 10094Srgrimes break; 10104Srgrimes case QUAD: 10114Srgrimes db_printf("q"); 10124Srgrimes break; 10134Srgrimes default: 10144Srgrimes break; 10154Srgrimes } 10164Srgrimes db_printf("\t"); 10174Srgrimes db_print_address(seg, BYTE, &address); 10184Srgrimes } 10194Srgrimes else { 10204Srgrimes /* 10214Srgrimes * 'reg-reg' - special formats 10224Srgrimes */ 10234Srgrimes switch (fp->f_rrmode) { 10244Srgrimes case op2(ST,STI): 10254Srgrimes name = (fp->f_rrname) ? fp->f_rrname : fp->f_name; 10264Srgrimes db_printf("%s\t%%st,%%st(%d)",name,f_rm(regmodrm)); 10274Srgrimes break; 10284Srgrimes case op2(STI,ST): 10294Srgrimes name = (fp->f_rrname) ? fp->f_rrname : fp->f_name; 10304Srgrimes db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm)); 10314Srgrimes break; 10324Srgrimes case op1(STI): 10334Srgrimes name = (fp->f_rrname) ? fp->f_rrname : fp->f_name; 10344Srgrimes db_printf("%s\t%%st(%d)",name, f_rm(regmodrm)); 10354Srgrimes break; 10364Srgrimes case op1(X): 10374Srgrimes db_printf("%s", ((char **)fp->f_rrname)[f_rm(regmodrm)]); 10384Srgrimes break; 10394Srgrimes case op1(XA): 10404Srgrimes db_printf("%s\t%%ax", 10414Srgrimes ((char **)fp->f_rrname)[f_rm(regmodrm)]); 10424Srgrimes break; 10434Srgrimes default: 10444Srgrimes db_printf("<bad instruction>"); 10454Srgrimes break; 10464Srgrimes } 10474Srgrimes } 10484Srgrimes 10494Srgrimes return (loc); 10504Srgrimes} 10514Srgrimes 10524Srgrimes/* 10534Srgrimes * Disassemble instruction at 'loc'. 'altfmt' specifies an 10544Srgrimes * (optional) alternate format. Return address of start of 10554Srgrimes * next instruction. 10564Srgrimes */ 10574Srgrimesdb_addr_t 10584Srgrimesdb_disasm(loc, altfmt) 10594Srgrimes db_addr_t loc; 10604Srgrimes boolean_t altfmt; 10614Srgrimes{ 10624Srgrimes int inst; 10634Srgrimes int size; 10644Srgrimes int short_addr; 10654Srgrimes char * seg; 10664Srgrimes struct inst * ip; 10674Srgrimes char * i_name; 10684Srgrimes int i_size; 10694Srgrimes int i_mode; 1070798Swollman int regmodrm = 0; 10714Srgrimes boolean_t first; 10724Srgrimes int displ; 10734Srgrimes int prefix; 10744Srgrimes int imm; 10754Srgrimes int imm2; 10764Srgrimes int len; 10774Srgrimes struct i_addr address; 10784Srgrimes 10794Srgrimes get_value_inc(inst, loc, 1, FALSE); 10804Srgrimes short_addr = FALSE; 10814Srgrimes size = LONG; 10824Srgrimes seg = 0; 10834Srgrimes 10844Srgrimes /* 10854Srgrimes * Get prefixes 10864Srgrimes */ 10874Srgrimes prefix = TRUE; 10884Srgrimes do { 10894Srgrimes switch (inst) { 10904Srgrimes case 0x66: /* data16 */ 10914Srgrimes size = WORD; 10924Srgrimes break; 10934Srgrimes case 0x67: 10944Srgrimes short_addr = TRUE; 10954Srgrimes break; 10964Srgrimes case 0x26: 10974Srgrimes seg = "%es"; 10984Srgrimes break; 10994Srgrimes case 0x36: 11004Srgrimes seg = "%ss"; 11014Srgrimes break; 11024Srgrimes case 0x2e: 11034Srgrimes seg = "%cs"; 11044Srgrimes break; 11054Srgrimes case 0x3e: 11064Srgrimes seg = "%ds"; 11074Srgrimes break; 11084Srgrimes case 0x64: 11094Srgrimes seg = "%fs"; 11104Srgrimes break; 11114Srgrimes case 0x65: 11124Srgrimes seg = "%gs"; 11134Srgrimes break; 11144Srgrimes case 0xf0: 11154Srgrimes db_printf("lock "); 11164Srgrimes break; 11174Srgrimes case 0xf2: 11184Srgrimes db_printf("repne "); 11194Srgrimes break; 11204Srgrimes case 0xf3: 11214Srgrimes db_printf("repe "); /* XXX repe VS rep */ 11224Srgrimes break; 11234Srgrimes default: 11244Srgrimes prefix = FALSE; 11254Srgrimes break; 11264Srgrimes } 11274Srgrimes if (prefix) { 11284Srgrimes get_value_inc(inst, loc, 1, FALSE); 11294Srgrimes } 11304Srgrimes } while (prefix); 11314Srgrimes 11324Srgrimes if (inst >= 0xd8 && inst <= 0xdf) { 11334Srgrimes loc = db_disasm_esc(loc, inst, short_addr, size, seg); 11344Srgrimes db_printf("\n"); 11354Srgrimes return (loc); 11364Srgrimes } 11374Srgrimes 11384Srgrimes if (inst == 0x0f) { 11394Srgrimes get_value_inc(inst, loc, 1, FALSE); 11404Srgrimes ip = db_inst_0f[inst>>4]; 11414Srgrimes if (ip == 0) { 11424Srgrimes ip = &db_bad_inst; 11434Srgrimes } 11444Srgrimes else { 11454Srgrimes ip = &ip[inst&0xf]; 11464Srgrimes } 11474Srgrimes } 11484Srgrimes else 11494Srgrimes ip = &db_inst_table[inst]; 11504Srgrimes 11514Srgrimes if (ip->i_has_modrm) { 11524Srgrimes get_value_inc(regmodrm, loc, 1, FALSE); 11534Srgrimes loc = db_read_address(loc, short_addr, regmodrm, &address); 11544Srgrimes } 11554Srgrimes 11564Srgrimes i_name = ip->i_name; 11574Srgrimes i_size = ip->i_size; 11584Srgrimes i_mode = ip->i_mode; 11594Srgrimes 11604Srgrimes if (ip->i_extra == (char *)db_Grp1 || 11614Srgrimes ip->i_extra == (char *)db_Grp2 || 11624Srgrimes ip->i_extra == (char *)db_Grp6 || 11634Srgrimes ip->i_extra == (char *)db_Grp7 || 11644Srgrimes ip->i_extra == (char *)db_Grp8) { 11654Srgrimes i_name = ((char **)ip->i_extra)[f_reg(regmodrm)]; 11664Srgrimes } 11674Srgrimes else if (ip->i_extra == (char *)db_Grp3) { 11684Srgrimes ip = (struct inst *)ip->i_extra; 11694Srgrimes ip = &ip[f_reg(regmodrm)]; 11704Srgrimes i_name = ip->i_name; 11714Srgrimes i_mode = ip->i_mode; 11724Srgrimes } 11734Srgrimes else if (ip->i_extra == (char *)db_Grp4 || 11744Srgrimes ip->i_extra == (char *)db_Grp5) { 11754Srgrimes ip = (struct inst *)ip->i_extra; 11764Srgrimes ip = &ip[f_reg(regmodrm)]; 11774Srgrimes i_name = ip->i_name; 11784Srgrimes i_mode = ip->i_mode; 11794Srgrimes i_size = ip->i_size; 11804Srgrimes } 11814Srgrimes 11824Srgrimes if (i_size == SDEP) { 11834Srgrimes if (size == WORD) 11844Srgrimes db_printf(i_name); 11854Srgrimes else 11864Srgrimes db_printf(ip->i_extra); 11874Srgrimes } 11884Srgrimes else { 11894Srgrimes db_printf(i_name); 11904Srgrimes if (i_size != NONE) { 11914Srgrimes if (i_size == BYTE) { 11924Srgrimes db_printf("b"); 11934Srgrimes size = BYTE; 11944Srgrimes } 11954Srgrimes else if (i_size == WORD) { 11964Srgrimes db_printf("w"); 11974Srgrimes size = WORD; 11984Srgrimes } 11994Srgrimes else if (size == WORD) 12004Srgrimes db_printf("w"); 12014Srgrimes else 12024Srgrimes db_printf("l"); 12034Srgrimes } 12044Srgrimes } 12054Srgrimes db_printf("\t"); 12064Srgrimes for (first = TRUE; 12074Srgrimes i_mode != 0; 12084Srgrimes i_mode >>= 8, first = FALSE) 12094Srgrimes { 12104Srgrimes if (!first) 12114Srgrimes db_printf(","); 12124Srgrimes 12134Srgrimes switch (i_mode & 0xFF) { 12144Srgrimes 12154Srgrimes case E: 12164Srgrimes db_print_address(seg, size, &address); 12174Srgrimes break; 12184Srgrimes 12194Srgrimes case Eind: 12204Srgrimes db_printf("*"); 12214Srgrimes db_print_address(seg, size, &address); 12224Srgrimes break; 12234Srgrimes 12244Srgrimes case Ew: 12254Srgrimes db_print_address(seg, WORD, &address); 12264Srgrimes break; 12274Srgrimes 12284Srgrimes case Eb: 12294Srgrimes db_print_address(seg, BYTE, &address); 12304Srgrimes break; 12314Srgrimes 12324Srgrimes case R: 12334Srgrimes db_printf("%s", db_reg[size][f_reg(regmodrm)]); 12344Srgrimes break; 12354Srgrimes 12364Srgrimes case Rw: 12374Srgrimes db_printf("%s", db_reg[WORD][f_reg(regmodrm)]); 12384Srgrimes break; 12394Srgrimes 12404Srgrimes case Ri: 12414Srgrimes db_printf("%s", db_reg[size][f_rm(inst)]); 12424Srgrimes break; 12434Srgrimes 12444Srgrimes case S: 12454Srgrimes db_printf("%s", db_seg_reg[f_reg(regmodrm)]); 12464Srgrimes break; 12474Srgrimes 12484Srgrimes case Si: 12494Srgrimes db_printf("%s", db_seg_reg[f_reg(inst)]); 12504Srgrimes break; 12514Srgrimes 12524Srgrimes case A: 12534Srgrimes db_printf("%s", db_reg[size][0]); /* acc */ 12544Srgrimes break; 12554Srgrimes 12564Srgrimes case BX: 12574Srgrimes if (seg) 12584Srgrimes db_printf("%s:", seg); 12594Srgrimes db_printf("(%s)", short_addr ? "%bx" : "%ebx"); 12604Srgrimes break; 12614Srgrimes 12624Srgrimes case CL: 12634Srgrimes db_printf("%%cl"); 12644Srgrimes break; 12654Srgrimes 12664Srgrimes case DX: 12674Srgrimes db_printf("%%dx"); 12684Srgrimes break; 12694Srgrimes 12704Srgrimes case SI: 12714Srgrimes if (seg) 12724Srgrimes db_printf("%s:", seg); 12734Srgrimes db_printf("(%s)", short_addr ? "%si" : "%esi"); 12744Srgrimes break; 12754Srgrimes 12764Srgrimes case DI: 12774Srgrimes db_printf("%%es:(%s)", short_addr ? "%di" : "%edi"); 12784Srgrimes break; 12794Srgrimes 12804Srgrimes case CR: 12814Srgrimes db_printf("%%cr%d", f_reg(regmodrm)); 12824Srgrimes break; 12834Srgrimes 12844Srgrimes case DR: 12854Srgrimes db_printf("%%dr%d", f_reg(regmodrm)); 12864Srgrimes break; 12874Srgrimes 12884Srgrimes case TR: 12894Srgrimes db_printf("%%tr%d", f_reg(regmodrm)); 12904Srgrimes break; 12914Srgrimes 12924Srgrimes case I: 12934Srgrimes len = db_lengths[size]; 12944Srgrimes get_value_inc(imm, loc, len, FALSE);/* unsigned */ 12954Srgrimes db_printf("$%#n", imm); 12964Srgrimes break; 12974Srgrimes 12984Srgrimes case Is: 12994Srgrimes len = db_lengths[size]; 13004Srgrimes get_value_inc(imm, loc, len, TRUE); /* signed */ 13014Srgrimes db_printf("$%#r", imm); 13024Srgrimes break; 13034Srgrimes 13044Srgrimes case Ib: 13054Srgrimes get_value_inc(imm, loc, 1, FALSE); /* unsigned */ 13064Srgrimes db_printf("$%#n", imm); 13074Srgrimes break; 13084Srgrimes 13094Srgrimes case Ibs: 13104Srgrimes get_value_inc(imm, loc, 1, TRUE); /* signed */ 13114Srgrimes db_printf("$%#r", imm); 13124Srgrimes break; 13134Srgrimes 13144Srgrimes case Iw: 13154Srgrimes get_value_inc(imm, loc, 2, FALSE); /* unsigned */ 13164Srgrimes db_printf("$%#n", imm); 13174Srgrimes break; 13184Srgrimes 13194Srgrimes case Il: 13204Srgrimes get_value_inc(imm, loc, 4, FALSE); 13214Srgrimes db_printf("$%#n", imm); 13224Srgrimes break; 13234Srgrimes 13244Srgrimes case O: 13254Srgrimes if (short_addr) { 13264Srgrimes get_value_inc(displ, loc, 2, TRUE); 13274Srgrimes } 13284Srgrimes else { 13294Srgrimes get_value_inc(displ, loc, 4, TRUE); 13304Srgrimes } 13314Srgrimes if (seg) 13324Srgrimes db_printf("%s:%#r",seg, displ); 13334Srgrimes else 13344Srgrimes db_printsym((db_addr_t)displ, DB_STGY_ANY); 13354Srgrimes break; 13364Srgrimes 13374Srgrimes case Db: 13384Srgrimes get_value_inc(displ, loc, 1, TRUE); 13394Srgrimes db_printsym((db_addr_t)(displ + loc), DB_STGY_XTRN); 13404Srgrimes break; 13414Srgrimes 13424Srgrimes case Dl: 13434Srgrimes get_value_inc(displ, loc, 4, TRUE); 13444Srgrimes db_printsym((db_addr_t)(displ + loc), DB_STGY_XTRN); 13454Srgrimes break; 13464Srgrimes 13474Srgrimes case o1: 13484Srgrimes db_printf("$1"); 13494Srgrimes break; 13504Srgrimes 13514Srgrimes case o3: 13524Srgrimes db_printf("$3"); 13534Srgrimes break; 13544Srgrimes 13554Srgrimes case OS: 13564Srgrimes get_value_inc(imm, loc, 4, FALSE); /* offset */ 13574Srgrimes get_value_inc(imm2, loc, 2, FALSE); /* segment */ 13584Srgrimes db_printf("$%#n,%#n", imm2, imm); 13594Srgrimes break; 13604Srgrimes } 13614Srgrimes } 13624Srgrimes 13634Srgrimes if (altfmt == 0) { 13644Srgrimes if (inst == 0xe9 || inst == 0xeb) { 13654Srgrimes /* 13664Srgrimes * GAS pads to longword boundary after unconditional jumps. 13674Srgrimes */ 13684Srgrimes loc = (loc + (4-1)) & ~(4-1); 13694Srgrimes } 13704Srgrimes } 13714Srgrimes db_printf("\n"); 13724Srgrimes return (loc); 13734Srgrimes} 13744Srgrimes 1375