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