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