disasm.c

   1 /* disasm.c   where all the _work_ gets done in the Netwide Disassembler
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  *
   8  * initial version 27/iii/95 by Simon Tatham
   9  */
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <inttypes.h>
  14
  15 #include "nasm.h"
  16 #include "disasm.h"
  17 #include "sync.h"
  18 #include "insns.h"
  19
  20 #include "names.c"
  21
  22 /*
  23  * Flags that go into the `segment' field of `insn' structures
  24  * during disassembly.
  25  */
  26 #define SEG_RELATIVE      1
  27 #define SEG_32BIT         2
  28 #define SEG_RMREG         4
  29 #define SEG_DISP8         8
  30 #define SEG_DISP16       16
  31 #define SEG_DISP32       32
  32 #define SEG_NODISP       64
  33 #define SEG_SIGNED      128
  34 #define SEG_64BIT       256
  35
  36 #include "regdis.c"
  37
  38 #define getu8(x) (*(uint8_t *)(x))
  39 #if defined(__i386__) || defined(__x86_64__)
  40 /* Littleendian CPU which can handle unaligned references */
  41 #define getu16(x) (*(uint16_t *)(x))
  42 #define getu32(x) (*(uint32_t *)(x))
  43 #define getu64(x) (*(uint64_t *)(x))
  44 #else
  45 static uint16_t getu16(uint8_t *data)
  46 {
  47     return (uint16_t)data[0] + ((uint16_t)data[1] << 8);
  48 }
  49 static uint32_t getu32(uint8_t *data)
  50 {
  51     return (uint32_t)getu16(data) + ((uint32_t)getu16(data+2) << 16);
  52 }
  53 static uint64_t getu64(uint8_t *data)
  54 {
  55     return (uint64_t)getu32(data) + ((uint64_t)getu32(data+4) << 32);
  56 }
  57 #endif
  58
  59 #define gets8(x) ((int8_t)getu8(x))
  60 #define gets16(x) ((int16_t)getu16(x))
  61 #define gets32(x) ((int32_t)getu32(x))
  62 #define gets64(x) ((int64_t)getu64(x))
  63
  64 /* Important: regval must already have been adjusted for rex extensions */
  65 static int whichreg(int32_t regflags, int regval, int rex)
  66 {
  67     if (!(REG_AL & ~regflags))
  68         return R_AL;
  69     if (!(REG_AX & ~regflags))
  70         return R_AX;
  71     if (!(REG_EAX & ~regflags))
  72         return R_EAX;
  73     if (!(REG_RAX & ~regflags))
  74         return R_RAX;
  75     if (!(REG_DL & ~regflags))
  76         return R_DL;
  77     if (!(REG_DX & ~regflags))
  78         return R_DX;
  79     if (!(REG_EDX & ~regflags))
  80         return R_EDX;
  81     if (!(REG_RDX & ~regflags))
  82         return R_RDX;
  83     if (!(REG_CL & ~regflags))
  84         return R_CL;
  85     if (!(REG_CX & ~regflags))
  86         return R_CX;
  87     if (!(REG_ECX & ~regflags))
  88         return R_ECX;
  89     if (!(REG_RCX & ~regflags))
  90         return R_RCX;
  91     if (!(FPU0 & ~regflags))
  92         return R_ST0;
  93     if (!(REG_CS & ~regflags))
  94         return (regval == 1) ? R_CS : 0;
  95     if (!(REG_DESS & ~regflags))
  96         return (regval == 0 || regval == 2
  97                 || regval == 3 ? rd_sreg[regval] : 0);
  98     if (!(REG_FSGS & ~regflags))
  99         return (regval == 4 || regval == 5 ? rd_sreg[regval] : 0);
 100     if (!(REG_SEG67 & ~regflags))
 101         return (regval == 6 || regval == 7 ? rd_sreg[regval] : 0);
 102
 103     /* All the entries below look up regval in an 16-entry array */
 104     if (regval < 0 || regval > 15)
 105         return 0;
 106
 107     if (!((REGMEM | BITS8) & ~regflags)) {
 108         if (rex & REX_P)
 109             return rd_reg8_rex[regval];
 110         else
 111             return rd_reg8[regval];
 112     }
 113     if (!((REGMEM | BITS16) & ~regflags))
 114         return rd_reg16[regval];
 115     if (!((REGMEM | BITS32) & ~regflags))
 116         return rd_reg32[regval];
 117     if (!((REGMEM | BITS64) & ~regflags))
 118         return rd_reg64[regval];
 119     if (!(REG_SREG & ~regflags))
 120         return rd_sreg[regval & 7]; /* Ignore REX */
 121     if (!(REG_CREG & ~regflags))
 122         return rd_creg[regval];
 123     if (!(REG_DREG & ~regflags))
 124         return rd_dreg[regval];
 125     if (!(REG_TREG & ~regflags)) {
 126         if (rex & REX_P)
 127             return 0;           /* TR registers are ill-defined with rex */
 128         return rd_treg[regval];
 129     }
 130     if (!(FPUREG & ~regflags))
 131         return rd_fpureg[regval & 7]; /* Ignore REX */
 132     if (!(MMXREG & ~regflags))
 133         return rd_mmxreg[regval & 7]; /* Ignore REX */
 134     if (!(XMMREG & ~regflags))
 135         return rd_xmmreg[regval];
 136
 137     return 0;
 138 }
 139
 140 static const char *whichcond(int condval)
 141 {
 142     static int conds[] = {
 143         C_O, C_NO, C_C, C_NC, C_Z, C_NZ, C_NA, C_A,
 144         C_S, C_NS, C_PE, C_PO, C_L, C_NL, C_NG, C_G
 145     };
 146     return conditions[conds[condval]];
 147 }
 148
 149 /*
 150  * Process an effective address (ModRM) specification.
 151  */
 152 static uint8_t *do_ea(uint8_t *data, int modrm, int asize,
 153                       int segsize, operand * op, int rex)
 154 {
 155     int mod, rm, scale, index, base;
 156
 157     mod = (modrm >> 6) & 03;
 158     rm = modrm & 07;
 159
 160     if (mod == 3) {             /* pure register version */
 161         op->basereg = rm+(rex & REX_B ? 8 : 0);
 162         op->segment |= SEG_RMREG;
 163         return data;
 164     }
 165
 166     op->addr_size = 0;
 167     op->eaflags = 0;
 168
 169     if (asize == 16) {
 170         /*
 171          * <mod> specifies the displacement size (none, byte or
 172          * word), and <rm> specifies the register combination.
 173          * Exception: mod=0,rm=6 does not specify [BP] as one might
 174          * expect, but instead specifies [disp16].
 175          */
 176         op->indexreg = op->basereg = -1;
 177         op->scale = 1;          /* always, in 16 bits */
 178         switch (rm) {
 179         case 0:
 180             op->basereg = R_BX;
 181             op->indexreg = R_SI;
 182             break;
 183         case 1:
 184             op->basereg = R_BX;
 185             op->indexreg = R_DI;
 186             break;
 187         case 2:
 188             op->basereg = R_BP;
 189             op->indexreg = R_SI;
 190             break;
 191         case 3:
 192             op->basereg = R_BP;
 193             op->indexreg = R_DI;
 194             break;
 195         case 4:
 196             op->basereg = R_SI;
 197             break;
 198         case 5:
 199             op->basereg = R_DI;
 200             break;
 201         case 6:
 202             op->basereg = R_BP;
 203             break;
 204         case 7:
 205             op->basereg = R_BX;
 206             break;
 207         }
 208         if (rm == 6 && mod == 0) {      /* special case */
 209             op->basereg = -1;
 210             if (segsize != 16)
 211                 op->addr_size = 16;
 212             mod = 2;            /* fake disp16 */
 213         }
 214         switch (mod) {
 215         case 0:
 216             op->segment |= SEG_NODISP;
 217             break;
 218         case 1:
 219             op->segment |= SEG_DISP8;
 220             op->offset = (int8_t)*data++;
 221             break;
 222         case 2:
 223             op->segment |= SEG_DISP16;
 224             op->offset = *data++;
 225             op->offset |= ((unsigned)*data++) << 8;
 226             break;
 227         }
 228         return data;
 229     } else {
 230         /*
 231          * Once again, <mod> specifies displacement size (this time
 232          * none, byte or *dword*), while <rm> specifies the base
 233          * register. Again, [EBP] is missing, replaced by a pure
 234          * disp32 (this time that's mod=0,rm=*5*) in 32-bit mode,
 235          * and RIP-relative addressing in 64-bit mode.
 236          *
 237          * However, rm=4
 238          * indicates not a single base register, but instead the
 239          * presence of a SIB byte...
 240          */
 241         int a64 = asize == 64;
 242
 243         op->indexreg = -1;
 244
 245         if (a64)
 246             op->basereg = rd_reg64[rm | ((rex & REX_B) ? 8 : 0)];
 247         else
 248             op->basereg = rd_reg32[rm | ((rex & REX_B) ? 8 : 0)];
 249
 250         if (rm == 5 && mod == 0) {
 251             if (segsize == 64) {
 252                 op->eaflags |= EAF_REL;
 253                 op->segment |= SEG_RELATIVE;
 254                 mod = 2;        /* fake disp32 */
 255             }
 256
 257             if (asize != 64)
 258                 op->addr_size = asize;
 259
 260             op->basereg = -1;
 261             mod = 2;            /* fake disp32 */
 262         }
 263
 264         if (rm == 4) {          /* process SIB */
 265             scale = (*data >> 6) & 03;
 266             index = (*data >> 3) & 07;
 267             base = *data & 07;
 268             data++;
 269
 270             op->scale = 1 << scale;
 271
 272             if (index == 4)
 273                 op->indexreg = -1; /* ESP/RSP/R12 cannot be an index */
 274             else if (a64)
 275                 op->indexreg = rd_reg64[index | ((rex & REX_X) ? 8 : 0)];
 276             else
 277                 op->indexreg = rd_reg64[index | ((rex & REX_X) ? 8 : 0)];
 278
 279             if (base == 5 && mod == 0) {
 280                 op->basereg = -1;
 281                 mod = 2;        /* Fake disp32 */
 282             } else if (a64)
 283                 op->basereg = rd_reg64[base | ((rex & REX_B) ? 8 : 0)];
 284             else
 285                 op->basereg = rd_reg32[base | ((rex & REX_B) ? 8 : 0)];
 286
 287             if (segsize != 32)
 288                 op->addr_size = 32;
 289         }
 290
 291         switch (mod) {
 292         case 0:
 293             op->segment |= SEG_NODISP;
 294             break;
 295         case 1:
 296             op->segment |= SEG_DISP8;
 297             op->offset = gets8(data);
 298             data++;
 299             break;
 300         case 2:
 301             op->segment |= SEG_DISP32;
 302             op->offset = getu32(data);
 303             data += 4;
 304             break;
 305         }
 306         return data;
 307     }
 308 }
 309
 310 /*
 311  * Determine whether the instruction template in t corresponds to the data
 312  * stream in data. Return the number of bytes matched if so.
 313  */
 314 static int matches(const struct itemplate *t, uint8_t *data, int asize,
 315                    int osize, int segsize, int rep, insn * ins,
 316                    int rex, int *rexout, int lock)
 317 {
 318     uint8_t *r = (uint8_t *)(t->code);
 319     uint8_t *origdata = data;
 320     int a_used = FALSE, o_used = FALSE;
 321     int drep = 0;
 322
 323     *rexout = rex;
 324
 325     if (t->flags & (segsize == 64 ? IF_NOLONG : IF_LONG))
 326         return FALSE;
 327
 328     if (rep == 0xF2)
 329         drep = P_REPNE;
 330     else if (rep == 0xF3)
 331         drep = P_REP;
 332
 333     while (*r) {
 334         int c = *r++;
 335
 336         /* FIX: change this into a switch */
 337         if (c >= 01 && c <= 03) {
 338             while (c--)
 339                 if (*r++ != *data++)
 340                     return FALSE;
 341         } else if (c == 04) {
 342             switch (*data++) {
 343             case 0x07:
 344                 ins->oprs[0].basereg = 0;
 345                 break;
 346             case 0x17:
 347                 ins->oprs[0].basereg = 2;
 348                 break;
 349             case 0x1F:
 350                 ins->oprs[0].basereg = 3;
 351                 break;
 352             default:
 353                 return FALSE;
 354             }
 355         } else if (c == 05) {
 356             switch (*data++) {
 357             case 0xA1:
 358                 ins->oprs[0].basereg = 4;
 359                 break;
 360             case 0xA9:
 361                 ins->oprs[0].basereg = 5;
 362                 break;
 363             default:
 364                 return FALSE;
 365             }
 366         } else if (c == 06) {
 367             switch (*data++) {
 368             case 0x06:
 369                 ins->oprs[0].basereg = 0;
 370                 break;
 371             case 0x0E:
 372                 ins->oprs[0].basereg = 1;
 373                 break;
 374             case 0x16:
 375                 ins->oprs[0].basereg = 2;
 376                 break;
 377             case 0x1E:
 378                 ins->oprs[0].basereg = 3;
 379                 break;
 380             default:
 381                 return FALSE;
 382             }
 383         } else if (c == 07) {
 384             switch (*data++) {
 385             case 0xA0:
 386                 ins->oprs[0].basereg = 4;
 387                 break;
 388             case 0xA8:
 389                 ins->oprs[0].basereg = 5;
 390                 break;
 391             default:
 392                 return FALSE;
 393             }
 394         } else if (c >= 010 && c <= 012) {
 395             int t = *r++, d = *data++;
 396             if (d < t || d > t + 7)
 397                 return FALSE;
 398             else {
 399                 ins->oprs[c - 010].basereg = (d-t)+(rex & REX_B ? 8 : 0);
 400                 ins->oprs[c - 010].segment |= SEG_RMREG;
 401             }
 402         } else if (c == 017) {
 403             if (*data++)
 404                 return FALSE;
 405         } else if (c >= 014 && c <= 016) {
 406             ins->oprs[c - 014].offset = (int8_t)*data++;
 407             ins->oprs[c - 014].segment |= SEG_SIGNED;
 408         } else if (c >= 020 && c <= 022) {
 409             ins->oprs[c - 020].offset = *data++;
 410         } else if (c >= 024 && c <= 026) {
 411             ins->oprs[c - 024].offset = *data++;
 412         } else if (c >= 030 && c <= 032) {
 413             ins->oprs[c - 030].offset = getu16(data);
 414             data += 2;
 415         } else if (c >= 034 && c <= 036) {
 416             if (osize == 32) {
 417                 ins->oprs[c - 034].offset = getu32(data);
 418                 data += 4;
 419             } else {
 420                 ins->oprs[c - 034].offset = getu16(data);
 421                 data += 2;
 422             }
 423             if (segsize != asize)
 424                 ins->oprs[c - 034].addr_size = asize;
 425         } else if (c >= 040 && c <= 042) {
 426             ins->oprs[c - 040].offset = getu32(data);
 427             data += 4;
 428         } else if (c >= 044 && c <= 046) {
 429             switch (asize) {
 430             case 16:
 431                 ins->oprs[c - 044].offset = getu16(data);
 432                 data += 2;
 433                 break;
 434             case 32:
 435                 ins->oprs[c - 044].offset = getu32(data);
 436                 data += 4;
 437                 break;
 438             case 64:
 439                 ins->oprs[c - 044].offset = getu64(data);
 440                 data += 8;
 441                 break;
 442             }
 443             if (segsize != asize)
 444                 ins->oprs[c - 044].addr_size = asize;
 445         } else if (c >= 050 && c <= 052) {
 446             ins->oprs[c - 050].offset = gets8(data++);
 447             ins->oprs[c - 050].segment |= SEG_RELATIVE;
 448         } else if (c >= 054 && c <= 056) {
 449             ins->oprs[c - 054].offset = getu64(data);
 450             data += 8;
 451         } else if (c >= 060 && c <= 062) {
 452             ins->oprs[c - 060].offset = gets16(data);
 453             data += 2;
 454             ins->oprs[c - 060].segment |= SEG_RELATIVE;
 455             ins->oprs[c - 060].segment &= ~SEG_32BIT;
 456         } else if (c >= 064 && c <= 066) {
 457             if (osize == 16) {
 458                 ins->oprs[c - 064].offset = getu16(data);
 459                 data += 2;
 460                 ins->oprs[c - 064].segment &= ~(SEG_32BIT|SEG_64BIT);
 461             } else if (osize == 32) {
 462                 ins->oprs[c - 064].offset = getu32(data);
 463                 data += 4;
 464                 ins->oprs[c - 064].segment &= ~SEG_64BIT;
 465                 ins->oprs[c - 064].segment |= SEG_32BIT;
 466             }
 467             if (segsize != osize) {
 468                 ins->oprs[c - 064].type =
 469                     (ins->oprs[c - 064].type & ~SIZE_MASK)
 470                     | ((osize == 16) ? BITS16 : BITS32);
 471             }
 472         } else if (c >= 070 && c <= 072) {
 473             ins->oprs[c - 070].offset = getu32(data);
 474             data += 4;
 475             ins->oprs[c - 070].segment |= SEG_32BIT | SEG_RELATIVE;
 476         } else if (c >= 0100 && c < 0130) {
 477             int modrm = *data++;
 478             ins->oprs[c & 07].basereg = ((modrm >> 3)&7)+(rex & REX_R ? 8 : 0);
 479             ins->oprs[c & 07].segment |= SEG_RMREG;
 480             data = do_ea(data, modrm, asize, segsize,
 481                          &ins->oprs[(c >> 3) & 07], rex);
 482         } else if (c >= 0130 && c <= 0132) {
 483             ins->oprs[c - 0130].offset = getu16(data);
 484             data += 2;
 485         } else if (c >= 0140 && c <= 0142) {
 486             ins->oprs[c - 0140].offset = getu32(data);
 487             data += 4;
 488         } else if (c >= 0200 && c <= 0277) {
 489             int modrm = *data++;
 490             if (((modrm >> 3) & 07) != (c & 07))
 491                 return FALSE;   /* spare field doesn't match up */
 492             data = do_ea(data, modrm, asize, segsize,
 493                          &ins->oprs[(c >> 3) & 07], rex);
 494         } else if (c >= 0300 && c <= 0302) {
 495             a_used = TRUE;
 496         } else if (c == 0310) {
 497             if (asize != 16)
 498                 return FALSE;
 499             else
 500                 a_used = TRUE;
 501         } else if (c == 0311) {
 502             if (asize == 16)
 503                 return FALSE;
 504             else
 505                 a_used = TRUE;
 506         } else if (c == 0312) {
 507             if (asize != segsize)
 508                 return FALSE;
 509             else
 510                 a_used = TRUE;
 511         } else if (c == 0313) {
 512             if (asize != 64)
 513                 return FALSE;
 514             else
 515                 a_used = TRUE;
 516         } else if (c == 0320) {
 517             if (osize != 16)
 518                 return FALSE;
 519             else
 520                 o_used = TRUE;
 521         } else if (c == 0321) {
 522             if (osize != 32)
 523                 return FALSE;
 524             else
 525                 o_used = TRUE;
 526         } else if (c == 0322) {
 527             if (osize != (segsize == 16) ? 16 : 32)
 528                 return FALSE;
 529             else
 530                 o_used = TRUE;
 531         } else if (c == 0323) {
 532             rex |= REX_W;       /* 64-bit only instruction */
 533             osize = 64;
 534         } else if (c == 0324) {
 535             if (!(rex & (REX_P|REX_W)) || osize != 64)
 536                 return FALSE;
 537         } else if (c == 0330) {
 538             int t = *r++, d = *data++;
 539             if (d < t || d > t + 15)
 540                 return FALSE;
 541             else
 542                 ins->condition = d - t;
 543         } else if (c == 0331) {
 544             if (rep)
 545                 return FALSE;
 546         } else if (c == 0332) {
 547             if (drep == P_REP)
 548                 drep = P_REPE;
 549         } else if (c == 0333) {
 550             if (rep != 0xF3)
 551                 return FALSE;
 552             drep = 0;
 553         } else if (c == 0334) {
 554             if (lock) {
 555                 rex |= REX_R;
 556                 lock = 0;
 557             }
 558         }
 559     }
 560
 561     /*
 562      * Check for unused rep or a/o prefixes.
 563      */
 564     ins->nprefix = 0;
 565     if (lock)
 566         ins->prefixes[ins->nprefix++] = P_LOCK;
 567     if (drep)
 568         ins->prefixes[ins->nprefix++] = drep;
 569     if (!a_used && asize != segsize)
 570         ins->prefixes[ins->nprefix++] = asize == 16 ? P_A16 : P_A32;
 571     if (!o_used && osize == ((segsize == 16) ? 32 : 16))
 572         ins->prefixes[ins->nprefix++] = osize == 16 ? P_O16 : P_O32;
 573
 574     /* Fix: check for redundant REX prefixes */
 575
 576     *rexout = rex;
 577     return data - origdata;
 578 }
 579
 580 int32_t disasm(uint8_t *data, char *output, int outbufsize, int segsize,
 581             int32_t offset, int autosync, uint32_t prefer)
 582 {
 583     const struct itemplate * const *p, * const *best_p;
 584     int length, best_length = 0;
 585     char *segover;
 586     int rep, lock, asize, osize, i, slen, colon, rex, rexout, best_rex;
 587     uint8_t *origdata;
 588     int works;
 589     insn tmp_ins, ins;
 590     uint32_t goodness, best;
 591
 592     memset(&ins, 0, sizeof ins);
 593
 594     /*
 595      * Scan for prefixes.
 596      */
 597     asize = segsize;
 598     osize = (segsize == 64) ? 32 : segsize;
 599     rex = 0;
 600     segover = NULL;
 601     rep = lock = 0;
 602     origdata = data;
 603     for (;;) {
 604         if (*data == 0xF3 || *data == 0xF2)
 605             rep = *data++;
 606         else if (*data == 0xF0)
 607             lock = *data++;
 608         else if (*data == 0x2E)
 609             segover = "cs", data++;
 610         else if (*data == 0x36)
 611             segover = "ss", data++;
 612         else if (*data == 0x3E)
 613             segover = "ds", data++;
 614         else if (*data == 0x26)
 615             segover = "es", data++;
 616         else if (*data == 0x64)
 617             segover = "fs", data++;
 618         else if (*data == 0x65)
 619             segover = "gs", data++;
 620         else if (*data == 0x66) {
 621             osize = (segsize == 16) ? 32 : 16;
 622             data++;
 623         } else if (*data == 0x67) {
 624             asize = (segsize == 32) ? 16 : 32;
 625             data++;
 626         } else if (segsize == 64 && (*data & 0xf0) == REX_P) {
 627             rex = *data++;
 628             if (rex & REX_W)
 629                 osize = 64;
 630             break;              /* REX is always the last prefix */
 631         } else {
 632             break;
 633         }
 634     }
 635
 636     tmp_ins.oprs[0].segment = tmp_ins.oprs[1].segment =
 637         tmp_ins.oprs[2].segment =
 638         tmp_ins.oprs[0].addr_size = tmp_ins.oprs[1].addr_size =
 639         tmp_ins.oprs[2].addr_size = (segsize == 64 ? SEG_64BIT :
 640                                      segsize == 32 ? SEG_32BIT : 0);
 641     tmp_ins.condition = -1;
 642     best = -1;                  /* Worst possible */
 643     best_p = NULL;
 644     best_rex = 0;
 645     for (p = itable[*data]; *p; p++) {
 646         if ((length = matches(*p, data, asize, osize, segsize, rep,
 647                               &tmp_ins, rex, &rexout, lock))) {
 648             works = TRUE;
 649             /*
 650              * Final check to make sure the types of r/m match up.
 651              * XXX: Need to make sure this is actually correct.
 652              */
 653             for (i = 0; i < (*p)->operands; i++) {
 654                 if (
 655                        /* If it's a mem-only EA but we have a register, die. */
 656                        ((tmp_ins.oprs[i].segment & SEG_RMREG) &&
 657                         !(MEMORY & ~(*p)->opd[i])) ||
 658                        /* If it's a reg-only EA but we have a memory ref, die. */
 659                        (!(tmp_ins.oprs[i].segment & SEG_RMREG) &&
 660                         !(REG_EA & ~(*p)->opd[i]) &&
 661                         !((*p)->opd[i] & REG_SMASK)) ||
 662                        /* Register type mismatch (eg FS vs REG_DESS): die. */
 663                        ((((*p)->opd[i] & (REGISTER | FPUREG)) ||
 664                          (tmp_ins.oprs[i].segment & SEG_RMREG)) &&
 665                         !whichreg((*p)->opd[i],
 666                                   tmp_ins.oprs[i].basereg, rexout))) {
 667                     works = FALSE;
 668                     break;
 669                 }
 670             }
 671
 672             if (works) {
 673                 goodness = ((*p)->flags & IF_PFMASK) ^ prefer;
 674                 if (goodness < best) {
 675                     /* This is the best one found so far */
 676                     best = goodness;
 677                     best_p = p;
 678                     best_length = length;
 679                     ins = tmp_ins;
 680                     best_rex = rexout;
 681                 }
 682             }
 683         }
 684     }
 685
 686     if (!best_p)
 687         return 0;               /* no instruction was matched */
 688
 689     /* Pick the best match */
 690     p = best_p;
 691     length = best_length;
 692     rex = best_rex;
 693     if (best_rex & REX_W)
 694         osize = 64;
 695
 696     slen = 0;
 697
 698     /* TODO: snprintf returns the value that the string would have if
 699      *      the buffer were long enough, and not the actual length of
 700      *      the returned string, so each instance of using the return
 701      *      value of snprintf should actually be checked to assure that
 702      *      the return value is "sane."  Maybe a macro wrapper could
 703      *      be used for that purpose.
 704      */
 705     for (i = 0; i < ins.nprefix; i++)
 706         switch (ins.prefixes[i]) {
 707         case P_LOCK:
 708             slen += snprintf(output + slen, outbufsize - slen, "lock ");
 709             break;
 710         case P_REP:
 711             slen += snprintf(output + slen, outbufsize - slen, "rep ");
 712             break;
 713         case P_REPE:
 714             slen += snprintf(output + slen, outbufsize - slen, "repe ");
 715             break;
 716         case P_REPNE:
 717             slen += snprintf(output + slen, outbufsize - slen, "repne ");
 718             break;
 719         case P_A16:
 720             slen += snprintf(output + slen, outbufsize - slen, "a16 ");
 721             break;
 722         case P_A32:
 723             slen += snprintf(output + slen, outbufsize - slen, "a32 ");
 724             break;
 725         case P_O16:
 726             slen += snprintf(output + slen, outbufsize - slen, "o16 ");
 727             break;
 728         case P_O32:
 729             slen += snprintf(output + slen, outbufsize - slen, "o32 ");
 730             break;
 731         }
 732
 733     for (i = 0; i < elements(ico); i++)
 734         if ((*p)->opcode == ico[i]) {
 735             slen +=
 736                 snprintf(output + slen, outbufsize - slen, "%s%s", icn[i],
 737                          whichcond(ins.condition));
 738             break;
 739         }
 740     if (i >= elements(ico))
 741         slen +=
 742             snprintf(output + slen, outbufsize - slen, "%s",
 743                      insn_names[(*p)->opcode]);
 744     colon = FALSE;
 745     length += data - origdata;  /* fix up for prefixes */
 746     for (i = 0; i < (*p)->operands; i++) {
 747         output[slen++] = (colon ? ':' : i == 0 ? ' ' : ',');
 748
 749         if (ins.oprs[i].segment & SEG_RELATIVE) {
 750             ins.oprs[i].offset += offset + length;
 751             /*
 752              * sort out wraparound
 753              */
 754             if (!(ins.oprs[i].segment & (SEG_32BIT|SEG_64BIT)))
 755                 ins.oprs[i].offset &= 0xffff;
 756             /*
 757              * add sync marker, if autosync is on
 758              */
 759             if (autosync)
 760                 add_sync(ins.oprs[i].offset, 0L);
 761         }
 762
 763         if ((*p)->opd[i] & COLON)
 764             colon = TRUE;
 765         else
 766             colon = FALSE;
 767
 768         if (((*p)->opd[i] & (REGISTER | FPUREG)) ||
 769             (ins.oprs[i].segment & SEG_RMREG)) {
 770             ins.oprs[i].basereg = whichreg((*p)->opd[i],
 771                                            ins.oprs[i].basereg, rex);
 772             if ((*p)->opd[i] & TO)
 773                 slen += snprintf(output + slen, outbufsize - slen, "to ");
 774             slen += snprintf(output + slen, outbufsize - slen, "%s",
 775                              reg_names[ins.oprs[i].basereg -
 776                                        EXPR_REG_START]);
 777         } else if (!(UNITY & ~(*p)->opd[i])) {
 778             output[slen++] = '1';
 779         } else if ((*p)->opd[i] & IMMEDIATE) {
 780             if ((*p)->opd[i] & BITS8) {
 781                 slen +=
 782                     snprintf(output + slen, outbufsize - slen, "byte ");
 783                 if (ins.oprs[i].segment & SEG_SIGNED) {
 784                     if (ins.oprs[i].offset < 0) {
 785                         ins.oprs[i].offset *= -1;
 786                         output[slen++] = '-';
 787                     } else
 788                         output[slen++] = '+';
 789                 }
 790             } else if ((*p)->opd[i] & BITS16) {
 791                 slen +=
 792                     snprintf(output + slen, outbufsize - slen, "word ");
 793             } else if ((*p)->opd[i] & BITS32) {
 794                 slen +=
 795                     snprintf(output + slen, outbufsize - slen, "dword ");
 796             } else if ((*p)->opd[i] & BITS64) {
 797                 slen +=
 798                     snprintf(output + slen, outbufsize - slen, "qword ");
 799             } else if ((*p)->opd[i] & NEAR) {
 800                 slen +=
 801                     snprintf(output + slen, outbufsize - slen, "near ");
 802             } else if ((*p)->opd[i] & SHORT) {
 803                 slen +=
 804                     snprintf(output + slen, outbufsize - slen, "short ");
 805             }
 806             slen +=
 807                 snprintf(output + slen, outbufsize - slen, "0x%"PRIx64"",
 808                          ins.oprs[i].offset);
 809         } else if (!(MEM_OFFS & ~(*p)->opd[i])) {
 810             slen +=
 811                 snprintf(output + slen, outbufsize - slen, "[%s%s%s0x%"PRIx64"]",
 812                          ((const char*)segover ? (const char*)segover : ""),    /* placate type mistmatch warning */
 813                          ((const char*)segover ? ":" : ""),                     /* by using (const char*) instead of uint8_t* */
 814                          (ins.oprs[i].addr_size ==
 815                           32 ? "dword " : ins.oprs[i].addr_size ==
 816                           16 ? "word " : ""), ins.oprs[i].offset);
 817             segover = NULL;
 818         } else if (!(REGMEM & ~(*p)->opd[i])) {
 819             int started = FALSE;
 820             if ((*p)->opd[i] & BITS8)
 821                 slen +=
 822                     snprintf(output + slen, outbufsize - slen, "byte ");
 823             if ((*p)->opd[i] & BITS16)
 824                 slen +=
 825                     snprintf(output + slen, outbufsize - slen, "word ");
 826             if ((*p)->opd[i] & BITS32)
 827                 slen +=
 828                     snprintf(output + slen, outbufsize - slen, "dword ");
 829             if ((*p)->opd[i] & BITS64)
 830                 slen +=
 831                     snprintf(output + slen, outbufsize - slen, "qword ");
 832             if ((*p)->opd[i] & BITS80)
 833                 slen +=
 834                     snprintf(output + slen, outbufsize - slen, "tword ");
 835             if ((*p)->opd[i] & FAR)
 836                 slen += snprintf(output + slen, outbufsize - slen, "far ");
 837             if ((*p)->opd[i] & NEAR)
 838                 slen +=
 839                     snprintf(output + slen, outbufsize - slen, "near ");
 840             output[slen++] = '[';
 841             if (ins.oprs[i].addr_size)
 842                 slen += snprintf(output + slen, outbufsize - slen, "%s",
 843                                  (ins.oprs[i].addr_size == 64 ? "qword " :
 844                                   ins.oprs[i].addr_size == 32 ? "dword " :
 845                                   ins.oprs[i].addr_size == 16 ? "word " :
 846                                   ""));
 847             if (ins.oprs[i].eaflags & EAF_REL)
 848                 slen += snprintf(output + slen, outbufsize - slen, "rel ");
 849             if (segover) {
 850                 slen +=
 851                     snprintf(output + slen, outbufsize - slen, "%s:",
 852                              segover);
 853                 segover = NULL;
 854             }
 855             if (ins.oprs[i].basereg != -1) {
 856                 slen += snprintf(output + slen, outbufsize - slen, "%s",
 857                                  reg_names[(ins.oprs[i].basereg -
 858                                             EXPR_REG_START)]);
 859                 started = TRUE;
 860             }
 861             if (ins.oprs[i].indexreg != -1) {
 862                 if (started)
 863                     output[slen++] = '+';
 864                 slen += snprintf(output + slen, outbufsize - slen, "%s",
 865                                  reg_names[(ins.oprs[i].indexreg -
 866                                             EXPR_REG_START)]);
 867                 if (ins.oprs[i].scale > 1)
 868                     slen +=
 869                         snprintf(output + slen, outbufsize - slen, "*%d",
 870                                  ins.oprs[i].scale);
 871                 started = TRUE;
 872             }
 873             if (ins.oprs[i].segment & SEG_DISP8) {
 874                 int minus = 0;
 875                 int8_t offset = ins.oprs[i].offset;
 876                 if (offset < 0) {
 877                     minus = 1;
 878                     offset = -offset;
 879                 }
 880                 slen +=
 881                     snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx8"",
 882                              minus ? "-" : "+", offset);
 883             } else if (ins.oprs[i].segment & SEG_DISP16) {
 884                 int minus = 0;
 885                 int16_t offset = ins.oprs[i].offset;
 886                 if (offset < 0) {
 887                     minus = 1;
 888                     offset = -offset;
 889                 }
 890                 slen +=
 891                     snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx16"",
 892                              minus ? "-" : started ? "+" : "", offset);
 893             } else if (ins.oprs[i].segment & SEG_DISP32) {
 894                     char *prefix = "";
 895                     int32_t offset = ins.oprs[i].offset;
 896                     if (offset < 0) {
 897                         offset = -offset;
 898                         prefix = "-";
 899                     } else {
 900                         prefix = started ? "+" : "";
 901                     }
 902                     slen +=
 903                         snprintf(output + slen, outbufsize - slen,
 904                                  "%s0x%"PRIx32"", prefix, offset);
 905             }
 906             output[slen++] = ']';
 907         } else {
 908             slen +=
 909                 snprintf(output + slen, outbufsize - slen, "<operand%d>",
 910                          i);
 911         }
 912     }
 913     output[slen] = '\0';
 914     if (segover) {              /* unused segment override */
 915         char *p = output;
 916         int count = slen + 1;
 917         while (count--)
 918             p[count + 3] = p[count];
 919         strncpy(output, segover, 2);
 920         output[2] = ' ';
 921     }
 922     return length;
 923 }
 924
 925 int32_t eatbyte(uint8_t *data, char *output, int outbufsize)
 926 {
 927     snprintf(output, outbufsize, "db 0x%02X", *data);
 928     return 1;
 929 }