assemble.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2011 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * assemble.c   code generation for the Netwide Assembler
  36  *
  37  * the actual codes (C syntax, i.e. octal):
  38  * \0            - terminates the code. (Unless it's a literal of course.)
  39  * \1..\4        - that many literal bytes follow in the code stream
  40  * \5            - add 4 to the primary operand number (b, low octdigit)
  41  * \6            - add 4 to the secondary operand number (a, middle octdigit)
  42  * \7            - add 4 to both the primary and the secondary operand number
  43  * \10..\13      - a literal byte follows in the code stream, to be added
  44  *                 to the register value of operand 0..3
  45  * \14..\17      - a signed byte immediate operand, from operand 0..3
  46  * \20..\23      - a byte immediate operand, from operand 0..3
  47  * \24..\27      - an unsigned byte immediate operand, from operand 0..3
  48  * \30..\33      - a word immediate operand, from operand 0..3
  49  * \34..\37      - select between \3[0-3] and \4[0-3] depending on 16/32 bit
  50  *                 assembly mode or the operand-size override on the operand
  51  * \40..\43      - a long immediate operand, from operand 0..3
  52  * \44..\47      - select between \3[0-3], \4[0-3] and \5[4-7]
  53  *                 depending on the address size of the instruction.
  54  * \50..\53      - a byte relative operand, from operand 0..3
  55  * \54..\57      - a qword immediate operand, from operand 0..3
  56  * \60..\63      - a word relative operand, from operand 0..3
  57  * \64..\67      - select between \6[0-3] and \7[0-3] depending on 16/32 bit
  58  *                 assembly mode or the operand-size override on the operand
  59  * \70..\73      - a long relative operand, from operand 0..3
  60  * \74..\77      - a word constant, from the _segment_ part of operand 0..3
  61  * \1ab          - a ModRM, calculated on EA in operand a, with the spare
  62  *                 field the register value of operand b.
  63  * \140..\143    - an immediate word or signed byte for operand 0..3
  64  * \144..\147    - or 2 (s-field) into opcode byte if operand 0..3
  65  *                  is a signed byte rather than a word.  Opcode byte follows.
  66  * \150..\153    - an immediate dword or signed byte for operand 0..3
  67  * \154..\157    - or 2 (s-field) into opcode byte if operand 0..3
  68  *                  is a signed byte rather than a dword.  Opcode byte follows.
  69  * \172\ab       - the register number from operand a in bits 7..4, with
  70  *                 the 4-bit immediate from operand b in bits 3..0.
  71  * \173\xab      - the register number from operand a in bits 7..4, with
  72  *                 the value b in bits 3..0.
  73  * \174..\177    - the register number from operand 0..3 in bits 7..4, and
  74  *                 an arbitrary value in bits 3..0 (assembled as zero.)
  75  * \2ab          - a ModRM, calculated on EA in operand a, with the spare
  76  *                 field equal to digit b.
  77  * \250..\253    - same as \150..\153, except warn if the 64-bit operand
  78  *                 is not equal to the truncated and sign-extended 32-bit
  79  *                 operand; used for 32-bit immediates in 64-bit mode.
  80  * \254..\257    - a signed 32-bit operand to be extended to 64 bits.
  81  * \260..\263    - this instruction uses VEX/XOP rather than REX, with the
  82  *                 V field taken from operand 0..3.
  83  * \270          - this instruction uses VEX/XOP rather than REX, with the
  84  *                 V field set to 1111b.
  85  *
  86  * VEX/XOP prefixes are followed by the sequence:
  87  * \tmm\wlp        where mm is the M field; and wlp is:
  88  *                 00 wwl lpp
  89  *                 [l0]  ll = 0 for L = 0 (.128, .lz)
  90  *                 [l1]  ll = 1 for L = 1 (.256)
  91  *                 [lig] ll = 2 for L don't care (always assembled as 0)
  92  *
  93  *                 [w0]  ww = 0 for W = 0
  94  *                 [w1 ] ww = 1 for W = 1
  95  *                 [wig] ww = 2 for W don't care (always assembled as 0)
  96  *                 [ww]  ww = 3 for W used as REX.W
  97  *
  98  * t = 0 for VEX (C4/C5), t = 1 for XOP (8F).
  99  *
 100  * \274..\277    - a signed byte immediate operand, from operand 0..3,
 101  *                 which is to be extended to the operand size.
 102  * \310          - indicates fixed 16-bit address size, i.e. optional 0x67.
 103  * \311          - indicates fixed 32-bit address size, i.e. optional 0x67.
 104  * \312          - (disassembler only) invalid with non-default address size.
 105  * \313          - indicates fixed 64-bit address size, 0x67 invalid.
 106  * \314          - (disassembler only) invalid with REX.B
 107  * \315          - (disassembler only) invalid with REX.X
 108  * \316          - (disassembler only) invalid with REX.R
 109  * \317          - (disassembler only) invalid with REX.W
 110  * \320          - indicates fixed 16-bit operand size, i.e. optional 0x66.
 111  * \321          - indicates fixed 32-bit operand size, i.e. optional 0x66.
 112  * \322          - indicates that this instruction is only valid when the
 113  *                 operand size is the default (instruction to disassembler,
 114  *                 generates no code in the assembler)
 115  * \323          - indicates fixed 64-bit operand size, REX on extensions only.
 116  * \324          - indicates 64-bit operand size requiring REX prefix.
 117  * \325          - instruction which always uses spl/bpl/sil/dil
 118  * \330          - a literal byte follows in the code stream, to be added
 119  *                 to the condition code value of the instruction.
 120  * \331          - instruction not valid with REP prefix.  Hint for
 121  *                 disassembler only; for SSE instructions.
 122  * \332          - REP prefix (0xF2 byte) used as opcode extension.
 123  * \333          - REP prefix (0xF3 byte) used as opcode extension.
 124  * \334          - LOCK prefix used as REX.R (used in non-64-bit mode)
 125  * \335          - disassemble a rep (0xF3 byte) prefix as repe not rep.
 126  * \336          - force a REP(E) prefix (0xF2) even if not specified.
 127  * \337          - force a REPNE prefix (0xF3) even if not specified.
 128  *                 \336-\337 are still listed as prefixes in the disassembler.
 129  * \340          - reserve <operand 0> bytes of uninitialized storage.
 130  *                 Operand 0 had better be a segmentless constant.
 131  * \341          - this instruction needs a WAIT "prefix"
 132  * \344,\345     - the PUSH/POP (respectively) codes for CS, DS, ES, SS
 133  *                 (POP is never used for CS) depending on operand 0
 134  * \346,\347     - the second byte of PUSH/POP codes for FS, GS, depending
 135  *                 on operand 0
 136  * \360          - no SSE prefix (== \364\331)
 137  * \361          - 66 SSE prefix (== \366\331)
 138  * \362          - F2 SSE prefix (== \364\332)
 139  * \363          - F3 SSE prefix (== \364\333)
 140  * \364          - operand-size prefix (0x66) not permitted
 141  * \365          - address-size prefix (0x67) not permitted
 142  * \366          - operand-size prefix (0x66) used as opcode extension
 143  * \367          - address-size prefix (0x67) used as opcode extension
 144  * \370,\371,\372 - match only if operand 0 meets byte jump criteria.
 145  *                 370 is used for Jcc, 371 is used for JMP.
 146  * \373          - assemble 0x03 if bits==16, 0x05 if bits==32;
 147  *                 used for conditional jump over longer jump
 148  * \374          - this instruction takes an XMM VSIB memory EA
 149  * \375          - this instruction takes an YMM VSIB memory EA
 150  */
 151
 152 #include "compiler.h"
 153
 154 #include <stdio.h>
 155 #include <string.h>
 156 #include <inttypes.h>
 157
 158 #include "nasm.h"
 159 #include "nasmlib.h"
 160 #include "assemble.h"
 161 #include "insns.h"
 162 #include "tables.h"
 163
 164 enum match_result {
 165     /*
 166      * Matching errors.  These should be sorted so that more specific
 167      * errors come later in the sequence.
 168      */
 169     MERR_INVALOP,
 170     MERR_OPSIZEMISSING,
 171     MERR_OPSIZEMISMATCH,
 172     MERR_BADCPU,
 173     MERR_BADMODE,
 174     /*
 175      * Matching success; the conditional ones first
 176      */
 177     MOK_JUMP,   /* Matching OK but needs jmp_match() */
 178     MOK_GOOD    /* Matching unconditionally OK */
 179 };
 180
 181 typedef struct {
 182     enum ea_type type;            /* what kind of EA is this? */
 183     int sib_present;              /* is a SIB byte necessary? */
 184     int bytes;                    /* # of bytes of offset needed */
 185     int size;                     /* lazy - this is sib+bytes+1 */
 186     uint8_t modrm, sib, rex, rip; /* the bytes themselves */
 187 } ea;
 188
 189 static uint32_t cpu;            /* cpu level received from nasm.c */
 190 static efunc errfunc;
 191 static struct ofmt *outfmt;
 192 static ListGen *list;
 193
 194 static int64_t calcsize(int32_t, int64_t, int, insn *, const uint8_t *);
 195 static void gencode(int32_t segment, int64_t offset, int bits,
 196                     insn * ins, const struct itemplate *temp,
 197                     int64_t insn_end);
 198 static enum match_result find_match(const struct itemplate **tempp,
 199                                     insn *instruction,
 200                                     int32_t segment, int64_t offset, int bits);
 201 static enum match_result matches(const struct itemplate *, insn *, int bits);
 202 static opflags_t regflag(const operand *);
 203 static int32_t regval(const operand *);
 204 static int rexflags(int, opflags_t, int);
 205 static int op_rexflags(const operand *, int);
 206 static void add_asp(insn *, int);
 207
 208 static enum ea_type process_ea(operand *, ea *, int, int, int, opflags_t);
 209
 210 static int has_prefix(insn * ins, enum prefix_pos pos, enum prefixes prefix)
 211 {
 212     return ins->prefixes[pos] == prefix;
 213 }
 214
 215 static void assert_no_prefix(insn * ins, enum prefix_pos pos)
 216 {
 217     if (ins->prefixes[pos])
 218         errfunc(ERR_NONFATAL, "invalid %s prefix",
 219                 prefix_name(ins->prefixes[pos]));
 220 }
 221
 222 static const char *size_name(int size)
 223 {
 224     switch (size) {
 225     case 1:
 226         return "byte";
 227     case 2:
 228         return "word";
 229     case 4:
 230         return "dword";
 231     case 8:
 232         return "qword";
 233     case 10:
 234         return "tword";
 235     case 16:
 236         return "oword";
 237     case 32:
 238         return "yword";
 239     default:
 240         return "???";
 241     }
 242 }
 243
 244 static void warn_overflow(int pass, int size)
 245 {
 246     errfunc(ERR_WARNING | pass | ERR_WARN_NOV,
 247             "%s data exceeds bounds", size_name(size));
 248 }
 249
 250 static void warn_overflow_const(int64_t data, int size)
 251 {
 252     if (overflow_general(data, size))
 253         warn_overflow(ERR_PASS1, size);
 254 }
 255
 256 static void warn_overflow_opd(const struct operand *o, int size)
 257 {
 258     if (o->wrt == NO_SEG && o->segment == NO_SEG) {
 259         if (overflow_general(o->offset, size))
 260             warn_overflow(ERR_PASS2, size);
 261     }
 262 }
 263
 264 /*
 265  * This routine wrappers the real output format's output routine,
 266  * in order to pass a copy of the data off to the listing file
 267  * generator at the same time.
 268  */
 269 static void out(int64_t offset, int32_t segto, const void *data,
 270                 enum out_type type, uint64_t size,
 271                 int32_t segment, int32_t wrt)
 272 {
 273     static int32_t lineno = 0;     /* static!!! */
 274     static char *lnfname = NULL;
 275     uint8_t p[8];
 276
 277     if (type == OUT_ADDRESS && segment == NO_SEG && wrt == NO_SEG) {
 278         /*
 279          * This is a non-relocated address, and we're going to
 280          * convert it into RAWDATA format.
 281          */
 282         uint8_t *q = p;
 283
 284         if (size > 8) {
 285             errfunc(ERR_PANIC, "OUT_ADDRESS with size > 8");
 286             return;
 287         }
 288
 289         WRITEADDR(q, *(int64_t *)data, size);
 290         data = p;
 291         type = OUT_RAWDATA;
 292     }
 293
 294     list->output(offset, data, type, size);
 295
 296     /*
 297      * this call to src_get determines when we call the
 298      * debug-format-specific "linenum" function
 299      * it updates lineno and lnfname to the current values
 300      * returning 0 if "same as last time", -2 if lnfname
 301      * changed, and the amount by which lineno changed,
 302      * if it did. thus, these variables must be static
 303      */
 304
 305     if (src_get(&lineno, &lnfname))
 306         outfmt->current_dfmt->linenum(lnfname, lineno, segto);
 307
 308     outfmt->output(segto, data, type, size, segment, wrt);
 309 }
 310
 311 static bool jmp_match(int32_t segment, int64_t offset, int bits,
 312                      insn * ins, const uint8_t *code)
 313 {
 314     int64_t isize;
 315     uint8_t c = code[0];
 316
 317     if ((c != 0370 && c != 0371) || (ins->oprs[0].type & STRICT))
 318         return false;
 319     if (!optimizing)
 320         return false;
 321     if (optimizing < 0 && c == 0371)
 322         return false;
 323
 324     isize = calcsize(segment, offset, bits, ins, code);
 325
 326     if (ins->oprs[0].opflags & OPFLAG_UNKNOWN)
 327         /* Be optimistic in pass 1 */
 328         return true;
 329
 330     if (ins->oprs[0].segment != segment)
 331         return false;
 332
 333     isize = ins->oprs[0].offset - offset - isize; /* isize is delta */
 334     return (isize >= -128 && isize <= 127); /* is it byte size? */
 335 }
 336
 337 int64_t assemble(int32_t segment, int64_t offset, int bits, uint32_t cp,
 338                  insn * instruction, struct ofmt *output, efunc error,
 339                  ListGen * listgen)
 340 {
 341     const struct itemplate *temp;
 342     int j;
 343     enum match_result m;
 344     int64_t insn_end;
 345     int32_t itimes;
 346     int64_t start = offset;
 347     int64_t wsize;              /* size for DB etc. */
 348
 349     errfunc = error;            /* to pass to other functions */
 350     cpu = cp;
 351     outfmt = output;            /* likewise */
 352     list = listgen;             /* and again */
 353
 354     wsize = idata_bytes(instruction->opcode);
 355     if (wsize == -1)
 356         return 0;
 357
 358     if (wsize) {
 359         extop *e;
 360         int32_t t = instruction->times;
 361         if (t < 0)
 362             errfunc(ERR_PANIC,
 363                     "instruction->times < 0 (%ld) in assemble()", t);
 364
 365         while (t--) {           /* repeat TIMES times */
 366             list_for_each(e, instruction->eops) {
 367                 if (e->type == EOT_DB_NUMBER) {
 368                     if (wsize > 8) {
 369                         errfunc(ERR_NONFATAL,
 370                                 "integer supplied to a DT, DO or DY"
 371                                 " instruction");
 372                     } else {
 373                         out(offset, segment, &e->offset,
 374                             OUT_ADDRESS, wsize, e->segment, e->wrt);
 375                         offset += wsize;
 376                     }
 377                 } else if (e->type == EOT_DB_STRING ||
 378                            e->type == EOT_DB_STRING_FREE) {
 379                     int align;
 380
 381                     out(offset, segment, e->stringval,
 382                         OUT_RAWDATA, e->stringlen, NO_SEG, NO_SEG);
 383                     align = e->stringlen % wsize;
 384
 385                     if (align) {
 386                         align = wsize - align;
 387                         out(offset, segment, zero_buffer,
 388                             OUT_RAWDATA, align, NO_SEG, NO_SEG);
 389                     }
 390                     offset += e->stringlen + align;
 391                 }
 392             }
 393             if (t > 0 && t == instruction->times - 1) {
 394                 /*
 395                  * Dummy call to list->output to give the offset to the
 396                  * listing module.
 397                  */
 398                 list->output(offset, NULL, OUT_RAWDATA, 0);
 399                 list->uplevel(LIST_TIMES);
 400             }
 401         }
 402         if (instruction->times > 1)
 403             list->downlevel(LIST_TIMES);
 404         return offset - start;
 405     }
 406
 407     if (instruction->opcode == I_INCBIN) {
 408         const char *fname = instruction->eops->stringval;
 409         FILE *fp;
 410
 411         fp = fopen(fname, "rb");
 412         if (!fp) {
 413             error(ERR_NONFATAL, "`incbin': unable to open file `%s'",
 414                   fname);
 415         } else if (fseek(fp, 0L, SEEK_END) < 0) {
 416             error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
 417                   fname);
 418         } else {
 419             static char buf[4096];
 420             size_t t = instruction->times;
 421             size_t base = 0;
 422             size_t len;
 423
 424             len = ftell(fp);
 425             if (instruction->eops->next) {
 426                 base = instruction->eops->next->offset;
 427                 len -= base;
 428                 if (instruction->eops->next->next &&
 429                     len > (size_t)instruction->eops->next->next->offset)
 430                     len = (size_t)instruction->eops->next->next->offset;
 431             }
 432             /*
 433              * Dummy call to list->output to give the offset to the
 434              * listing module.
 435              */
 436             list->output(offset, NULL, OUT_RAWDATA, 0);
 437             list->uplevel(LIST_INCBIN);
 438             while (t--) {
 439                 size_t l;
 440
 441                 fseek(fp, base, SEEK_SET);
 442                 l = len;
 443                 while (l > 0) {
 444                     int32_t m;
 445                     m = fread(buf, 1, l > sizeof(buf) ? sizeof(buf) : l, fp);
 446                     if (!m) {
 447                         /*
 448                          * This shouldn't happen unless the file
 449                          * actually changes while we are reading
 450                          * it.
 451                          */
 452                         error(ERR_NONFATAL,
 453                               "`incbin': unexpected EOF while"
 454                               " reading file `%s'", fname);
 455                         t = 0;  /* Try to exit cleanly */
 456                         break;
 457                     }
 458                     out(offset, segment, buf, OUT_RAWDATA, m,
 459                         NO_SEG, NO_SEG);
 460                     l -= m;
 461                 }
 462             }
 463             list->downlevel(LIST_INCBIN);
 464             if (instruction->times > 1) {
 465                 /*
 466                  * Dummy call to list->output to give the offset to the
 467                  * listing module.
 468                  */
 469                 list->output(offset, NULL, OUT_RAWDATA, 0);
 470                 list->uplevel(LIST_TIMES);
 471                 list->downlevel(LIST_TIMES);
 472             }
 473             fclose(fp);
 474             return instruction->times * len;
 475         }
 476         return 0;               /* if we're here, there's an error */
 477     }
 478
 479     /* Check to see if we need an address-size prefix */
 480     add_asp(instruction, bits);
 481
 482     m = find_match(&temp, instruction, segment, offset, bits);
 483
 484     if (m == MOK_GOOD) {
 485         /* Matches! */
 486         int64_t insn_size = calcsize(segment, offset, bits,
 487                                      instruction, temp->code);
 488         itimes = instruction->times;
 489         if (insn_size < 0)  /* shouldn't be, on pass two */
 490             error(ERR_PANIC, "errors made it through from pass one");
 491         else
 492             while (itimes--) {
 493                 for (j = 0; j < MAXPREFIX; j++) {
 494                     uint8_t c = 0;
 495                     switch (instruction->prefixes[j]) {
 496                     case P_WAIT:
 497                         c = 0x9B;
 498                         break;
 499                     case P_LOCK:
 500                         c = 0xF0;
 501                         break;
 502                     case P_REPNE:
 503                     case P_REPNZ:
 504                         c = 0xF2;
 505                         break;
 506                     case P_REPE:
 507                     case P_REPZ:
 508                     case P_REP:
 509                         c = 0xF3;
 510                         break;
 511                     case R_CS:
 512                         if (bits == 64) {
 513                             error(ERR_WARNING | ERR_PASS2,
 514                                   "cs segment base generated, but will be ignored in 64-bit mode");
 515                         }
 516                         c = 0x2E;
 517                         break;
 518                     case R_DS:
 519                         if (bits == 64) {
 520                             error(ERR_WARNING | ERR_PASS2,
 521                                   "ds segment base generated, but will be ignored in 64-bit mode");
 522                         }
 523                         c = 0x3E;
 524                         break;
 525                     case R_ES:
 526                         if (bits == 64) {
 527                             error(ERR_WARNING | ERR_PASS2,
 528                                   "es segment base generated, but will be ignored in 64-bit mode");
 529                         }
 530                         c = 0x26;
 531                         break;
 532                     case R_FS:
 533                         c = 0x64;
 534                         break;
 535                     case R_GS:
 536                         c = 0x65;
 537                         break;
 538                     case R_SS:
 539                         if (bits == 64) {
 540                             error(ERR_WARNING | ERR_PASS2,
 541                                   "ss segment base generated, but will be ignored in 64-bit mode");
 542                         }
 543                         c = 0x36;
 544                         break;
 545                     case R_SEGR6:
 546                     case R_SEGR7:
 547                         error(ERR_NONFATAL,
 548                               "segr6 and segr7 cannot be used as prefixes");
 549                         break;
 550                     case P_A16:
 551                         if (bits == 64) {
 552                             error(ERR_NONFATAL,
 553                                   "16-bit addressing is not supported "
 554                                   "in 64-bit mode");
 555                         } else if (bits != 16)
 556                             c = 0x67;
 557                         break;
 558                     case P_A32:
 559                         if (bits != 32)
 560                             c = 0x67;
 561                         break;
 562                     case P_A64:
 563                         if (bits != 64) {
 564                             error(ERR_NONFATAL,
 565                                   "64-bit addressing is only supported "
 566                                   "in 64-bit mode");
 567                         }
 568                         break;
 569                     case P_ASP:
 570                         c = 0x67;
 571                         break;
 572                     case P_O16:
 573                         if (bits != 16)
 574                             c = 0x66;
 575                         break;
 576                     case P_O32:
 577                         if (bits == 16)
 578                             c = 0x66;
 579                         break;
 580                     case P_O64:
 581                         /* REX.W */
 582                         break;
 583                     case P_OSP:
 584                         c = 0x66;
 585                         break;
 586                     case P_none:
 587                         break;
 588                     default:
 589                         error(ERR_PANIC, "invalid instruction prefix");
 590                     }
 591                     if (c != 0) {
 592                         out(offset, segment, &c, OUT_RAWDATA, 1,
 593                             NO_SEG, NO_SEG);
 594                         offset++;
 595                     }
 596                 }
 597                 insn_end = offset + insn_size;
 598                 gencode(segment, offset, bits, instruction,
 599                         temp, insn_end);
 600                 offset += insn_size;
 601                 if (itimes > 0 && itimes == instruction->times - 1) {
 602                     /*
 603                      * Dummy call to list->output to give the offset to the
 604                      * listing module.
 605                      */
 606                     list->output(offset, NULL, OUT_RAWDATA, 0);
 607                     list->uplevel(LIST_TIMES);
 608                 }
 609             }
 610         if (instruction->times > 1)
 611             list->downlevel(LIST_TIMES);
 612         return offset - start;
 613     } else {
 614         /* No match */
 615         switch (m) {
 616         case MERR_OPSIZEMISSING:
 617             error(ERR_NONFATAL, "operation size not specified");
 618             break;
 619         case MERR_OPSIZEMISMATCH:
 620             error(ERR_NONFATAL, "mismatch in operand sizes");
 621             break;
 622         case MERR_BADCPU:
 623             error(ERR_NONFATAL, "no instruction for this cpu level");
 624             break;
 625         case MERR_BADMODE:
 626             error(ERR_NONFATAL, "instruction not supported in %d-bit mode",
 627                   bits);
 628             break;
 629         default:
 630             error(ERR_NONFATAL,
 631                   "invalid combination of opcode and operands");
 632             break;
 633         }
 634     }
 635     return 0;
 636 }
 637
 638 int64_t insn_size(int32_t segment, int64_t offset, int bits, uint32_t cp,
 639                   insn * instruction, efunc error)
 640 {
 641     const struct itemplate *temp;
 642     enum match_result m;
 643
 644     errfunc = error;            /* to pass to other functions */
 645     cpu = cp;
 646
 647     if (instruction->opcode == I_none)
 648         return 0;
 649
 650     if (instruction->opcode == I_DB || instruction->opcode == I_DW ||
 651         instruction->opcode == I_DD || instruction->opcode == I_DQ ||
 652         instruction->opcode == I_DT || instruction->opcode == I_DO ||
 653         instruction->opcode == I_DY) {
 654         extop *e;
 655         int32_t isize, osize, wsize;
 656
 657         isize = 0;
 658         wsize = idata_bytes(instruction->opcode);
 659
 660         list_for_each(e, instruction->eops) {
 661             int32_t align;
 662
 663             osize = 0;
 664             if (e->type == EOT_DB_NUMBER) {
 665                 osize = 1;
 666                 warn_overflow_const(e->offset, wsize);
 667             } else if (e->type == EOT_DB_STRING ||
 668                        e->type == EOT_DB_STRING_FREE)
 669                 osize = e->stringlen;
 670
 671             align = (-osize) % wsize;
 672             if (align < 0)
 673                 align += wsize;
 674             isize += osize + align;
 675         }
 676         return isize * instruction->times;
 677     }
 678
 679     if (instruction->opcode == I_INCBIN) {
 680         const char *fname = instruction->eops->stringval;
 681         FILE *fp;
 682         int64_t val = 0;
 683         size_t len;
 684
 685         fp = fopen(fname, "rb");
 686         if (!fp)
 687             error(ERR_NONFATAL, "`incbin': unable to open file `%s'",
 688                   fname);
 689         else if (fseek(fp, 0L, SEEK_END) < 0)
 690             error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
 691                   fname);
 692         else {
 693             len = ftell(fp);
 694             if (instruction->eops->next) {
 695                 len -= instruction->eops->next->offset;
 696                 if (instruction->eops->next->next &&
 697                     len > (size_t)instruction->eops->next->next->offset) {
 698                     len = (size_t)instruction->eops->next->next->offset;
 699                 }
 700             }
 701             val = instruction->times * len;
 702         }
 703         if (fp)
 704             fclose(fp);
 705         return val;
 706     }
 707
 708     /* Check to see if we need an address-size prefix */
 709     add_asp(instruction, bits);
 710
 711     m = find_match(&temp, instruction, segment, offset, bits);
 712     if (m == MOK_GOOD) {
 713         /* we've matched an instruction. */
 714         int64_t isize;
 715         const uint8_t *codes = temp->code;
 716         int j;
 717
 718         isize = calcsize(segment, offset, bits, instruction, codes);
 719         if (isize < 0)
 720             return -1;
 721         for (j = 0; j < MAXPREFIX; j++) {
 722             switch (instruction->prefixes[j]) {
 723             case P_A16:
 724                 if (bits != 16)
 725                     isize++;
 726                 break;
 727             case P_A32:
 728                 if (bits != 32)
 729                     isize++;
 730                 break;
 731             case P_O16:
 732                 if (bits != 16)
 733                     isize++;
 734                 break;
 735             case P_O32:
 736                 if (bits == 16)
 737                     isize++;
 738                 break;
 739             case P_A64:
 740             case P_O64:
 741             case P_none:
 742                 break;
 743             default:
 744                 isize++;
 745                 break;
 746             }
 747         }
 748         return isize * instruction->times;
 749     } else {
 750         return -1;                  /* didn't match any instruction */
 751     }
 752 }
 753
 754 static bool possible_sbyte(operand *o)
 755 {
 756     return o->wrt == NO_SEG && o->segment == NO_SEG &&
 757         !(o->opflags & OPFLAG_UNKNOWN) &&
 758         optimizing >= 0 && !(o->type & STRICT);
 759 }
 760
 761 /* check that opn[op]  is a signed byte of size 16 or 32 */
 762 static bool is_sbyte16(operand *o)
 763 {
 764     int16_t v;
 765
 766     if (!possible_sbyte(o))
 767         return false;
 768
 769     v = o->offset;
 770     return v >= -128 && v <= 127;
 771 }
 772
 773 static bool is_sbyte32(operand *o)
 774 {
 775     int32_t v;
 776
 777     if (!possible_sbyte(o))
 778         return false;
 779
 780     v = o->offset;
 781     return v >= -128 && v <= 127;
 782 }
 783
 784 /* Common construct */
 785 #define case4(x) case (x): case (x)+1: case (x)+2: case (x)+3
 786
 787 static int64_t calcsize(int32_t segment, int64_t offset, int bits,
 788                         insn * ins, const uint8_t *codes)
 789 {
 790     int64_t length = 0;
 791     uint8_t c;
 792     int rex_mask = ~0;
 793     int op1, op2;
 794     struct operand *opx;
 795     uint8_t opex = 0;
 796     enum ea_type eat;
 797
 798     ins->rex = 0;               /* Ensure REX is reset */
 799     eat = EA_SCALAR;            /* Expect a scalar EA */
 800
 801     if (ins->prefixes[PPS_OSIZE] == P_O64)
 802         ins->rex |= REX_W;
 803
 804     (void)segment;              /* Don't warn that this parameter is unused */
 805     (void)offset;               /* Don't warn that this parameter is unused */
 806
 807     while (*codes) {
 808         c = *codes++;
 809         op1 = (c & 3) + ((opex & 1) << 2);
 810         op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
 811         opx = &ins->oprs[op1];
 812         opex = 0;               /* For the next iteration */
 813
 814         switch (c) {
 815         case 01:
 816         case 02:
 817         case 03:
 818         case 04:
 819             codes += c, length += c;
 820             break;
 821
 822         case 05:
 823         case 06:
 824         case 07:
 825             opex = c;
 826             break;
 827
 828         case4(010):
 829             ins->rex |=
 830                 op_rexflags(opx, REX_B|REX_H|REX_P|REX_W);
 831             codes++, length++;
 832             break;
 833
 834         case4(014):
 835         case4(020):
 836         case4(024):
 837             length++;
 838             break;
 839
 840         case4(030):
 841             length += 2;
 842             break;
 843
 844         case4(034):
 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
 851         case4(040):
 852             length += 4;
 853             break;
 854
 855         case4(044):
 856             length += ins->addr_size >> 3;
 857             break;
 858
 859         case4(050):
 860             length++;
 861             break;
 862
 863         case4(054):
 864             length += 8; /* MOV reg64/imm */
 865             break;
 866
 867         case4(060):
 868             length += 2;
 869             break;
 870
 871         case4(064):
 872             if (opx->type & (BITS16 | BITS32 | BITS64))
 873                 length += (opx->type & BITS16) ? 2 : 4;
 874             else
 875                 length += (bits == 16) ? 2 : 4;
 876             break;
 877
 878         case4(070):
 879             length += 4;
 880             break;
 881
 882         case4(074):
 883             length += 2;
 884             break;
 885
 886         case4(0140):
 887             length += is_sbyte16(opx) ? 1 : 2;
 888             break;
 889
 890         case4(0144):
 891             codes++;
 892             length++;
 893             break;
 894
 895         case4(0150):
 896             length += is_sbyte32(opx) ? 1 : 4;
 897             break;
 898
 899         case4(0154):
 900             codes++;
 901             length++;
 902             break;
 903
 904         case 0172:
 905         case 0173:
 906             codes++;
 907             length++;
 908             break;
 909
 910         case4(0174):
 911             length++;
 912             break;
 913
 914         case4(0250):
 915             length += is_sbyte32(opx) ? 1 : 4;
 916             break;
 917
 918         case4(0254):
 919             length += 4;
 920             break;
 921
 922         case4(0260):
 923             ins->rex |= REX_V;
 924             ins->vexreg = regval(opx);
 925             ins->vex_cm = *codes++;
 926             ins->vex_wlp = *codes++;
 927             break;
 928
 929         case 0270:
 930             ins->rex |= REX_V;
 931             ins->vexreg = 0;
 932             ins->vex_cm = *codes++;
 933             ins->vex_wlp = *codes++;
 934             break;
 935
 936         case4(0274):
 937             length++;
 938             break;
 939
 940         case4(0300):
 941             break;
 942
 943         case 0310:
 944             if (bits == 64)
 945                 return -1;
 946             length += (bits != 16) && !has_prefix(ins, PPS_ASIZE, P_A16);
 947             break;
 948
 949         case 0311:
 950             length += (bits != 32) && !has_prefix(ins, PPS_ASIZE, P_A32);
 951             break;
 952
 953         case 0312:
 954             break;
 955
 956         case 0313:
 957             if (bits != 64 || has_prefix(ins, PPS_ASIZE, P_A16) ||
 958                 has_prefix(ins, PPS_ASIZE, P_A32))
 959                 return -1;
 960             break;
 961
 962         case4(0314):
 963             break;
 964
 965         case 0320:
 966         {
 967             enum prefixes pfx = ins->prefixes[PPS_OSIZE];
 968             if (pfx == P_O16)
 969                 break;
 970             if (pfx != P_none)
 971                 errfunc(ERR_WARNING | ERR_PASS2, "invalid operand size prefix");
 972             else
 973                 ins->prefixes[PPS_OSIZE] = P_O16;
 974             break;
 975         }
 976
 977         case 0321:
 978         {
 979             enum prefixes pfx = ins->prefixes[PPS_OSIZE];
 980             if (pfx == P_O32)
 981                 break;
 982             if (pfx != P_none)
 983                 errfunc(ERR_WARNING | ERR_PASS2, "invalid operand size prefix");
 984             else
 985                 ins->prefixes[PPS_OSIZE] = P_O32;
 986             break;
 987         }
 988
 989         case 0322:
 990             break;
 991
 992         case 0323:
 993             rex_mask &= ~REX_W;
 994             break;
 995
 996         case 0324:
 997             ins->rex |= REX_W;
 998             break;
 999
1000         case 0325:
1001             ins->rex |= REX_NH;
1002             break;
1003
1004         case 0330:
1005             codes++, length++;
1006             break;
1007
1008         case 0331:
1009             break;
1010
1011         case 0332:
1012         case 0333:
1013             length++;
1014             break;
1015
1016         case 0334:
1017             ins->rex |= REX_L;
1018             break;
1019
1020         case 0335:
1021             break;
1022
1023         case 0336:
1024             if (!ins->prefixes[PPS_LREP])
1025                 ins->prefixes[PPS_LREP] = P_REP;
1026             break;
1027
1028         case 0337:
1029             if (!ins->prefixes[PPS_LREP])
1030                 ins->prefixes[PPS_LREP] = P_REPNE;
1031             break;
1032
1033         case 0340:
1034             if (ins->oprs[0].segment != NO_SEG)
1035                 errfunc(ERR_NONFATAL, "attempt to reserve non-constant"
1036                         " quantity of BSS space");
1037             else
1038                 length += ins->oprs[0].offset;
1039             break;
1040
1041         case 0341:
1042             if (!ins->prefixes[PPS_WAIT])
1043                 ins->prefixes[PPS_WAIT] = P_WAIT;
1044             break;
1045
1046         case4(0344):
1047             length++;
1048             break;
1049
1050         case 0360:
1051             break;
1052
1053         case 0361:
1054         case 0362:
1055         case 0363:
1056             length++;
1057             break;
1058
1059         case 0364:
1060         case 0365:
1061             break;
1062
1063         case 0366:
1064         case 0367:
1065             length++;
1066             break;
1067
1068         case 0370:
1069         case 0371:
1070         case 0372:
1071             break;
1072
1073         case 0373:
1074             length++;
1075             break;
1076
1077         case 0374:
1078             eat = EA_XMMVSIB;
1079             break;
1080
1081         case 0375:
1082             eat = EA_YMMVSIB;
1083             break;
1084
1085         case4(0100):
1086         case4(0110):
1087         case4(0120):
1088         case4(0130):
1089         case4(0200):
1090         case4(0204):
1091         case4(0210):
1092         case4(0214):
1093         case4(0220):
1094         case4(0224):
1095         case4(0230):
1096         case4(0234):
1097             {
1098                 ea ea_data;
1099                 int rfield;
1100                 opflags_t rflags;
1101                 struct operand *opy = &ins->oprs[op2];
1102
1103                 ea_data.rex = 0;           /* Ensure ea.REX is initially 0 */
1104
1105                 if (c <= 0177) {
1106                     /* pick rfield from operand b (opx) */
1107                     rflags = regflag(opx);
1108                     rfield = nasm_regvals[opx->basereg];
1109                 } else {
1110                     rflags = 0;
1111                     rfield = c & 7;
1112                 }
1113                 if (process_ea(opy, &ea_data, bits,ins->addr_size,
1114                                rfield, rflags) != eat) {
1115                     errfunc(ERR_NONFATAL, "invalid effective address");
1116                     return -1;
1117                 } else {
1118                     ins->rex |= ea_data.rex;
1119                     length += ea_data.size;
1120                 }
1121             }
1122             break;
1123
1124         default:
1125             errfunc(ERR_PANIC, "internal instruction table corrupt"
1126                     ": instruction code \\%o (0x%02X) given", c, c);
1127             break;
1128         }
1129     }
1130
1131     ins->rex &= rex_mask;
1132
1133     if (ins->rex & REX_NH) {
1134         if (ins->rex & REX_H) {
1135             errfunc(ERR_NONFATAL, "instruction cannot use high registers");
1136             return -1;
1137         }
1138         ins->rex &= ~REX_P;        /* Don't force REX prefix due to high reg */
1139     }
1140
1141     if (ins->rex & REX_V) {
1142         int bad32 = REX_R|REX_W|REX_X|REX_B;
1143
1144         if (ins->rex & REX_H) {
1145             errfunc(ERR_NONFATAL, "cannot use high register in vex instruction");
1146             return -1;
1147         }
1148         switch (ins->vex_wlp & 060) {
1149         case 000:
1150         case 040:
1151             ins->rex &= ~REX_W;
1152             break;
1153         case 020:
1154             ins->rex |= REX_W;
1155             bad32 &= ~REX_W;
1156             break;
1157         case 060:
1158             /* Follow REX_W */
1159             break;
1160         }
1161
1162         if (bits != 64 && ((ins->rex & bad32) || ins->vexreg > 7)) {
1163             errfunc(ERR_NONFATAL, "invalid operands in non-64-bit mode");
1164             return -1;
1165         }
1166         if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B)))
1167             length += 3;
1168         else
1169             length += 2;
1170     } else if (ins->rex & REX_REAL) {
1171         if (ins->rex & REX_H) {
1172             errfunc(ERR_NONFATAL, "cannot use high register in rex instruction");
1173             return -1;
1174         } else if (bits == 64) {
1175             length++;
1176         } else if ((ins->rex & REX_L) &&
1177                    !(ins->rex & (REX_P|REX_W|REX_X|REX_B)) &&
1178                    cpu >= IF_X86_64) {
1179             /* LOCK-as-REX.R */
1180             assert_no_prefix(ins, PPS_LREP);
1181             length++;
1182         } else {
1183             errfunc(ERR_NONFATAL, "invalid operands in non-64-bit mode");
1184             return -1;
1185         }
1186     }
1187
1188     return length;
1189 }
1190
1191 #define EMIT_REX()                                                              \
1192     if (!(ins->rex & REX_V) && (ins->rex & REX_REAL) && (bits == 64)) { \
1193         ins->rex = (ins->rex & REX_REAL)|REX_P;                                 \
1194         out(offset, segment, &ins->rex, OUT_RAWDATA, 1, NO_SEG, NO_SEG);        \
1195         ins->rex = 0;                                                           \
1196         offset += 1;                                                            \
1197     }
1198
1199 static void gencode(int32_t segment, int64_t offset, int bits,
1200                     insn * ins, const struct itemplate *temp,
1201                     int64_t insn_end)
1202 {
1203     static const char condval[] = {   /* conditional opcodes */
1204         0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2,
1205         0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5,
1206         0x0, 0xA, 0xA, 0xB, 0x8, 0x4
1207     };
1208     uint8_t c;
1209     uint8_t bytes[4];
1210     int64_t size;
1211     int64_t data;
1212     int op1, op2;
1213     struct operand *opx;
1214     const uint8_t *codes = temp->code;
1215     uint8_t opex = 0;
1216     enum ea_type eat = EA_SCALAR;
1217
1218     while (*codes) {
1219         c = *codes++;
1220         op1 = (c & 3) + ((opex & 1) << 2);
1221         op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
1222         opx = &ins->oprs[op1];
1223         opex = 0;                /* For the next iteration */
1224
1225         switch (c) {
1226         case 01:
1227         case 02:
1228         case 03:
1229         case 04:
1230             EMIT_REX();
1231             out(offset, segment, codes, OUT_RAWDATA, c, NO_SEG, NO_SEG);
1232             codes += c;
1233             offset += c;
1234             break;
1235
1236         case 05:
1237         case 06:
1238         case 07:
1239             opex = c;
1240             break;
1241
1242         case4(010):
1243             EMIT_REX();
1244             bytes[0] = *codes++ + (regval(opx) & 7);
1245             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1246             offset += 1;
1247             break;
1248
1249         case4(014):
1250             /*
1251              * The test for BITS8 and SBYTE here is intended to avoid
1252              * warning on optimizer actions due to SBYTE, while still
1253              * warn on explicit BYTE directives.  Also warn, obviously,
1254              * if the optimizer isn't enabled.
1255              */
1256             if (((opx->type & BITS8) ||
1257                  !(opx->type & temp->opd[op1] & BYTENESS)) &&
1258                 (opx->offset < -128 || opx->offset > 127)) {
1259                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1260                         "signed byte value exceeds bounds");
1261             }
1262             if (opx->segment != NO_SEG) {
1263                 data = opx->offset;
1264                 out(offset, segment, &data, OUT_ADDRESS, 1,
1265                     opx->segment, opx->wrt);
1266             } else {
1267                 bytes[0] = opx->offset;
1268                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1269                     NO_SEG);
1270             }
1271             offset += 1;
1272             break;
1273
1274         case4(020):
1275             if (opx->offset < -256 || opx->offset > 255) {
1276                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1277                         "byte value exceeds bounds");
1278             }
1279             if (opx->segment != NO_SEG) {
1280                 data = opx->offset;
1281                 out(offset, segment, &data, OUT_ADDRESS, 1,
1282                     opx->segment, opx->wrt);
1283             } else {
1284                 bytes[0] = opx->offset;
1285                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1286                     NO_SEG);
1287             }
1288             offset += 1;
1289             break;
1290
1291         case4(024):
1292             if (opx->offset < 0 || opx->offset > 255)
1293                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1294                         "unsigned byte value exceeds bounds");
1295             if (opx->segment != NO_SEG) {
1296                 data = opx->offset;
1297                 out(offset, segment, &data, OUT_ADDRESS, 1,
1298                     opx->segment, opx->wrt);
1299             } else {
1300                 bytes[0] = opx->offset;
1301                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1302                     NO_SEG);
1303             }
1304             offset += 1;
1305             break;
1306
1307         case4(030):
1308             warn_overflow_opd(opx, 2);
1309             data = opx->offset;
1310             out(offset, segment, &data, OUT_ADDRESS, 2,
1311                 opx->segment, opx->wrt);
1312             offset += 2;
1313             break;
1314
1315         case4(034):
1316             if (opx->type & (BITS16 | BITS32))
1317                 size = (opx->type & BITS16) ? 2 : 4;
1318             else
1319                 size = (bits == 16) ? 2 : 4;
1320             warn_overflow_opd(opx, size);
1321             data = opx->offset;
1322             out(offset, segment, &data, OUT_ADDRESS, size,
1323                 opx->segment, opx->wrt);
1324             offset += size;
1325             break;
1326
1327         case4(040):
1328             warn_overflow_opd(opx, 4);
1329             data = opx->offset;
1330             out(offset, segment, &data, OUT_ADDRESS, 4,
1331                 opx->segment, opx->wrt);
1332             offset += 4;
1333             break;
1334
1335         case4(044):
1336             data = opx->offset;
1337             size = ins->addr_size >> 3;
1338             warn_overflow_opd(opx, size);
1339             out(offset, segment, &data, OUT_ADDRESS, size,
1340                 opx->segment, opx->wrt);
1341             offset += size;
1342             break;
1343
1344         case4(050):
1345             if (opx->segment != segment) {
1346                 data = opx->offset;
1347                 out(offset, segment, &data,
1348                     OUT_REL1ADR, insn_end - offset,
1349                     opx->segment, opx->wrt);
1350             } else {
1351                 data = opx->offset - insn_end;
1352                 if (data > 127 || data < -128)
1353                     errfunc(ERR_NONFATAL, "short jump is out of range");
1354                 out(offset, segment, &data,
1355                     OUT_ADDRESS, 1, NO_SEG, NO_SEG);
1356             }
1357             offset += 1;
1358             break;
1359
1360         case4(054):
1361             data = (int64_t)opx->offset;
1362             out(offset, segment, &data, OUT_ADDRESS, 8,
1363                 opx->segment, opx->wrt);
1364             offset += 8;
1365             break;
1366
1367         case4(060):
1368             if (opx->segment != segment) {
1369                 data = opx->offset;
1370                 out(offset, segment, &data,
1371                     OUT_REL2ADR, insn_end - offset,
1372                     opx->segment, opx->wrt);
1373             } else {
1374                 data = opx->offset - insn_end;
1375                 out(offset, segment, &data,
1376                     OUT_ADDRESS, 2, NO_SEG, NO_SEG);
1377             }
1378             offset += 2;
1379             break;
1380
1381         case4(064):
1382             if (opx->type & (BITS16 | BITS32 | BITS64))
1383                 size = (opx->type & BITS16) ? 2 : 4;
1384             else
1385                 size = (bits == 16) ? 2 : 4;
1386             if (opx->segment != segment) {
1387                 data = opx->offset;
1388                 out(offset, segment, &data,
1389                     size == 2 ? OUT_REL2ADR : OUT_REL4ADR,
1390                     insn_end - offset, opx->segment, opx->wrt);
1391             } else {
1392                 data = opx->offset - insn_end;
1393                 out(offset, segment, &data,
1394                     OUT_ADDRESS, size, NO_SEG, NO_SEG);
1395             }
1396             offset += size;
1397             break;
1398
1399         case4(070):
1400             if (opx->segment != segment) {
1401                 data = opx->offset;
1402                 out(offset, segment, &data,
1403                     OUT_REL4ADR, insn_end - offset,
1404                     opx->segment, opx->wrt);
1405             } else {
1406                 data = opx->offset - insn_end;
1407                 out(offset, segment, &data,
1408                     OUT_ADDRESS, 4, NO_SEG, NO_SEG);
1409             }
1410             offset += 4;
1411             break;
1412
1413         case4(074):
1414             if (opx->segment == NO_SEG)
1415                 errfunc(ERR_NONFATAL, "value referenced by FAR is not"
1416                         " relocatable");
1417             data = 0;
1418             out(offset, segment, &data, OUT_ADDRESS, 2,
1419                 outfmt->segbase(1 + opx->segment),
1420                 opx->wrt);
1421             offset += 2;
1422             break;
1423
1424         case4(0140):
1425             data = opx->offset;
1426             warn_overflow_opd(opx, 2);
1427             if (is_sbyte16(opx)) {
1428                 bytes[0] = data;
1429                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1430                     NO_SEG);
1431                 offset++;
1432             } else {
1433                 out(offset, segment, &data, OUT_ADDRESS, 2,
1434                     opx->segment, opx->wrt);
1435                 offset += 2;
1436             }
1437             break;
1438
1439         case4(0144):
1440             EMIT_REX();
1441             bytes[0] = *codes++;
1442             if (is_sbyte16(opx))
1443                 bytes[0] |= 2;  /* s-bit */
1444             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1445             offset++;
1446             break;
1447
1448         case4(0150):
1449             data = opx->offset;
1450             warn_overflow_opd(opx, 4);
1451             if (is_sbyte32(opx)) {
1452                 bytes[0] = data;
1453                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1454                     NO_SEG);
1455                 offset++;
1456             } else {
1457                 out(offset, segment, &data, OUT_ADDRESS, 4,
1458                     opx->segment, opx->wrt);
1459                 offset += 4;
1460             }
1461             break;
1462
1463         case4(0154):
1464             EMIT_REX();
1465             bytes[0] = *codes++;
1466             if (is_sbyte32(opx))
1467                 bytes[0] |= 2;  /* s-bit */
1468             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1469             offset++;
1470             break;
1471
1472         case 0172:
1473             c = *codes++;
1474             opx = &ins->oprs[c >> 3];
1475             bytes[0] = nasm_regvals[opx->basereg] << 4;
1476             opx = &ins->oprs[c & 7];
1477             if (opx->segment != NO_SEG || opx->wrt != NO_SEG) {
1478                 errfunc(ERR_NONFATAL,
1479                         "non-absolute expression not permitted as argument %d",
1480                         c & 7);
1481             } else {
1482                 if (opx->offset & ~15) {
1483                     errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1484                             "four-bit argument exceeds bounds");
1485                 }
1486                 bytes[0] |= opx->offset & 15;
1487             }
1488             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1489             offset++;
1490             break;
1491
1492         case 0173:
1493             c = *codes++;
1494             opx = &ins->oprs[c >> 4];
1495             bytes[0] = nasm_regvals[opx->basereg] << 4;
1496             bytes[0] |= c & 15;
1497             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1498             offset++;
1499             break;
1500
1501         case4(0174):
1502             bytes[0] = nasm_regvals[opx->basereg] << 4;
1503             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1504             offset++;
1505             break;
1506
1507         case4(0250):
1508             data = opx->offset;
1509             if (opx->wrt == NO_SEG && opx->segment == NO_SEG &&
1510                 (int32_t)data != (int64_t)data) {
1511                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1512                         "signed dword immediate exceeds bounds");
1513             }
1514             if (is_sbyte32(opx)) {
1515                 bytes[0] = data;
1516                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1517                     NO_SEG);
1518                 offset++;
1519             } else {
1520                 out(offset, segment, &data, OUT_ADDRESS, 4,
1521                     opx->segment, opx->wrt);
1522                 offset += 4;
1523             }
1524             break;
1525
1526         case4(0254):
1527             data = opx->offset;
1528             if (opx->wrt == NO_SEG && opx->segment == NO_SEG &&
1529                 (int32_t)data != (int64_t)data) {
1530                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1531                         "signed dword immediate exceeds bounds");
1532             }
1533             out(offset, segment, &data, OUT_ADDRESS, 4,
1534                 opx->segment, opx->wrt);
1535             offset += 4;
1536             break;
1537
1538         case4(0260):
1539         case 0270:
1540             codes += 2;
1541             if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B))) {
1542                 bytes[0] = (ins->vex_cm >> 6) ? 0x8f : 0xc4;
1543                 bytes[1] = (ins->vex_cm & 31) | ((~ins->rex & 7) << 5);
1544                 bytes[2] = ((ins->rex & REX_W) << (7-3)) |
1545                     ((~ins->vexreg & 15)<< 3) | (ins->vex_wlp & 07);
1546                 out(offset, segment, &bytes, OUT_RAWDATA, 3, NO_SEG, NO_SEG);
1547                 offset += 3;
1548             } else {
1549                 bytes[0] = 0xc5;
1550                 bytes[1] = ((~ins->rex & REX_R) << (7-2)) |
1551                     ((~ins->vexreg & 15) << 3) | (ins->vex_wlp & 07);
1552                 out(offset, segment, &bytes, OUT_RAWDATA, 2, NO_SEG, NO_SEG);
1553                 offset += 2;
1554             }
1555             break;
1556
1557         case4(0274):
1558         {
1559             uint64_t uv, um;
1560             int s;
1561
1562             if (ins->rex & REX_W)
1563                 s = 64;
1564             else if (ins->prefixes[PPS_OSIZE] == P_O16)
1565                 s = 16;
1566             else if (ins->prefixes[PPS_OSIZE] == P_O32)
1567                 s = 32;
1568             else
1569                 s = bits;
1570
1571             um = (uint64_t)2 << (s-1);
1572             uv = opx->offset;
1573
1574             if (uv > 127 && uv < (uint64_t)-128 &&
1575                 (uv < um-128 || uv > um-1)) {
1576                 errfunc(ERR_WARNING | ERR_PASS2 | ERR_WARN_NOV,
1577                         "signed byte value exceeds bounds");
1578             }
1579             if (opx->segment != NO_SEG) {
1580                 data = uv;
1581                 out(offset, segment, &data, OUT_ADDRESS, 1,
1582                     opx->segment, opx->wrt);
1583             } else {
1584                 bytes[0] = uv;
1585                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG,
1586                     NO_SEG);
1587             }
1588             offset += 1;
1589             break;
1590         }
1591
1592         case4(0300):
1593             break;
1594
1595         case 0310:
1596             if (bits == 32 && !has_prefix(ins, PPS_ASIZE, P_A16)) {
1597                 *bytes = 0x67;
1598                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1599                 offset += 1;
1600             } else
1601                 offset += 0;
1602             break;
1603
1604         case 0311:
1605             if (bits != 32 && !has_prefix(ins, PPS_ASIZE, P_A32)) {
1606                 *bytes = 0x67;
1607                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1608                 offset += 1;
1609             } else
1610                 offset += 0;
1611             break;
1612
1613         case 0312:
1614             break;
1615
1616         case 0313:
1617             ins->rex = 0;
1618             break;
1619
1620         case4(0314):
1621             break;
1622
1623         case 0320:
1624         case 0321:
1625             break;
1626
1627         case 0322:
1628         case 0323:
1629             break;
1630
1631         case 0324:
1632             ins->rex |= REX_W;
1633             break;
1634
1635         case 0325:
1636             break;
1637
1638         case 0330:
1639             *bytes = *codes++ ^ condval[ins->condition];
1640             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1641             offset += 1;
1642             break;
1643
1644         case 0331:
1645             break;
1646
1647         case 0332:
1648         case 0333:
1649             *bytes = c - 0332 + 0xF2;
1650             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1651             offset += 1;
1652             break;
1653
1654         case 0334:
1655             if (ins->rex & REX_R) {
1656                 *bytes = 0xF0;
1657                 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1658                 offset += 1;
1659             }
1660             ins->rex &= ~(REX_L|REX_R);
1661             break;
1662
1663         case 0335:
1664             break;
1665
1666         case 0336:
1667         case 0337:
1668             break;
1669
1670         case 0340:
1671             if (ins->oprs[0].segment != NO_SEG)
1672                 errfunc(ERR_PANIC, "non-constant BSS size in pass two");
1673             else {
1674                 int64_t size = ins->oprs[0].offset;
1675                 if (size > 0)
1676                     out(offset, segment, NULL,
1677                         OUT_RESERVE, size, NO_SEG, NO_SEG);
1678                 offset += size;
1679             }
1680             break;
1681
1682         case 0341:
1683             break;
1684
1685         case 0344:
1686         case 0345:
1687             bytes[0] = c & 1;
1688             switch (ins->oprs[0].basereg) {
1689             case R_CS:
1690                 bytes[0] += 0x0E;
1691                 break;
1692             case R_DS:
1693                 bytes[0] += 0x1E;
1694                 break;
1695             case R_ES:
1696                 bytes[0] += 0x06;
1697                 break;
1698             case R_SS:
1699                 bytes[0] += 0x16;
1700                 break;
1701             default:
1702                 errfunc(ERR_PANIC,
1703                         "bizarre 8086 segment register received");
1704             }
1705             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1706             offset++;
1707             break;
1708
1709         case 0346:
1710         case 0347:
1711             bytes[0] = c & 1;
1712             switch (ins->oprs[0].basereg) {
1713             case R_FS:
1714                 bytes[0] += 0xA0;
1715                 break;
1716             case R_GS:
1717                 bytes[0] += 0xA8;
1718                 break;
1719             default:
1720                 errfunc(ERR_PANIC,
1721                         "bizarre 386 segment register received");
1722             }
1723             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1724             offset++;
1725             break;
1726
1727         case 0360:
1728             break;
1729
1730         case 0361:
1731             bytes[0] = 0x66;
1732             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1733             offset += 1;
1734             break;
1735
1736         case 0362:
1737         case 0363:
1738             bytes[0] = c - 0362 + 0xf2;
1739             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1740             offset += 1;
1741             break;
1742
1743         case 0364:
1744         case 0365:
1745             break;
1746
1747         case 0366:
1748         case 0367:
1749             *bytes = c - 0366 + 0x66;
1750             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1751             offset += 1;
1752             break;
1753
1754         case 0370:
1755         case 0371:
1756         case 0372:
1757             break;
1758
1759         case 0373:
1760             *bytes = bits == 16 ? 3 : 5;
1761             out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1762             offset += 1;
1763             break;
1764
1765         case 0374:
1766             eat = EA_XMMVSIB;
1767             break;
1768
1769         case 0375:
1770             eat = EA_YMMVSIB;
1771             break;
1772
1773         case4(0100):
1774         case4(0110):
1775         case4(0120):
1776         case4(0130):
1777         case4(0200):
1778         case4(0204):
1779         case4(0210):
1780         case4(0214):
1781         case4(0220):
1782         case4(0224):
1783         case4(0230):
1784         case4(0234):
1785             {
1786                 ea ea_data;
1787                 int rfield;
1788                 opflags_t rflags;
1789                 uint8_t *p;
1790                 int32_t s;
1791                 enum out_type type;
1792                 struct operand *opy = &ins->oprs[op2];
1793
1794                 if (c <= 0177) {
1795                     /* pick rfield from operand b (opx) */
1796                     rflags = regflag(opx);
1797                     rfield = nasm_regvals[opx->basereg];
1798                 } else {
1799                     /* rfield is constant */
1800                     rflags = 0;
1801                     rfield = c & 7;
1802                 }
1803
1804                 if (process_ea(opy, &ea_data, bits, ins->addr_size,
1805                                rfield, rflags) != eat) {
1806                     errfunc(ERR_NONFATAL, "invalid effective address");
1807                 }
1808
1809
1810                 p = bytes;
1811                 *p++ = ea_data.modrm;
1812                 if (ea_data.sib_present)
1813                     *p++ = ea_data.sib;
1814
1815                 s = p - bytes;
1816                 out(offset, segment, bytes, OUT_RAWDATA, s, NO_SEG, NO_SEG);
1817
1818                 /*
1819                  * Make sure the address gets the right offset in case
1820                  * the line breaks in the .lst file (BR 1197827)
1821                  */
1822                 offset += s;
1823                 s = 0;
1824
1825                 switch (ea_data.bytes) {
1826                 case 0:
1827                     break;
1828                 case 1:
1829                 case 2:
1830                 case 4:
1831                 case 8:
1832                     data = opy->offset;
1833                     s += ea_data.bytes;
1834                     if (ea_data.rip) {
1835                         if (opy->segment == segment) {
1836                             data -= insn_end;
1837                             if (overflow_signed(data, ea_data.bytes))
1838                                 warn_overflow(ERR_PASS2, ea_data.bytes);
1839                             out(offset, segment, &data, OUT_ADDRESS,
1840                                 ea_data.bytes, NO_SEG, NO_SEG);
1841                         } else {
1842                             /* overflow check in output/linker? */
1843                             out(offset, segment, &data,        OUT_REL4ADR,
1844                                 insn_end - offset, opy->segment, opy->wrt);
1845                         }
1846                     } else {
1847                         if (overflow_general(opy->offset, ins->addr_size >> 3) ||
1848                             signed_bits(opy->offset, ins->addr_size) !=
1849                             signed_bits(opy->offset, ea_data.bytes * 8))
1850                             warn_overflow(ERR_PASS2, ea_data.bytes);
1851
1852                         type = OUT_ADDRESS;
1853                         out(offset, segment, &data, OUT_ADDRESS,
1854                             ea_data.bytes, opy->segment, opy->wrt);
1855                     }
1856                     break;
1857                 default:
1858                     /* Impossible! */
1859                     errfunc(ERR_PANIC,
1860                             "Invalid amount of bytes (%d) for offset?!",
1861                             ea_data.bytes);
1862                     break;
1863                 }
1864                 offset += s;
1865             }
1866             break;
1867
1868         default:
1869             errfunc(ERR_PANIC, "internal instruction table corrupt"
1870                     ": instruction code \\%o (0x%02X) given", c, c);
1871             break;
1872         }
1873     }
1874 }
1875
1876 static opflags_t regflag(const operand * o)
1877 {
1878     if (!is_register(o->basereg))
1879         errfunc(ERR_PANIC, "invalid operand passed to regflag()");
1880     return nasm_reg_flags[o->basereg];
1881 }
1882
1883 static int32_t regval(const operand * o)
1884 {
1885     if (!is_register(o->basereg))
1886         errfunc(ERR_PANIC, "invalid operand passed to regval()");
1887     return nasm_regvals[o->basereg];
1888 }
1889
1890 static int op_rexflags(const operand * o, int mask)
1891 {
1892     opflags_t flags;
1893     int val;
1894
1895     if (!is_register(o->basereg))
1896         errfunc(ERR_PANIC, "invalid operand passed to op_rexflags()");
1897
1898     flags = nasm_reg_flags[o->basereg];
1899     val = nasm_regvals[o->basereg];
1900
1901     return rexflags(val, flags, mask);
1902 }
1903
1904 static int rexflags(int val, opflags_t flags, int mask)
1905 {
1906     int rex = 0;
1907
1908     if (val >= 8)
1909         rex |= REX_B|REX_X|REX_R;
1910     if (flags & BITS64)
1911         rex |= REX_W;
1912     if (!(REG_HIGH & ~flags))                   /* AH, CH, DH, BH */
1913         rex |= REX_H;
1914     else if (!(REG8 & ~flags) && val >= 4)      /* SPL, BPL, SIL, DIL */
1915         rex |= REX_P;
1916
1917     return rex & mask;
1918 }
1919
1920 static enum match_result find_match(const struct itemplate **tempp,
1921                                     insn *instruction,
1922                                     int32_t segment, int64_t offset, int bits)
1923 {
1924     const struct itemplate *temp;
1925     enum match_result m, merr;
1926     opflags_t xsizeflags[MAX_OPERANDS];
1927     bool opsizemissing = false;
1928     int i;
1929
1930     for (i = 0; i < instruction->operands; i++)
1931         xsizeflags[i] = instruction->oprs[i].type & SIZE_MASK;
1932
1933     merr = MERR_INVALOP;
1934
1935     for (temp = nasm_instructions[instruction->opcode];
1936          temp->opcode != I_none; temp++) {
1937         m = matches(temp, instruction, bits);
1938         if (m == MOK_JUMP) {
1939             if (jmp_match(segment, offset, bits, instruction, temp->code))
1940                 m = MOK_GOOD;
1941             else
1942                 m = MERR_INVALOP;
1943         } else if (m == MERR_OPSIZEMISSING &&
1944                    (temp->flags & IF_SMASK) != IF_SX) {
1945             /*
1946              * Missing operand size and a candidate for fuzzy matching...
1947              */
1948             for (i = 0; i < temp->operands; i++) {
1949                 if ((temp->opd[i] & SAME_AS) == 0)
1950                     xsizeflags[i] |= temp->opd[i] & SIZE_MASK;
1951             }
1952             opsizemissing = true;
1953         }
1954         if (m > merr)
1955             merr = m;
1956         if (merr == MOK_GOOD)
1957             goto done;
1958     }
1959
1960     /* No match, but see if we can get a fuzzy operand size match... */
1961     if (!opsizemissing)
1962         goto done;
1963
1964     for (i = 0; i < instruction->operands; i++) {
1965         /*
1966          * We ignore extrinsic operand sizes on registers, so we should
1967          * never try to fuzzy-match on them.  This also resolves the case
1968          * when we have e.g. "xmmrm128" in two different positions.
1969          */
1970         if (is_class(REGISTER, instruction->oprs[i].type))
1971             continue;
1972
1973         /* This tests if xsizeflags[i] has more than one bit set */
1974         if ((xsizeflags[i] & (xsizeflags[i]-1)))
1975             goto done;                /* No luck */
1976
1977         instruction->oprs[i].type |= xsizeflags[i]; /* Set the size */
1978     }
1979
1980     /* Try matching again... */
1981     for (temp = nasm_instructions[instruction->opcode];
1982          temp->opcode != I_none; temp++) {
1983         m = matches(temp, instruction, bits);
1984         if (m == MOK_JUMP) {
1985             if (jmp_match(segment, offset, bits, instruction, temp->code))
1986                 m = MOK_GOOD;
1987             else
1988                 m = MERR_INVALOP;
1989         }
1990         if (m > merr)
1991             merr = m;
1992         if (merr == MOK_GOOD)
1993             goto done;
1994     }
1995
1996 done:
1997     *tempp = temp;
1998     return merr;
1999 }
2000
2001 static enum match_result matches(const struct itemplate *itemp,
2002                                  insn *instruction, int bits)
2003 {
2004     int i, size[MAX_OPERANDS], asize, oprs;
2005     bool opsizemissing = false;
2006
2007     /*
2008      * Check the opcode
2009      */
2010     if (itemp->opcode != instruction->opcode)
2011         return MERR_INVALOP;
2012
2013     /*
2014      * Count the operands
2015      */
2016     if (itemp->operands != instruction->operands)
2017         return MERR_INVALOP;
2018
2019     /*
2020      * Is it legal?
2021      */
2022     if (!(optimizing > 0) && (itemp->flags & IF_OPT))
2023         return MERR_INVALOP;
2024
2025     /*
2026      * Check that no spurious colons or TOs are present
2027      */
2028     for (i = 0; i < itemp->operands; i++)
2029         if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO))
2030             return MERR_INVALOP;
2031
2032     /*
2033      * Process size flags
2034      */
2035     switch (itemp->flags & IF_SMASK) {
2036     case IF_SB:
2037         asize = BITS8;
2038         break;
2039     case IF_SW:
2040         asize = BITS16;
2041         break;
2042     case IF_SD:
2043         asize = BITS32;
2044         break;
2045     case IF_SQ:
2046         asize = BITS64;
2047         break;
2048     case IF_SO:
2049         asize = BITS128;
2050         break;
2051     case IF_SY:
2052         asize = BITS256;
2053         break;
2054     case IF_SZ:
2055         switch (bits) {
2056         case 16:
2057             asize = BITS16;
2058             break;
2059         case 32:
2060             asize = BITS32;
2061             break;
2062         case 64:
2063             asize = BITS64;
2064             break;
2065         default:
2066             asize = 0;
2067             break;
2068         }
2069         break;
2070     default:
2071         asize = 0;
2072         break;
2073     }
2074
2075     if (itemp->flags & IF_ARMASK) {
2076         /* S- flags only apply to a specific operand */
2077         i = ((itemp->flags & IF_ARMASK) >> IF_ARSHFT) - 1;
2078         memset(size, 0, sizeof size);
2079         size[i] = asize;
2080     } else {
2081         /* S- flags apply to all operands */
2082         for (i = 0; i < MAX_OPERANDS; i++)
2083             size[i] = asize;
2084     }
2085
2086     /*
2087      * Check that the operand flags all match up,
2088      * it's a bit tricky so lets be verbose:
2089      *
2090      * 1) Find out the size of operand. If instruction
2091      *    doesn't have one specified -- we're trying to
2092      *    guess it either from template (IF_S* flag) or
2093      *    from code bits.
2094      *
2095      * 2) If template operand (i) has SAME_AS flag [used for registers only]
2096      *    (ie the same operand as was specified somewhere in template, and
2097      *    this referred operand index is being achieved via ~SAME_AS)
2098      *    we are to be sure that both registers (in template and instruction)
2099      *    do exactly match.
2100      *
2101      * 3) If template operand do not match the instruction OR
2102      *    template has an operand size specified AND this size differ
2103      *    from which instruction has (perhaps we got it from code bits)
2104      *    we are:
2105      *      a)  Check that only size of instruction and operand is differ
2106      *          other characteristics do match
2107      *      b)  Perhaps it's a register specified in instruction so
2108      *          for such a case we just mark that operand as "size
2109      *          missing" and this will turn on fuzzy operand size
2110      *          logic facility (handled by a caller)
2111      */
2112     for (i = 0; i < itemp->operands; i++) {
2113         opflags_t type = instruction->oprs[i].type;
2114         if (!(type & SIZE_MASK))
2115             type |= size[i];
2116
2117         if (itemp->opd[i] & SAME_AS) {
2118             int j = itemp->opd[i] & ~SAME_AS;
2119             if (type != instruction->oprs[j].type ||
2120                 instruction->oprs[i].basereg != instruction->oprs[j].basereg)
2121                 return MERR_INVALOP;
2122         } else if (itemp->opd[i] & ~type ||
2123             ((itemp->opd[i] & SIZE_MASK) &&
2124              ((itemp->opd[i] ^ type) & SIZE_MASK))) {
2125             if ((itemp->opd[i] & ~type & ~SIZE_MASK) || (type & SIZE_MASK)) {
2126                 return MERR_INVALOP;
2127             } else if (!is_class(REGISTER, type)) {
2128                 /*
2129                  * Note: we don't honor extrinsic operand sizes for registers,
2130                  * so "missing operand size" for a register should be
2131                  * considered a wildcard match rather than an error.
2132                  */
2133                 opsizemissing = true;
2134             }
2135         }
2136     }
2137
2138     if (opsizemissing)
2139         return MERR_OPSIZEMISSING;
2140
2141     /*
2142      * Check operand sizes
2143      */
2144     if (itemp->flags & (IF_SM | IF_SM2)) {
2145         oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands);
2146         for (i = 0; i < oprs; i++) {
2147             asize = itemp->opd[i] & SIZE_MASK;
2148             if (asize) {
2149                 for (i = 0; i < oprs; i++)
2150                     size[i] = asize;
2151                 break;
2152             }
2153         }
2154     } else {
2155         oprs = itemp->operands;
2156     }
2157
2158     for (i = 0; i < itemp->operands; i++) {
2159         if (!(itemp->opd[i] & SIZE_MASK) &&
2160             (instruction->oprs[i].type & SIZE_MASK & ~size[i]))
2161             return MERR_OPSIZEMISMATCH;
2162     }
2163
2164     /*
2165      * Check template is okay at the set cpu level
2166      */
2167     if (((itemp->flags & IF_PLEVEL) > cpu))
2168         return MERR_BADCPU;
2169
2170     /*
2171      * Verify the appropriate long mode flag.
2172      */
2173     if ((itemp->flags & (bits == 64 ? IF_NOLONG : IF_LONG)))
2174         return MERR_BADMODE;
2175
2176     /*
2177      * Check if special handling needed for Jumps
2178      */
2179     if ((itemp->code[0] & 0374) == 0370)
2180         return MOK_JUMP;
2181
2182     return MOK_GOOD;
2183 }
2184
2185 static enum ea_type process_ea(operand * input, ea * output, int bits,
2186                                int addrbits, int rfield, opflags_t rflags)
2187 {
2188     bool forw_ref = !!(input->opflags & OPFLAG_UNKNOWN);
2189
2190     output->type = EA_SCALAR;
2191     output->rip = false;
2192
2193     /* REX flags for the rfield operand */
2194     output->rex |= rexflags(rfield, rflags, REX_R | REX_P | REX_W | REX_H);
2195
2196     if (is_class(REGISTER, input->type)) {  /* register direct */
2197         int i;
2198         opflags_t f;
2199
2200         if (!is_register(input->basereg))
2201             goto err;
2202         f = regflag(input);
2203         i = nasm_regvals[input->basereg];
2204
2205         if (REG_EA & ~f)
2206             goto err;
2207
2208         output->rex |= op_rexflags(input, REX_B | REX_P | REX_W | REX_H);
2209
2210         output->sib_present = false;    /* no SIB necessary */
2211         output->bytes = 0;              /* no offset necessary either */
2212         output->modrm = 0xC0 | ((rfield & 7) << 3) | (i & 7);
2213     } else {                    /* it's a memory reference */
2214         if (input->basereg == -1 &&
2215             (input->indexreg == -1 || input->scale == 0)) {
2216             /* it's a pure offset */
2217
2218             if (bits == 64 && ((input->type & IP_REL) == IP_REL) &&
2219                 input->segment == NO_SEG) {
2220                 nasm_error(ERR_WARNING | ERR_PASS1, "absolute address can not be RIP-relative");
2221                 input->type &= ~IP_REL;
2222                 input->type |= MEMORY;
2223             }
2224
2225             if (input->eaflags & EAF_BYTEOFFS ||
2226                 (input->eaflags & EAF_WORDOFFS &&
2227                  input->disp_size != (addrbits != 16 ? 32 : 16))) {
2228                 nasm_error(ERR_WARNING | ERR_PASS1, "displacement size ignored on absolute address");
2229             }
2230
2231             if (bits == 64 && (~input->type & IP_REL)) {
2232                 int scale, index, base;
2233                 output->sib_present = true;
2234                 scale = 0;
2235                 index = 4;
2236                 base = 5;
2237                 output->sib = (scale << 6) | (index << 3) | base;
2238                 output->bytes = 4;
2239                 output->modrm = 4 | ((rfield & 7) << 3);
2240                 output->rip = false;
2241             } else {
2242                 output->sib_present = false;
2243                 output->bytes = (addrbits != 16 ? 4 : 2);
2244                 output->modrm = (addrbits != 16 ? 5 : 6) | ((rfield & 7) << 3);
2245                 output->rip = bits == 64;
2246             }
2247         } else {                /* it's an indirection */
2248             int i = input->indexreg, b = input->basereg, s = input->scale;
2249             int32_t seg = input->segment;
2250             int hb = input->hintbase, ht = input->hinttype;
2251             int t, it, bt;              /* register numbers */
2252             opflags_t x, ix, bx;        /* register flags */
2253
2254             if (s == 0)
2255                 i = -1;         /* make this easy, at least */
2256
2257             if (is_register(i)) {
2258                 it = nasm_regvals[i];
2259                 ix = nasm_reg_flags[i];
2260             } else {
2261                 it = -1;
2262                 ix = 0;
2263             }
2264
2265             if (is_register(b)) {
2266                 bt = nasm_regvals[b];
2267                 bx = nasm_reg_flags[b];
2268             } else {
2269                 bt = -1;
2270                 bx = 0;
2271             }
2272
2273             /* if either one are a vector register... */
2274             if ((ix|bx) & (XMMREG|YMMREG) & ~REG_EA) {
2275                 int32_t sok = BITS32 | BITS64;
2276                 int32_t o = input->offset;
2277                 int mod, scale, index, base;
2278
2279                 printf("bt = %x, bx = %x, it = %x, ix = %x, s = %d\n",
2280                        bt, bx, it, ix, s);
2281
2282                 /*
2283                  * For a vector SIB, one has to be a vector and the other,
2284                  * if present, a GPR.  The vector must be the index operand.
2285                  */
2286                 if (it == -1 || (bx & (XMMREG|YMMREG) & ~REG_EA)) {
2287                     if (s == 0)
2288                         s = 1;
2289                     else if (s != 1)
2290                         goto err;
2291
2292                     t = bt, bt = it, it = t;
2293                     x = bx, bx = ix, ix = x;
2294                 }
2295
2296                 if (bt != -1) {
2297                     if (REG_GPR & ~bx)
2298                         goto err;
2299                     if (!(REG64 & ~bx) || !(REG32 & ~bx))
2300                         sok &= bx;
2301                     else
2302                         goto err;
2303                 }
2304
2305                 /*
2306                  * While we're here, ensure the user didn't specify
2307                  * WORD or QWORD
2308                  */
2309                 if (input->disp_size == 16 || input->disp_size == 64)
2310                     goto err;
2311
2312                 if (addrbits == 16 ||
2313                     (addrbits == 32 && !(sok & BITS32)) ||
2314                     (addrbits == 64 && !(sok & BITS64)))
2315                     goto err;
2316
2317                 output->type = (ix & YMMREG & ~REG_EA)
2318                     ? EA_YMMVSIB : EA_XMMVSIB;
2319
2320                 output->rex |= rexflags(it, ix, REX_X);
2321                 output->rex |= rexflags(bt, bx, REX_B);
2322
2323                 index = it & 7; /* it is known to be != -1 */
2324
2325                 switch (s) {
2326                 case 1:
2327                     scale = 0;
2328                     break;
2329                 case 2:
2330                     scale = 1;
2331                     break;
2332                 case 4:
2333                     scale = 2;
2334                     break;
2335                 case 8:
2336                     scale = 3;
2337                     break;
2338                 default:   /* then what the smeg is it? */
2339                     goto err;    /* panic */
2340                 }
2341
2342                 if (bt == -1) {
2343                     base = 5;
2344                     mod = 0;
2345                 } else {
2346                     base = (bt & 7);
2347                     if (base != REG_NUM_EBP && o == 0 &&
2348                         seg == NO_SEG && !forw_ref &&
2349                         !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2350                         mod = 0;
2351                     else if (input->eaflags & EAF_BYTEOFFS ||
2352                              (o >= -128 && o <= 127 &&
2353                               seg == NO_SEG && !forw_ref &&
2354                               !(input->eaflags & EAF_WORDOFFS)))
2355                         mod = 1;
2356                     else
2357                         mod = 2;
2358                 }
2359
2360                 output->sib_present = true;
2361                 output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
2362                 output->modrm = (mod << 6) | ((rfield & 7) << 3) | 4;
2363                 output->sib = (scale << 6) | (index << 3) | base;
2364             } else if ((ix|bx) & (BITS32|BITS64)) {
2365                 /*
2366                  * it must be a 32/64-bit memory reference. Firstly we have
2367                  * to check that all registers involved are type E/Rxx.
2368                  */
2369                 int32_t sok = BITS32 | BITS64;
2370                 int32_t o = input->offset;
2371
2372                 if (it != -1) {
2373                     if (!(REG64 & ~ix) || !(REG32 & ~ix))
2374                         sok &= ix;
2375                     else
2376                         goto err;
2377                 }
2378
2379                 if (bt != -1) {
2380                     if (REG_GPR & ~bx)
2381                         goto err; /* Invalid register */
2382                     if (~sok & bx & SIZE_MASK)
2383                         goto err; /* Invalid size */
2384                     sok &= bx;
2385                 }
2386
2387                 /*
2388                  * While we're here, ensure the user didn't specify
2389                  * WORD or QWORD
2390                  */
2391                 if (input->disp_size == 16 || input->disp_size == 64)
2392                     goto err;
2393
2394                 if (addrbits == 16 ||
2395                     (addrbits == 32 && !(sok & BITS32)) ||
2396                     (addrbits == 64 && !(sok & BITS64)))
2397                     goto err;
2398
2399                 /* now reorganize base/index */
2400                 if (s == 1 && bt != it && bt != -1 && it != -1 &&
2401                     ((hb == b && ht == EAH_NOTBASE) ||
2402                      (hb == i && ht == EAH_MAKEBASE))) {
2403                     /* swap if hints say so */
2404                     t = bt, bt = it, it = t;
2405                     x = bx, bx = ix, ix = x;
2406                 }
2407                 if (bt == it)     /* convert EAX+2*EAX to 3*EAX */
2408                     bt = -1, bx = 0, s++;
2409                 if (bt == -1 && s == 1 && !(hb == it && ht == EAH_NOTBASE)) {
2410                     /* make single reg base, unless hint */
2411                     bt = it, bx = ix, it = -1, ix = 0;
2412                 }
2413                 if (((s == 2 && it != REG_NUM_ESP && !(input->eaflags & EAF_TIMESTWO)) ||
2414                       s == 3 || s == 5 || s == 9) && bt == -1)
2415                     bt = it, bx = ix, s--; /* convert 3*EAX to EAX+2*EAX */
2416                 if (it == -1 && (bt & 7) != REG_NUM_ESP &&
2417                     (input->eaflags & EAF_TIMESTWO))
2418                     it = bt, ix = bx, bt = -1, bx = 0, s = 1;
2419                 /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */
2420                 if (s == 1 && it == REG_NUM_ESP) {
2421                     /* swap ESP into base if scale is 1 */
2422                     t = it, it = bt, bt = t;
2423                     x = ix, ix = bx, bx = x;
2424                 }
2425                 if (it == REG_NUM_ESP ||
2426                     (s != 1 && s != 2 && s != 4 && s != 8 && it != -1))
2427                     goto err;        /* wrong, for various reasons */
2428
2429                 output->rex |= rexflags(it, ix, REX_X);
2430                 output->rex |= rexflags(bt, bx, REX_B);
2431
2432                 if (it == -1 && (bt & 7) != REG_NUM_ESP) {
2433                     /* no SIB needed */
2434                     int mod, rm;
2435
2436                     if (bt == -1) {
2437                         rm = 5;
2438                         mod = 0;
2439                     } else {
2440                         rm = (bt & 7);
2441                         if (rm != REG_NUM_EBP && o == 0 &&
2442                             seg == NO_SEG && !forw_ref &&
2443                             !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2444                             mod = 0;
2445                         else if (input->eaflags & EAF_BYTEOFFS ||
2446                                  (o >= -128 && o <= 127 &&
2447                                   seg == NO_SEG && !forw_ref &&
2448                                   !(input->eaflags & EAF_WORDOFFS)))
2449                             mod = 1;
2450                         else
2451                             mod = 2;
2452                     }
2453
2454                     output->sib_present = false;
2455                     output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
2456                     output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
2457                 } else {
2458                     /* we need a SIB */
2459                     int mod, scale, index, base;
2460
2461                     if (it == -1)
2462                         index = 4, s = 1;
2463                     else
2464                         index = (it & 7);
2465
2466                     switch (s) {
2467                     case 1:
2468                         scale = 0;
2469                         break;
2470                     case 2:
2471                         scale = 1;
2472                         break;
2473                     case 4:
2474                         scale = 2;
2475                         break;
2476                     case 8:
2477                         scale = 3;
2478                         break;
2479                     default:   /* then what the smeg is it? */
2480                         goto err;    /* panic */
2481                     }
2482
2483                     if (bt == -1) {
2484                         base = 5;
2485                         mod = 0;
2486                     } else {
2487                         base = (bt & 7);
2488                         if (base != REG_NUM_EBP && o == 0 &&
2489                             seg == NO_SEG && !forw_ref &&
2490                             !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2491                             mod = 0;
2492                         else if (input->eaflags & EAF_BYTEOFFS ||
2493                                  (o >= -128 && o <= 127 &&
2494                                   seg == NO_SEG && !forw_ref &&
2495                                   !(input->eaflags & EAF_WORDOFFS)))
2496                             mod = 1;
2497                         else
2498                             mod = 2;
2499                     }
2500
2501                     output->sib_present = true;
2502                     output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
2503                     output->modrm = (mod << 6) | ((rfield & 7) << 3) | 4;
2504                     output->sib = (scale << 6) | (index << 3) | base;
2505                 }
2506             } else {            /* it's 16-bit */
2507                 int mod, rm;
2508                 int16_t o = input->offset;
2509
2510                 /* check for 64-bit long mode */
2511                 if (addrbits == 64)
2512                     goto err;
2513
2514                 /* check all registers are BX, BP, SI or DI */
2515                 if ((b != -1 && b != R_BP && b != R_BX && b != R_SI && b != R_DI) ||
2516                     (i != -1 && i != R_BP && i != R_BX && i != R_SI && i != R_DI))
2517                     goto err;
2518
2519                 /* ensure the user didn't specify DWORD/QWORD */
2520                 if (input->disp_size == 32 || input->disp_size == 64)
2521                     goto err;
2522
2523                 if (s != 1 && i != -1)
2524                     goto err;        /* no can do, in 16-bit EA */
2525                 if (b == -1 && i != -1) {
2526                     int tmp = b;
2527                     b = i;
2528                     i = tmp;
2529                 }               /* swap */
2530                 if ((b == R_SI || b == R_DI) && i != -1) {
2531                     int tmp = b;
2532                     b = i;
2533                     i = tmp;
2534                 }
2535                 /* have BX/BP as base, SI/DI index */
2536                 if (b == i)
2537                     goto err;        /* shouldn't ever happen, in theory */
2538                 if (i != -1 && b != -1 &&
2539                     (i == R_BP || i == R_BX || b == R_SI || b == R_DI))
2540                     goto err;        /* invalid combinations */
2541                 if (b == -1)            /* pure offset: handled above */
2542                     goto err;        /* so if it gets to here, panic! */
2543
2544                 rm = -1;
2545                 if (i != -1)
2546                     switch (i * 256 + b) {
2547                     case R_SI * 256 + R_BX:
2548                         rm = 0;
2549                         break;
2550                     case R_DI * 256 + R_BX:
2551                         rm = 1;
2552                         break;
2553                     case R_SI * 256 + R_BP:
2554                         rm = 2;
2555                         break;
2556                     case R_DI * 256 + R_BP:
2557                         rm = 3;
2558                         break;
2559                 } else
2560                     switch (b) {
2561                     case R_SI:
2562                         rm = 4;
2563                         break;
2564                     case R_DI:
2565                         rm = 5;
2566                         break;
2567                     case R_BP:
2568                         rm = 6;
2569                         break;
2570                     case R_BX:
2571                         rm = 7;
2572                         break;
2573                     }
2574                 if (rm == -1)           /* can't happen, in theory */
2575                     goto err;        /* so panic if it does */
2576
2577                 if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 &&
2578                     !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2579                     mod = 0;
2580                 else if (input->eaflags & EAF_BYTEOFFS ||
2581                          (o >= -128 && o <= 127 && seg == NO_SEG &&
2582                           !forw_ref && !(input->eaflags & EAF_WORDOFFS)))
2583                     mod = 1;
2584                 else
2585                     mod = 2;
2586
2587                 output->sib_present = false;    /* no SIB - it's 16-bit */
2588                 output->bytes = mod;            /* bytes of offset needed */
2589                 output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
2590             }
2591         }
2592     }
2593
2594     output->size = 1 + output->sib_present + output->bytes;
2595     return output->type;
2596
2597 err:
2598     return output->type = EA_INVALID;
2599 }
2600
2601 static void add_asp(insn *ins, int addrbits)
2602 {
2603     int j, valid;
2604     int defdisp;
2605
2606     valid = (addrbits == 64) ? 64|32 : 32|16;
2607
2608     switch (ins->prefixes[PPS_ASIZE]) {
2609     case P_A16:
2610         valid &= 16;
2611         break;
2612     case P_A32:
2613         valid &= 32;
2614         break;
2615     case P_A64:
2616         valid &= 64;
2617         break;
2618     case P_ASP:
2619         valid &= (addrbits == 32) ? 16 : 32;
2620         break;
2621     default:
2622         break;
2623     }
2624
2625     for (j = 0; j < ins->operands; j++) {
2626         if (is_class(MEMORY, ins->oprs[j].type)) {
2627             opflags_t i, b;
2628
2629             /* Verify as Register */
2630             if (!is_register(ins->oprs[j].indexreg))
2631                 i = 0;
2632             else
2633                 i = nasm_reg_flags[ins->oprs[j].indexreg];
2634
2635             /* Verify as Register */
2636             if (!is_register(ins->oprs[j].basereg))
2637                 b = 0;
2638             else
2639                 b = nasm_reg_flags[ins->oprs[j].basereg];
2640
2641             if (ins->oprs[j].scale == 0)
2642                 i = 0;
2643
2644             if (!i && !b) {
2645                 int ds = ins->oprs[j].disp_size;
2646                 if ((addrbits != 64 && ds > 8) ||
2647                     (addrbits == 64 && ds == 16))
2648                     valid &= ds;
2649             } else {
2650                 if (!(REG16 & ~b))
2651                     valid &= 16;
2652                 if (!(REG32 & ~b))
2653                     valid &= 32;
2654                 if (!(REG64 & ~b))
2655                     valid &= 64;
2656
2657                 if (!(REG16 & ~i))
2658                     valid &= 16;
2659                 if (!(REG32 & ~i))
2660                     valid &= 32;
2661                 if (!(REG64 & ~i))
2662                     valid &= 64;
2663             }
2664         }
2665     }
2666
2667     if (valid & addrbits) {
2668         ins->addr_size = addrbits;
2669     } else if (valid & ((addrbits == 32) ? 16 : 32)) {
2670         /* Add an address size prefix */
2671         enum prefixes pref = (addrbits == 32) ? P_A16 : P_A32;
2672         ins->prefixes[PPS_ASIZE] = pref;
2673         ins->addr_size = (addrbits == 32) ? 16 : 32;
2674     } else {
2675         /* Impossible... */
2676         errfunc(ERR_NONFATAL, "impossible combination of address sizes");
2677         ins->addr_size = addrbits; /* Error recovery */
2678     }
2679
2680     defdisp = ins->addr_size == 16 ? 16 : 32;
2681
2682     for (j = 0; j < ins->operands; j++) {
2683         if (!(MEM_OFFS & ~ins->oprs[j].type) &&
2684             (ins->oprs[j].disp_size ? ins->oprs[j].disp_size : defdisp) != ins->addr_size) {
2685             /*
2686              * mem_offs sizes must match the address size; if not,
2687              * strip the MEM_OFFS bit and match only EA instructions
2688              */
2689             ins->oprs[j].type &= ~(MEM_OFFS & ~MEMORY);
2690         }
2691     }
2692 }