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