Annotation of sys/arch/i386/i386/db_disasm.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 31:
! 32: /*
! 33: * Instruction disassembler.
! 34: */
! 35: #include <sys/param.h>
! 36: #include <sys/proc.h>
! 37: #include <machine/db_machdep.h>
! 38:
! 39: #include <ddb/db_access.h>
! 40: #include <ddb/db_sym.h>
! 41: #include <ddb/db_output.h>
! 42: #include <ddb/db_interface.h>
! 43:
! 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
! 56:
! 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 */
! 96:
! 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: };
! 104:
! 105: #define op1(x) (x)
! 106: #define op2(x,y) ((x)|((y)<<8))
! 107: #define op3(x,y,z) ((x)|((y)<<8)|((z)<<16))
! 108:
! 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: };
! 116:
! 117: char * db_Grp6[] = {
! 118: "sldt", "str", "lldt", "ltr",
! 119: "verr", "verw", "", ""
! 120: };
! 121:
! 122: char * db_Grp7[] = {
! 123: "sgdt", "sidt", "lgdt", "lidt",
! 124: "smsw", "", "lmsw", "invlpg"
! 125: };
! 126:
! 127: char * db_Grp8[] = {
! 128: "", "", "", "",
! 129: "bt", "bts", "btr", "btc"
! 130: };
! 131:
! 132: char * db_Grp9[] = {
! 133: "fxsave", "fxrstor", "", "",
! 134: "", "", "", ""
! 135: };
! 136:
! 137: char * db_GrpA[] = {
! 138: "", "cmpxchg8b", "", "",
! 139: "", "", "", ""
! 140: };
! 141:
! 142: char * db_GrpB[] = {
! 143: "xstore-rng", "xcrypt-ecb", "xcrypt-cbc", "xcrypt-ctr",
! 144: "xcrypt-cfb", "xcrypt-ofb", "", ""
! 145: };
! 146:
! 147: char * db_GrpC[] = {
! 148: "montmul", "xsha1", "xsha256", "",
! 149: "", "", "", ""
! 150: };
! 151:
! 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 },
! 161:
! 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: };
! 171:
! 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 },
! 181:
! 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: };
! 191:
! 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 },
! 201:
! 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: };
! 211:
! 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 },
! 221:
! 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: };
! 231:
! 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 },
! 241:
! 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: };
! 251:
! 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 },
! 261:
! 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: };
! 271:
! 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 },
! 281:
! 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: };
! 291:
! 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 },
! 301:
! 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: };
! 311:
! 312: struct inst *db_inst_0f[] = {
! 313: db_inst_0f0x,
! 314: NULL,
! 315: db_inst_0f2x,
! 316: db_inst_0f3x,
! 317: NULL,
! 318: NULL,
! 319: NULL,
! 320: NULL,
! 321: db_inst_0f8x,
! 322: db_inst_0f9x,
! 323: db_inst_0fax,
! 324: db_inst_0fbx,
! 325: db_inst_0fcx,
! 326: NULL,
! 327: NULL,
! 328: NULL
! 329: };
! 330:
! 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: };
! 351:
! 352: char * db_Esca5[] = {
! 353: "", "fucompp", "", "",
! 354: "", "", "", ""
! 355: };
! 356:
! 357: char * db_Escb4[] = {
! 358: "fneni", "fndisi", "fnclex", "fninit",
! 359: "fsetpm", "", "", ""
! 360: };
! 361:
! 362: char * db_Esce3[] = {
! 363: "", "fcompp", "", "",
! 364: "", "", "", ""
! 365: };
! 366:
! 367: char * db_Escf4[] = {
! 368: "fnstsw", "", "", "",
! 369: "", "", "", ""
! 370: };
! 371:
! 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: };
! 382:
! 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: };
! 393:
! 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: };
! 404:
! 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: };
! 415:
! 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: };
! 426:
! 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: };
! 437:
! 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: };
! 448:
! 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: };
! 459:
! 460: struct finst *db_Esc_inst[] = {
! 461: db_Esc8, db_Esc9, db_Esca, db_Escb,
! 462: db_Escc, db_Escd, db_Esce, db_Escf
! 463: };
! 464:
! 465: char * db_Grp1[] = {
! 466: "add",
! 467: "or",
! 468: "adc",
! 469: "sbb",
! 470: "and",
! 471: "sub",
! 472: "xor",
! 473: "cmp"
! 474: };
! 475:
! 476: char * db_Grp2[] = {
! 477: "rol",
! 478: "ror",
! 479: "rcl",
! 480: "rcr",
! 481: "shl",
! 482: "shr",
! 483: "shl",
! 484: "sar"
! 485: };
! 486:
! 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: };
! 497:
! 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: };
! 508:
! 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: };
! 519:
! 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 },
! 529:
! 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 },
! 538:
! 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 },
! 547:
! 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 },
! 556:
! 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 },
! 565:
! 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 },
! 574:
! 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 },
! 583:
! 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 },
! 592:
! 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 },
! 601:
! 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 },
! 610:
! 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 },
! 619:
! 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 },
! 628:
! 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 },
! 637:
! 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 },
! 646:
! 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 },
! 655:
! 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 },
! 664:
! 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 },
! 673:
! 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 },
! 682:
! 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 },
! 691:
! 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 },
! 700:
! 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 },
! 709:
! 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 },
! 718:
! 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 },
! 727:
! 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 },
! 736:
! 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 },
! 745:
! 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 },
! 754:
! 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 },
! 763:
! 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 },
! 772:
! 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 },
! 781:
! 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 },
! 790:
! 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 },
! 799:
! 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: };
! 809:
! 810: struct inst db_bad_inst =
! 811: { "???", FALSE, NONE, 0, 0 }
! 812: ;
! 813:
! 814: #define f_mod(byte) ((byte)>>6)
! 815: #define f_reg(byte) (((byte)>>3)&0x7)
! 816: #define f_rm(byte) ((byte)&0x7)
! 817:
! 818: #define sib_ss(byte) ((byte)>>6)
! 819: #define sib_index(byte) (((byte)>>3)&0x7)
! 820: #define sib_base(byte) ((byte)&0x7)
! 821:
! 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: };
! 829:
! 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: };
! 840:
! 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: };
! 846:
! 847: char * db_seg_reg[8] = {
! 848: "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "", ""
! 849: };
! 850:
! 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: };
! 863:
! 864: #define get_value_inc(result, loc, size, is_signed) \
! 865: do { \
! 866: result = db_get_value((loc), (size), (is_signed)); \
! 867: (loc) += (size); \
! 868: } while (0)
! 869:
! 870:
! 871: db_addr_t db_read_address(db_addr_t, int, int, struct i_addr *);
! 872: void db_print_address(char *, int, struct i_addr *);
! 873: db_addr_t db_disasm_esc(db_addr_t, int, int, int, char *);
! 874:
! 875: /*
! 876: * Read address at location and return updated location.
! 877: */
! 878: db_addr_t
! 879: 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;
! 883:
! 884: mod = f_mod(regmodrm);
! 885: rm = f_rm(regmodrm);
! 886:
! 887: if (mod == 3) {
! 888: addrp->is_reg = TRUE;
! 889: addrp->disp = rm;
! 890: return (loc);
! 891: }
! 892: addrp->is_reg = FALSE;
! 893: addrp->index = 0;
! 894:
! 895: if (short_addr) {
! 896: addrp->index = 0;
! 897: addrp->ss = 0;
! 898: switch (mod) {
! 899: case 0:
! 900: if (rm == 6) {
! 901: get_value_inc(disp, loc, 2, FALSE);
! 902: addrp->disp = disp;
! 903: addrp->base = 0;
! 904: } else {
! 905: addrp->disp = 0;
! 906: addrp->base = db_index_reg_16[rm];
! 907: }
! 908: break;
! 909: case 1:
! 910: get_value_inc(disp, loc, 1, TRUE);
! 911: disp &= 0xffff;
! 912: addrp->disp = disp;
! 913: addrp->base = db_index_reg_16[rm];
! 914: break;
! 915: case 2:
! 916: get_value_inc(disp, loc, 2, FALSE);
! 917: addrp->disp = disp;
! 918: addrp->base = db_index_reg_16[rm];
! 919: break;
! 920: }
! 921: } else {
! 922: if (rm == 4) {
! 923: get_value_inc(sib, loc, 1, FALSE);
! 924: rm = sib_base(sib);
! 925: index = sib_index(sib);
! 926: if (index != 4)
! 927: addrp->index = db_reg[LONG][index];
! 928: addrp->ss = sib_ss(sib);
! 929: }
! 930:
! 931: switch (mod) {
! 932: case 0:
! 933: if (rm == 5) {
! 934: get_value_inc(addrp->disp, loc, 4, FALSE);
! 935: addrp->base = 0;
! 936: } else {
! 937: addrp->disp = 0;
! 938: addrp->base = db_reg[LONG][rm];
! 939: }
! 940: break;
! 941: case 1:
! 942: get_value_inc(disp, loc, 1, TRUE);
! 943: addrp->disp = disp;
! 944: addrp->base = db_reg[LONG][rm];
! 945: break;
! 946: case 2:
! 947: get_value_inc(disp, loc, 4, FALSE);
! 948: addrp->disp = disp;
! 949: addrp->base = db_reg[LONG][rm];
! 950: break;
! 951: }
! 952: }
! 953: return (loc);
! 954: }
! 955:
! 956: void
! 957: db_print_address(char *seg, int size, struct i_addr *addrp)
! 958: {
! 959: if (addrp->is_reg) {
! 960: db_printf("%s", db_reg[size][addrp->disp]);
! 961: return;
! 962: }
! 963:
! 964: if (seg)
! 965: db_printf("%s:", seg);
! 966:
! 967: db_printsym((db_addr_t)addrp->disp, DB_STGY_ANY, db_printf);
! 968: if (addrp->base != 0 || addrp->index != 0) {
! 969: db_printf("(");
! 970: if (addrp->base)
! 971: db_printf("%s", addrp->base);
! 972: if (addrp->index)
! 973: db_printf(",%s,%d", addrp->index, 1<<addrp->ss);
! 974: db_printf(")");
! 975: }
! 976: }
! 977:
! 978: /*
! 979: * Disassemble floating-point ("escape") instruction
! 980: * and return updated location.
! 981: */
! 982: db_addr_t
! 983: 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;
! 990:
! 991: get_value_inc(regmodrm, loc, 1, FALSE);
! 992: fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm)];
! 993: mod = f_mod(regmodrm);
! 994: if (mod != 3) {
! 995: if (*fp->f_name == '\0') {
! 996: db_printf("<bad instruction>");
! 997: return (loc);
! 998: }
! 999:
! 1000: /*
! 1001: * Normal address modes.
! 1002: */
! 1003: loc = db_read_address(loc, short_addr, regmodrm, &address);
! 1004: db_printf(fp->f_name);
! 1005: switch(fp->f_size) {
! 1006: case SNGL:
! 1007: db_printf("s");
! 1008: break;
! 1009: case DBLR:
! 1010: db_printf("l");
! 1011: break;
! 1012: case EXTR:
! 1013: db_printf("t");
! 1014: break;
! 1015: case WORD:
! 1016: db_printf("s");
! 1017: break;
! 1018: case LONG:
! 1019: db_printf("l");
! 1020: break;
! 1021: case QUAD:
! 1022: db_printf("q");
! 1023: break;
! 1024: default:
! 1025: break;
! 1026: }
! 1027: db_printf("\t");
! 1028: 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):
! 1035: name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
! 1036: db_printf("%s\t%%st,%%st(%d)",name,f_rm(regmodrm));
! 1037: break;
! 1038: case op2(STI,ST):
! 1039: name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
! 1040: db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm));
! 1041: break;
! 1042: case op1(STI):
! 1043: name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
! 1044: db_printf("%s\t%%st(%d)",name, f_rm(regmodrm));
! 1045: break;
! 1046: case op1(X):
! 1047: name = ((char * const *)fp->f_rrname)[f_rm(regmodrm)];
! 1048: if (*name == '\0')
! 1049: goto bad;
! 1050: db_printf("%s", name);
! 1051: break;
! 1052: case op1(XA):
! 1053: name = ((char * const *)fp->f_rrname)[f_rm(regmodrm)];
! 1054: if (*name == '\0')
! 1055: goto bad;
! 1056: db_printf("%s\t%%ax", name);
! 1057: break;
! 1058: default:
! 1059: bad:
! 1060: db_printf("<bad instruction>");
! 1061: break;
! 1062: }
! 1063: }
! 1064:
! 1065: return (loc);
! 1066: }
! 1067:
! 1068: /*
! 1069: * Disassemble instruction at 'loc'. 'altfmt' specifies an
! 1070: * (optional) alternate format. Return address of start of
! 1071: * next instruction.
! 1072: */
! 1073: db_addr_t
! 1074: 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;
! 1085: boolean_t first;
! 1086: int displ;
! 1087: int prefix;
! 1088: int imm;
! 1089: int imm2;
! 1090: int len;
! 1091: struct i_addr address;
! 1092:
! 1093: get_value_inc(inst, loc, 1, FALSE);
! 1094: short_addr = FALSE;
! 1095: size = LONG;
! 1096: seg = 0;
! 1097:
! 1098: /*
! 1099: * Get prefixes
! 1100: */
! 1101: prefix = TRUE;
! 1102: do {
! 1103: switch (inst) {
! 1104: case 0x66: /* data16 */
! 1105: size = WORD;
! 1106: break;
! 1107: case 0x67:
! 1108: short_addr = TRUE;
! 1109: break;
! 1110: case 0x26:
! 1111: seg = "%es";
! 1112: break;
! 1113: case 0x36:
! 1114: seg = "%ss";
! 1115: break;
! 1116: case 0x2e:
! 1117: seg = "%cs";
! 1118: break;
! 1119: case 0x3e:
! 1120: seg = "%ds";
! 1121: break;
! 1122: case 0x64:
! 1123: seg = "%fs";
! 1124: break;
! 1125: case 0x65:
! 1126: seg = "%gs";
! 1127: break;
! 1128: case 0xf0:
! 1129: db_printf("lock ");
! 1130: break;
! 1131: case 0xf2:
! 1132: db_printf("repne ");
! 1133: break;
! 1134: case 0xf3:
! 1135: db_printf("repe "); /* XXX repe VS rep */
! 1136: break;
! 1137: default:
! 1138: prefix = FALSE;
! 1139: break;
! 1140: }
! 1141: if (prefix)
! 1142: get_value_inc(inst, loc, 1, FALSE);
! 1143: } while (prefix);
! 1144:
! 1145: if (inst >= 0xd8 && inst <= 0xdf) {
! 1146: loc = db_disasm_esc(loc, inst, short_addr, size, seg);
! 1147: db_printf("\n");
! 1148: return (loc);
! 1149: }
! 1150:
! 1151: if (inst == 0x0f) {
! 1152: get_value_inc(inst, loc, 1, FALSE);
! 1153: ip = db_inst_0f[inst>>4];
! 1154: if (ip == 0)
! 1155: ip = &db_bad_inst;
! 1156: else
! 1157: ip = &ip[inst&0xf];
! 1158: } else {
! 1159: ip = &db_inst_table[inst];
! 1160: }
! 1161:
! 1162: if (ip->i_has_modrm) {
! 1163: get_value_inc(regmodrm, loc, 1, FALSE);
! 1164: loc = db_read_address(loc, short_addr, regmodrm, &address);
! 1165: }
! 1166:
! 1167: i_name = ip->i_name;
! 1168: i_size = ip->i_size;
! 1169: i_mode = ip->i_mode;
! 1170:
! 1171: if (ip->i_extra == db_Grp1 || ip->i_extra == db_Grp2 ||
! 1172: ip->i_extra == db_Grp6 || ip->i_extra == db_Grp7 ||
! 1173: ip->i_extra == db_Grp8 || ip->i_extra == db_Grp9 ||
! 1174: ip->i_extra == db_GrpA || ip->i_extra == db_GrpB ||
! 1175: ip->i_extra == db_GrpC) {
! 1176: i_name = ((char **)ip->i_extra)[f_reg(regmodrm)];
! 1177: } else if (ip->i_extra == db_Grp3) {
! 1178: ip = (struct inst *)ip->i_extra;
! 1179: ip = &ip[f_reg(regmodrm)];
! 1180: i_name = ip->i_name;
! 1181: i_mode = ip->i_mode;
! 1182: } else if (ip->i_extra == db_Grp4 || ip->i_extra == db_Grp5) {
! 1183: ip = (struct inst *)ip->i_extra;
! 1184: ip = &ip[f_reg(regmodrm)];
! 1185: i_name = ip->i_name;
! 1186: i_mode = ip->i_mode;
! 1187: i_size = ip->i_size;
! 1188: }
! 1189:
! 1190: if (i_size == SDEP) {
! 1191: if (size == WORD)
! 1192: db_printf("%s", i_name);
! 1193: else
! 1194: db_printf("%s", ip->i_extra);
! 1195: } else {
! 1196: db_printf("%s", i_name);
! 1197: if (i_size != NONE) {
! 1198: if (i_size == BYTE) {
! 1199: db_printf("b");
! 1200: size = BYTE;
! 1201: } else if (i_size == WORD) {
! 1202: db_printf("w");
! 1203: size = WORD;
! 1204: } else if (size == WORD) {
! 1205: db_printf("w");
! 1206: } else {
! 1207: db_printf("l");
! 1208: }
! 1209: }
! 1210: }
! 1211: db_printf("\t");
! 1212: for (first = TRUE;
! 1213: i_mode != 0;
! 1214: i_mode >>= 8, first = FALSE) {
! 1215: if (!first)
! 1216: db_printf(",");
! 1217:
! 1218: switch (i_mode & 0xFF) {
! 1219: case E:
! 1220: db_print_address(seg, size, &address);
! 1221: break;
! 1222: case Eind:
! 1223: db_printf("*");
! 1224: db_print_address(seg, size, &address);
! 1225: break;
! 1226: case El:
! 1227: db_print_address(seg, LONG, &address);
! 1228: break;
! 1229: case Ew:
! 1230: db_print_address(seg, WORD, &address);
! 1231: break;
! 1232: case Eb:
! 1233: db_print_address(seg, BYTE, &address);
! 1234: break;
! 1235: case R:
! 1236: db_printf("%s", db_reg[size][f_reg(regmodrm)]);
! 1237: break;
! 1238: case Rw:
! 1239: db_printf("%s", db_reg[WORD][f_reg(regmodrm)]);
! 1240: break;
! 1241: case Ri:
! 1242: db_printf("%s", db_reg[size][f_rm(inst)]);
! 1243: break;
! 1244: case Ril:
! 1245: db_printf("%s", db_reg[LONG][f_rm(inst)]);
! 1246: break;
! 1247: case S:
! 1248: db_printf("%s", db_seg_reg[f_reg(regmodrm)]);
! 1249: break;
! 1250: case Si:
! 1251: db_printf("%s", db_seg_reg[f_reg(inst)]);
! 1252: break;
! 1253: case A:
! 1254: db_printf("%s", db_reg[size][0]); /* acc */
! 1255: break;
! 1256: case BX:
! 1257: if (seg)
! 1258: db_printf("%s:", seg);
! 1259: db_printf("(%s)", short_addr ? "%bx" : "%ebx");
! 1260: break;
! 1261: case CL:
! 1262: db_printf("%%cl");
! 1263: break;
! 1264: case DX:
! 1265: db_printf("%%dx");
! 1266: break;
! 1267: case SI:
! 1268: if (seg)
! 1269: db_printf("%s:", seg);
! 1270: db_printf("(%s)", short_addr ? "%si" : "%esi");
! 1271: break;
! 1272: case DI:
! 1273: db_printf("%%es:(%s)", short_addr ? "%di" : "%edi");
! 1274: break;
! 1275: case CR:
! 1276: db_printf("%%cr%d", f_reg(regmodrm));
! 1277: break;
! 1278: case DR:
! 1279: db_printf("%%dr%d", f_reg(regmodrm));
! 1280: break;
! 1281: case TR:
! 1282: db_printf("%%tr%d", f_reg(regmodrm));
! 1283: break;
! 1284: case I:
! 1285: len = db_lengths[size];
! 1286: get_value_inc(imm, loc, len, FALSE);
! 1287: db_printf("$%#n", imm);
! 1288: break;
! 1289: case Is:
! 1290: len = db_lengths[size];
! 1291: get_value_inc(imm, loc, len, TRUE);
! 1292: db_printf("$%#r", imm);
! 1293: break;
! 1294: case Ib:
! 1295: get_value_inc(imm, loc, 1, FALSE);
! 1296: db_printf("$%#n", imm);
! 1297: break;
! 1298: case Iba:
! 1299: get_value_inc(imm, loc, 1, FALSE);
! 1300: if (imm != 0x0a)
! 1301: db_printf("$%#n", imm);
! 1302: break;
! 1303: case Ibs:
! 1304: get_value_inc(imm, loc, 1, TRUE);
! 1305: if (size == WORD)
! 1306: imm &= 0xFFFF;
! 1307: db_printf("$%#r", imm);
! 1308: break;
! 1309: case Iw:
! 1310: get_value_inc(imm, loc, 2, FALSE);
! 1311: db_printf("$%#n", imm);
! 1312: break;
! 1313: case O:
! 1314: if (short_addr)
! 1315: get_value_inc(displ, loc, 2, TRUE);
! 1316: else
! 1317: get_value_inc(displ, loc, 4, TRUE);
! 1318: if (seg)
! 1319: db_printf("%s:%#r",seg, displ);
! 1320: else
! 1321: db_printsym((db_addr_t)displ, DB_STGY_ANY,
! 1322: db_printf);
! 1323: break;
! 1324: case Db:
! 1325: get_value_inc(displ, loc, 1, TRUE);
! 1326: displ += loc;
! 1327: if (size == WORD)
! 1328: displ &= 0xFFFF;
! 1329: db_printsym((db_addr_t)displ, DB_STGY_XTRN, db_printf);
! 1330: break;
! 1331: case Dl:
! 1332: len = db_lengths[size];
! 1333: get_value_inc(displ, loc, len, FALSE);
! 1334: displ += loc;
! 1335: if (size == WORD)
! 1336: displ &= 0xFFFF;
! 1337: db_printsym((db_addr_t)displ, DB_STGY_XTRN, db_printf);
! 1338: break;
! 1339: case o1:
! 1340: db_printf("$1");
! 1341: break;
! 1342: case o3:
! 1343: db_printf("$3");
! 1344: break;
! 1345: case OS:
! 1346: get_value_inc(imm, loc, len, FALSE); /* offset */
! 1347: get_value_inc(imm2, loc, 2, FALSE); /* segment */
! 1348: db_printf("$%#n,%#n", imm2, imm);
! 1349: break;
! 1350: }
! 1351: }
! 1352:
! 1353: if (altfmt == 0 && (inst == 0xe9 || inst == 0xeb)) {
! 1354: /*
! 1355: * GAS pads to longword boundary after unconditional jumps.
! 1356: */
! 1357: loc = (loc + (4-1)) & ~(4-1);
! 1358: }
! 1359: db_printf("\n");
! 1360: return (loc);
! 1361: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to db_disasm.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / i386 / i386