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