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