assemble.c

   1 /* assemble.c   code generation for the Netwide Assembler
   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  * the actual codes (C syntax, i.e. octal):
   9  * \0            - terminates the code. (Unless it's a literal of course.)
  10  * \1, \2, \3    - that many literal bytes follow in the code stream
  11  * \4, \6        - the POP/PUSH (respectively) codes for CS, DS, ES, SS
  12  *                 (POP is never used for CS) depending on operand 0
  13  * \5, \7        - the second byte of POP/PUSH codes for FS, GS, depending
  14  *                 on operand 0
  15  * \10..\13      - a literal byte follows in the code stream, to be added
  16  *                 to the register value of operand 0..3
  17  * \14..\17      - a signed byte immediate operand, from operand 0..3
  18  * \20..\23      - a byte immediate operand, from operand 0..3
  19  * \24..\27      - an unsigned byte immediate operand, from operand 0..3
  20  * \30..\33      - a word immediate operand, from operand 0..3
  21  * \34..\37      - select between \3[0-3] and \4[0-3] depending on 16/32 bit
  22  *                 assembly mode or the operand-size override on the operand
  23  * \40..\43      - a long immediate operand, from operand 0..3
  24  * \44..\47      - select between \3[0-3], \4[0-3] and \5[4-7]
  25  *                 depending on assembly mode or the address-size override
  26  *                 on the operand.
  27  * \50..\53      - a byte relative operand, from operand 0..3
  28  * \54..\57      - a qword immediate operand, from operand 0..3
  29  * \60..\63      - a word relative operand, from operand 0..3
  30  * \64..\67      - select between \6[0-3] and \7[0-3] depending on 16/32 bit
  31  *                 assembly mode or the operand-size override on the operand
  32  * \70..\73      - a long relative operand, from operand 0..3
  33  * \74..\77       - a word constant, from the _segment_ part of operand 0..3
  34  * \1ab          - a ModRM, calculated on EA in operand a, with the spare
  35  *                 field the register value of operand b.
  36  * \140..\143    - an immediate word or signed byte for operand 0..3
  37  * \144..\147    - or 2 (s-field) into next opcode byte if operand 0..3
  38  *                  is a signed byte rather than a word.
  39  * \150..\153     - an immediate dword or signed byte for operand 0..3
  40  * \154..\157     - or 2 (s-field) into next opcode byte if operand 0..3
  41  *                  is a signed byte rather than a dword.
  42  * \160..\163    - this instruction uses DREX rather than REX, with the
  43  *                 OC0 field set to 0, and the dest field taken from
  44  *                 operand 0..3.
  45  * \164..\167    - this instruction uses DREX rather than REX, with the
  46  *                 OC0 field set to 1, and the dest field taken from
  47  *                 operand 0..3.
  48  * \170          - encodes the literal byte 0. (Some compilers don't take
  49  *                 kindly to a zero byte in the _middle_ of a compile time
  50  *                 string constant, so I had to put this hack in.)
  51  * \171          - placement of DREX suffix in the absence of an EA
  52  * \2ab          - a ModRM, calculated on EA in operand a, with the spare
  53  *                 field equal to digit b.
  54  * \30x          - might be an 0x67 byte, depending on the address size of
  55  *                 the memory reference in operand x.
  56  * \310          - indicates fixed 16-bit address size, i.e. optional 0x67.
  57  * \311          - indicates fixed 32-bit address size, i.e. optional 0x67.
  58  * \312          - (disassembler only) marker on LOOP, LOOPxx instructions.
  59  * \313          - indicates fixed 64-bit address size, 0x67 invalid.
  60  * \320          - indicates fixed 16-bit operand size, i.e. optional 0x66.
  61  * \321          - indicates fixed 32-bit operand size, i.e. optional 0x66.
  62  * \322          - indicates that this instruction is only valid when the
  63  *                 operand size is the default (instruction to disassembler,
  64  *                 generates no code in the assembler)
  65  * \323          - indicates fixed 64-bit operand size, REX on extensions only.
  66  * \324          - indicates 64-bit operand size requiring REX prefix.
  67  * \330          - a literal byte follows in the code stream, to be added
  68  *                 to the condition code value of the instruction.
  69  * \331          - instruction not valid with REP prefix.  Hint for
  70  *                 disassembler only; for SSE instructions.
  71  * \332          - REP prefix (0xF2 byte) used as opcode extension.
  72  * \333          - REP prefix (0xF3 byte) used as opcode extension.
  73  * \334          - LOCK prefix used instead of REX.R
  74  * \335          - disassemble a rep (0xF3 byte) prefix as repe not rep.
  75  * \340          - reserve <operand 0> bytes of uninitialized storage.
  76  *                 Operand 0 had better be a segmentless constant.
  77  * \364          - operand-size prefix (0x66) not permitted
  78  * \365          - address-size prefix (0x67) not permitted
  79  * \366          - operand-size prefix (0x66) used as opcode extension
  80  * \367          - address-size prefix (0x67) used as opcode extension
  81  * \370,\371,\372 - match only if operand 0 meets byte jump criteria.
  82  *                 370 is used for Jcc, 371 is used for JMP.
  83  * \373          - assemble 0x03 if bits==16, 0x05 if bits==32;
  84  *                 used for conditional jump over longer jump
  85  */
  86
  87 #include <stdio.h>
  88 #include <string.h>
  89 #include <inttypes.h>
  90
  91 #include "nasm.h"
  92 #include "nasmlib.h"
  93 #include "assemble.h"
  94 #include "insns.h"
  95 #include "preproc.h"
  96 #include "regflags.c"
  97 #include "regvals.c"
  98
  99 typedef struct {
 100     int sib_present;                 /* is a SIB byte necessary? */
 101     int bytes;                       /* # of bytes of offset needed */
 102     int size;                        /* lazy - this is sib+bytes+1 */
 103     uint8_t modrm, sib, rex, rip;    /* the bytes themselves */
 104 } ea;
 105
 106 static uint32_t cpu;            /* cpu level received from nasm.c */
 107 static efunc errfunc;
 108 static struct ofmt *outfmt;
 109 static ListGen *list;
 110
 111 static int32_t calcsize(int32_t, int32_t, int, insn *, const char *);
 112 static void gencode(int32_t, int32_t, int, insn *, const char *, int32_t);
 113 static int matches(const struct itemplate *, insn *, int bits);
 114 static int32_t regflag(const operand *);
 115 static int32_t regval(const operand *);
 116 static int rexflags(int, int32_t, int);
 117 static int op_rexflags(const operand *, int);
 118 static ea *process_ea(operand *, ea *, int, int, int32_t, int);
 119 static int chsize(operand *, int);
 120
 121 static void assert_no_prefix(insn * ins, int prefix)
 122 {
 123     int j;
 124
 125     for (j = 0; j < ins->nprefix; j++) {
 126         if (ins->prefixes[j] == prefix) {
 127             errfunc(ERR_NONFATAL, "invalid %s prefix", prefix_name(prefix));
 128             break;
 129         }
 130     }
 131 }
 132
 133 /*
 134  * This routine wrappers the real output format's output routine,
 135  * in order to pass a copy of the data off to the listing file
 136  * generator at the same time.
 137  */
 138 static void out(int32_t offset, int32_t segto, const void *data,
 139                 uint32_t type, int32_t segment, int32_t wrt)
 140 {
 141     static int32_t lineno = 0;     /* static!!! */
 142     static char *lnfname = NULL;
 143
 144     if ((type & OUT_TYPMASK) == OUT_ADDRESS) {
 145         if (segment != NO_SEG || wrt != NO_SEG) {
 146             /*
 147              * This address is relocated. We must write it as
 148              * OUT_ADDRESS, so there's no work to be done here.
 149              */
 150             list->output(offset, data, type);
 151         } else {
 152             uint8_t p[8], *q = p;
 153             /*
 154              * This is a non-relocated address, and we're going to
 155              * convert it into RAWDATA format.
 156              */
 157             if ((type & OUT_SIZMASK) == 4) {
 158                 WRITELONG(q, *(int32_t *)data);
 159                 list->output(offset, p, OUT_RAWDATA + 4);
 160             } else if ((type & OUT_SIZMASK) == 8) {
 161                 WRITEDLONG(q, *(int64_t *)data);
 162                 list->output(offset, p, OUT_RAWDATA + 8);
 163             } else {
 164                 WRITESHORT(q, *(int32_t *)data);
 165                 list->output(offset, p, OUT_RAWDATA + 2);
 166             }
 167         }
 168     } else if ((type & OUT_TYPMASK) == OUT_RAWDATA) {
 169         list->output(offset, data, type);
 170     } else if ((type & OUT_TYPMASK) == OUT_RESERVE) {
 171         list->output(offset, NULL, type);
 172     } else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
 173                (type & OUT_TYPMASK) == OUT_REL4ADR) {
 174         list->output(offset, data, type);
 175     }
 176
 177     /*
 178      * this call to src_get determines when we call the
 179      * debug-format-specific "linenum" function
 180      * it updates lineno and lnfname to the current values
 181      * returning 0 if "same as last time", -2 if lnfname
 182      * changed, and the amount by which lineno changed,
 183      * if it did. thus, these variables must be static
 184      */
 185
 186     if (src_get(&lineno, &lnfname)) {
 187         outfmt->current_dfmt->linenum(lnfname, lineno, segto);
 188     }
 189
 190     outfmt->output(segto, data, type, segment, wrt);
 191 }
 192
 193 static int jmp_match(int32_t segment, int32_t offset, int bits,
 194                      insn * ins, const char *code)
 195 {
 196     int32_t isize;
 197     uint8_t c = code[0];
 198
 199     if (c != 0370 && c != 0371)
 200         return 0;
 201     if (ins->oprs[0].opflags & OPFLAG_FORWARD) {
 202         if ((optimizing < 0 || (ins->oprs[0].type & STRICT))
 203             && c == 0370)
 204             return 1;
 205         else
 206             return (pass0 == 0);        /* match a forward reference */
 207     }
 208     isize = calcsize(segment, offset, bits, ins, code);
 209     if (ins->oprs[0].segment != segment)
 210         return 0;
 211     isize = ins->oprs[0].offset - offset - isize;       /* isize is now the delta */
 212     if (isize >= -128L && isize <= 127L)
 213         return 1;               /* it is byte size */
 214
 215     return 0;
 216 }
 217
 218 int32_t assemble(int32_t segment, int32_t offset, int bits, uint32_t cp,
 219               insn * instruction, struct ofmt *output, efunc error,
 220               ListGen * listgen)
 221 {
 222     const struct itemplate *temp;
 223     int j;
 224     int size_prob;
 225     int32_t insn_end;
 226     int32_t itimes;
 227     int32_t start = offset;
 228     int32_t wsize = 0;             /* size for DB etc. */
 229
 230     errfunc = error;            /* to pass to other functions */
 231     cpu = cp;
 232     outfmt = output;            /* likewise */
 233     list = listgen;             /* and again */
 234
 235     switch (instruction->opcode) {
 236     case -1:
 237         return 0;
 238     case I_DB:
 239         wsize = 1;
 240         break;
 241     case I_DW:
 242         wsize = 2;
 243         break;
 244     case I_DD:
 245         wsize = 4;
 246         break;
 247     case I_DQ:
 248         wsize = 8;
 249         break;
 250     case I_DT:
 251         wsize = 10;
 252         break;
 253     case I_DO:
 254         wsize = 16;
 255         break;
 256     default:
 257         break;
 258     }
 259
 260     if (wsize) {
 261         extop *e;
 262         int32_t t = instruction->times;
 263         if (t < 0)
 264             errfunc(ERR_PANIC,
 265                     "instruction->times < 0 (%ld) in assemble()", t);
 266
 267         while (t--) {           /* repeat TIMES times */
 268             for (e = instruction->eops; e; e = e->next) {
 269                 if (e->type == EOT_DB_NUMBER) {
 270                     if (wsize == 1) {
 271                         if (e->segment != NO_SEG)
 272                             errfunc(ERR_NONFATAL,
 273                                     "one-byte relocation attempted");
 274                         else {
 275                             uint8_t out_byte = e->offset;
 276                             out(offset, segment, &out_byte,
 277                                 OUT_RAWDATA + 1, NO_SEG, NO_SEG);
 278                         }
 279                     } else if (wsize > 8) {
 280                         errfunc(ERR_NONFATAL, "integer supplied to a DT"
 281                                 " instruction");
 282                     } else
 283                         out(offset, segment, &e->offset,
 284                             OUT_ADDRESS + wsize, e->segment, e->wrt);
 285                     offset += wsize;
 286                 } else if (e->type == EOT_DB_STRING) {
 287                     int align;
 288
 289                     out(offset, segment, e->stringval,
 290                         OUT_RAWDATA + e->stringlen, NO_SEG, NO_SEG);
 291                     align = e->stringlen % wsize;
 292
 293                     if (align) {
 294                         align = wsize - align;
 295                         out(offset, segment, "\0\0\0\0\0\0\0\0",
 296                             OUT_RAWDATA + align, NO_SEG, NO_SEG);
 297                     }
 298                     offset += e->stringlen + align;
 299                 }
 300             }
 301             if (t > 0 && t == instruction->times - 1) {
 302                 /*
 303                  * Dummy call to list->output to give the offset to the
 304                  * listing module.
 305                  */
 306                 list->output(offset, NULL, OUT_RAWDATA);
 307                 list->uplevel(LIST_TIMES);
 308             }
 309         }
 310         if (instruction->times > 1)
 311             list->downlevel(LIST_TIMES);
 312         return offset - start;
 313     }
 314
 315     if (instruction->opcode == I_INCBIN) {
 316         static char fname[FILENAME_MAX];
 317         FILE *fp;
 318         int32_t len;
 319         char *prefix = "", *combine;
 320         char **pPrevPath = NULL;
 321
 322         len = FILENAME_MAX - 1;
 323         if (len > instruction->eops->stringlen)
 324             len = instruction->eops->stringlen;
 325         strncpy(fname, instruction->eops->stringval, len);
 326         fname[len] = '\0';
 327
 328         while (1) {         /* added by alexfru: 'incbin' uses include paths */
 329             combine = nasm_malloc(strlen(prefix) + len + 1);
 330             strcpy(combine, prefix);
 331             strcat(combine, fname);
 332
 333             if ((fp = fopen(combine, "rb")) != NULL) {
 334                 nasm_free(combine);
 335                 break;
 336             }
 337
 338             nasm_free(combine);
 339             pPrevPath = pp_get_include_path_ptr(pPrevPath);
 340             if (pPrevPath == NULL)
 341                 break;
 342             prefix = *pPrevPath;
 343         }
 344
 345         if (fp == NULL)
 346             error(ERR_NONFATAL, "`incbin': unable to open file `%s'",
 347                   fname);
 348         else if (fseek(fp, 0L, SEEK_END) < 0)
 349             error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
 350                   fname);
 351         else {
 352             static char buf[2048];
 353             int32_t t = instruction->times;
 354             int32_t base = 0;
 355
 356             len = ftell(fp);
 357             if (instruction->eops->next) {
 358                 base = instruction->eops->next->offset;
 359                 len -= base;
 360                 if (instruction->eops->next->next &&
 361                     len > instruction->eops->next->next->offset)
 362                     len = instruction->eops->next->next->offset;
 363             }
 364             /*
 365              * Dummy call to list->output to give the offset to the
 366              * listing module.
 367              */
 368             list->output(offset, NULL, OUT_RAWDATA);
 369             list->uplevel(LIST_INCBIN);
 370             while (t--) {
 371                 int32_t l;
 372
 373                 fseek(fp, base, SEEK_SET);
 374                 l = len;
 375                 while (l > 0) {
 376                     int32_t m =
 377                         fread(buf, 1, (l > sizeof(buf) ? sizeof(buf) : l),
 378                               fp);
 379                     if (!m) {
 380                         /*
 381                          * This shouldn't happen unless the file
 382                          * actually changes while we are reading
 383                          * it.
 384                          */
 385                         error(ERR_NONFATAL,
 386                               "`incbin': unexpected EOF while"
 387                               " reading file `%s'", fname);
 388                         t = 0;  /* Try to exit cleanly */
 389                         break;
 390                     }
 391                     out(offset, segment, buf, OUT_RAWDATA + m,
 392                         NO_SEG, NO_SEG);
 393                     l -= m;
 394                 }
 395             }
 396             list->downlevel(LIST_INCBIN);
 397             if (instruction->times > 1) {
 398                 /*
 399                  * Dummy call to list->output to give the offset to the
 400                  * listing module.
 401                  */
 402                 list->output(offset, NULL, OUT_RAWDATA);
 403                 list->uplevel(LIST_TIMES);
 404                 list->downlevel(LIST_TIMES);
 405             }
 406             fclose(fp);
 407             return instruction->times * len;
 408         }
 409         return 0;               /* if we're here, there's an error */
 410     }
 411
 412     size_prob = FALSE;
 413
 414     for (temp = nasm_instructions[instruction->opcode]; temp->opcode != -1; temp++){
 415         int m = matches(temp, instruction, bits);
 416
 417         if (m == 99)
 418             m += jmp_match(segment, offset, bits, instruction, temp->code);
 419
 420         if (m == 100) {         /* matches! */
 421             const char *codes = temp->code;
 422             int32_t insn_size = calcsize(segment, offset, bits,
 423                                       instruction, codes);
 424             itimes = instruction->times;
 425             if (insn_size < 0)  /* shouldn't be, on pass two */
 426                 error(ERR_PANIC, "errors made it through from pass one");
 427             else
 428                 while (itimes--) {
 429                     for (j = 0; j < instruction->nprefix; j++) {
 430                         uint8_t c = 0;
 431                         switch (instruction->prefixes[j]) {
 432                         case P_LOCK:
 433                             c = 0xF0;
 434                             break;
 435                         case P_REPNE:
 436                         case P_REPNZ:
 437                             c = 0xF2;
 438                             break;
 439                         case P_REPE:
 440                         case P_REPZ:
 441                         case P_REP:
 442                             c = 0xF3;
 443                             break;
 444                         case R_CS:
 445                             if (bits == 64) {
 446                                 error(ERR_WARNING,
 447                                       "cs segment base ignored in 64-bit mode");
 448                             }
 449                             c = 0x2E;
 450                             break;
 451                         case R_DS:
 452                             if (bits == 64) {
 453                                 error(ERR_WARNING,
 454                                       "ds segment base ignored in 64-bit mode");
 455                             }
 456                             c = 0x3E;
 457                             break;
 458                         case R_ES:
 459                            if (bits == 64) {
 460                                 error(ERR_WARNING,
 461                                       "es segment base ignored in 64-bit mode");
 462                            }
 463                             c = 0x26;
 464                             break;
 465                         case R_FS:
 466                             c = 0x64;
 467                             break;
 468                         case R_GS:
 469                             c = 0x65;
 470                             break;
 471                         case R_SS:
 472                             if (bits == 64) {
 473                                 error(ERR_WARNING,
 474                                       "ss segment base ignored in 64-bit mode");
 475                             }
 476                             c = 0x36;
 477                             break;
 478                         case R_SEGR6:
 479                         case R_SEGR7:
 480                             error(ERR_NONFATAL,
 481                                   "segr6 and segr7 cannot be used as prefixes");
 482                             break;
 483                         case P_A16:
 484                             if (bits == 64) {
 485                                 error(ERR_NONFATAL,
 486                                       "16-bit addressing is not supported "
 487                                       "in 64-bit mode");
 488                                 break;
 489                             }
 490                             if (bits != 16)
 491                                 c = 0x67;
 492                             break;
 493                         case P_A32:
 494                             if (bits != 32)
 495                                 c = 0x67;
 496                             break;
 497                         case P_O16:
 498                             if (bits != 16)
 499                                 c = 0x66;
 500                             break;
 501                         case P_O32:
 502                             if (bits == 16)
 503                                 c = 0x66;
 504                             break;
 505                         default:
 506                             error(ERR_PANIC, "invalid instruction prefix");
 507                         }
 508                         if (c != 0) {
 509                             out(offset, segment, &c, OUT_RAWDATA + 1,
 510                                 NO_SEG, NO_SEG);
 511                             offset++;
 512                         }
 513                     }
 514                     insn_end = offset + insn_size;
 515                     gencode(segment, offset, bits, instruction, codes,
 516                             insn_end);
 517                     offset += insn_size;
 518                     if (itimes > 0 && itimes == instruction->times - 1) {
 519                         /*
 520                          * Dummy call to list->output to give the offset to the
 521                          * listing module.
 522                          */
 523                         list->output(offset, NULL, OUT_RAWDATA);
 524                         list->uplevel(LIST_TIMES);
 525                     }
 526                 }
 527             if (instruction->times > 1)
 528                 list->downlevel(LIST_TIMES);
 529             return offset - start;
 530         } else if (m > 0 && m > size_prob) {
 531             size_prob = m;
 532         }
 533 //        temp++;
 534     }
 535
 536     if (temp->opcode == -1) {   /* didn't match any instruction */
 537         switch (size_prob) {
 538         case 1:
 539             error(ERR_NONFATAL, "operation size not specified");
 540             break;
 541         case 2:
 542             error(ERR_NONFATAL, "mismatch in operand sizes");
 543             break;
 544         case 3:
 545             error(ERR_NONFATAL, "no instruction for this cpu level");
 546             break;
 547         case 4:
 548             error(ERR_NONFATAL, "instruction not supported in 64-bit mode");
 549             break;
 550         default:
 551             error(ERR_NONFATAL,
 552                   "invalid combination of opcode and operands");
 553             break;
 554         }
 555     }
 556     return 0;
 557 }
 558
 559 int32_t insn_size(int32_t segment, int32_t offset, int bits, uint32_t cp,
 560                insn * instruction, efunc error)
 561 {
 562     const struct itemplate *temp;
 563
 564     errfunc = error;            /* to pass to other functions */
 565     cpu = cp;
 566
 567     if (instruction->opcode == -1)
 568         return 0;
 569
 570     if (instruction->opcode == I_DB || instruction->opcode == I_DW ||
 571         instruction->opcode == I_DD || instruction->opcode == I_DQ ||
 572         instruction->opcode == I_DT || instruction->opcode == I_DO) {
 573         extop *e;
 574         int32_t isize, osize, wsize = 0;   /* placate gcc */
 575
 576         isize = 0;
 577         switch (instruction->opcode) {
 578         case I_DB:
 579             wsize = 1;
 580             break;
 581         case I_DW:
 582             wsize = 2;
 583             break;
 584         case I_DD:
 585             wsize = 4;
 586             break;
 587         case I_DQ:
 588             wsize = 8;
 589             break;
 590         case I_DT:
 591             wsize = 10;
 592             break;
 593         case I_DO:
 594             wsize = 16;
 595             break;
 596         default:
 597             break;
 598         }
 599
 600         for (e = instruction->eops; e; e = e->next) {
 601             int32_t align;
 602
 603             osize = 0;
 604             if (e->type == EOT_DB_NUMBER)
 605                 osize = 1;
 606             else if (e->type == EOT_DB_STRING)
 607                 osize = e->stringlen;
 608
 609             align = (-osize) % wsize;
 610             if (align < 0)
 611                 align += wsize;
 612             isize += osize + align;
 613         }
 614         return isize * instruction->times;
 615     }
 616
 617     if (instruction->opcode == I_INCBIN) {
 618         char fname[FILENAME_MAX];
 619         FILE *fp;
 620         int32_t len;
 621         char *prefix = "", *combine;
 622         char **pPrevPath = NULL;
 623
 624         len = FILENAME_MAX - 1;
 625         if (len > instruction->eops->stringlen)
 626             len = instruction->eops->stringlen;
 627         strncpy(fname, instruction->eops->stringval, len);
 628         fname[len] = '\0';
 629
 630         while (1) {             /* added by alexfru: 'incbin' uses include paths */
 631             combine = nasm_malloc(strlen(prefix) + len + 1);
 632             strcpy(combine, prefix);
 633             strcat(combine, fname);
 634
 635             if ((fp = fopen(combine, "rb")) != NULL) {
 636                 nasm_free(combine);
 637                 break;
 638             }
 639
 640             nasm_free(combine);
 641             pPrevPath = pp_get_include_path_ptr(pPrevPath);
 642             if (pPrevPath == NULL)
 643                 break;
 644             prefix = *pPrevPath;
 645         }
 646
 647         if (fp == NULL)
 648             error(ERR_NONFATAL, "`incbin': unable to open file `%s'",
 649                   fname);
 650         else if (fseek(fp, 0L, SEEK_END) < 0)
 651             error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
 652                   fname);
 653         else {
 654             len = ftell(fp);
 655             fclose(fp);
 656             if (instruction->eops->next) {
 657                 len -= instruction->eops->next->offset;
 658                 if (instruction->eops->next->next &&
 659                     len > instruction->eops->next->next->offset) {
 660                     len = instruction->eops->next->next->offset;
 661                 }
 662             }
 663             return instruction->times * len;
 664         }
 665         return 0;               /* if we're here, there's an error */
 666     }
 667
 668     for (temp = nasm_instructions[instruction->opcode]; temp->opcode != -1; temp++) {
 669         int m = matches(temp, instruction, bits);
 670         if (m == 99)
 671             m += jmp_match(segment, offset, bits, instruction, temp->code);
 672
 673         if (m == 100) {
 674             /* we've matched an instruction. */
 675             int32_t isize;
 676             const char *codes = temp->code;
 677             int j;
 678
 679             isize = calcsize(segment, offset, bits, instruction, codes);
 680             if (isize < 0)
 681                 return -1;
 682             for (j = 0; j < instruction->nprefix; j++) {
 683                 if ((instruction->prefixes[j] != P_A16 &&
 684                      instruction->prefixes[j] != P_O16 && bits == 16) ||
 685                     (instruction->prefixes[j] != P_A32 &&
 686                      instruction->prefixes[j] != P_O32 && bits >= 32)) {
 687                     isize++;
 688                 }
 689             }
 690             return isize * instruction->times;
 691         }
 692     }
 693     return -1;                  /* didn't match any instruction */
 694 }
 695
 696 /* check that  opn[op]  is a signed byte of size 16 or 32,
 697                                         and return the signed value*/
 698 static int is_sbyte(insn * ins, int op, int size)
 699 {
 700     int32_t v;
 701     int ret;
 702
 703     ret = !(ins->forw_ref && ins->oprs[op].opflags) &&  /* dead in the water on forward reference or External */
 704         optimizing >= 0 &&
 705         !(ins->oprs[op].type & STRICT) &&
 706         ins->oprs[op].wrt == NO_SEG && ins->oprs[op].segment == NO_SEG;
 707
 708     v = ins->oprs[op].offset;
 709     if (size == 16)
 710         v = (int16_t)v;    /* sign extend if 16 bits */
 711
 712     return ret && v >= -128L && v <= 127L;
 713 }
 714
 715 static int32_t calcsize(int32_t segment, int32_t offset, int bits,
 716                      insn * ins, const char *codes)
 717 {
 718     int32_t length = 0;
 719     uint8_t c;
 720     int rex_mask = ~0;
 721     ins->rex = 0;               /* Ensure REX is reset */
 722
 723     (void)segment;              /* Don't warn that this parameter is unused */
 724     (void)offset;               /* Don't warn that this parameter is unused */
 725
 726     while (*codes)
 727         switch (c = *codes++) {
 728         case 01:
 729         case 02:
 730         case 03:
 731             codes += c, length += c;
 732             break;
 733         case 04:
 734         case 05:
 735         case 06:
 736         case 07:
 737             length++;
 738             break;
 739         case 010:
 740         case 011:
 741         case 012:
 742         case 013:
 743             ins->rex |=
 744                 op_rexflags(&ins->oprs[c - 010], REX_B|REX_H|REX_P|REX_W);
 745             codes++, length++;
 746             break;
 747         case 014:
 748         case 015:
 749         case 016:
 750         case 017:
 751             length++;
 752             break;
 753         case 020:
 754         case 021:
 755         case 022:
 756         case 023:
 757             length++;
 758             break;
 759         case 024:
 760         case 025:
 761         case 026:
 762         case 027:
 763             length++;
 764             break;
 765         case 030:
 766         case 031:
 767         case 032:
 768         case 033:
 769             length += 2;
 770             break;
 771         case 034:
 772         case 035:
 773         case 036:
 774         case 037:
 775             if (ins->oprs[c - 034].type & (BITS16 | BITS32 | BITS64))
 776                 length += (ins->oprs[c - 034].type & BITS16) ? 2 : 4;
 777             else
 778                 length += (bits == 16) ? 2 : 4;
 779             break;
 780         case 040:
 781         case 041:
 782         case 042:
 783         case 043:
 784             length += 4;
 785             break;
 786         case 044:
 787         case 045:
 788         case 046:
 789         case 047:
 790             length += ((ins->oprs[c - 044].addr_size ?
 791                         ins->oprs[c - 044].addr_size : bits) >> 3);
 792             break;
 793         case 050:
 794         case 051:
 795         case 052:
 796         case 053:
 797             length++;
 798             break;
 799         case 054:
 800         case 055:
 801         case 056:
 802         case 057:
 803             length += 8; /* MOV reg64/imm */
 804             break;
 805         case 060:
 806         case 061:
 807         case 062:
 808         case 063:
 809             length += 2;
 810             break;
 811         case 064:
 812         case 065:
 813         case 066:
 814         case 067:
 815             if (ins->oprs[c - 064].type & (BITS16 | BITS32 | BITS64))
 816                 length += (ins->oprs[c - 064].type & BITS16) ? 2 : 4;
 817             else
 818                 length += (bits == 16) ? 2 : 4;
 819             break;
 820         case 070:
 821         case 071:
 822         case 072:
 823         case 073:
 824             length += 4;
 825             break;
 826         case 074:
 827         case 075:
 828         case 076:
 829         case 077:
 830             length += 2;
 831             break;
 832         case 0140:
 833         case 0141:
 834         case 0142:
 835         case 0143:
 836             length += is_sbyte(ins, c - 0140, 16) ? 1 : 2;
 837             break;
 838         case 0144:
 839         case 0145:
 840         case 0146:
 841         case 0147:
 842             codes += 2;
 843             length++;
 844             break;
 845         case 0150:
 846         case 0151:
 847         case 0152:
 848         case 0153:
 849             length += is_sbyte(ins, c - 0150, 32) ? 1 : 4;
 850             break;
 851         case 0154:
 852         case 0155:
 853         case 0156:
 854         case 0157:
 855             codes += 2;
 856             length++;
 857             break;
 858         case 0160:
 859         case 0161:
 860         case 0162:
 861         case 0163:
 862             length++;
 863             ins->rex |= REX_D;
 864             ins->drexdst = regval(&ins->oprs[c & 3]);
 865             break;
 866         case 0164:
 867         case 0165:
 868         case 0166:
 869         case 0167:
 870             length++;
 871             ins->rex |= REX_D|REX_OC;
 872             ins->drexdst = regval(&ins->oprs[c & 3]);
 873             break;
 874         case 0170:
 875             length++;
 876             break;
 877         case 0171:
 878             break;
 879         case 0300:
 880         case 0301:
 881         case 0302:
 882         case 0303:
 883             length += chsize(&ins->oprs[c - 0300], bits);
 884             break;
 885         case 0310:
 886             length += (bits != 16);
 887             break;
 888         case 0311:
 889             length += (bits != 32);
 890             break;
 891         case 0312:
 892             break;
 893         case 0313:
 894             break;
 895         case 0320:
 896             length += (bits != 16);
 897             break;
 898         case 0321:
 899             length += (bits == 16);
 900             break;
 901         case 0322:
 902             break;
 903         case 0323:
 904             rex_mask &= ~REX_W;
 905             break;
 906         case 0324:
 907             ins->rex |= REX_W;
 908             break;
 909         case 0330:
 910             codes++, length++;
 911             break;
 912         case 0331:
 913             break;
 914         case 0332:
 915         case 0333:
 916             length++;
 917             break;
 918         case 0334:
 919             assert_no_prefix(ins, P_LOCK);
 920             ins->rex |= REX_L;
 921             break;
 922         case 0335:
 923             break;
 924         case 0340:
 925         case 0341:
 926         case 0342:
 927             if (ins->oprs[0].segment != NO_SEG)
 928                 errfunc(ERR_NONFATAL, "attempt to reserve non-constant"
 929                         " quantity of BSS space");
 930             else
 931                 length += ins->oprs[0].offset << (c - 0340);
 932             break;
 933         case 0364:
 934         case 0365:
 935             break;
 936         case 0366:
 937         case 0367:
 938             length++;
 939             break;
 940         case 0370:
 941         case 0371:
 942         case 0372:
 943             break;
 944         case 0373:
 945             length++;
 946             break;
 947         default:               /* can't do it by 'case' statements */
 948             if (c >= 0100 && c <= 0277) {       /* it's an EA */
 949                 ea ea_data;
 950                 int rfield;
 951                 int32_t rflags;
 952                 ea_data.rex = 0;           /* Ensure ea.REX is initially 0 */
 953
 954                 if (c <= 0177) {
 955                     /* pick rfield from operand b */
 956                     rflags = regflag(&ins->oprs[c & 7]);
 957                     rfield = regvals[ins->oprs[c & 7].basereg];
 958                 } else {
 959                     rflags = 0;
 960                     rfield = c & 7;
 961                 }
 962
 963                 if (!process_ea
 964                     (&ins->oprs[(c >> 3) & 7], &ea_data, bits,
 965                      rfield, rflags, ins->forw_ref)) {
 966                     errfunc(ERR_NONFATAL, "invalid effective address");
 967                     return -1;
 968                 } else {
 969                     ins->rex |= ea_data.rex;
 970                     length += ea_data.size;
 971                 }
 972             } else
 973                 errfunc(ERR_PANIC, "internal instruction table corrupt"
 974                         ": instruction code 0x%02X given", c);
 975         }
 976
 977     ins->rex &= rex_mask;
 978
 979     if (ins->rex & REX_D) {
 980         if (ins->rex & REX_H) {
 981             errfunc(ERR_NONFATAL, "cannot use high register in drex instruction");
 982             return -1;
 983         }
 984         if (bits != 64 && ((ins->rex & (REX_W|REX_X|REX_B)) ||
 985                            ins->drexdst > 7)) {
 986             errfunc(ERR_NONFATAL, "invalid operands in non-64-bit mode");
 987             return -1;
 988         }
 989         length++;
 990     } else if (ins->rex & REX_REAL) {
 991         if (ins->rex & REX_H) {
 992             errfunc(ERR_NONFATAL, "cannot use high register in rex instruction");
 993             return -1;
 994         } else if (bits == 64 ||
 995                    ((ins->rex & REX_L) &&
 996                     !(ins->rex & (REX_P|REX_W|REX_X|REX_B)) &&
 997                     cpu >= IF_X86_64)) {
 998             length++;
 999         } else {
1000             errfunc(ERR_NONFATAL, "invalid operands in non-64-bit mode");
1001             return -1;
1002         }
1003     }
1004
1005     return length;
1006 }
1007
1008 #define EMIT_REX()                                                      \
1009     if (!(ins->rex & REX_D) && (ins->rex & REX_REAL) && (bits == 64)) { \
1010         ins->rex = (ins->rex & REX_REAL)|REX_P;                         \
1011         out(offset, segment, &ins->rex, OUT_RAWDATA+1, NO_SEG, NO_SEG); \
1012         ins->rex = 0;                                                   \
1013         offset += 1; \
1014     }
1015
1016 static void gencode(int32_t segment, int32_t offset, int bits,
1017                     insn * ins, const char *codes, int32_t insn_end)
1018 {
1019     static char condval[] = {   /* conditional opcodes */
1020         0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2,
1021         0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5,
1022         0x0, 0xA, 0xA, 0xB, 0x8, 0x4
1023     };
1024     uint8_t c;
1025     uint8_t bytes[4];
1026     int32_t size;
1027     int64_t data;
1028
1029     while (*codes)
1030         switch (c = *codes++) {
1031         case 01:
1032         case 02:
1033         case 03:
1034             EMIT_REX();
1035             out(offset, segment, codes, OUT_RAWDATA + c, NO_SEG, NO_SEG);
1036             codes += c;
1037             offset += c;
1038             break;
1039
1040         case 04:
1041         case 06:
1042             switch (ins->oprs[0].basereg) {
1043             case R_CS:
1044                 bytes[0] = 0x0E + (c == 0x04 ? 1 : 0);
1045                 break;
1046             case R_DS:
1047                 bytes[0] = 0x1E + (c == 0x04 ? 1 : 0);
1048                 break;
1049             case R_ES:
1050                 bytes[0] = 0x06 + (c == 0x04 ? 1 : 0);
1051                 break;
1052             case R_SS:
1053                 bytes[0] = 0x16 + (c == 0x04 ? 1 : 0);
1054                 break;
1055             default:
1056                 errfunc(ERR_PANIC,
1057                         "bizarre 8086 segment register received");
1058             }
1059             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1060             offset++;
1061             break;
1062
1063         case 05:
1064         case 07:
1065             switch (ins->oprs[0].basereg) {
1066             case R_FS:
1067                 bytes[0] = 0xA0 + (c == 0x05 ? 1 : 0);
1068                 break;
1069             case R_GS:
1070                 bytes[0] = 0xA8 + (c == 0x05 ? 1 : 0);
1071                 break;
1072             default:
1073                 errfunc(ERR_PANIC,
1074                         "bizarre 386 segment register received");
1075             }
1076             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1077             offset++;
1078             break;
1079
1080         case 010:
1081         case 011:
1082         case 012:
1083         case 013:
1084             EMIT_REX();
1085             bytes[0] = *codes++ + ((regval(&ins->oprs[c - 010])) & 7);
1086             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1087             offset += 1;
1088             break;
1089
1090         case 014:
1091         case 015:
1092         case 016:
1093         case 017:
1094             if (ins->oprs[c - 014].offset < -128
1095                 || ins->oprs[c - 014].offset > 127) {
1096                 errfunc(ERR_WARNING, "signed byte value exceeds bounds");
1097             }
1098
1099             if (ins->oprs[c - 014].segment != NO_SEG) {
1100                 data = ins->oprs[c - 014].offset;
1101                 out(offset, segment, &data, OUT_ADDRESS + 1,
1102                     ins->oprs[c - 014].segment, ins->oprs[c - 014].wrt);
1103             } else {
1104                 bytes[0] = ins->oprs[c - 014].offset;
1105                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG,
1106                     NO_SEG);
1107             }
1108             offset += 1;
1109             break;
1110
1111         case 020:
1112         case 021:
1113         case 022:
1114         case 023:
1115             if (ins->oprs[c - 020].offset < -256
1116                 || ins->oprs[c - 020].offset > 255) {
1117                 errfunc(ERR_WARNING, "byte value exceeds bounds");
1118             }
1119             if (ins->oprs[c - 020].segment != NO_SEG) {
1120                 data = ins->oprs[c - 020].offset;
1121                 out(offset, segment, &data, OUT_ADDRESS + 1,
1122                     ins->oprs[c - 020].segment, ins->oprs[c - 020].wrt);
1123             } else {
1124                 bytes[0] = ins->oprs[c - 020].offset;
1125                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG,
1126                     NO_SEG);
1127             }
1128             offset += 1;
1129             break;
1130
1131         case 024:
1132         case 025:
1133         case 026:
1134         case 027:
1135             if (ins->oprs[c - 024].offset < 0
1136                 || ins->oprs[c - 024].offset > 255)
1137                 errfunc(ERR_WARNING, "unsigned byte value exceeds bounds");
1138             if (ins->oprs[c - 024].segment != NO_SEG) {
1139                 data = ins->oprs[c - 024].offset;
1140                 out(offset, segment, &data, OUT_ADDRESS + 1,
1141                     ins->oprs[c - 024].segment, ins->oprs[c - 024].wrt);
1142             } else {
1143                 bytes[0] = ins->oprs[c - 024].offset;
1144                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG,
1145                     NO_SEG);
1146             }
1147             offset += 1;
1148             break;
1149
1150         case 030:
1151         case 031:
1152         case 032:
1153         case 033:
1154             if (ins->oprs[c - 030].segment == NO_SEG &&
1155                 ins->oprs[c - 030].wrt == NO_SEG &&
1156                 (ins->oprs[c - 030].offset < -65536L ||
1157                  ins->oprs[c - 030].offset > 65535L)) {
1158                 errfunc(ERR_WARNING, "word value exceeds bounds");
1159             }
1160             data = ins->oprs[c - 030].offset;
1161             out(offset, segment, &data, OUT_ADDRESS + 2,
1162                 ins->oprs[c - 030].segment, ins->oprs[c - 030].wrt);
1163             offset += 2;
1164             break;
1165
1166         case 034:
1167         case 035:
1168         case 036:
1169         case 037:
1170             if (ins->oprs[c - 034].type & (BITS16 | BITS32))
1171                 size = (ins->oprs[c - 034].type & BITS16) ? 2 : 4;
1172             else
1173                 size = (bits == 16) ? 2 : 4;
1174             data = ins->oprs[c - 034].offset;
1175             if (size == 2 && (data < -65536L || data > 65535L))
1176                 errfunc(ERR_WARNING, "word value exceeds bounds");
1177             out(offset, segment, &data, OUT_ADDRESS + size,
1178                 ins->oprs[c - 034].segment, ins->oprs[c - 034].wrt);
1179             offset += size;
1180             break;
1181
1182         case 040:
1183         case 041:
1184         case 042:
1185         case 043:
1186             data = ins->oprs[c - 040].offset;
1187             out(offset, segment, &data, OUT_ADDRESS + 4,
1188                 ins->oprs[c - 040].segment, ins->oprs[c - 040].wrt);
1189             offset += 4;
1190             break;
1191
1192         case 044:
1193         case 045:
1194         case 046:
1195         case 047:
1196             data = ins->oprs[c - 044].offset;
1197             size = ((ins->oprs[c - 044].addr_size ?
1198                      ins->oprs[c - 044].addr_size : bits) >> 3);
1199             if (size == 2 && (data < -65536L || data > 65535L))
1200                 errfunc(ERR_WARNING, "word value exceeds bounds");
1201             out(offset, segment, &data, OUT_ADDRESS + size,
1202                 ins->oprs[c - 044].segment, ins->oprs[c - 044].wrt);
1203             offset += size;
1204             break;
1205
1206         case 050:
1207         case 051:
1208         case 052:
1209         case 053:
1210             if (ins->oprs[c - 050].segment != segment)
1211                 errfunc(ERR_NONFATAL,
1212                         "short relative jump outside segment");
1213             data = ins->oprs[c - 050].offset - insn_end;
1214             if (data > 127 || data < -128)
1215                 errfunc(ERR_NONFATAL, "short jump is out of range");
1216             bytes[0] = data;
1217             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1218             offset += 1;
1219             break;
1220
1221         case 054:
1222         case 055:
1223         case 056:
1224         case 057:
1225             data = (int64_t)ins->oprs[c - 054].offset;
1226             out(offset, segment, &data, OUT_ADDRESS + 8,
1227                 ins->oprs[c - 054].segment, ins->oprs[c - 054].wrt);
1228             offset += 8;
1229             break;
1230
1231         case 060:
1232         case 061:
1233         case 062:
1234         case 063:
1235             if (ins->oprs[c - 060].segment != segment) {
1236                 data = ins->oprs[c - 060].offset;
1237                 out(offset, segment, &data,
1238                     OUT_REL2ADR + insn_end - offset,
1239                     ins->oprs[c - 060].segment, ins->oprs[c - 060].wrt);
1240             } else {
1241                 data = ins->oprs[c - 060].offset - insn_end;
1242                 out(offset, segment, &data,
1243                     OUT_ADDRESS + 2, NO_SEG, NO_SEG);
1244             }
1245             offset += 2;
1246             break;
1247
1248         case 064:
1249         case 065:
1250         case 066:
1251         case 067:
1252             if (ins->oprs[c - 064].type & (BITS16 | BITS32 | BITS64))
1253                 size = (ins->oprs[c - 064].type & BITS16) ? 2 : 4;
1254             else
1255                 size = (bits == 16) ? 2 : 4;
1256             if (ins->oprs[c - 064].segment != segment) {
1257                 int32_t reltype = (size == 2 ? OUT_REL2ADR : OUT_REL4ADR);
1258                 data = ins->oprs[c - 064].offset;
1259                 out(offset, segment, &data, reltype + insn_end - offset,
1260                     ins->oprs[c - 064].segment, ins->oprs[c - 064].wrt);
1261             } else {
1262                 data = ins->oprs[c - 064].offset - insn_end;
1263                 out(offset, segment, &data,
1264                     OUT_ADDRESS + size, NO_SEG, NO_SEG);
1265             }
1266             offset += size;
1267             break;
1268
1269         case 070:
1270         case 071:
1271         case 072:
1272         case 073:
1273             if (ins->oprs[c - 070].segment != segment) {
1274                 data = ins->oprs[c - 070].offset;
1275                 out(offset, segment, &data,
1276                     OUT_REL4ADR + insn_end - offset,
1277                     ins->oprs[c - 070].segment, ins->oprs[c - 070].wrt);
1278             } else {
1279                 data = ins->oprs[c - 070].offset - insn_end;
1280                 out(offset, segment, &data,
1281                     OUT_ADDRESS + 4, NO_SEG, NO_SEG);
1282             }
1283             offset += 4;
1284             break;
1285
1286         case 074:
1287         case 075:
1288         case 076:
1289         case 077:
1290             if (ins->oprs[c - 074].segment == NO_SEG)
1291                 errfunc(ERR_NONFATAL, "value referenced by FAR is not"
1292                         " relocatable");
1293             data = 0L;
1294             out(offset, segment, &data, OUT_ADDRESS + 2,
1295                 outfmt->segbase(1 + ins->oprs[c - 074].segment),
1296                 ins->oprs[c - 074].wrt);
1297             offset += 2;
1298             break;
1299
1300         case 0140:
1301         case 0141:
1302         case 0142:
1303         case 0143:
1304             data = ins->oprs[c - 0140].offset;
1305             if (is_sbyte(ins, c - 0140, 16)) {
1306                 bytes[0] = data;
1307                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG,
1308                     NO_SEG);
1309                 offset++;
1310             } else {
1311                 if (ins->oprs[c - 0140].segment == NO_SEG &&
1312                     ins->oprs[c - 0140].wrt == NO_SEG &&
1313                     (data < -65536L || data > 65535L)) {
1314                     errfunc(ERR_WARNING, "word value exceeds bounds");
1315                 }
1316                 out(offset, segment, &data, OUT_ADDRESS + 2,
1317                     ins->oprs[c - 0140].segment, ins->oprs[c - 0140].wrt);
1318                 offset += 2;
1319             }
1320             break;
1321
1322         case 0144:
1323         case 0145:
1324         case 0146:
1325         case 0147:
1326             EMIT_REX();
1327             codes++;
1328             bytes[0] = *codes++;
1329             if (is_sbyte(ins, c - 0144, 16))
1330                 bytes[0] |= 2;  /* s-bit */
1331             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1332             offset++;
1333             break;
1334
1335         case 0150:
1336         case 0151:
1337         case 0152:
1338         case 0153:
1339             data = ins->oprs[c - 0150].offset;
1340             if (is_sbyte(ins, c - 0150, 32)) {
1341                 bytes[0] = data;
1342                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG,
1343                     NO_SEG);
1344                 offset++;
1345             } else {
1346                 out(offset, segment, &data, OUT_ADDRESS + 4,
1347                     ins->oprs[c - 0150].segment, ins->oprs[c - 0150].wrt);
1348                 offset += 4;
1349             }
1350             break;
1351
1352         case 0154:
1353         case 0155:
1354         case 0156:
1355         case 0157:
1356             EMIT_REX();
1357             codes++;
1358             bytes[0] = *codes++;
1359             if (is_sbyte(ins, c - 0154, 32))
1360                 bytes[0] |= 2;  /* s-bit */
1361             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1362             offset++;
1363             break;
1364
1365         case 0160:
1366         case 0161:
1367         case 0162:
1368         case 0163:
1369         case 0164:
1370         case 0165:
1371         case 0166:
1372         case 0167:
1373             break;
1374
1375         case 0170:
1376             bytes[0] = 0;
1377             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1378             offset += 1;
1379             break;
1380
1381         case 0171:
1382             bytes[0] =
1383                 (ins->drexdst << 4) |
1384                 (ins->rex & REX_OC ? 0x08 : 0) |
1385                 (ins->rex & (REX_R|REX_X|REX_B));
1386             ins->rex = 0;
1387             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1388             offset++;
1389             break;
1390
1391         case 0300:
1392         case 0301:
1393         case 0302:
1394         case 0303:
1395             if (chsize(&ins->oprs[c - 0300], bits)) {
1396                 *bytes = 0x67;
1397                 out(offset, segment, bytes,
1398                     OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1399                 offset += 1;
1400             } else
1401                 offset += 0;
1402             break;
1403
1404         case 0310:
1405             if (bits != 16) {
1406                 *bytes = 0x67;
1407                 out(offset, segment, bytes,
1408                     OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1409                 offset += 1;
1410             } else
1411                 offset += 0;
1412             break;
1413
1414         case 0311:
1415             if (bits != 32) {
1416                 *bytes = 0x67;
1417                 out(offset, segment, bytes,
1418                     OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1419                 offset += 1;
1420             } else
1421                 offset += 0;
1422             break;
1423
1424         case 0312:
1425             break;
1426
1427         case 0313:
1428             ins->rex = 0;
1429             break;
1430
1431         case 0320:
1432             if (bits != 16) {
1433                 *bytes = 0x66;
1434                 out(offset, segment, bytes,
1435                     OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1436                 offset += 1;
1437             } else
1438                 offset += 0;
1439             break;
1440
1441         case 0321:
1442             if (bits == 16) {
1443                 *bytes = 0x66;
1444                 out(offset, segment, bytes,
1445                     OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1446                 offset += 1;
1447             } else
1448                 offset += 0;
1449             break;
1450
1451         case 0322:
1452         case 0323:
1453             break;
1454
1455         case 0324:
1456             ins->rex |= REX_W;
1457             break;
1458
1459         case 0330:
1460             *bytes = *codes++ ^ condval[ins->condition];
1461             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1462             offset += 1;
1463             break;
1464
1465         case 0331:
1466             break;
1467
1468         case 0332:
1469         case 0333:
1470             *bytes = c - 0332 + 0xF2;
1471             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1472             offset += 1;
1473             break;
1474
1475         case 0334:
1476             if (ins->rex & REX_R) {
1477                 *bytes = 0xF0;
1478                 out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1479                 offset += 1;
1480             }
1481             ins->rex &= ~(REX_L|REX_R);
1482             break;
1483
1484         case 0335:
1485             break;
1486
1487         case 0340:
1488         case 0341:
1489         case 0342:
1490             if (ins->oprs[0].segment != NO_SEG)
1491                 errfunc(ERR_PANIC, "non-constant BSS size in pass two");
1492             else {
1493                 int32_t size = ins->oprs[0].offset << (c - 0340);
1494                 if (size > 0)
1495                     out(offset, segment, NULL,
1496                         OUT_RESERVE + size, NO_SEG, NO_SEG);
1497                 offset += size;
1498             }
1499             break;
1500
1501         case 0364:
1502         case 0365:
1503             break;
1504
1505         case 0366:
1506         case 0367:
1507             *bytes = c - 0366 + 0x66;
1508             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1509             offset += 1;
1510             break;
1511
1512         case 0370:
1513         case 0371:
1514         case 0372:
1515             break;
1516
1517         case 0373:
1518             *bytes = bits == 16 ? 3 : 5;
1519             out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG);
1520             offset += 1;
1521             break;
1522
1523         default:               /* can't do it by 'case' statements */
1524             if (c >= 0100 && c <= 0277) {       /* it's an EA */
1525                 ea ea_data;
1526                 int rfield;
1527                 int32_t rflags;
1528                 uint8_t *p;
1529                 int32_t s;
1530
1531                 if (c <= 0177) {
1532                     /* pick rfield from operand b */
1533                     rflags = regflag(&ins->oprs[c & 7]);
1534                     rfield = regvals[ins->oprs[c & 7].basereg];
1535                 } else {
1536                     /* rfield is constant */
1537                     rflags = 0;
1538                     rfield = c & 7;
1539                 }
1540
1541                 if (!process_ea
1542                     (&ins->oprs[(c >> 3) & 7], &ea_data, bits,
1543                      rfield, rflags, ins->forw_ref)) {
1544                     errfunc(ERR_NONFATAL, "invalid effective address");
1545                 }
1546
1547                 p = bytes;
1548                 *p++ = ea_data.modrm;
1549                 if (ea_data.sib_present)
1550                     *p++ = ea_data.sib;
1551
1552                 /* DREX suffixes come between the SIB and the displacement */
1553                 if (ins->rex & REX_D) {
1554                     *p++ =
1555                         (ins->drexdst << 4) |
1556                         (ins->rex & REX_OC ? 0x08 : 0) |
1557                         (ins->rex & (REX_R|REX_X|REX_B));
1558                     ins->rex = 0;
1559                 }
1560
1561                 s = p - bytes;
1562                 out(offset, segment, bytes, OUT_RAWDATA + s,
1563                     NO_SEG, NO_SEG);
1564
1565                 switch (ea_data.bytes) {
1566                 case 0:
1567                     break;
1568                 case 1:
1569                     if (ins->oprs[(c >> 3) & 7].segment != NO_SEG) {
1570                         data = ins->oprs[(c >> 3) & 7].offset;
1571                         out(offset, segment, &data, OUT_ADDRESS + 1,
1572                             ins->oprs[(c >> 3) & 7].segment,
1573                             ins->oprs[(c >> 3) & 7].wrt);
1574                     } else {
1575                         *bytes = ins->oprs[(c >> 3) & 7].offset;
1576                         out(offset, segment, bytes, OUT_RAWDATA + 1,
1577                             NO_SEG, NO_SEG);
1578                     }
1579                     s++;
1580                     break;
1581                 case 8:
1582                 case 2:
1583                 case 4:
1584                     data = ins->oprs[(c >> 3) & 7].offset;
1585                     if (ea_data.rip && (ins->oprs[(c >> 3) & 7].segment == 0xFFFFFFFF))
1586                             ea_data.rip = 0;    /* Make distinction between Symbols and Immediates */
1587                     out(offset, segment, &data,   /* RIP = Relative, not Absolute */
1588                         (ea_data.rip ?  OUT_REL4ADR : OUT_ADDRESS) + ea_data.bytes,
1589                         ins->oprs[(c >> 3) & 7].segment,
1590                         ins->oprs[(c >> 3) & 7].wrt);
1591                     s += ea_data.bytes;
1592                     break;
1593                 }
1594                 offset += s;
1595             } else
1596                 errfunc(ERR_PANIC, "internal instruction table corrupt"
1597                         ": instruction code 0x%02X given", c);
1598         }
1599 }
1600
1601 static int32_t regflag(const operand * o)
1602 {
1603     if (o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT) {
1604         errfunc(ERR_PANIC, "invalid operand passed to regflag()");
1605     }
1606     return reg_flags[o->basereg];
1607 }
1608
1609 static int32_t regval(const operand * o)
1610 {
1611     if (o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT) {
1612         errfunc(ERR_PANIC, "invalid operand passed to regval()");
1613     }
1614     return regvals[o->basereg];
1615 }
1616
1617 static int op_rexflags(const operand * o, int mask)
1618 {
1619     int32_t flags;
1620     int val;
1621
1622     if (o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT) {
1623         errfunc(ERR_PANIC, "invalid operand passed to op_rexflags()");
1624     }
1625
1626     flags = reg_flags[o->basereg];
1627     val = regvals[o->basereg];
1628
1629     return rexflags(val, flags, mask);
1630 }
1631
1632 static int rexflags(int val, int32_t flags, int mask)
1633 {
1634     int rex = 0;
1635
1636     if (val >= 8)
1637         rex |= REX_B|REX_X|REX_R;
1638     if (flags & BITS64)
1639         rex |= REX_W;
1640     if (!(REG_HIGH & ~flags))   /* AH, CH, DH, BH */
1641         rex |= REX_H;
1642     else if (!(REG8 & ~flags) && val >= 4) /* SPL, BPL, SIL, DIL */
1643         rex |= REX_P;
1644
1645     return rex & mask;
1646 }
1647
1648 static int matches(const struct itemplate *itemp, insn * instruction, int bits)
1649 {
1650     int i, size[MAX_OPERANDS], asize, oprs, ret;
1651
1652     ret = 100;
1653
1654     /*
1655      * Check the opcode
1656      */
1657     if (itemp->opcode != instruction->opcode)
1658         return 0;
1659
1660     /*
1661      * Count the operands
1662      */
1663     if (itemp->operands != instruction->operands)
1664         return 0;
1665
1666     /*
1667      * Check that no spurious colons or TOs are present
1668      */
1669     for (i = 0; i < itemp->operands; i++)
1670         if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO))
1671             return 0;
1672
1673     /*
1674      * Check that the operand flags all match up
1675      */
1676     for (i = 0; i < itemp->operands; i++) {
1677         if (itemp->opd[i] & SAME_AS) {
1678             int j = itemp->opd[i] & ~SAME_AS;
1679             if (instruction->oprs[i].type != instruction->oprs[j].type ||
1680                 instruction->oprs[i].basereg != instruction->oprs[j].basereg)
1681                 return 0;
1682         } else  if (itemp->opd[i] & ~instruction->oprs[i].type ||
1683             ((itemp->opd[i] & SIZE_MASK) &&
1684              ((itemp->opd[i] ^ instruction->oprs[i].type) & SIZE_MASK))) {
1685             if ((itemp->opd[i] & ~instruction->oprs[i].type & ~SIZE_MASK) ||
1686                 (instruction->oprs[i].type & SIZE_MASK))
1687                 return 0;
1688             else
1689                 return 1;
1690         }
1691     }
1692
1693     /*
1694      * Check operand sizes
1695      */
1696     if (itemp->flags & IF_ARMASK) {
1697         memset(size, 0, sizeof size);
1698
1699         switch (itemp->flags & IF_ARMASK) {
1700         case IF_AR0:
1701             i = 0;
1702             break;
1703         case IF_AR1:
1704             i = 1;
1705             break;
1706         case IF_AR2:
1707             i = 2;
1708             break;
1709         case IF_AR3:
1710             i = 3;
1711             break;
1712         default:
1713             break;              /* Shouldn't happen */
1714         }
1715         switch (itemp->flags & IF_SMASK) {
1716         case IF_SB:
1717             size[i] = BITS8;
1718             break;
1719         case IF_SW:
1720             size[i] = BITS16;
1721             break;
1722         case IF_SD:
1723             size[i] = BITS32;
1724             break;
1725         case IF_SQ:
1726             size[i] = BITS64;
1727             break;
1728         case IF_SO:
1729             size[i] = BITS128;
1730             break;
1731         default:
1732             break;
1733         }
1734     } else {
1735         asize = 0;
1736         switch (itemp->flags & IF_SMASK) {
1737         case IF_SB:
1738             asize = BITS8;
1739             oprs = itemp->operands;
1740             break;
1741         case IF_SW:
1742             asize = BITS16;
1743             oprs = itemp->operands;
1744             break;
1745         case IF_SD:
1746             asize = BITS32;
1747             oprs = itemp->operands;
1748             break;
1749         case IF_SQ:
1750             asize = BITS64;
1751             oprs = itemp->operands;
1752             break;
1753         case IF_SO:
1754             asize = BITS128;
1755             oprs = itemp->operands;
1756             break;
1757         default:
1758             break;
1759         }
1760         for (i = 0; i < MAX_OPERANDS; i++)
1761             size[i] = asize;
1762     }
1763
1764     if (itemp->flags & (IF_SM | IF_SM2)) {
1765         oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands);
1766         asize = 0;
1767         for (i = 0; i < oprs; i++) {
1768             if ((asize = itemp->opd[i] & SIZE_MASK) != 0) {
1769                 int j;
1770                 for (j = 0; j < oprs; j++)
1771                     size[j] = asize;
1772                 break;
1773             }
1774         }
1775     } else {
1776         oprs = itemp->operands;
1777     }
1778
1779     for (i = 0; i < itemp->operands; i++) {
1780         if (!(itemp->opd[i] & SIZE_MASK) &&
1781             (instruction->oprs[i].type & SIZE_MASK & ~size[i]))
1782             return 2;
1783     }
1784
1785     /*
1786      * Check template is okay at the set cpu level
1787      */
1788     if (((itemp->flags & IF_PLEVEL) > cpu))
1789         return 3;
1790
1791     /*
1792      * Check if instruction is available in long mode
1793      */
1794     if ((itemp->flags & IF_NOLONG) && (bits == 64))
1795         return 4;
1796
1797     /*
1798      * Check if special handling needed for Jumps
1799      */
1800     if ((uint8_t)(itemp->code[0]) >= 0370)
1801         return 99;
1802
1803     return ret;
1804 }
1805
1806 static ea *process_ea(operand * input, ea * output, int addrbits,
1807                       int rfield, int32_t rflags, int forw_ref)
1808 {
1809     output->rip = FALSE;
1810
1811     /* REX flags for the rfield operand */
1812     output->rex |= rexflags(rfield, rflags, REX_R|REX_P|REX_W|REX_H);
1813
1814     if (!(REGISTER & ~input->type)) {   /* register direct */
1815         int i;
1816         int32_t f;
1817
1818         if (input->basereg < EXPR_REG_START /* Verify as Register */
1819             || input->basereg >= REG_ENUM_LIMIT)
1820             return NULL;
1821         f = regflag(input);
1822         i = regvals[input->basereg];
1823
1824         if (REG_EA & ~f)
1825             return NULL;        /* Invalid EA register */
1826
1827         output->rex |= op_rexflags(input, REX_B|REX_P|REX_W|REX_H);
1828
1829         output->sib_present = FALSE;             /* no SIB necessary */
1830         output->bytes = 0;  /* no offset necessary either */
1831         output->modrm = 0xC0 | ((rfield & 7) << 3) | (i & 7);
1832     } else {                    /* it's a memory reference */
1833         if (input->basereg == -1
1834             && (input->indexreg == -1 || input->scale == 0)) {
1835             /* it's a pure offset */
1836             if (input->addr_size)
1837                 addrbits = input->addr_size;
1838
1839             if (globalbits == 64 && (~input->type & IP_REL)) {
1840               int scale, index, base;
1841               output->sib_present = TRUE;
1842               scale = 0;
1843               index = 4;
1844               base = 5;
1845               output->sib = (scale << 6) | (index << 3) | base;
1846               output->bytes = 4;
1847               output->modrm = 4 | ((rfield & 7) << 3);
1848               output->rip = FALSE;
1849             } else {
1850               output->sib_present = FALSE;
1851               output->bytes = (addrbits != 16 ? 4 : 2);
1852               output->modrm = (addrbits != 16 ? 5 : 6) | ((rfield & 7) << 3);
1853               output->rip = globalbits == 64;
1854             }
1855         } else {                /* it's an indirection */
1856             int i = input->indexreg, b = input->basereg, s = input->scale;
1857             int32_t o = input->offset, seg = input->segment;
1858             int hb = input->hintbase, ht = input->hinttype;
1859             int t;
1860             int it, bt;
1861             int32_t ix, bx;     /* register flags */
1862
1863             if (s == 0)
1864                 i = -1;         /* make this easy, at least */
1865
1866             if (i >= EXPR_REG_START && i < REG_ENUM_LIMIT) {
1867                 it = regvals[i];
1868                 ix = reg_flags[i];
1869             } else {
1870                 it = -1;
1871                 ix = 0;
1872             }
1873
1874             if (b != -1 && b >= EXPR_REG_START && b < REG_ENUM_LIMIT) {
1875                 bt = regvals[b];
1876                 bx = reg_flags[b];
1877             } else {
1878                 bt = -1;
1879                 bx = 0;
1880             }
1881
1882             /* check for a 32/64-bit memory reference... */
1883             if ((ix|bx) & (BITS32|BITS64)) {
1884                 /* it must be a 32/64-bit memory reference. Firstly we have
1885                  * to check that all registers involved are type E/Rxx. */
1886                 int32_t sok = BITS32|BITS64;
1887
1888                 if (it != -1) {
1889                     if (!(REG64 & ~ix) || !(REG32 & ~ix))
1890                         sok &= ix;
1891                     else
1892                         return NULL;
1893                 }
1894
1895                 if (bt != -1) {
1896                     if (REG_GPR & ~bx)
1897                         return NULL; /* Invalid register */
1898                     if (~sok & bx & SIZE_MASK)
1899                         return NULL; /* Invalid size */
1900                     sok &= ~bx;
1901                 }
1902
1903                 /* While we're here, ensure the user didn't specify WORD. */
1904                 if (input->addr_size == 16 ||
1905                     (input->addr_size == 32 && !(sok & BITS32)) ||
1906                     (input->addr_size == 64 && !(sok & BITS64)))
1907                     return NULL;
1908
1909                 /* now reorganize base/index */
1910                 if (s == 1 && bt != it && bt != -1 && it != -1 &&
1911                     ((hb == b && ht == EAH_NOTBASE)
1912                      || (hb == i && ht == EAH_MAKEBASE))) {
1913                     /* swap if hints say so */
1914                     t = bt, bt = it, it = t;
1915                     t = bx, bx = ix, ix = t;
1916                 }
1917                 if (bt == it)     /* convert EAX+2*EAX to 3*EAX */
1918                     bt = -1, bx = 0, s++;
1919                 if (bt == -1 && s == 1 && !(hb == it && ht == EAH_NOTBASE)) {
1920                     /* make single reg base, unless hint */
1921                     bt = it, bx = ix, it = -1, ix = 0;
1922                 }
1923                 if (((s == 2 && it != REG_NUM_ESP
1924                       && !(input->eaflags & EAF_TIMESTWO)) || s == 3
1925                      || s == 5 || s == 9) && bt == -1)
1926                     bt = it, bx = ix, s--; /* convert 3*EAX to EAX+2*EAX */
1927                 if (it == -1 && (bt & 7) != REG_NUM_ESP
1928                     && (input->eaflags & EAF_TIMESTWO))
1929                     it = bt, ix = bx, bt = -1, bx = 0, s = 1;
1930                 /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */
1931                 if (s == 1 && it == REG_NUM_ESP) {
1932                     /* swap ESP into base if scale is 1 */
1933                     t = it, it = bt, bt = t;
1934                     t = ix, ix = bx, bx = t;
1935                 }
1936                 if (it == REG_NUM_ESP
1937                     || (s != 1 && s != 2 && s != 4 && s != 8 && it != -1))
1938                     return NULL;        /* wrong, for various reasons */
1939
1940                 output->rex |= rexflags(it, ix, REX_X);
1941                 output->rex |= rexflags(bt, bx, REX_B);
1942
1943                 if (it == -1 && (bt & 7) != REG_NUM_ESP) {
1944                     /* no SIB needed */
1945                     int mod, rm;
1946
1947                     if (bt == -1) {
1948                         rm = 5;
1949                         mod = 0;
1950                     } else {
1951                         rm = (bt & 7);
1952                         if (rm != REG_NUM_EBP && o == 0 &&
1953                                 seg == NO_SEG && !forw_ref &&
1954                                 !(input->eaflags &
1955                                   (EAF_BYTEOFFS | EAF_WORDOFFS)))
1956                             mod = 0;
1957                         else if (input->eaflags & EAF_BYTEOFFS ||
1958                                  (o >= -128 && o <= 127 && seg == NO_SEG
1959                                   && !forw_ref
1960                                   && !(input->eaflags & EAF_WORDOFFS)))
1961                             mod = 1;
1962                         else
1963                             mod = 2;
1964                     }
1965
1966                     output->sib_present = FALSE;
1967                     output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
1968                     output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
1969                 } else {
1970                     /* we need a SIB */
1971                     int mod, scale, index, base;
1972
1973                     if (it == -1)
1974                         index = 4, s = 1;
1975                     else
1976                         index = (it & 7);
1977
1978                     switch (s) {
1979                     case 1:
1980                         scale = 0;
1981                         break;
1982                     case 2:
1983                         scale = 1;
1984                         break;
1985                     case 4:
1986                         scale = 2;
1987                         break;
1988                     case 8:
1989                         scale = 3;
1990                         break;
1991                     default:   /* then what the smeg is it? */
1992                         return NULL;    /* panic */
1993                     }
1994
1995                     if (bt == -1) {
1996                         base = 5;
1997                         mod = 0;
1998                     } else {
1999                         base = (bt & 7);
2000                         if (base != REG_NUM_EBP && o == 0 &&
2001                                     seg == NO_SEG && !forw_ref &&
2002                                     !(input->eaflags &
2003                                       (EAF_BYTEOFFS | EAF_WORDOFFS)))
2004                             mod = 0;
2005                         else if (input->eaflags & EAF_BYTEOFFS ||
2006                                  (o >= -128 && o <= 127 && seg == NO_SEG
2007                                   && !forw_ref
2008                                   && !(input->eaflags & EAF_WORDOFFS)))
2009                             mod = 1;
2010                         else
2011                             mod = 2;
2012                     }
2013
2014                     output->sib_present = TRUE;
2015                     output->bytes =  (bt == -1 || mod == 2 ? 4 : mod);
2016                     output->modrm = (mod << 6) | ((rfield & 7) << 3) | 4;
2017                     output->sib = (scale << 6) | (index << 3) | base;
2018                 }
2019             } else {            /* it's 16-bit */
2020                 int mod, rm;
2021
2022                 /* check for 64-bit long mode */
2023                 if (addrbits == 64)
2024                     return NULL;
2025
2026                 /* check all registers are BX, BP, SI or DI */
2027                 if ((b != -1 && b != R_BP && b != R_BX && b != R_SI
2028                      && b != R_DI) || (i != -1 && i != R_BP && i != R_BX
2029                                        && i != R_SI && i != R_DI))
2030                     return NULL;
2031
2032                 /* ensure the user didn't specify DWORD/QWORD */
2033                 if (input->addr_size == 32 || input->addr_size == 64)
2034                     return NULL;
2035
2036                 if (s != 1 && i != -1)
2037                     return NULL;        /* no can do, in 16-bit EA */
2038                 if (b == -1 && i != -1) {
2039                     int tmp = b;
2040                     b = i;
2041                     i = tmp;
2042                 }               /* swap */
2043                 if ((b == R_SI || b == R_DI) && i != -1) {
2044                     int tmp = b;
2045                     b = i;
2046                     i = tmp;
2047                 }
2048                 /* have BX/BP as base, SI/DI index */
2049                 if (b == i)
2050                     return NULL;        /* shouldn't ever happen, in theory */
2051                 if (i != -1 && b != -1 &&
2052                     (i == R_BP || i == R_BX || b == R_SI || b == R_DI))
2053                     return NULL;        /* invalid combinations */
2054                 if (b == -1)    /* pure offset: handled above */
2055                     return NULL;        /* so if it gets to here, panic! */
2056
2057                 rm = -1;
2058                 if (i != -1)
2059                     switch (i * 256 + b) {
2060                     case R_SI * 256 + R_BX:
2061                         rm = 0;
2062                         break;
2063                     case R_DI * 256 + R_BX:
2064                         rm = 1;
2065                         break;
2066                     case R_SI * 256 + R_BP:
2067                         rm = 2;
2068                         break;
2069                     case R_DI * 256 + R_BP:
2070                         rm = 3;
2071                         break;
2072                 } else
2073                     switch (b) {
2074                     case R_SI:
2075                         rm = 4;
2076                         break;
2077                     case R_DI:
2078                         rm = 5;
2079                         break;
2080                     case R_BP:
2081                         rm = 6;
2082                         break;
2083                     case R_BX:
2084                         rm = 7;
2085                         break;
2086                     }
2087                 if (rm == -1)   /* can't happen, in theory */
2088                     return NULL;        /* so panic if it does */
2089
2090                 if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 &&
2091                     !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2092                     mod = 0;
2093                 else if (input->eaflags & EAF_BYTEOFFS ||
2094                          (o >= -128 && o <= 127 && seg == NO_SEG
2095                           && !forw_ref
2096                           && !(input->eaflags & EAF_WORDOFFS)))
2097                     mod = 1;
2098                 else
2099                     mod = 2;
2100
2101                 output->sib_present = FALSE;    /* no SIB - it's 16-bit */
2102                 output->bytes = mod;    /* bytes of offset needed */
2103                 output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
2104             }
2105         }
2106     }
2107
2108     output->size = 1 + output->sib_present + output->bytes;
2109     return output;
2110 }
2111
2112 static int chsize(operand * input, int addrbits)
2113 {
2114     if (!(MEMORY & ~input->type)) {
2115         int32_t i, b;
2116
2117         if (input->indexreg < EXPR_REG_START /* Verify as Register */
2118             || input->indexreg >= REG_ENUM_LIMIT)
2119             i = 0;
2120         else
2121             i = reg_flags[input->indexreg];
2122
2123         if (input->basereg < EXPR_REG_START /* Verify as Register */
2124             || input->basereg >= REG_ENUM_LIMIT)
2125             b = 0;
2126         else
2127             b = reg_flags[input->basereg];
2128
2129         if (input->scale == 0)
2130             i = 0;
2131
2132         if (!i && !b)           /* pure offset */
2133             return (input->addr_size != 0 && input->addr_size != addrbits);
2134
2135         if (!(REG32 & ~i) || !(REG32 & ~b))
2136             return (addrbits != 32);
2137         else
2138             return (addrbits == 32);
2139     } else {
2140         return 0;
2141     }
2142 }