sys/src/libmach/8db.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <mach.h>
   5
   6 /*
   7  * i386-specific debugger interface
   8  * also amd64 extensions
   9  */
  10
  11 static  char    *i386excep(Map*, Rgetter);
  12
  13 static  int     i386trace(Map*, uvlong, uvlong, uvlong, Tracer);
  14 static  uvlong  i386frame(Map*, uvlong, uvlong, uvlong, uvlong);
  15 static  int     i386foll(Map*, uvlong, Rgetter, uvlong*);
  16 static  int     i386inst(Map*, uvlong, char, char*, int);
  17 static  int     i386das(Map*, uvlong, char*, int);
  18 static  int     i386instlen(Map*, uvlong);
  19
  20 static  char    STARTSYM[] =    "_main";
  21 static  char    PROFSYM[] =     "_mainp";
  22 static  char    FRAMENAME[] =   ".frame";
  23 static char *excname[] =
  24 {
  25 [0]     "divide error",
  26 [1]     "debug exception",
  27 [4]     "overflow",
  28 [5]     "bounds check",
  29 [6]     "invalid opcode",
  30 [7]     "math coprocessor emulation",
  31 [8]     "double fault",
  32 [9]     "math coprocessor overrun",
  33 [10]    "invalid TSS",
  34 [11]    "segment not present",
  35 [12]    "stack exception",
  36 [13]    "general protection violation",
  37 [14]    "page fault",
  38 [16]    "math coprocessor error",
  39 [17]    "alignment check",
  40 [18]    "machine check",
  41 [19]    "floating-point exception",
  42 [24]    "clock",
  43 [25]    "keyboard",
  44 [27]    "modem status",
  45 [28]    "serial line status",
  46 [30]    "floppy disk",
  47 [36]    "mouse",
  48 [37]    "math coprocessor",
  49 [38]    "hard disk",
  50 [64]    "system call",
  51 };
  52
  53 Machdata i386mach =
  54 {
  55         {0xCC, 0, 0, 0},        /* break point: INT 3 */
  56         1,                      /* break point size */
  57
  58         leswab,                 /* convert short to local byte order */
  59         leswal,                 /* convert long to local byte order */
  60         leswav,                 /* convert vlong to local byte order */
  61         i386trace,              /* C traceback */
  62         i386frame,              /* frame finder */
  63         i386excep,              /* print exception */
  64         0,                      /* breakpoint fixup */
  65         leieeesftos,            /* single precision float printer */
  66         leieeedftos,            /* double precision float printer */
  67         i386foll,               /* following addresses */
  68         i386inst,               /* print instruction */
  69         i386das,                /* dissembler */
  70         i386instlen,            /* instruction size calculation */
  71 };
  72
  73 static char*
  74 i386excep(Map *map, Rgetter rget)
  75 {
  76         ulong c;
  77         uvlong pc;
  78         static char buf[16];
  79
  80         c = (*rget)(map, "TRAP");
  81         if(c > 64 || excname[c] == 0) {
  82                 if (c == 3) {
  83                         pc = (*rget)(map, "PC");
  84                         if (get1(map, pc, (uchar*)buf, machdata->bpsize) > 0)
  85                         if (memcmp(buf, machdata->bpinst, machdata->bpsize) == 0)
  86                                 return "breakpoint";
  87                 }
  88                 snprint(buf, sizeof(buf), "exception %ld", c);
  89                 return buf;
  90         } else
  91                 return excname[c];
  92 }
  93
  94 static int
  95 i386trace(Map *map, uvlong pc, uvlong sp, uvlong link, Tracer trace)
  96 {
  97         int i;
  98         uvlong osp;
  99         Symbol s, f;
 100
 101         USED(link);
 102         i = 0;
 103         osp = 0;
 104         while(findsym(pc, CTEXT, &s)) {
 105                 if (osp == sp)
 106                         break;
 107                 osp = sp;
 108
 109                 if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
 110                         break;
 111
 112                 if(pc != s.value) {     /* not at first instruction */
 113                         if(findlocal(&s, FRAMENAME, &f) == 0)
 114                                 break;
 115                         sp += f.value-mach->szaddr;
 116                 }
 117
 118                 if (geta(map, sp, &pc) < 0)
 119                         break;
 120
 121                 if(pc == 0)
 122                         break;
 123
 124                 (*trace)(map, pc, sp, &s);
 125                 sp += mach->szaddr;
 126
 127                 if(++i > 1000)
 128                         break;
 129         }
 130         return i;
 131 }
 132
 133 static uvlong
 134 i386frame(Map *map, uvlong addr, uvlong pc, uvlong sp, uvlong link)
 135 {
 136         Symbol s, f;
 137
 138         USED(link);
 139         while (findsym(pc, CTEXT, &s)) {
 140                 if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
 141                         break;
 142
 143                 if(pc != s.value) {     /* not first instruction */
 144                         if(findlocal(&s, FRAMENAME, &f) == 0)
 145                                 break;
 146                         sp += f.value-mach->szaddr;
 147                 }
 148
 149                 if (s.value == addr)
 150                         return sp;
 151
 152                 if (geta(map, sp, &pc) < 0)
 153                         break;
 154                 sp += mach->szaddr;
 155         }
 156         return 0;
 157 }
 158
 159         /* I386/486 - Disassembler and related functions */
 160
 161 /*
 162  *  an instruction
 163  */
 164 typedef struct Instr Instr;
 165 struct  Instr
 166 {
 167         uchar   mem[1+1+1+1+2+1+1+4+4];         /* raw instruction */
 168         uvlong  addr;           /* address of start of instruction */
 169         int     n;              /* number of bytes in instruction */
 170         char    *prefix;        /* instr prefix */
 171         char    *segment;       /* segment override */
 172         uchar   jumptype;       /* set to the operand type for jump/ret/call */
 173         uchar   amd64;
 174         uchar   rex;            /* REX prefix (or zero) */
 175         char    osize;          /* 'W' or 'L' (or 'Q' on amd64) */
 176         char    asize;          /* address size 'W' or 'L' (or 'Q' or amd64) */
 177         uchar   mod;            /* bits 6-7 of mod r/m field */
 178         uchar   reg;            /* bits 3-5 of mod r/m field */
 179         char    ss;             /* bits 6-7 of SIB */
 180         char    index;          /* bits 3-5 of SIB */
 181         char    base;           /* bits 0-2 of SIB */
 182         char    rip;            /* RIP-relative in amd64 mode */
 183         uchar   opre;           /* f2/f3 could introduce media */
 184         short   seg;            /* segment of far address */
 185         ulong   disp;           /* displacement */
 186         ulong   imm;            /* immediate */
 187         ulong   imm2;           /* second immediate operand */
 188         uvlong  imm64;          /* big immediate */
 189         char    *curr;          /* fill level in output buffer */
 190         char    *end;           /* end of output buffer */
 191         char    *err;           /* error message */
 192 };
 193
 194         /* 386 register (ha!) set */
 195 enum{
 196         AX=0,
 197         CX,
 198         DX,
 199         BX,
 200         SP,
 201         BP,
 202         SI,
 203         DI,
 204
 205         /* amd64 */
 206         R8,
 207         R9,
 208         R10,
 209         R11,
 210         R12,
 211         R13,
 212         R14,
 213         R15
 214 };
 215
 216         /* amd64 rex extension byte */
 217 enum{
 218         REXW            = 1<<3, /* =1, 64-bit operand size */
 219         REXR            = 1<<2, /* extend modrm reg */
 220         REXX            = 1<<1, /* extend sib index */
 221         REXB            = 1<<0  /* extend modrm r/m, sib base, or opcode reg */
 222 };
 223
 224         /* Operand Format codes */
 225 /*
 226 %A      -       address size register modifier (!asize -> 'E')
 227 %C      -       Control register CR0/CR1/CR2
 228 %D      -       Debug register DR0/DR1/DR2/DR3/DR6/DR7
 229 %I      -       second immediate operand
 230 %O      -       Operand size register modifier (!osize -> 'E')
 231 %T      -       Test register TR6/TR7
 232 %S      -       size code ('W' or 'L')
 233 %W      -       Weird opcode: OSIZE == 'W' => "CBW"; else => "CWDE"
 234 %d      -       displacement 16-32 bits
 235 %e      -       effective address - Mod R/M value
 236 %f      -       floating point register F0-F7 - from Mod R/M register
 237 %g      -       segment register
 238 %i      -       immediate operand 8-32 bits
 239 %p      -       PC-relative - signed displacement in immediate field
 240 %r      -       Reg from Mod R/M
 241 %w      -       Weird opcode: OSIZE == 'W' => "CWD"; else => "CDQ"
 242 */
 243
 244 typedef struct Optable Optable;
 245 struct Optable
 246 {
 247         char    operand[2];
 248         void    *proto;         /* actually either (char*) or (Optable*) */
 249 };
 250         /* Operand decoding codes */
 251 enum {
 252         Ib = 1,                 /* 8-bit immediate - (no sign extension)*/
 253         Ibs,                    /* 8-bit immediate (sign extended) */
 254         Jbs,                    /* 8-bit sign-extended immediate in jump or call */
 255         Iw,                     /* 16-bit immediate -> imm */
 256         Iw2,                    /* 16-bit immediate -> imm2 */
 257         Iwd,                    /* Operand-sized immediate (no sign extension)*/
 258         Iwdq,                   /* Operand-sized immediate, possibly 64 bits */
 259         Awd,                    /* Address offset */
 260         Iwds,                   /* Operand-sized immediate (sign extended) */
 261         RM,                     /* Word or long R/M field with register (/r) */
 262         RMB,                    /* Byte R/M field with register (/r) */
 263         RMOP,                   /* Word or long R/M field with op code (/digit) */
 264         RMOPB,                  /* Byte R/M field with op code (/digit) */
 265         RMR,                    /* R/M register only (mod = 11) */
 266         RMM,                    /* R/M memory only (mod = 0/1/2) */
 267         R0,                     /* Base reg of Mod R/M is literal 0x00 */
 268         R1,                     /* Base reg of Mod R/M is literal 0x01 */
 269         FRMOP,                  /* Floating point R/M field with opcode */
 270         FRMEX,                  /* Extended floating point R/M field with opcode */
 271         JUMP,                   /* Jump or Call flag - no operand */
 272         RET,                    /* Return flag - no operand */
 273         OA,                     /* literal 0x0a byte */
 274         PTR,                    /* Seg:Displacement addr (ptr16:16 or ptr16:32) */
 275         AUX,                    /* Multi-byte op code - Auxiliary table */
 276         AUXMM,                  /* multi-byte op code - auxiliary table chosen by prefix */
 277         PRE,                    /* Instr Prefix */
 278         OPRE,                   /* Instr Prefix or media op extension */
 279         SEG,                    /* Segment Prefix */
 280         OPOVER,                 /* Operand size override */
 281         ADDOVER,                /* Address size override */
 282 };
 283
 284 static Optable optab0F00[8]=
 285 {
 286 [0x00]  0,0,            "MOVW   LDT,%e",
 287 [0x01]  0,0,            "MOVW   TR,%e",
 288 [0x02]  0,0,            "MOVW   %e,LDT",
 289 [0x03]  0,0,            "MOVW   %e,TR",
 290 [0x04]  0,0,            "VERR   %e",
 291 [0x05]  0,0,            "VERW   %e",
 292 };
 293
 294 static Optable optab0F01[8]=
 295 {
 296 [0x00]  0,0,            "MOVL   GDTR,%e",
 297 [0x01]  0,0,            "MOVL   IDTR,%e",
 298 [0x02]  0,0,            "MOVL   %e,GDTR",
 299 [0x03]  0,0,            "MOVL   %e,IDTR",
 300 [0x04]  0,0,            "MOVW   MSW,%e",        /* word */
 301 [0x06]  0,0,            "MOVW   %e,MSW",        /* word */
 302 [0x07]  0,0,            "INVLPG %e",            /* or SWAPGS */
 303 };
 304
 305 static Optable optab0F01F8[1]=
 306 {
 307 [0x00]  0,0,            "SWAPGS",
 308 };
 309
 310 /* 0F71 */
 311 /* 0F72 */
 312 /* 0F73 */
 313
 314 static Optable optab0FAE[8]=
 315 {
 316 [0x00]  0,0,            "FXSAVE %e",
 317 [0x01]  0,0,            "FXRSTOR        %e",
 318 [0x02]  0,0,            "LDMXCSR        %e",
 319 [0x03]  0,0,            "STMXCSR        %e",
 320 [0x05]  0,0,            "LFENCE",
 321 [0x06]  0,0,            "MFENCE",
 322 [0x07]  0,0,            "SFENCE",
 323 };
 324
 325 /* 0F18 */
 326 /* 0F0D */
 327
 328 static Optable optab0FBA[8]=
 329 {
 330 [0x04]  Ib,0,           "BT%S   %i,%e",
 331 [0x05]  Ib,0,           "BTS%S  %i,%e",
 332 [0x06]  Ib,0,           "BTR%S  %i,%e",
 333 [0x07]  Ib,0,           "BTC%S  %i,%e",
 334 };
 335
 336 static Optable optab0F0F[256]=
 337 {
 338 [0x0c]  0,0,            "PI2FW  %m,%M",
 339 [0x0d]  0,0,            "PI2L   %m,%M",
 340 [0x1c]  0,0,            "PF2IW  %m,%M",
 341 [0x1d]  0,0,            "PF2IL  %m,%M",
 342 [0x8a]  0,0,            "PFNACC %m,%M",
 343 [0x8e]  0,0,            "PFPNACC        %m,%M",
 344 [0x90]  0,0,            "PFCMPGE        %m,%M",
 345 [0x94]  0,0,            "PFMIN  %m,%M",
 346 [0x96]  0,0,            "PFRCP  %m,%M",
 347 [0x97]  0,0,            "PFRSQRT        %m,%M",
 348 [0x9a]  0,0,            "PFSUB  %m,%M",
 349 [0x9e]  0,0,            "PFADD  %m,%M",
 350 [0xa0]  0,0,            "PFCMPGT        %m,%M",
 351 [0xa4]  0,0,            "PFMAX  %m,%M",
 352 [0xa6]  0,0,            "PFRCPIT1       %m,%M",
 353 [0xa7]  0,0,            "PFRSQIT1       %m,%M",
 354 [0xaa]  0,0,            "PFSUBR %m,%M",
 355 [0xae]  0,0,            "PFACC  %m,%M",
 356 [0xb0]  0,0,            "PFCMPEQ        %m,%M",
 357 [0xb4]  0,0,            "PFMUL  %m,%M",
 358 [0xb6]  0,0,            "PFRCPI2T       %m,%M",
 359 [0xb7]  0,0,            "PMULHRW        %m,%M",
 360 [0xbb]  0,0,            "PSWAPL %m,%M",
 361 };
 362
 363 static Optable optab0FC7[8]=
 364 {
 365 [0x01]  0,0,            "CMPXCHG8B      %e",
 366 };
 367
 368 static Optable optab660F71[8]=
 369 {
 370 [0x02]  Ib,0,           "PSRLW  %i,%X",
 371 [0x04]  Ib,0,           "PSRAW  %i,%X",
 372 [0x06]  Ib,0,           "PSLLW  %i,%X",
 373 };
 374
 375 static Optable optab660F72[8]=
 376 {
 377 [0x02]  Ib,0,           "PSRLL  %i,%X",
 378 [0x04]  Ib,0,           "PSRAL  %i,%X",
 379 [0x06]  Ib,0,           "PSLLL  %i,%X",
 380 };
 381
 382 static Optable optab660F73[8]=
 383 {
 384 [0x02]  Ib,0,           "PSRLQ  %i,%X",
 385 [0x03]  Ib,0,           "PSRLO  %i,%X",
 386 [0x06]  Ib,0,           "PSLLQ  %i,%X",
 387 [0x07]  Ib,0,           "PSLLO  %i,%X",
 388 };
 389
 390 static Optable optab660F[256]=
 391 {
 392 [0x2B]  RM,0,           "MOVNTPD        %x,%e",
 393 [0x2E]  RM,0,           "UCOMISD        %x,%X",
 394 [0x2F]  RM,0,           "COMISD %x,%X",
 395 [0x5A]  RM,0,           "CVTPD2PS       %x,%X",
 396 [0x5B]  RM,0,           "CVTPS2PL       %x,%X",
 397 [0x6A]  RM,0,           "PUNPCKHLQ %x,%X",
 398 [0x6B]  RM,0,           "PACKSSLW %x,%X",
 399 [0x6C]  RM,0,           "PUNPCKLQDQ %x,%X",
 400 [0x6D]  RM,0,           "PUNPCKHQDQ %x,%X",
 401 [0x6E]  RM,0,           "MOV%S  %e,%X",
 402 [0x6F]  RM,0,           "MOVO   %x,%X",         /* MOVDQA */
 403 [0x70]  RM,Ib,          "PSHUFL %i,%x,%X",
 404 [0x71]  RMOP,0,         optab660F71,
 405 [0x72]  RMOP,0,         optab660F72,
 406 [0x73]  RMOP,0,         optab660F73,
 407 [0x7E]  RM,0,           "MOV%S  %X,%e",
 408 [0x7F]  RM,0,           "MOVO   %X,%x",
 409 [0xC4]  RM,Ib,          "PINSRW %i,%e,%X",
 410 [0xC5]  RMR,Ib,         "PEXTRW %i,%X,%e",
 411 [0xD4]  RM,0,           "PADDQ  %x,%X",
 412 [0xD5]  RM,0,           "PMULLW %x,%X",
 413 [0xD6]  RM,0,           "MOVQ   %X,%x",
 414 [0xE6]  RM,0,           "CVTTPD2PL      %x,%X",
 415 [0xE7]  RM,0,           "MOVNTO %X,%e",
 416 [0xF7]  RM,0,           "MASKMOVOU      %x,%X",
 417 };
 418
 419 static Optable optabF20F[256]=
 420 {
 421 [0x10]  RM,0,           "MOVSD  %x,%X",
 422 [0x11]  RM,0,           "MOVSD  %X,%x",
 423 [0x2A]  RM,0,           "CVTS%S2SD      %e,%X",
 424 [0x2C]  RM,0,           "CVTTSD2S%S     %x,%r",
 425 [0x2D]  RM,0,           "CVTSD2S%S      %x,%r",
 426 [0x5A]  RM,0,           "CVTSD2SS       %x,%X",
 427 [0x6F]  RM,0,           "MOVOU  %x,%X",
 428 [0x70]  RM,Ib,          "PSHUFLW        %i,%x,%X",
 429 [0x7F]  RM,0,           "MOVOU  %X,%x",
 430 [0xD6]  RM,0,           "MOVQOZX        %M,%X",
 431 [0xE6]  RM,0,           "CVTPD2PL       %x,%X",
 432 };
 433
 434 static Optable optabF30F[256]=
 435 {
 436 [0x10]  RM,0,           "MOVSS  %x,%X",
 437 [0x11]  RM,0,           "MOVSS  %X,%x",
 438 [0x2A]  RM,0,           "CVTS%S2SS      %e,%X",
 439 [0x2C]  RM,0,           "CVTTSS2S%S     %x,%r",
 440 [0x2D]  RM,0,           "CVTSS2S%S      %x,%r",
 441 [0x5A]  RM,0,           "CVTSS2SD       %x,%X",
 442 [0x5B]  RM,0,           "CVTTPS2PL      %x,%X",
 443 [0x6F]  RM,0,           "MOVOU  %x,%X",
 444 [0x70]  RM,Ib,          "PSHUFHW        %i,%x,%X",
 445 [0x7E]  RM,0,           "MOVQOZX        %x,%X",
 446 [0x7F]  RM,0,           "MOVOU  %X,%x",
 447 [0xD6]  RM,0,           "MOVQOZX        %m*,%X",
 448 [0xE6]  RM,0,           "CVTPL2PD       %x,%X",
 449 };
 450
 451 static Optable optab0F[256]=
 452 {
 453 [0x00]  RMOP,0,         optab0F00,
 454 [0x01]  RMOP,0,         optab0F01,
 455 [0x02]  RM,0,           "LAR    %e,%r",
 456 [0x03]  RM,0,           "LSL    %e,%r",
 457 [0x05]  0,0,            "SYSCALL",
 458 [0x06]  0,0,            "CLTS",
 459 [0x07]  0,0,            "SYSRET",
 460 [0x08]  0,0,            "INVD",
 461 [0x09]  0,0,            "WBINVD",
 462 [0x0B]  0,0,            "UD2",
 463 [0x0F]  RM,AUX,         optab0F0F,              /* 3DNow! */
 464 [0x10]  RM,0,           "MOVU%s %x,%X",
 465 [0x11]  RM,0,           "MOVU%s %X,%x",
 466 [0x12]  RM,0,           "MOV[H]L%s      %x,%X", /* TO DO: H if source is XMM */
 467 [0x13]  RM,0,           "MOVL%s %X,%e",
 468 [0x14]  RM,0,           "UNPCKL%s       %x,%X",
 469 [0x15]  RM,0,           "UNPCKH%s       %x,%X",
 470 [0x16]  RM,0,           "MOV[L]H%s      %x,%X", /* TO DO: L if source is XMM */
 471 [0x17]  RM,0,           "MOVH%s %X,%x",
 472 [0x20]  RMR,0,          "MOVL   %C,%e",
 473 [0x21]  RMR,0,          "MOVL   %D,%e",
 474 [0x22]  RMR,0,          "MOVL   %e,%C",
 475 [0x23]  RMR,0,          "MOVL   %e,%D",
 476 [0x24]  RMR,0,          "MOVL   %T,%e",
 477 [0x26]  RMR,0,          "MOVL   %e,%T",
 478 [0x28]  RM,0,           "MOVA%s %x,%X",
 479 [0x29]  RM,0,           "MOVA%s %X,%x",
 480 [0x2A]  RM,0,           "CVTPL2%s       %m*,%X",
 481 [0x2B]  RM,0,           "MOVNT%s        %X,%e",
 482 [0x2C]  RM,0,           "CVTT%s2PL      %x,%M",
 483 [0x2D]  RM,0,           "CVT%s2PL       %x,%M",
 484 [0x2E]  RM,0,           "UCOMISS        %x,%X",
 485 [0x2F]  RM,0,           "COMISS %x,%X",
 486 [0x30]  0,0,            "WRMSR",
 487 [0x31]  0,0,            "RDTSC",
 488 [0x32]  0,0,            "RDMSR",
 489 [0x33]  0,0,            "RDPMC",
 490 [0x42]  RM,0,           "CMOVC  %e,%r",         /* CF */
 491 [0x43]  RM,0,           "CMOVNC %e,%r",         /* ¬ CF */
 492 [0x44]  RM,0,           "CMOVZ  %e,%r",         /* ZF */
 493 [0x45]  RM,0,           "CMOVNZ %e,%r",         /* ¬ ZF */
 494 [0x46]  RM,0,           "CMOVBE %e,%r",         /* CF ∨ ZF */
 495 [0x47]  RM,0,           "CMOVA  %e,%r",         /* ¬CF ∧ ¬ZF */
 496 [0x48]  RM,0,           "CMOVS  %e,%r",         /* SF */
 497 [0x49]  RM,0,           "CMOVNS %e,%r",         /* ¬ SF */
 498 [0x4A]  RM,0,           "CMOVP  %e,%r",         /* PF */
 499 [0x4B]  RM,0,           "CMOVNP %e,%r",         /* ¬ PF */
 500 [0x4C]  RM,0,           "CMOVLT %e,%r",         /* LT ≡ OF ≠ SF */
 501 [0x4D]  RM,0,           "CMOVGE %e,%r",         /* GE ≡ ZF ∨ SF */
 502 [0x4E]  RM,0,           "CMOVLE %e,%r",         /* LE ≡ ZF ∨ LT */
 503 [0x4F]  RM,0,           "CMOVGT %e,%r",         /* GT ≡ ¬ZF ∧ GE */
 504 [0x50]  RM,0,           "MOVMSK%s       %X,%r", /* TO DO: check */
 505 [0x51]  RM,0,           "SQRT%s %x,%X",
 506 [0x52]  RM,0,           "RSQRT%s        %x,%X",
 507 [0x53]  RM,0,           "RCP%s  %x,%X",
 508 [0x54]  RM,0,           "AND%s  %x,%X",
 509 [0x55]  RM,0,           "ANDN%s %x,%X",
 510 [0x56]  RM,0,           "OR%s   %x,%X",         /* TO DO: S/D */
 511 [0x57]  RM,0,           "XOR%s  %x,%X",         /* S/D */
 512 [0x58]  RM,0,           "ADD%s  %x,%X",         /* S/P S/D */
 513 [0x59]  RM,0,           "MUL%s  %x,%X",
 514 [0x5A]  RM,0,           "CVTPS2PD       %x,%X",
 515 [0x5B]  RM,0,           "CVTPL2PS       %x,%X",
 516 [0x5C]  RM,0,           "SUB%s  %x,%X",
 517 [0x5D]  RM,0,           "MIN%s  %x,%X",
 518 [0x5E]  RM,0,           "DIV%s  %x,%X",         /* TO DO: S/P S/D */
 519 [0x5F]  RM,0,           "MAX%s  %x,%X",
 520 [0x60]  RM,0,           "PUNPCKLBW %m,%M",
 521 [0x61]  RM,0,           "PUNPCKLWL %m,%M",
 522 [0x62]  RM,0,           "PUNPCKLLQ %m,%M",
 523 [0x63]  RM,0,           "PACKSSWB %m,%M",
 524 [0x64]  RM,0,           "PCMPGTB %m,%M",
 525 [0x65]  RM,0,           "PCMPGTW %m,%M",
 526 [0x66]  RM,0,           "PCMPGTL %m,%M",
 527 [0x67]  RM,0,           "PACKUSWB %m,%M",
 528 [0x68]  RM,0,           "PUNPCKHBW %m,%M",
 529 [0x69]  RM,0,           "PUNPCKHWL %m,%M",
 530 [0x6A]  RM,0,           "PUNPCKHLQ %m,%M",
 531 [0x6B]  RM,0,           "PACKSSLW %m,%M",
 532 [0x6E]  RM,0,           "MOV%S %e,%M",
 533 [0x6F]  RM,0,           "MOVQ %m,%M",
 534 [0x70]  RM,Ib,          "PSHUFW %i,%m,%M",
 535 [0x74]  RM,0,           "PCMPEQB %m,%M",
 536 [0x75]  RM,0,           "PCMPEQW %m,%M",
 537 [0x76]  RM,0,           "PCMPEQL %m,%M",
 538 [0x7E]  RM,0,           "MOV%S %M,%e",
 539 [0x7F]  RM,0,           "MOVQ %M,%m",
 540 [0xAE]  RMOP,0,         optab0FAE,
 541 [0xAA]  0,0,            "RSM",
 542 [0xB0]  RM,0,           "CMPXCHGB       %r,%e",
 543 [0xB1]  RM,0,           "CMPXCHG%S      %r,%e",
 544 [0xC0]  RMB,0,          "XADDB  %r,%e",
 545 [0xC1]  RM,0,           "XADD%S %r,%e",
 546 [0xC2]  RM,Ib,          "CMP%s  %i,%x,%X",
 547 [0xC3]  RM,0,           "MOVNTI%S       %r,%e",
 548 [0xC6]  RM,Ib,          "SHUF%s %i,%x,%X",
 549 [0xC8]  0,0,            "BSWAP  AX",
 550 [0xC9]  0,0,            "BSWAP  CX",
 551 [0xCA]  0,0,            "BSWAP  DX",
 552 [0xCB]  0,0,            "BSWAP  BX",
 553 [0xCC]  0,0,            "BSWAP  SP",
 554 [0xCD]  0,0,            "BSWAP  BP",
 555 [0xCE]  0,0,            "BSWAP  SI",
 556 [0xCF]  0,0,            "BSWAP  DI",
 557 [0xD1]  RM,0,           "PSRLW %m,%M",
 558 [0xD2]  RM,0,           "PSRLL %m,%M",
 559 [0xD3]  RM,0,           "PSRLQ %m,%M",
 560 [0xD5]  RM,0,           "PMULLW %m,%M",
 561 [0xD6]  RM,0,           "MOVQOZX        %m*,%X",
 562 [0xD7]  RM,0,           "PMOVMSKB %m,%r",
 563 [0xD8]  RM,0,           "PSUBUSB %m,%M",
 564 [0xD9]  RM,0,           "PSUBUSW %m,%M",
 565 [0xDA]  RM,0,           "PMINUB %m,%M",
 566 [0xDB]  RM,0,           "PAND %m,%M",
 567 [0xDC]  RM,0,           "PADDUSB %m,%M",
 568 [0xDD]  RM,0,           "PADDUSW %m,%M",
 569 [0xDE]  RM,0,           "PMAXUB %m,%M",
 570 [0xDF]  RM,0,           "PANDN %m,%M",
 571 [0xE0]  RM,0,           "PAVGB %m,%M",
 572 [0xE1]  RM,0,           "PSRAW %m,%M",
 573 [0xE2]  RM,0,           "PSRAL %m,%M",
 574 [0xE3]  RM,0,           "PAVGW %m,%M",
 575 [0xE4]  RM,0,           "PMULHUW %m,%M",
 576 [0xE5]  RM,0,           "PMULHW %m,%M",
 577 [0xE7]  RM,0,           "MOVNTQ %M,%e",
 578 [0xE8]  RM,0,           "PSUBSB %m,%M",
 579 [0xE9]  RM,0,           "PSUBSW %m,%M",
 580 [0xEA]  RM,0,           "PMINSW %m,%M",
 581 [0xEB]  RM,0,           "POR %m,%M",
 582 [0xEC]  RM,0,           "PADDSB %m,%M",
 583 [0xED]  RM,0,           "PADDSW %m,%M",
 584 [0xEE]  RM,0,           "PMAXSW %m,%M",
 585 [0xEF]  RM,0,           "PXOR %m,%M",
 586 [0xF1]  RM,0,           "PSLLW %m,%M",
 587 [0xF2]  RM,0,           "PSLLL %m,%M",
 588 [0xF3]  RM,0,           "PSLLQ %m,%M",
 589 [0xF4]  RM,0,           "PMULULQ        %m,%M",
 590 [0xF5]  RM,0,           "PMADDWL %m,%M",
 591 [0xF6]  RM,0,           "PSADBW %m,%M",
 592 [0xF7]  RMR,0,          "MASKMOVQ       %m,%M",
 593 [0xF8]  RM,0,           "PSUBB %m,%M",
 594 [0xF9]  RM,0,           "PSUBW %m,%M",
 595 [0xFA]  RM,0,           "PSUBL %m,%M",
 596 [0xFC]  RM,0,           "PADDB %m,%M",
 597 [0xFD]  RM,0,           "PADDW %m,%M",
 598 [0xFE]  RM,0,           "PADDL %m,%M",
 599
 600 [0x80]  Iwds,0,         "JOS    %p",
 601 [0x81]  Iwds,0,         "JOC    %p",
 602 [0x82]  Iwds,0,         "JCS    %p",
 603 [0x83]  Iwds,0,         "JCC    %p",
 604 [0x84]  Iwds,0,         "JEQ    %p",
 605 [0x85]  Iwds,0,         "JNE    %p",
 606 [0x86]  Iwds,0,         "JLS    %p",
 607 [0x87]  Iwds,0,         "JHI    %p",
 608 [0x88]  Iwds,0,         "JMI    %p",
 609 [0x89]  Iwds,0,         "JPL    %p",
 610 [0x8a]  Iwds,0,         "JPS    %p",
 611 [0x8b]  Iwds,0,         "JPC    %p",
 612 [0x8c]  Iwds,0,         "JLT    %p",
 613 [0x8d]  Iwds,0,         "JGE    %p",
 614 [0x8e]  Iwds,0,         "JLE    %p",
 615 [0x8f]  Iwds,0,         "JGT    %p",
 616 [0x90]  RMB,0,          "SETOS  %e",
 617 [0x91]  RMB,0,          "SETOC  %e",
 618 [0x92]  RMB,0,          "SETCS  %e",
 619 [0x93]  RMB,0,          "SETCC  %e",
 620 [0x94]  RMB,0,          "SETEQ  %e",
 621 [0x95]  RMB,0,          "SETNE  %e",
 622 [0x96]  RMB,0,          "SETLS  %e",
 623 [0x97]  RMB,0,          "SETHI  %e",
 624 [0x98]  RMB,0,          "SETMI  %e",
 625 [0x99]  RMB,0,          "SETPL  %e",
 626 [0x9a]  RMB,0,          "SETPS  %e",
 627 [0x9b]  RMB,0,          "SETPC  %e",
 628 [0x9c]  RMB,0,          "SETLT  %e",
 629 [0x9d]  RMB,0,          "SETGE  %e",
 630 [0x9e]  RMB,0,          "SETLE  %e",
 631 [0x9f]  RMB,0,          "SETGT  %e",
 632 [0xa0]  0,0,            "PUSHL  FS",
 633 [0xa1]  0,0,            "POPL   FS",
 634 [0xa2]  0,0,            "CPUID",
 635 [0xa3]  RM,0,           "BT%S   %r,%e",
 636 [0xa4]  RM,Ib,          "SHLD%S %r,%i,%e",
 637 [0xa5]  RM,0,           "SHLD%S %r,CL,%e",
 638 [0xa8]  0,0,            "PUSHL  GS",
 639 [0xa9]  0,0,            "POPL   GS",
 640 [0xab]  RM,0,           "BTS%S  %r,%e",
 641 [0xac]  RM,Ib,          "SHRD%S %r,%i,%e",
 642 [0xad]  RM,0,           "SHRD%S %r,CL,%e",
 643 [0xaf]  RM,0,           "IMUL%S %e,%r",
 644 [0xb2]  RMM,0,          "LSS    %e,%r",
 645 [0xb3]  RM,0,           "BTR%S  %r,%e",
 646 [0xb4]  RMM,0,          "LFS    %e,%r",
 647 [0xb5]  RMM,0,          "LGS    %e,%r",
 648 [0xb6]  RMB,0,          "MOVBZX %e,%R",
 649 [0xb7]  RM,0,           "MOVWZX %e,%R",
 650 [0xba]  RMOP,0,         optab0FBA,
 651 [0xbb]  RM,0,           "BTC%S  %e,%r",
 652 [0xbc]  RM,0,           "BSF%S  %e,%r",
 653 [0xbd]  RM,0,           "BSR%S  %e,%r",
 654 [0xbe]  RMB,0,          "MOVBSX %e,%R",
 655 [0xbf]  RM,0,           "MOVWSX %e,%R",
 656 [0xc7]  RMOP,0,         optab0FC7,
 657 };
 658
 659 static Optable optab80[8]=
 660 {
 661 [0x00]  Ib,0,           "ADDB   %i,%e",
 662 [0x01]  Ib,0,           "ORB    %i,%e",
 663 [0x02]  Ib,0,           "ADCB   %i,%e",
 664 [0x03]  Ib,0,           "SBBB   %i,%e",
 665 [0x04]  Ib,0,           "ANDB   %i,%e",
 666 [0x05]  Ib,0,           "SUBB   %i,%e",
 667 [0x06]  Ib,0,           "XORB   %i,%e",
 668 [0x07]  Ib,0,           "CMPB   %e,%i",
 669 };
 670
 671 static Optable optab81[8]=
 672 {
 673 [0x00]  Iwd,0,          "ADD%S  %i,%e",
 674 [0x01]  Iwd,0,          "OR%S   %i,%e",
 675 [0x02]  Iwd,0,          "ADC%S  %i,%e",
 676 [0x03]  Iwd,0,          "SBB%S  %i,%e",
 677 [0x04]  Iwd,0,          "AND%S  %i,%e",
 678 [0x05]  Iwd,0,          "SUB%S  %i,%e",
 679 [0x06]  Iwd,0,          "XOR%S  %i,%e",
 680 [0x07]  Iwd,0,          "CMP%S  %e,%i",
 681 };
 682
 683 static Optable optab83[8]=
 684 {
 685 [0x00]  Ibs,0,          "ADD%S  %i,%e",
 686 [0x01]  Ibs,0,          "OR%S   %i,%e",
 687 [0x02]  Ibs,0,          "ADC%S  %i,%e",
 688 [0x03]  Ibs,0,          "SBB%S  %i,%e",
 689 [0x04]  Ibs,0,          "AND%S  %i,%e",
 690 [0x05]  Ibs,0,          "SUB%S  %i,%e",
 691 [0x06]  Ibs,0,          "XOR%S  %i,%e",
 692 [0x07]  Ibs,0,          "CMP%S  %e,%i",
 693 };
 694
 695 static Optable optabC0[8] =
 696 {
 697 [0x00]  Ib,0,           "ROLB   %i,%e",
 698 [0x01]  Ib,0,           "RORB   %i,%e",
 699 [0x02]  Ib,0,           "RCLB   %i,%e",
 700 [0x03]  Ib,0,           "RCRB   %i,%e",
 701 [0x04]  Ib,0,           "SHLB   %i,%e",
 702 [0x05]  Ib,0,           "SHRB   %i,%e",
 703 [0x07]  Ib,0,           "SARB   %i,%e",
 704 };
 705
 706 static Optable optabC1[8] =
 707 {
 708 [0x00]  Ib,0,           "ROL%S  %i,%e",
 709 [0x01]  Ib,0,           "ROR%S  %i,%e",
 710 [0x02]  Ib,0,           "RCL%S  %i,%e",
 711 [0x03]  Ib,0,           "RCR%S  %i,%e",
 712 [0x04]  Ib,0,           "SHL%S  %i,%e",
 713 [0x05]  Ib,0,           "SHR%S  %i,%e",
 714 [0x07]  Ib,0,           "SAR%S  %i,%e",
 715 };
 716
 717 static Optable optabD0[8] =
 718 {
 719 [0x00]  0,0,            "ROLB   %e",
 720 [0x01]  0,0,            "RORB   %e",
 721 [0x02]  0,0,            "RCLB   %e",
 722 [0x03]  0,0,            "RCRB   %e",
 723 [0x04]  0,0,            "SHLB   %e",
 724 [0x05]  0,0,            "SHRB   %e",
 725 [0x07]  0,0,            "SARB   %e",
 726 };
 727
 728 static Optable optabD1[8] =
 729 {
 730 [0x00]  0,0,            "ROL%S  %e",
 731 [0x01]  0,0,            "ROR%S  %e",
 732 [0x02]  0,0,            "RCL%S  %e",
 733 [0x03]  0,0,            "RCR%S  %e",
 734 [0x04]  0,0,            "SHL%S  %e",
 735 [0x05]  0,0,            "SHR%S  %e",
 736 [0x07]  0,0,            "SAR%S  %e",
 737 };
 738
 739 static Optable optabD2[8] =
 740 {
 741 [0x00]  0,0,            "ROLB   CL,%e",
 742 [0x01]  0,0,            "RORB   CL,%e",
 743 [0x02]  0,0,            "RCLB   CL,%e",
 744 [0x03]  0,0,            "RCRB   CL,%e",
 745 [0x04]  0,0,            "SHLB   CL,%e",
 746 [0x05]  0,0,            "SHRB   CL,%e",
 747 [0x07]  0,0,            "SARB   CL,%e",
 748 };
 749
 750 static Optable optabD3[8] =
 751 {
 752 [0x00]  0,0,            "ROL%S  CL,%e",
 753 [0x01]  0,0,            "ROR%S  CL,%e",
 754 [0x02]  0,0,            "RCL%S  CL,%e",
 755 [0x03]  0,0,            "RCR%S  CL,%e",
 756 [0x04]  0,0,            "SHL%S  CL,%e",
 757 [0x05]  0,0,            "SHR%S  CL,%e",
 758 [0x07]  0,0,            "SAR%S  CL,%e",
 759 };
 760
 761 static Optable optabD8[8+8] =
 762 {
 763 [0x00]  0,0,            "FADDF  %e,F0",
 764 [0x01]  0,0,            "FMULF  %e,F0",
 765 [0x02]  0,0,            "FCOMF  %e,F0",
 766 [0x03]  0,0,            "FCOMFP %e,F0",
 767 [0x04]  0,0,            "FSUBF  %e,F0",
 768 [0x05]  0,0,            "FSUBRF %e,F0",
 769 [0x06]  0,0,            "FDIVF  %e,F0",
 770 [0x07]  0,0,            "FDIVRF %e,F0",
 771 [0x08]  0,0,            "FADDD  %f,F0",
 772 [0x09]  0,0,            "FMULD  %f,F0",
 773 [0x0a]  0,0,            "FCOMD  %f,F0",
 774 [0x0b]  0,0,            "FCOMPD %f,F0",
 775 [0x0c]  0,0,            "FSUBD  %f,F0",
 776 [0x0d]  0,0,            "FSUBRD %f,F0",
 777 [0x0e]  0,0,            "FDIVD  %f,F0",
 778 [0x0f]  0,0,            "FDIVRD %f,F0",
 779 };
 780 /*
 781  *      optabD9 and optabDB use the following encoding:
 782  *      if (0 <= modrm <= 2) instruction = optabDx[modrm&0x07];
 783  *      else instruction = optabDx[(modrm&0x3f)+8];
 784  *
 785  *      the instructions for MOD == 3, follow the 8 instructions
 786  *      for the other MOD values stored at the front of the table.
 787  */
 788 static Optable optabD9[64+8] =
 789 {
 790 [0x00]  0,0,            "FMOVF  %e,F0",
 791 [0x02]  0,0,            "FMOVF  F0,%e",
 792 [0x03]  0,0,            "FMOVFP F0,%e",
 793 [0x04]  0,0,            "FLDENV%S %e",
 794 [0x05]  0,0,            "FLDCW  %e",
 795 [0x06]  0,0,            "FSTENV%S %e",
 796 [0x07]  0,0,            "FSTCW  %e",
 797 [0x08]  0,0,            "FMOVD  F0,F0",         /* Mod R/M = 11xx xxxx*/
 798 [0x09]  0,0,            "FMOVD  F1,F0",
 799 [0x0a]  0,0,            "FMOVD  F2,F0",
 800 [0x0b]  0,0,            "FMOVD  F3,F0",
 801 [0x0c]  0,0,            "FMOVD  F4,F0",
 802 [0x0d]  0,0,            "FMOVD  F5,F0",
 803 [0x0e]  0,0,            "FMOVD  F6,F0",
 804 [0x0f]  0,0,            "FMOVD  F7,F0",
 805 [0x10]  0,0,            "FXCHD  F0,F0",
 806 [0x11]  0,0,            "FXCHD  F1,F0",
 807 [0x12]  0,0,            "FXCHD  F2,F0",
 808 [0x13]  0,0,            "FXCHD  F3,F0",
 809 [0x14]  0,0,            "FXCHD  F4,F0",
 810 [0x15]  0,0,            "FXCHD  F5,F0",
 811 [0x16]  0,0,            "FXCHD  F6,F0",
 812 [0x17]  0,0,            "FXCHD  F7,F0",
 813 [0x18]  0,0,            "FNOP",
 814 [0x28]  0,0,            "FCHS",
 815 [0x29]  0,0,            "FABS",
 816 [0x2c]  0,0,            "FTST",
 817 [0x2d]  0,0,            "FXAM",
 818 [0x30]  0,0,            "FLD1",
 819 [0x31]  0,0,            "FLDL2T",
 820 [0x32]  0,0,            "FLDL2E",
 821 [0x33]  0,0,            "FLDPI",
 822 [0x34]  0,0,            "FLDLG2",
 823 [0x35]  0,0,            "FLDLN2",
 824 [0x36]  0,0,            "FLDZ",
 825 [0x38]  0,0,            "F2XM1",
 826 [0x39]  0,0,            "FYL2X",
 827 [0x3a]  0,0,            "FPTAN",
 828 [0x3b]  0,0,            "FPATAN",
 829 [0x3c]  0,0,            "FXTRACT",
 830 [0x3d]  0,0,            "FPREM1",
 831 [0x3e]  0,0,            "FDECSTP",
 832 [0x3f]  0,0,            "FNCSTP",
 833 [0x40]  0,0,            "FPREM",
 834 [0x41]  0,0,            "FYL2XP1",
 835 [0x42]  0,0,            "FSQRT",
 836 [0x43]  0,0,            "FSINCOS",
 837 [0x44]  0,0,            "FRNDINT",
 838 [0x45]  0,0,            "FSCALE",
 839 [0x46]  0,0,            "FSIN",
 840 [0x47]  0,0,            "FCOS",
 841 };
 842
 843 static Optable optabDA[8+8] =
 844 {
 845 [0x00]  0,0,            "FADDL  %e,F0",
 846 [0x01]  0,0,            "FMULL  %e,F0",
 847 [0x02]  0,0,            "FCOML  %e,F0",
 848 [0x03]  0,0,            "FCOMLP %e,F0",
 849 [0x04]  0,0,            "FSUBL  %e,F0",
 850 [0x05]  0,0,            "FSUBRL %e,F0",
 851 [0x06]  0,0,            "FDIVL  %e,F0",
 852 [0x07]  0,0,            "FDIVRL %e,F0",
 853 [0x0d]  R1,0,           "FUCOMPP",
 854 };
 855
 856 static Optable optabDB[8+64] =
 857 {
 858 [0x00]  0,0,            "FMOVL  %e,F0",
 859 [0x02]  0,0,            "FMOVL  F0,%e",
 860 [0x03]  0,0,            "FMOVLP F0,%e",
 861 [0x05]  0,0,            "FMOVX  %e,F0",
 862 [0x07]  0,0,            "FMOVXP F0,%e",
 863 [0x2a]  0,0,            "FCLEX",
 864 [0x2b]  0,0,            "FINIT",
 865 };
 866
 867 static Optable optabDC[8+8] =
 868 {
 869 [0x00]  0,0,            "FADDD  %e,F0",
 870 [0x01]  0,0,            "FMULD  %e,F0",
 871 [0x02]  0,0,            "FCOMD  %e,F0",
 872 [0x03]  0,0,            "FCOMDP %e,F0",
 873 [0x04]  0,0,            "FSUBD  %e,F0",
 874 [0x05]  0,0,            "FSUBRD %e,F0",
 875 [0x06]  0,0,            "FDIVD  %e,F0",
 876 [0x07]  0,0,            "FDIVRD %e,F0",
 877 [0x08]  0,0,            "FADDD  F0,%f",
 878 [0x09]  0,0,            "FMULD  F0,%f",
 879 [0x0c]  0,0,            "FSUBRD F0,%f",
 880 [0x0d]  0,0,            "FSUBD  F0,%f",
 881 [0x0e]  0,0,            "FDIVRD F0,%f",
 882 [0x0f]  0,0,            "FDIVD  F0,%f",
 883 };
 884
 885 static Optable optabDD[8+8] =
 886 {
 887 [0x00]  0,0,            "FMOVD  %e,F0",
 888 [0x02]  0,0,            "FMOVD  F0,%e",
 889 [0x03]  0,0,            "FMOVDP F0,%e",
 890 [0x04]  0,0,            "FRSTOR%S %e",
 891 [0x06]  0,0,            "FSAVE%S %e",
 892 [0x07]  0,0,            "FSTSW  %e",
 893 [0x08]  0,0,            "FFREED %f",
 894 [0x0a]  0,0,            "FMOVD  %f,F0",
 895 [0x0b]  0,0,            "FMOVDP %f,F0",
 896 [0x0c]  0,0,            "FUCOMD %f,F0",
 897 [0x0d]  0,0,            "FUCOMDP %f,F0",
 898 };
 899
 900 static Optable optabDE[8+8] =
 901 {
 902 [0x00]  0,0,            "FADDW  %e,F0",
 903 [0x01]  0,0,            "FMULW  %e,F0",
 904 [0x02]  0,0,            "FCOMW  %e,F0",
 905 [0x03]  0,0,            "FCOMWP %e,F0",
 906 [0x04]  0,0,            "FSUBW  %e,F0",
 907 [0x05]  0,0,            "FSUBRW %e,F0",
 908 [0x06]  0,0,            "FDIVW  %e,F0",
 909 [0x07]  0,0,            "FDIVRW %e,F0",
 910 [0x08]  0,0,            "FADDDP F0,%f",
 911 [0x09]  0,0,            "FMULDP F0,%f",
 912 [0x0b]  R1,0,           "FCOMPDP",
 913 [0x0c]  0,0,            "FSUBRDP F0,%f",
 914 [0x0d]  0,0,            "FSUBDP F0,%f",
 915 [0x0e]  0,0,            "FDIVRDP F0,%f",
 916 [0x0f]  0,0,            "FDIVDP F0,%f",
 917 };
 918
 919 static Optable optabDF[8+8] =
 920 {
 921 [0x00]  0,0,            "FMOVW  %e,F0",
 922 [0x02]  0,0,            "FMOVW  F0,%e",
 923 [0x03]  0,0,            "FMOVWP F0,%e",
 924 [0x04]  0,0,            "FBLD   %e",
 925 [0x05]  0,0,            "FMOVL  %e,F0",
 926 [0x06]  0,0,            "FBSTP  %e",
 927 [0x07]  0,0,            "FMOVLP F0,%e",
 928 [0x0c]  R0,0,           "FSTSW  %OAX",
 929 };
 930
 931 static Optable optabF6[8] =
 932 {
 933 [0x00]  Ib,0,           "TESTB  %i,%e",
 934 [0x02]  0,0,            "NOTB   %e",
 935 [0x03]  0,0,            "NEGB   %e",
 936 [0x04]  0,0,            "MULB   AL,%e",
 937 [0x05]  0,0,            "IMULB  AL,%e",
 938 [0x06]  0,0,            "DIVB   AL,%e",
 939 [0x07]  0,0,            "IDIVB  AL,%e",
 940 };
 941
 942 static Optable optabF7[8] =
 943 {
 944 [0x00]  Iwd,0,          "TEST%S %i,%e",
 945 [0x02]  0,0,            "NOT%S  %e",
 946 [0x03]  0,0,            "NEG%S  %e",
 947 [0x04]  0,0,            "MUL%S  %OAX,%e",
 948 [0x05]  0,0,            "IMUL%S %OAX,%e",
 949 [0x06]  0,0,            "DIV%S  %OAX,%e",
 950 [0x07]  0,0,            "IDIV%S %OAX,%e",
 951 };
 952
 953 static Optable optabFE[8] =
 954 {
 955 [0x00]  0,0,            "INCB   %e",
 956 [0x01]  0,0,            "DECB   %e",
 957 };
 958
 959 static Optable optabFF[8] =
 960 {
 961 [0x00]  0,0,            "INC%S  %e",
 962 [0x01]  0,0,            "DEC%S  %e",
 963 [0x02]  JUMP,0,         "CALL*  %e",
 964 [0x03]  JUMP,0,         "CALLF* %e",
 965 [0x04]  JUMP,0,         "JMP*   %e",
 966 [0x05]  JUMP,0,         "JMPF*  %e",
 967 [0x06]  0,0,            "PUSHL  %e",
 968 };
 969
 970 static Optable optable[256+1] =
 971 {
 972 [0x00]  RMB,0,          "ADDB   %r,%e",
 973 [0x01]  RM,0,           "ADD%S  %r,%e",
 974 [0x02]  RMB,0,          "ADDB   %e,%r",
 975 [0x03]  RM,0,           "ADD%S  %e,%r",
 976 [0x04]  Ib,0,           "ADDB   %i,AL",
 977 [0x05]  Iwd,0,          "ADD%S  %i,%OAX",
 978 [0x06]  0,0,            "PUSHL  ES",
 979 [0x07]  0,0,            "POPL   ES",
 980 [0x08]  RMB,0,          "ORB    %r,%e",
 981 [0x09]  RM,0,           "OR%S   %r,%e",
 982 [0x0a]  RMB,0,          "ORB    %e,%r",
 983 [0x0b]  RM,0,           "OR%S   %e,%r",
 984 [0x0c]  Ib,0,           "ORB    %i,AL",
 985 [0x0d]  Iwd,0,          "OR%S   %i,%OAX",
 986 [0x0e]  0,0,            "PUSHL  CS",
 987 [0x0f]  AUXMM,0,        optab0F,
 988 [0x10]  RMB,0,          "ADCB   %r,%e",
 989 [0x11]  RM,0,           "ADC%S  %r,%e",
 990 [0x12]  RMB,0,          "ADCB   %e,%r",
 991 [0x13]  RM,0,           "ADC%S  %e,%r",
 992 [0x14]  Ib,0,           "ADCB   %i,AL",
 993 [0x15]  Iwd,0,          "ADC%S  %i,%OAX",
 994 [0x16]  0,0,            "PUSHL  SS",
 995 [0x17]  0,0,            "POPL   SS",
 996 [0x18]  RMB,0,          "SBBB   %r,%e",
 997 [0x19]  RM,0,           "SBB%S  %r,%e",
 998 [0x1a]  RMB,0,          "SBBB   %e,%r",
 999 [0x1b]  RM,0,           "SBB%S  %e,%r",
1000 [0x1c]  Ib,0,           "SBBB   %i,AL",
1001 [0x1d]  Iwd,0,          "SBB%S  %i,%OAX",
1002 [0x1e]  0,0,            "PUSHL  DS",
1003 [0x1f]  0,0,            "POPL   DS",
1004 [0x20]  RMB,0,          "ANDB   %r,%e",
1005 [0x21]  RM,0,           "AND%S  %r,%e",
1006 [0x22]  RMB,0,          "ANDB   %e,%r",
1007 [0x23]  RM,0,           "AND%S  %e,%r",
1008 [0x24]  Ib,0,           "ANDB   %i,AL",
1009 [0x25]  Iwd,0,          "AND%S  %i,%OAX",
1010 [0x26]  SEG,0,          "ES:",
1011 [0x27]  0,0,            "DAA",
1012 [0x28]  RMB,0,          "SUBB   %r,%e",
1013 [0x29]  RM,0,           "SUB%S  %r,%e",
1014 [0x2a]  RMB,0,          "SUBB   %e,%r",
1015 [0x2b]  RM,0,           "SUB%S  %e,%r",
1016 [0x2c]  Ib,0,           "SUBB   %i,AL",
1017 [0x2d]  Iwd,0,          "SUB%S  %i,%OAX",
1018 [0x2e]  SEG,0,          "CS:",
1019 [0x2f]  0,0,            "DAS",
1020 [0x30]  RMB,0,          "XORB   %r,%e",
1021 [0x31]  RM,0,           "XOR%S  %r,%e",
1022 [0x32]  RMB,0,          "XORB   %e,%r",
1023 [0x33]  RM,0,           "XOR%S  %e,%r",
1024 [0x34]  Ib,0,           "XORB   %i,AL",
1025 [0x35]  Iwd,0,          "XOR%S  %i,%OAX",
1026 [0x36]  SEG,0,          "SS:",
1027 [0x37]  0,0,            "AAA",
1028 [0x38]  RMB,0,          "CMPB   %r,%e",
1029 [0x39]  RM,0,           "CMP%S  %r,%e",
1030 [0x3a]  RMB,0,          "CMPB   %e,%r",
1031 [0x3b]  RM,0,           "CMP%S  %e,%r",
1032 [0x3c]  Ib,0,           "CMPB   %i,AL",
1033 [0x3d]  Iwd,0,          "CMP%S  %i,%OAX",
1034 [0x3e]  SEG,0,          "DS:",
1035 [0x3f]  0,0,            "AAS",
1036 [0x40]  0,0,            "INC%S  %OAX",
1037 [0x41]  0,0,            "INC%S  %OCX",
1038 [0x42]  0,0,            "INC%S  %ODX",
1039 [0x43]  0,0,            "INC%S  %OBX",
1040 [0x44]  0,0,            "INC%S  %OSP",
1041 [0x45]  0,0,            "INC%S  %OBP",
1042 [0x46]  0,0,            "INC%S  %OSI",
1043 [0x47]  0,0,            "INC%S  %ODI",
1044 [0x48]  0,0,            "DEC%S  %OAX",
1045 [0x49]  0,0,            "DEC%S  %OCX",
1046 [0x4a]  0,0,            "DEC%S  %ODX",
1047 [0x4b]  0,0,            "DEC%S  %OBX",
1048 [0x4c]  0,0,            "DEC%S  %OSP",
1049 [0x4d]  0,0,            "DEC%S  %OBP",
1050 [0x4e]  0,0,            "DEC%S  %OSI",
1051 [0x4f]  0,0,            "DEC%S  %ODI",
1052 [0x50]  0,0,            "PUSH%S %OAX",
1053 [0x51]  0,0,            "PUSH%S %OCX",
1054 [0x52]  0,0,            "PUSH%S %ODX",
1055 [0x53]  0,0,            "PUSH%S %OBX",
1056 [0x54]  0,0,            "PUSH%S %OSP",
1057 [0x55]  0,0,            "PUSH%S %OBP",
1058 [0x56]  0,0,            "PUSH%S %OSI",
1059 [0x57]  0,0,            "PUSH%S %ODI",
1060 [0x58]  0,0,            "POP%S  %OAX",
1061 [0x59]  0,0,            "POP%S  %OCX",
1062 [0x5a]  0,0,            "POP%S  %ODX",
1063 [0x5b]  0,0,            "POP%S  %OBX",
1064 [0x5c]  0,0,            "POP%S  %OSP",
1065 [0x5d]  0,0,            "POP%S  %OBP",
1066 [0x5e]  0,0,            "POP%S  %OSI",
1067 [0x5f]  0,0,            "POP%S  %ODI",
1068 [0x60]  0,0,            "PUSHA%S",
1069 [0x61]  0,0,            "POPA%S",
1070 [0x62]  RMM,0,          "BOUND  %e,%r",
1071 [0x63]  RM,0,           "ARPL   %r,%e",
1072 [0x64]  SEG,0,          "FS:",
1073 [0x65]  SEG,0,          "GS:",
1074 [0x66]  OPOVER,0,       "",
1075 [0x67]  ADDOVER,0,      "",
1076 [0x68]  Iwd,0,          "PUSH%S %i",
1077 [0x69]  RM,Iwd,         "IMUL%S %e,%i,%r",
1078 [0x6a]  Ib,0,           "PUSH%S %i",
1079 [0x6b]  RM,Ibs,         "IMUL%S %e,%i,%r",
1080 [0x6c]  0,0,            "INSB   DX,(%ODI)",
1081 [0x6d]  0,0,            "INS%S  DX,(%ODI)",
1082 [0x6e]  0,0,            "OUTSB  (%ASI),DX",
1083 [0x6f]  0,0,            "OUTS%S (%ASI),DX",
1084 [0x70]  Jbs,0,          "JOS    %p",
1085 [0x71]  Jbs,0,          "JOC    %p",
1086 [0x72]  Jbs,0,          "JCS    %p",
1087 [0x73]  Jbs,0,          "JCC    %p",
1088 [0x74]  Jbs,0,          "JEQ    %p",
1089 [0x75]  Jbs,0,          "JNE    %p",
1090 [0x76]  Jbs,0,          "JLS    %p",
1091 [0x77]  Jbs,0,          "JHI    %p",
1092 [0x78]  Jbs,0,          "JMI    %p",
1093 [0x79]  Jbs,0,          "JPL    %p",
1094 [0x7a]  Jbs,0,          "JPS    %p",
1095 [0x7b]  Jbs,0,          "JPC    %p",
1096 [0x7c]  Jbs,0,          "JLT    %p",
1097 [0x7d]  Jbs,0,          "JGE    %p",
1098 [0x7e]  Jbs,0,          "JLE    %p",
1099 [0x7f]  Jbs,0,          "JGT    %p",
1100 [0x80]  RMOPB,0,        optab80,
1101 [0x81]  RMOP,0,         optab81,
1102 [0x83]  RMOP,0,         optab83,
1103 [0x84]  RMB,0,          "TESTB  %r,%e",
1104 [0x85]  RM,0,           "TEST%S %r,%e",
1105 [0x86]  RMB,0,          "XCHGB  %r,%e",
1106 [0x87]  RM,0,           "XCHG%S %r,%e",
1107 [0x88]  RMB,0,          "MOVB   %r,%e",
1108 [0x89]  RM,0,           "MOV%S  %r,%e",
1109 [0x8a]  RMB,0,          "MOVB   %e,%r",
1110 [0x8b]  RM,0,           "MOV%S  %e,%r",
1111 [0x8c]  RM,0,           "MOVW   %g,%e",
1112 [0x8d]  RM,0,           "LEA%S  %e,%r",
1113 [0x8e]  RM,0,           "MOVW   %e,%g",
1114 [0x8f]  RM,0,           "POP%S  %e",
1115 [0x90]  0,0,            "NOP",
1116 [0x91]  0,0,            "XCHG   %OCX,%OAX",
1117 [0x92]  0,0,            "XCHG   %ODX,%OAX",
1118 [0x93]  0,0,            "XCHG   %OBX,%OAX",
1119 [0x94]  0,0,            "XCHG   %OSP,%OAX",
1120 [0x95]  0,0,            "XCHG   %OBP,%OAX",
1121 [0x96]  0,0,            "XCHG   %OSI,%OAX",
1122 [0x97]  0,0,            "XCHG   %ODI,%OAX",
1123 [0x98]  0,0,            "%W",                   /* miserable CBW or CWDE */
1124 [0x99]  0,0,            "%w",                   /* idiotic CWD or CDQ */
1125 [0x9a]  PTR,0,          "CALL%S %d",
1126 [0x9b]  0,0,            "WAIT",
1127 [0x9c]  0,0,            "PUSHF",
1128 [0x9d]  0,0,            "POPF",
1129 [0x9e]  0,0,            "SAHF",
1130 [0x9f]  0,0,            "LAHF",
1131 [0xa0]  Awd,0,          "MOVB   %i,AL",
1132 [0xa1]  Awd,0,          "MOV%S  %i,%OAX",
1133 [0xa2]  Awd,0,          "MOVB   AL,%i",
1134 [0xa3]  Awd,0,          "MOV%S  %OAX,%i",
1135 [0xa4]  0,0,            "MOVSB  (%ASI),(%ADI)",
1136 [0xa5]  0,0,            "MOVS%S (%ASI),(%ADI)",
1137 [0xa6]  0,0,            "CMPSB  (%ASI),(%ADI)",
1138 [0xa7]  0,0,            "CMPS%S (%ASI),(%ADI)",
1139 [0xa8]  Ib,0,           "TESTB  %i,AL",
1140 [0xa9]  Iwd,0,          "TEST%S %i,%OAX",
1141 [0xaa]  0,0,            "STOSB  AL,(%ADI)",
1142 [0xab]  0,0,            "STOS%S %OAX,(%ADI)",
1143 [0xac]  0,0,            "LODSB  (%ASI),AL",
1144 [0xad]  0,0,            "LODS%S (%ASI),%OAX",
1145 [0xae]  0,0,            "SCASB  (%ADI),AL",
1146 [0xaf]  0,0,            "SCAS%S (%ADI),%OAX",
1147 [0xb0]  Ib,0,           "MOVB   %i,AL",
1148 [0xb1]  Ib,0,           "MOVB   %i,CL",
1149 [0xb2]  Ib,0,           "MOVB   %i,DL",
1150 [0xb3]  Ib,0,           "MOVB   %i,BL",
1151 [0xb4]  Ib,0,           "MOVB   %i,AH",
1152 [0xb5]  Ib,0,           "MOVB   %i,CH",
1153 [0xb6]  Ib,0,           "MOVB   %i,DH",
1154 [0xb7]  Ib,0,           "MOVB   %i,BH",
1155 [0xb8]  Iwdq,0,         "MOV%S  %i,%OAX",
1156 [0xb9]  Iwdq,0,         "MOV%S  %i,%OCX",
1157 [0xba]  Iwdq,0,         "MOV%S  %i,%ODX",
1158 [0xbb]  Iwdq,0,         "MOV%S  %i,%OBX",
1159 [0xbc]  Iwdq,0,         "MOV%S  %i,%OSP",
1160 [0xbd]  Iwdq,0,         "MOV%S  %i,%OBP",
1161 [0xbe]  Iwdq,0,         "MOV%S  %i,%OSI",
1162 [0xbf]  Iwdq,0,         "MOV%S  %i,%ODI",
1163 [0xc0]  RMOPB,0,        optabC0,
1164 [0xc1]  RMOP,0,         optabC1,
1165 [0xc2]  Iw,0,           "RET    %i",
1166 [0xc3]  RET,0,          "RET",
1167 [0xc4]  RM,0,           "LES    %e,%r",
1168 [0xc5]  RM,0,           "LDS    %e,%r",
1169 [0xc6]  RMB,Ib,         "MOVB   %i,%e",
1170 [0xc7]  RM,Iwd,         "MOV%S  %i,%e",
1171 [0xc8]  Iw2,Ib,         "ENTER  %i,%I",         /* loony ENTER */
1172 [0xc9]  RET,0,          "LEAVE",                /* bizarre LEAVE */
1173 [0xca]  Iw,0,           "RETF   %i",
1174 [0xcb]  RET,0,          "RETF",
1175 [0xcc]  0,0,            "INT    3",
1176 [0xcd]  Ib,0,           "INTB   %i",
1177 [0xce]  0,0,            "INTO",
1178 [0xcf]  0,0,            "IRET",
1179 [0xd0]  RMOPB,0,        optabD0,
1180 [0xd1]  RMOP,0,         optabD1,
1181 [0xd2]  RMOPB,0,        optabD2,
1182 [0xd3]  RMOP,0,         optabD3,
1183 [0xd4]  OA,0,           "AAM",
1184 [0xd5]  OA,0,           "AAD",
1185 [0xd7]  0,0,            "XLAT",
1186 [0xd8]  FRMOP,0,        optabD8,
1187 [0xd9]  FRMEX,0,        optabD9,
1188 [0xda]  FRMOP,0,        optabDA,
1189 [0xdb]  FRMEX,0,        optabDB,
1190 [0xdc]  FRMOP,0,        optabDC,
1191 [0xdd]  FRMOP,0,        optabDD,
1192 [0xde]  FRMOP,0,        optabDE,
1193 [0xdf]  FRMOP,0,        optabDF,
1194 [0xe0]  Jbs,0,          "LOOPNE %p",
1195 [0xe1]  Jbs,0,          "LOOPE  %p",
1196 [0xe2]  Jbs,0,          "LOOP   %p",
1197 [0xe3]  Jbs,0,          "JCXZ   %p",
1198 [0xe4]  Ib,0,           "INB    %i,AL",
1199 [0xe5]  Ib,0,           "IN%S   %i,%OAX",
1200 [0xe6]  Ib,0,           "OUTB   AL,%i",
1201 [0xe7]  Ib,0,           "OUT%S  %OAX,%i",
1202 [0xe8]  Iwds,0,         "CALL   %p",
1203 [0xe9]  Iwds,0,         "JMP    %p",
1204 [0xea]  PTR,0,          "JMP    %d",
1205 [0xeb]  Jbs,0,          "JMP    %p",
1206 [0xec]  0,0,            "INB    DX,AL",
1207 [0xed]  0,0,            "IN%S   DX,%OAX",
1208 [0xee]  0,0,            "OUTB   AL,DX",
1209 [0xef]  0,0,            "OUT%S  %OAX,DX",
1210 [0xf0]  PRE,0,          "LOCK",
1211 [0xf2]  OPRE,0,         "REPNE",
1212 [0xf3]  OPRE,0,         "REP",
1213 [0xf4]  0,0,            "HLT",
1214 [0xf5]  0,0,            "CMC",
1215 [0xf6]  RMOPB,0,        optabF6,
1216 [0xf7]  RMOP,0,         optabF7,
1217 [0xf8]  0,0,            "CLC",
1218 [0xf9]  0,0,            "STC",
1219 [0xfa]  0,0,            "CLI",
1220 [0xfb]  0,0,            "STI",
1221 [0xfc]  0,0,            "CLD",
1222 [0xfd]  0,0,            "STD",
1223 [0xfe]  RMOPB,0,        optabFE,
1224 [0xff]  RMOP,0,         optabFF,
1225 [0x100] RM,0,           "MOVLQSX        %r,%e",
1226 };
1227
1228 /*
1229  *  get a byte of the instruction
1230  */
1231 static int
1232 igetc(Map *map, Instr *ip, uchar *c)
1233 {
1234         if(ip->n+1 > sizeof(ip->mem)){
1235                 werrstr("instruction too long");
1236                 return -1;
1237         }
1238         if (get1(map, ip->addr+ip->n, c, 1) < 0) {
1239                 werrstr("can't read instruction: %r");
1240                 return -1;
1241         }
1242         ip->mem[ip->n++] = *c;
1243         return 1;
1244 }
1245
1246 /*
1247  *  get two bytes of the instruction
1248  */
1249 static int
1250 igets(Map *map, Instr *ip, ushort *sp)
1251 {
1252         uchar c;
1253         ushort s;
1254
1255         if (igetc(map, ip, &c) < 0)
1256                 return -1;
1257         s = c;
1258         if (igetc(map, ip, &c) < 0)
1259                 return -1;
1260         s |= (c<<8);
1261         *sp = s;
1262         return 1;
1263 }
1264
1265 /*
1266  *  get 4 bytes of the instruction
1267  */
1268 static int
1269 igetl(Map *map, Instr *ip, ulong *lp)
1270 {
1271         ushort s;
1272         long    l;
1273
1274         if (igets(map, ip, &s) < 0)
1275                 return -1;
1276         l = s;
1277         if (igets(map, ip, &s) < 0)
1278                 return -1;
1279         l |= (s<<16);
1280         *lp = l;
1281         return 1;
1282 }
1283
1284 /*
1285  *  get 8 bytes of the instruction
1286  */
1287 static int
1288 igetq(Map *map, Instr *ip, vlong *qp)
1289 {
1290         ulong   l;
1291         uvlong q;
1292
1293         if (igetl(map, ip, &l) < 0)
1294                 return -1;
1295         q = l;
1296         if (igetl(map, ip, &l) < 0)
1297                 return -1;
1298         q |= ((uvlong)l<<32);
1299         *qp = q;
1300         return 1;
1301 }
1302
1303 static int
1304 getdisp(Map *map, Instr *ip, int mod, int rm, int code, int pcrel)
1305 {
1306         uchar c;
1307         ushort s;
1308
1309         if (mod > 2)
1310                 return 1;
1311         if (mod == 1) {
1312                 if (igetc(map, ip, &c) < 0)
1313                         return -1;
1314                 if (c&0x80)
1315                         ip->disp = c|0xffffff00;
1316                 else
1317                         ip->disp = c&0xff;
1318         } else if (mod == 2 || rm == code) {
1319                 if (ip->asize == 'E') {
1320                         if (igetl(map, ip, &ip->disp) < 0)
1321                                 return -1;
1322                         if (mod == 0)
1323                                 ip->rip = pcrel;
1324                 } else {
1325                         if (igets(map, ip, &s) < 0)
1326                                 return -1;
1327                         if (s&0x8000)
1328                                 ip->disp = s|0xffff0000;
1329                         else
1330                                 ip->disp = s;
1331                 }
1332                 if (mod == 0)
1333                         ip->base = -1;
1334         }
1335         return 1;
1336 }
1337
1338 static int
1339 modrm(Map *map, Instr *ip, uchar c)
1340 {
1341         uchar rm, mod;
1342
1343         mod = (c>>6)&3;
1344         rm = c&7;
1345         ip->mod = mod;
1346         ip->base = rm;
1347         ip->reg = (c>>3)&7;
1348         ip->rip = 0;
1349         if (mod == 3)                   /* register */
1350                 return 1;
1351         if (ip->asize == 0) {           /* 16-bit mode */
1352                 switch(rm) {
1353                 case 0:
1354                         ip->base = BX; ip->index = SI;
1355                         break;
1356                 case 1:
1357                         ip->base = BX; ip->index = DI;
1358                         break;
1359                 case 2:
1360                         ip->base = BP; ip->index = SI;
1361                         break;
1362                 case 3:
1363                         ip->base = BP; ip->index = DI;
1364                         break;
1365                 case 4:
1366                         ip->base = SI;
1367                         break;
1368                 case 5:
1369                         ip->base = DI;
1370                         break;
1371                 case 6:
1372                         ip->base = BP;
1373                         break;
1374                 case 7:
1375                         ip->base = BX;
1376                         break;
1377                 default:
1378                         break;
1379                 }
1380                 return getdisp(map, ip, mod, rm, 6, 0);
1381         }
1382         if (rm == 4) {  /* scummy sib byte */
1383                 if (igetc(map, ip, &c) < 0)
1384                         return -1;
1385                 ip->ss = (c>>6)&0x03;
1386                 ip->index = (c>>3)&0x07;
1387                 if (ip->index == 4)
1388                         ip->index = -1;
1389                 ip->base = c&0x07;
1390                 return getdisp(map, ip, mod, ip->base, 5, 0);
1391         }
1392         return getdisp(map, ip, mod, rm, 5, ip->amd64);
1393 }
1394
1395 static Optable *
1396 mkinstr(Map *map, Instr *ip, uvlong pc)
1397 {
1398         int i, n, norex;
1399         uchar c;
1400         ushort s;
1401         Optable *op, *obase;
1402         char buf[128];
1403
1404         memset(ip, 0, sizeof(*ip));
1405         norex = 1;
1406         ip->base = -1;
1407         ip->index = -1;
1408         if(asstype == AI8086)
1409                 ip->osize = 'W';
1410         else {
1411                 ip->osize = 'L';
1412                 ip->asize = 'E';
1413                 ip->amd64 = asstype != AI386;
1414                 norex = 0;
1415         }
1416         ip->addr = pc;
1417         if (igetc(map, ip, &c) < 0)
1418                 return 0;
1419         obase = optable;
1420 newop:
1421         if(ip->amd64 && !norex){
1422                 if(c >= 0x40 && c <= 0x4f) {
1423                         ip->rex = c;
1424                         if(igetc(map, ip, &c) < 0)
1425                                 return 0;
1426                 }
1427                 if(c == 0x63){
1428                         op = &obase[0x100];     /* MOVLQSX */
1429                         goto hack;
1430                 }
1431         }
1432         op = &obase[c];
1433 hack:
1434         if (op->proto == 0) {
1435 badop:
1436                 n = snprint(buf, sizeof(buf), "opcode: ??");
1437                 for (i = 0; i < ip->n && n < sizeof(buf)-3; i++, n+=2)
1438                         _hexify(buf+n, ip->mem[i], 1);
1439                 strcpy(buf+n, "??");
1440                 werrstr(buf);
1441                 return 0;
1442         }
1443         for(i = 0; i < 2 && op->operand[i]; i++) {
1444                 switch(op->operand[i]) {
1445                 case Ib:        /* 8-bit immediate - (no sign extension)*/
1446                         if (igetc(map, ip, &c) < 0)
1447                                 return 0;
1448                         ip->imm = c&0xff;
1449                         ip->imm64 = ip->imm;
1450                         break;
1451                 case Jbs:       /* 8-bit jump immediate (sign extended) */
1452                         if (igetc(map, ip, &c) < 0)
1453                                 return 0;
1454                         if (c&0x80)
1455                                 ip->imm = c|0xffffff00;
1456                         else
1457                                 ip->imm = c&0xff;
1458                         ip->imm64 = (long)ip->imm;
1459                         ip->jumptype = Jbs;
1460                         break;
1461                 case Ibs:       /* 8-bit immediate (sign extended) */
1462                         if (igetc(map, ip, &c) < 0)
1463                                 return 0;
1464                         if (c&0x80)
1465                                 if (ip->osize == 'L')
1466                                         ip->imm = c|0xffffff00;
1467                                 else
1468                                         ip->imm = c|0xff00;
1469                         else
1470                                 ip->imm = c&0xff;
1471                         ip->imm64 = (long)ip->imm;
1472                         break;
1473                 case Iw:        /* 16-bit immediate -> imm */
1474                         if (igets(map, ip, &s) < 0)
1475                                 return 0;
1476                         ip->imm = s&0xffff;
1477                         ip->imm64 = ip->imm;
1478                         ip->jumptype = Iw;
1479                         break;
1480                 case Iw2:       /* 16-bit immediate -> in imm2*/
1481                         if (igets(map, ip, &s) < 0)
1482                                 return 0;
1483                         ip->imm2 = s&0xffff;
1484                         break;
1485                 case Iwd:       /* Operand-sized immediate (no sign extension unless 64 bits)*/
1486                         if (ip->osize == 'L') {
1487                                 if (igetl(map, ip, &ip->imm) < 0)
1488                                         return 0;
1489                                 ip->imm64 = ip->imm;
1490                                 if(ip->rex&REXW && (ip->imm & (1<<31)) != 0)
1491                                         ip->imm64 |= (vlong)~0 << 32;
1492                         } else {
1493                                 if (igets(map, ip, &s)< 0)
1494                                         return 0;
1495                                 ip->imm = s&0xffff;
1496                                 ip->imm64 = ip->imm;
1497                         }
1498                         break;
1499                 case Iwdq:      /* Operand-sized immediate, possibly big */
1500                         if (ip->osize == 'L') {
1501                                 if (igetl(map, ip, &ip->imm) < 0)
1502                                         return 0;
1503                                 ip->imm64 = ip->imm;
1504                                 if (ip->rex & REXW) {
1505                                         ulong l;
1506                                         if (igetl(map, ip, &l) < 0)
1507                                                 return 0;
1508                                         ip->imm64 |= (uvlong)l << 32;
1509                                 }
1510                         } else {
1511                                 if (igets(map, ip, &s)< 0)
1512                                         return 0;
1513                                 ip->imm = s&0xffff;
1514                         }
1515                         break;
1516                 case Awd:       /* Address-sized immediate (no sign extension)*/
1517                         if (ip->asize == 'E') {
1518                                 if (igetl(map, ip, &ip->imm) < 0)
1519                                         return 0;
1520                                 /* TO DO: REX */
1521                         } else {
1522                                 if (igets(map, ip, &s)< 0)
1523                                         return 0;
1524                                 ip->imm = s&0xffff;
1525                         }
1526                         break;
1527                 case Iwds:      /* Operand-sized immediate (sign extended) */
1528                         if (ip->osize == 'L') {
1529                                 if (igetl(map, ip, &ip->imm) < 0)
1530                                         return 0;
1531                         } else {
1532                                 if (igets(map, ip, &s)< 0)
1533                                         return 0;
1534                                 if (s&0x8000)
1535                                         ip->imm = s|0xffff0000;
1536                                 else
1537                                         ip->imm = s&0xffff;
1538                         }
1539                         ip->jumptype = Iwds;
1540                         break;
1541                 case OA:        /* literal 0x0a byte */
1542                         if (igetc(map, ip, &c) < 0)
1543                                 return 0;
1544                         if (c != 0x0a)
1545                                 goto badop;
1546                         break;
1547                 case R0:        /* base register must be R0 */
1548                         if (ip->base != 0)
1549                                 goto badop;
1550                         break;
1551                 case R1:        /* base register must be R1 */
1552                         if (ip->base != 1)
1553                                 goto badop;
1554                         break;
1555                 case RMB:       /* R/M field with byte register (/r)*/
1556                         if (igetc(map, ip, &c) < 0)
1557                                 return 0;
1558                         if (modrm(map, ip, c) < 0)
1559                                 return 0;
1560                         ip->osize = 'B';
1561                         break;
1562                 case RM:        /* R/M field with register (/r) */
1563                         if (igetc(map, ip, &c) < 0)
1564                                 return 0;
1565                         if (modrm(map, ip, c) < 0)
1566                                 return 0;
1567                         break;
1568                 case RMOPB:     /* R/M field with op code (/digit) */
1569                         if (igetc(map, ip, &c) < 0)
1570                                 return 0;
1571                         if (modrm(map, ip, c) < 0)
1572                                 return 0;
1573                         c = ip->reg;            /* secondary op code */
1574                         obase = (Optable*)op->proto;
1575                         ip->osize = 'B';
1576                         goto newop;
1577                 case RMOP:      /* R/M field with op code (/digit) */
1578                         if (igetc(map, ip, &c) < 0)
1579                                 return 0;
1580                         if (modrm(map, ip, c) < 0)
1581                                 return 0;
1582                         obase = (Optable*)op->proto;
1583                         if(ip->amd64 && obase == optab0F01 && c == 0xF8)
1584                                 return optab0F01F8;
1585                         c = ip->reg;
1586                         goto newop;
1587                 case FRMOP:     /* FP R/M field with op code (/digit) */
1588                         if (igetc(map, ip, &c) < 0)
1589                                 return 0;
1590                         if (modrm(map, ip, c) < 0)
1591                                 return 0;
1592                         if ((c&0xc0) == 0xc0)
1593                                 c = ip->reg+8;          /* 16 entry table */
1594                         else
1595                                 c = ip->reg;
1596                         obase = (Optable*)op->proto;
1597                         goto newop;
1598                 case FRMEX:     /* Extended FP R/M field with op code (/digit) */
1599                         if (igetc(map, ip, &c) < 0)
1600                                 return 0;
1601                         if (modrm(map, ip, c) < 0)
1602                                 return 0;
1603                         if ((c&0xc0) == 0xc0)
1604                                 c = (c&0x3f)+8;         /* 64-entry table */
1605                         else
1606                                 c = ip->reg;
1607                         obase = (Optable*)op->proto;
1608                         goto newop;
1609                 case RMR:       /* R/M register only (mod = 11) */
1610                         if (igetc(map, ip, &c) < 0)
1611                                 return 0;
1612                         if ((c&0xc0) != 0xc0) {
1613                                 werrstr("invalid R/M register: %x", c);
1614                                 return 0;
1615                         }
1616                         if (modrm(map, ip, c) < 0)
1617                                 return 0;
1618                         break;
1619                 case RMM:       /* R/M register only (mod = 11) */
1620                         if (igetc(map, ip, &c) < 0)
1621                                 return 0;
1622                         if ((c&0xc0) == 0xc0) {
1623                                 werrstr("invalid R/M memory mode: %x", c);
1624                                 return 0;
1625                         }
1626                         if (modrm(map, ip, c) < 0)
1627                                 return 0;
1628                         break;
1629                 case PTR:       /* Seg:Displacement addr (ptr16:16 or ptr16:32) */
1630                         if (ip->osize == 'L') {
1631                                 if (igetl(map, ip, &ip->disp) < 0)
1632                                         return 0;
1633                         } else {
1634                                 if (igets(map, ip, &s)< 0)
1635                                         return 0;
1636                                 ip->disp = s&0xffff;
1637                         }
1638                         if (igets(map, ip, (ushort*)&ip->seg) < 0)
1639                                 return 0;
1640                         ip->jumptype = PTR;
1641                         break;
1642                 case AUXMM:     /* Multi-byte op code; prefix determines table selection */
1643                         if (igetc(map, ip, &c) < 0)
1644                                 return 0;
1645                         obase = (Optable*)op->proto;
1646                         switch (ip->opre) {
1647                         case 0x66:      op = optab660F; break;
1648                         case 0xF2:      op = optabF20F; break;
1649                         case 0xF3:      op = optabF30F; break;
1650                         default:        op = nil; break;
1651                         }
1652                         if(op != nil && op[c].proto != nil)
1653                                 obase = op;
1654                         norex = 1;      /* no more rex prefixes */
1655                         /* otherwise the optab entry captures it */
1656                         goto newop;
1657                 case AUX:       /* Multi-byte op code - Auxiliary table */
1658                         obase = (Optable*)op->proto;
1659                         if (igetc(map, ip, &c) < 0)
1660                                 return 0;
1661                         goto newop;
1662                 case OPRE:      /* Instr Prefix or media op */
1663                         ip->opre = c;
1664                         /* fall through */
1665                 case PRE:       /* Instr Prefix */
1666                         ip->prefix = (char*)op->proto;
1667                         if (igetc(map, ip, &c) < 0)
1668                                 return 0;
1669                         if (ip->opre && c == 0x0F)
1670                                 ip->prefix = 0;
1671                         goto newop;
1672                 case SEG:       /* Segment Prefix */
1673                         ip->segment = (char*)op->proto;
1674                         if (igetc(map, ip, &c) < 0)
1675                                 return 0;
1676                         goto newop;
1677                 case OPOVER:    /* Operand size override */
1678                         ip->opre = c;
1679                         ip->osize = 'W';
1680                         if (igetc(map, ip, &c) < 0)
1681                                 return 0;
1682                         if (c == 0x0F)
1683                                 ip->osize = 'L';
1684                         else if (ip->amd64 && (c&0xF0) == 0x40)
1685                                 ip->osize = 'Q';
1686                         goto newop;
1687                 case ADDOVER:   /* Address size override */
1688                         ip->asize = 0;
1689                         if (igetc(map, ip, &c) < 0)
1690                                 return 0;
1691                         goto newop;
1692                 case JUMP:      /* mark instruction as JUMP or RET */
1693                 case RET:
1694                         ip->jumptype = op->operand[i];
1695                         break;
1696                 default:
1697                         werrstr("bad operand type %d", op->operand[i]);
1698                         return 0;
1699                 }
1700         }
1701         return op;
1702 }
1703
1704 #pragma varargck        argpos  bprint          2
1705
1706 static void
1707 bprint(Instr *ip, char *fmt, ...)
1708 {
1709         va_list arg;
1710
1711         va_start(arg, fmt);
1712         ip->curr = vseprint(ip->curr, ip->end, fmt, arg);
1713         va_end(arg);
1714 }
1715
1716 /*
1717  *  if we want to call 16 bit regs AX,BX,CX,...
1718  *  and 32 bit regs EAX,EBX,ECX,... then
1719  *  change the defs of ANAME and ONAME to:
1720  *  #define     ANAME(ip)       ((ip->asize == 'E' ? "E" : "")
1721  *  #define     ONAME(ip)       ((ip)->osize == 'L' ? "E" : "")
1722  */
1723 #define ANAME(ip)       ""
1724 #define ONAME(ip)       ""
1725
1726 static char *reg[] =  {
1727 [AX]    "AX",
1728 [CX]    "CX",
1729 [DX]    "DX",
1730 [BX]    "BX",
1731 [SP]    "SP",
1732 [BP]    "BP",
1733 [SI]    "SI",
1734 [DI]    "DI",
1735
1736         /* amd64 */
1737 [R8]    "R8",
1738 [R9]    "R9",
1739 [R10]   "R10",
1740 [R11]   "R11",
1741 [R12]   "R12",
1742 [R13]   "R13",
1743 [R14]   "R14",
1744 [R15]   "R15",
1745 };
1746
1747 static char *breg[] = { "AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH" };
1748 static char *breg64[] = { "AL", "CL", "DL", "BL", "SPB", "BPB", "SIB", "DIB",
1749         "R8B", "R9B", "R10B", "R11B", "R12B", "R13B", "R14B", "R15B" };
1750 static char *sreg[] = { "ES", "CS", "SS", "DS", "FS", "GS" };
1751
1752 static void
1753 plocal(Instr *ip)
1754 {
1755         int ret;
1756         long offset;
1757         Symbol s;
1758         char *reg;
1759
1760         offset = ip->disp;
1761         if (!findsym(ip->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s)) {
1762                 bprint(ip, "%lux(SP)", offset);
1763                 return;
1764         }
1765
1766         if (s.value > ip->disp) {
1767                 ret = getauto(&s, s.value-ip->disp-mach->szaddr, CAUTO, &s);
1768                 reg = "(SP)";
1769         } else {
1770                 offset -= s.value;
1771                 ret = getauto(&s, offset, CPARAM, &s);
1772                 reg = "(FP)";
1773         }
1774         if (ret)
1775                 bprint(ip, "%s+", s.name);
1776         else
1777                 offset = ip->disp;
1778         bprint(ip, "%lux%s", offset, reg);
1779 }
1780
1781 static int
1782 isjmp(Instr *ip)
1783 {
1784         switch(ip->jumptype){
1785         case Iwds:
1786         case Jbs:
1787         case JUMP:
1788                 return 1;
1789         default:
1790                 return 0;
1791         }
1792 }
1793
1794 /*
1795  * This is too smart for its own good, but it really is nice
1796  * to have accurate translations when debugging, and it
1797  * helps us identify which code is different in binaries that
1798  * are changed on sources.
1799  */
1800 static int
1801 issymref(Instr *ip, Symbol *s, long w, long val)
1802 {
1803         Symbol next, tmp;
1804         long isstring, size;
1805
1806         if (isjmp(ip))
1807                 return 1;
1808         if (s->class==CTEXT && w==0)
1809                 return 1;
1810         if (s->class==CDATA) {
1811                 /* use first bss symbol (or "end") rather than edata */
1812                 if (s->name[0]=='e' && strcmp(s->name, "edata") == 0){
1813                         if((s ->index >= 0 && globalsym(&tmp, s->index+1) && tmp.value==s->value)
1814                         || (s->index > 0 && globalsym(&tmp, s->index-1) && tmp.value==s->value))
1815                                 *s = tmp;
1816                 }
1817                 if (w == 0)
1818                         return 1;
1819                 for (next=*s; next.value==s->value; next=tmp)
1820                         if (!globalsym(&tmp, next.index+1))
1821                                 break;
1822                 size = next.value - s->value;
1823                 if (w >= size)
1824                         return 0;
1825                 if (w > size-w)
1826                         w = size-w;
1827                 /* huge distances are usually wrong except in .string */
1828                 isstring = (s->name[0]=='.' && strcmp(s->name, ".string") == 0);
1829                 if (w > 8192 && !isstring)
1830                         return 0;
1831                 /* medium distances are tricky - look for constants */
1832                 /* near powers of two */
1833                 if ((val&(val-1)) == 0 || (val&(val+1)) == 0)
1834                         return 0;
1835                 return 1;
1836         }
1837         return 0;
1838 }
1839
1840 static void
1841 immediate(Instr *ip, vlong val)
1842 {
1843         Symbol s;
1844         long w;
1845
1846         if (findsym(val, CANY, &s)) {           /* TO DO */
1847                 w = val - s.value;
1848                 if (w < 0)
1849                         w = -w;
1850                 if (issymref(ip, &s, w, val)) {
1851                         if (w)
1852                                 bprint(ip, "%s+%lux(SB)", s.name, w);
1853                         else
1854                                 bprint(ip, "%s(SB)", s.name);
1855                         return;
1856                 }
1857 /*
1858                 if (s.class==CDATA && globalsym(&s, s.index+1)) {
1859                         w = s.value - val;
1860                         if (w < 0)
1861                                 w = -w;
1862                         if (w < 4096) {
1863                                 bprint(ip, "%s-%lux(SB)", s.name, w);
1864                                 return;
1865                         }
1866                 }
1867 */
1868         }
1869         if((ip->rex & REXW) == 0)
1870                 bprint(ip, "%lux", (long)val);
1871         else
1872                 bprint(ip, "%llux", val);
1873 }
1874
1875 static void
1876 pea(Instr *ip)
1877 {
1878         if (ip->mod == 3) {
1879                 if (ip->osize == 'B')
1880                         bprint(ip, (ip->rex & REXB? breg64: breg)[ip->base]);
1881                 else if(ip->rex & REXB)
1882                         bprint(ip, "%s%s", ANAME(ip), reg[ip->base+8]);
1883                 else
1884                         bprint(ip, "%s%s", ANAME(ip), reg[ip->base]);
1885                 return;
1886         }
1887         if (ip->segment)
1888                 bprint(ip, ip->segment);
1889         if (ip->asize == 'E' && ip->base == SP)
1890                 plocal(ip);
1891         else {
1892                 if (ip->base < 0)
1893                         immediate(ip, ip->disp);
1894                 else {
1895                         bprint(ip, "%lux", ip->disp);
1896                         if(ip->rip)
1897                                 bprint(ip, "(RIP)");
1898                         bprint(ip,"(%s%s)", ANAME(ip), reg[ip->rex&REXB? ip->base+8: ip->base]);
1899                 }
1900         }
1901         if (ip->index >= 0)
1902                 bprint(ip,"(%s%s*%d)", ANAME(ip), reg[ip->rex&REXX? ip->index+8: ip->index], 1<<ip->ss);
1903 }
1904
1905 static void
1906 prinstr(Instr *ip, char *fmt)
1907 {
1908         vlong v;
1909
1910         if (ip->prefix)
1911                 bprint(ip, "%s ", ip->prefix);
1912         for (; *fmt && ip->curr < ip->end; fmt++) {
1913                 if (*fmt != '%'){
1914                         *ip->curr++ = *fmt;
1915                         continue;
1916                 }
1917                 switch(*++fmt){
1918                 case '%':
1919                         *ip->curr++ = '%';
1920                         break;
1921                 case 'A':
1922                         bprint(ip, "%s", ANAME(ip));
1923                         break;
1924                 case 'C':
1925                         bprint(ip, "CR%d", ip->reg);
1926                         break;
1927                 case 'D':
1928                         if (ip->reg < 4 || ip->reg == 6 || ip->reg == 7)
1929                                 bprint(ip, "DR%d",ip->reg);
1930                         else
1931                                 bprint(ip, "???");
1932                         break;
1933                 case 'I':
1934                         bprint(ip, "$");
1935                         immediate(ip, ip->imm2);
1936                         break;
1937                 case 'O':
1938                         bprint(ip,"%s", ONAME(ip));
1939                         break;
1940                 case 'i':
1941                         bprint(ip, "$");
1942                         v = ip->imm;
1943                         if(ip->rex & REXW)
1944                                 v = ip->imm64;
1945                         immediate(ip, v);
1946                         break;
1947                 case 'R':
1948                         bprint(ip, "%s%s", ONAME(ip), reg[ip->rex&REXR? ip->reg+8: ip->reg]);
1949                         break;
1950                 case 'S':
1951                         if(ip->osize == 'Q' || ip->osize == 'L' && ip->rex & REXW)
1952                                 bprint(ip, "Q");
1953                         else
1954                                 bprint(ip, "%c", ip->osize);
1955                         break;
1956                 case 's':
1957                         if(ip->opre == 0 || ip->opre == 0x66)
1958                                 bprint(ip, "P");
1959                         else
1960                                 bprint(ip, "S");
1961                         if(ip->opre == 0xf2 || ip->opre == 0x66)
1962                                 bprint(ip, "D");
1963                         else
1964                                 bprint(ip, "S");
1965                         break;
1966                 case 'T':
1967                         if (ip->reg == 6 || ip->reg == 7)
1968                                 bprint(ip, "TR%d",ip->reg);
1969                         else
1970                                 bprint(ip, "???");
1971                         break;
1972                 case 'W':
1973                         if (ip->osize == 'Q' || ip->osize == 'L' && ip->rex & REXW)
1974                                 bprint(ip, "CDQE");
1975                         else if (ip->osize == 'L')
1976                                 bprint(ip,"CWDE");
1977                         else
1978                                 bprint(ip, "CBW");
1979                         break;
1980                 case 'd':
1981                         bprint(ip,"%ux:%lux",ip->seg,ip->disp);
1982                         break;
1983                 case 'm':
1984                         if (ip->mod == 3 && ip->osize != 'B') {
1985                                 if(fmt[1] != '*'){
1986                                         if(ip->opre != 0) {
1987                                                 bprint(ip, "X%d", ip->rex&REXB? ip->base+8: ip->base);
1988                                                 break;
1989                                         }
1990                                 } else
1991                                         fmt++;
1992                                 bprint(ip, "M%d", ip->base);
1993                                 break;
1994                         }
1995                         pea(ip);
1996                         break;
1997                 case 'e':
1998                         pea(ip);
1999                         break;
2000                 case 'f':
2001                         bprint(ip, "F%d", ip->base);
2002                         break;
2003                 case 'g':
2004                         if (ip->reg < 6)
2005                                 bprint(ip,"%s",sreg[ip->reg]);
2006                         else
2007                                 bprint(ip,"???");
2008                         break;
2009                 case 'p':
2010                         /*
2011                          * signed immediate in the ulong ip->imm.
2012                          */
2013                         v = (long)ip->imm;
2014                         immediate(ip, v+ip->addr+ip->n);
2015                         break;
2016                 case 'r':
2017                         if (ip->osize == 'B')
2018                                 bprint(ip,"%s", (ip->rex? breg64: breg)[ip->rex&REXR? ip->reg+8: ip->reg]);
2019                         else
2020                                 bprint(ip, reg[ip->rex&REXR? ip->reg+8: ip->reg]);
2021                         break;
2022                 case 'w':
2023                         if (ip->osize == 'Q' || ip->rex & REXW)
2024                                 bprint(ip, "CQO");
2025                         else if (ip->osize == 'L')
2026                                 bprint(ip,"CDQ");
2027                         else
2028                                 bprint(ip, "CWD");
2029                         break;
2030                 case 'M':
2031                         if(ip->opre != 0)
2032                                 bprint(ip, "X%d", ip->rex&REXR? ip->reg+8: ip->reg);
2033                         else
2034                                 bprint(ip, "M%d", ip->reg);
2035                         break;
2036                 case 'x':
2037                         if (ip->mod == 3 && ip->osize != 'B') {
2038                                 bprint(ip, "X%d", ip->rex&REXB? ip->base+8: ip->base);
2039                                 break;
2040                         }
2041                         pea(ip);
2042                         break;
2043                 case 'X':
2044                         bprint(ip, "X%d", ip->rex&REXR? ip->reg+8: ip->reg);
2045                         break;
2046                 default:
2047                         bprint(ip, "%%%c", *fmt);
2048                         break;
2049                 }
2050         }
2051         *ip->curr = 0;          /* there's always room for 1 byte */
2052 }
2053
2054 static int
2055 i386inst(Map *map, uvlong pc, char modifier, char *buf, int n)
2056 {
2057         Instr instr;
2058         Optable *op;
2059
2060         USED(modifier);
2061         op = mkinstr(map, &instr, pc);
2062         if (op == 0) {
2063                 errstr(buf, n);
2064                 return -1;
2065         }
2066         instr.curr = buf;
2067         instr.end = buf+n-1;
2068         prinstr(&instr, op->proto);
2069         return instr.n;
2070 }
2071
2072 static int
2073 i386das(Map *map, uvlong pc, char *buf, int n)
2074 {
2075         Instr instr;
2076         int i;
2077
2078         if (mkinstr(map, &instr, pc) == 0) {
2079                 errstr(buf, n);
2080                 return -1;
2081         }
2082         for(i = 0; i < instr.n && n > 2; i++) {
2083                 _hexify(buf, instr.mem[i], 1);
2084                 buf += 2;
2085                 n -= 2;
2086         }
2087         *buf = 0;
2088         return instr.n;
2089 }
2090
2091 static int
2092 i386instlen(Map *map, uvlong pc)
2093 {
2094         Instr i;
2095
2096         if (mkinstr(map, &i, pc))
2097                 return i.n;
2098         return -1;
2099 }
2100
2101 static int
2102 i386foll(Map *map, uvlong pc, Rgetter rget, uvlong *foll)
2103 {
2104         Instr i;
2105         Optable *op;
2106         ushort s;
2107         uvlong l, addr;
2108         vlong v;
2109         int n;
2110
2111         op = mkinstr(map, &i, pc);
2112         if (!op)
2113                 return -1;
2114
2115         n = 0;
2116
2117         switch(i.jumptype) {
2118         case RET:               /* RETURN or LEAVE */
2119         case Iw:                /* RETURN */
2120                 if (strcmp(op->proto, "LEAVE") == 0) {
2121                         if (geta(map, (*rget)(map, "BP"), &l) < 0)
2122                                 return -1;
2123                 } else if (geta(map, (*rget)(map, mach->sp), &l) < 0)
2124                         return -1;
2125                 foll[0] = l;
2126                 return 1;
2127         case Iwds:              /* pc relative JUMP or CALL*/
2128         case Jbs:               /* pc relative JUMP or CALL */
2129                 v = (long)i.imm;
2130                 foll[0] = pc+v+i.n;
2131                 n = 1;
2132                 break;
2133         case PTR:               /* seg:displacement JUMP or CALL */
2134                 foll[0] = (i.seg<<4)+i.disp;
2135                 return 1;
2136         case JUMP:              /* JUMP or CALL EA */
2137
2138                 if(i.mod == 3) {
2139                         foll[0] = (*rget)(map, reg[i.rex&REXB? i.base+8: i.base]);
2140                         return 1;
2141                 }
2142                         /* calculate the effective address */
2143                 addr = i.disp;
2144                 if (i.base >= 0) {
2145                         if (geta(map, (*rget)(map, reg[i.rex&REXB? i.base+8: i.base]), &l) < 0)
2146                                 return -1;
2147                         addr += l;
2148                 }
2149                 if (i.index >= 0) {
2150                         if (geta(map, (*rget)(map, reg[i.rex&REXX? i.index+8: i.index]), &l) < 0)
2151                                 return -1;
2152                         addr += l*(1<<i.ss);
2153                 }
2154                         /* now retrieve a seg:disp value at that address */
2155                 if (get2(map, addr, &s) < 0)                    /* seg */
2156                         return -1;
2157                 foll[0] = s<<4;
2158                 addr += 2;
2159                 if (i.asize == 'L') {
2160                         if (geta(map, addr, &l) < 0)            /* disp32 */
2161                                 return -1;
2162                         foll[0] += l;
2163                 } else {                                        /* disp16 */
2164                         if (get2(map, addr, &s) < 0)
2165                                 return -1;
2166                         foll[0] += s;
2167                 }
2168                 return 1;
2169         default:
2170                 break;
2171         }
2172         if (strncmp(op->proto,"JMP", 3) == 0 || strncmp(op->proto,"CALL", 4) == 0)
2173                 return 1;
2174         foll[n++] = pc+i.n;
2175         return n;
2176 }