?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
preproc.c: placate errors in OpenWatcom Compiler
[nasm.git] / assemble.c
blobbb2911aedb1b78953db6b63924c8204fb155c134
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 {
1640 enum prefixes pfx = ins->prefixes[PPS_OSIZE];
1641 if (pfx != P_O16 && pfx != P_none)
1642 nasm_error(ERR_WARNING, "Invalid operand size prefix");
1643 if (pfx != P_O16 && bits != 16) {
1644 ins->prefixes[PPS_OSIZE] = P_O16;
1645 *bytes = 0x66;
1646 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1647 offset += 1;
1648 }
1649 break;
1650 }
1651
1652 case 0321:
1653 {
1654 enum prefixes pfx = ins->prefixes[PPS_OSIZE];
1655 if (pfx != P_O32 && pfx != P_none)
1656 nasm_error(ERR_WARNING, "Invalid operand size prefix");
1657 if (pfx != P_O32 && bits == 16) {
1658 ins->prefixes[PPS_OSIZE] = P_O32;
1659 *bytes = 0x66;
1660 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1661 offset += 1;
1662 }
1663 break;
1664 }
1665
1666 case 0322:
1667 case 0323:
1668 break;
1669
1670 case 0324:
1671 ins->rex |= REX_W;
1672 break;
1673
1674 case 0325:
1675 break;
1676
1677 case 0330:
1678 *bytes = *codes++ ^ condval[ins->condition];
1679 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1680 offset += 1;
1681 break;
1682
1683 case 0331:
1684 break;
1685
1686 case 0332:
1687 case 0333:
1688 *bytes = c - 0332 + 0xF2;
1689 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1690 offset += 1;
1691 break;
1692
1693 case 0334:
1694 if (ins->rex & REX_R) {
1695 *bytes = 0xF0;
1696 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1697 offset += 1;
1698 }
1699 ins->rex &= ~(REX_L|REX_R);
1700 break;
1701
1702 case 0335:
1703 break;
1704
1705 case 0336:
1706 case 0337:
1707 break;
1708
1709 case 0340:
1710 if (ins->oprs[0].segment != NO_SEG)
1711 errfunc(ERR_PANIC, "non-constant BSS size in pass two");
1712 else {
1713 int64_t size = ins->oprs[0].offset;
1714 if (size > 0)
1715 out(offset, segment, NULL,
1716 OUT_RESERVE, size, NO_SEG, NO_SEG);
1717 offset += size;
1718 }
1719 break;
1720
1721 case 0341:
1722 break;
1723
1724 case 0344:
1725 case 0345:
1726 bytes[0] = c & 1;
1727 switch (ins->oprs[0].basereg) {
1728 case R_CS:
1729 bytes[0] += 0x0E;
1730 break;
1731 case R_DS:
1732 bytes[0] += 0x1E;
1733 break;
1734 case R_ES:
1735 bytes[0] += 0x06;
1736 break;
1737 case R_SS:
1738 bytes[0] += 0x16;
1739 break;
1740 default:
1741 errfunc(ERR_PANIC,
1742 "bizarre 8086 segment register received");
1743 }
1744 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1745 offset++;
1746 break;
1747
1748 case 0346:
1749 case 0347:
1750 bytes[0] = c & 1;
1751 switch (ins->oprs[0].basereg) {
1752 case R_FS:
1753 bytes[0] += 0xA0;
1754 break;
1755 case R_GS:
1756 bytes[0] += 0xA8;
1757 break;
1758 default:
1759 errfunc(ERR_PANIC,
1760 "bizarre 386 segment register received");
1761 }
1762 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1763 offset++;
1764 break;
1765
1766 case 0360:
1767 break;
1768
1769 case 0361:
1770 bytes[0] = 0x66;
1771 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1772 offset += 1;
1773 break;
1774
1775 case 0362:
1776 case 0363:
1777 bytes[0] = c - 0362 + 0xf2;
1778 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1779 offset += 1;
1780 break;
1781
1782 case 0364:
1783 case 0365:
1784 break;
1785
1786 case 0366:
1787 case 0367:
1788 *bytes = c - 0366 + 0x66;
1789 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1790 offset += 1;
1791 break;
1792
1793 case 0370:
1794 case 0371:
1795 case 0372:
1796 break;
1797
1798 case 0373:
1799 *bytes = bits == 16 ? 3 : 5;
1800 out(offset, segment, bytes, OUT_RAWDATA, 1, NO_SEG, NO_SEG);
1801 offset += 1;
1802 break;
1803
1804 case4(0100):
1805 case4(0110):
1806 case4(0120):
1807 case4(0130):
1808 case4(0200):
1809 case4(0204):
1810 case4(0210):
1811 case4(0214):
1812 case4(0220):
1813 case4(0224):
1814 case4(0230):
1815 case4(0234):
1816 {
1817 ea ea_data;
1818 int rfield;
1819 opflags_t rflags;
1820 uint8_t *p;
1821 int32_t s;
1822 enum out_type type;
1823 struct operand *opy = &ins->oprs[op2];
1824
1825 if (c <= 0177) {
1826 /* pick rfield from operand b (opx) */
1827 rflags = regflag(opx);
1828 rfield = nasm_regvals[opx->basereg];
1829 } else {
1830 /* rfield is constant */
1831 rflags = 0;
1832 rfield = c & 7;
1833 }
1834
1835 if (!process_ea(opy, &ea_data, bits, ins->addr_size,
1836 rfield, rflags)) {
1837 errfunc(ERR_NONFATAL, "invalid effective address");
1838 }
1839
1840
1841 p = bytes;
1842 *p++ = ea_data.modrm;
1843 if (ea_data.sib_present)
1844 *p++ = ea_data.sib;
1845
1846 /* DREX suffixes come between the SIB and the displacement */
1847 if (ins->rex & REX_D) {
1848 *p++ = (ins->drexdst << 4) |
1849 (ins->rex & REX_OC ? 0x08 : 0) |
1850 (ins->rex & (REX_R|REX_X|REX_B));
1851 ins->rex = 0;
1852 }
1853
1854 s = p - bytes;
1855 out(offset, segment, bytes, OUT_RAWDATA, s, NO_SEG, NO_SEG);
1856
1857 /*
1858 * Make sure the address gets the right offset in case
1859 * the line breaks in the .lst file (BR 1197827)
1860 */
1861 offset += s;
1862 s = 0;
1863
1864 switch (ea_data.bytes) {
1865 case 0:
1866 break;
1867 case 1:
1868 case 2:
1869 case 4:
1870 case 8:
1871 data = opy->offset;
1872 s += ea_data.bytes;
1873 if (ea_data.rip) {
1874 if (opy->segment == segment) {
1875 data -= insn_end;
1876 if (overflow_signed(data, ea_data.bytes))
1877 warn_overflow(ERR_PASS2, ea_data.bytes);
1878 out(offset, segment, &data, OUT_ADDRESS,
1879 ea_data.bytes, NO_SEG, NO_SEG);
1880 } else {
1881 /* overflow check in output/linker? */
1882 out(offset, segment, &data, OUT_REL4ADR,
1883 insn_end - offset, opy->segment, opy->wrt);
1884 }
1885 } else {
1886 if (overflow_general(opy->offset, ins->addr_size >> 3) ||
1887 signed_bits(opy->offset, ins->addr_size) !=
1888 signed_bits(opy->offset, ea_data.bytes * 8))
1889 warn_overflow(ERR_PASS2, ea_data.bytes);
1890
1891 type = OUT_ADDRESS;
1892 out(offset, segment, &data, OUT_ADDRESS,
1893 ea_data.bytes, opy->segment, opy->wrt);
1894 }
1895 break;
1896 default:
1897 /* Impossible! */
1898 errfunc(ERR_PANIC,
1899 "Invalid amount of bytes (%d) for offset?!",
1900 ea_data.bytes);
1901 break;
1902 }
1903 offset += s;
1904 }
1905 break;
1906
1907 default:
1908 errfunc(ERR_PANIC, "internal instruction table corrupt"
1909 ": instruction code \\%o (0x%02X) given", c, c);
1910 break;
1911 }
1912 }
1913 }
1914
1915 static opflags_t regflag(const operand * o)
1916 {
1917 if (!is_register(o->basereg))
1918 errfunc(ERR_PANIC, "invalid operand passed to regflag()");
1919 return nasm_reg_flags[o->basereg];
1920 }
1921
1922 static int32_t regval(const operand * o)
1923 {
1924 if (!is_register(o->basereg))
1925 errfunc(ERR_PANIC, "invalid operand passed to regval()");
1926 return nasm_regvals[o->basereg];
1927 }
1928
1929 static int op_rexflags(const operand * o, int mask)
1930 {
1931 opflags_t flags;
1932 int val;
1933
1934 if (!is_register(o->basereg))
1935 errfunc(ERR_PANIC, "invalid operand passed to op_rexflags()");
1936
1937 flags = nasm_reg_flags[o->basereg];
1938 val = nasm_regvals[o->basereg];
1939
1940 return rexflags(val, flags, mask);
1941 }
1942
1943 static int rexflags(int val, opflags_t flags, int mask)
1944 {
1945 int rex = 0;
1946
1947 if (val >= 8)
1948 rex |= REX_B|REX_X|REX_R;
1949 if (flags & BITS64)
1950 rex |= REX_W;
1951 if (!(REG_HIGH & ~flags)) /* AH, CH, DH, BH */
1952 rex |= REX_H;
1953 else if (!(REG8 & ~flags) && val >= 4) /* SPL, BPL, SIL, DIL */
1954 rex |= REX_P;
1955
1956 return rex & mask;
1957 }
1958
1959 static enum match_result find_match(const struct itemplate **tempp,
1960 insn *instruction,
1961 int32_t segment, int64_t offset, int bits)
1962 {
1963 const struct itemplate *temp;
1964 enum match_result m, merr;
1965 opflags_t xsizeflags[MAX_OPERANDS];
1966 bool opsizemissing = false;
1967 int i;
1968
1969 for (i = 0; i < instruction->operands; i++)
1970 xsizeflags[i] = instruction->oprs[i].type & SIZE_MASK;
1971
1972 merr = MERR_INVALOP;
1973
1974 for (temp = nasm_instructions[instruction->opcode];
1975 temp->opcode != I_none; temp++) {
1976 m = matches(temp, instruction, bits);
1977 if (m == MOK_JUMP) {
1978 if (jmp_match(segment, offset, bits, instruction, temp->code))
1979 m = MOK_GOOD;
1980 else
1981 m = MERR_INVALOP;
1982 } else if (m == MERR_OPSIZEMISSING &&
1983 (temp->flags & IF_SMASK) != IF_SX) {
1984 /*
1985 * Missing operand size and a candidate for fuzzy matching...
1986 */
1987 for (i = 0; i < temp->operands; i++) {
1988 if ((temp->opd[i] & SAME_AS) == 0)
1989 xsizeflags[i] |= temp->opd[i] & SIZE_MASK;
1990 }
1991 opsizemissing = true;
1992 }
1993 if (m > merr)
1994 merr = m;
1995 if (merr == MOK_GOOD)
1996 goto done;
1997 }
1998
1999 /* No match, but see if we can get a fuzzy operand size match... */
2000 if (!opsizemissing)
2001 goto done;
2002
2003 for (i = 0; i < instruction->operands; i++) {
2004 /*
2005 * We ignore extrinsic operand sizes on registers, so we should
2006 * never try to fuzzy-match on them. This also resolves the case
2007 * when we have e.g. "xmmrm128" in two different positions.
2008 */
2009 if (is_class(REGISTER, instruction->oprs[i].type))
2010 continue;
2011
2012 /* This tests if xsizeflags[i] has more than one bit set */
2013 if ((xsizeflags[i] & (xsizeflags[i]-1)))
2014 goto done; /* No luck */
2015
2016 instruction->oprs[i].type |= xsizeflags[i]; /* Set the size */
2017 }
2018
2019 /* Try matching again... */
2020 for (temp = nasm_instructions[instruction->opcode];
2021 temp->opcode != I_none; temp++) {
2022 m = matches(temp, instruction, bits);
2023 if (m == MOK_JUMP) {
2024 if (jmp_match(segment, offset, bits, instruction, temp->code))
2025 m = MOK_GOOD;
2026 else
2027 m = MERR_INVALOP;
2028 }
2029 if (m > merr)
2030 merr = m;
2031 if (merr == MOK_GOOD)
2032 goto done;
2033 }
2034
2035 done:
2036 *tempp = temp;
2037 return merr;
2038 }
2039
2040 static enum match_result matches(const struct itemplate *itemp,
2041 insn *instruction, int bits)
2042 {
2043 int i, size[MAX_OPERANDS], asize, oprs;
2044 bool opsizemissing = false;
2045
2046 /*
2047 * Check the opcode
2048 */
2049 if (itemp->opcode != instruction->opcode)
2050 return MERR_INVALOP;
2051
2052 /*
2053 * Count the operands
2054 */
2055 if (itemp->operands != instruction->operands)
2056 return MERR_INVALOP;
2057
2058 /*
2059 * Is it legal?
2060 */
2061 if (!(optimizing > 0) && (itemp->flags & IF_OPT))
2062 return MERR_INVALOP;
2063
2064 /*
2065 * Check that no spurious colons or TOs are present
2066 */
2067 for (i = 0; i < itemp->operands; i++)
2068 if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO))
2069 return MERR_INVALOP;
2070
2071 /*
2072 * Process size flags
2073 */
2074 switch (itemp->flags & IF_SMASK) {
2075 case IF_SB:
2076 asize = BITS8;
2077 break;
2078 case IF_SW:
2079 asize = BITS16;
2080 break;
2081 case IF_SD:
2082 asize = BITS32;
2083 break;
2084 case IF_SQ:
2085 asize = BITS64;
2086 break;
2087 case IF_SO:
2088 asize = BITS128;
2089 break;
2090 case IF_SY:
2091 asize = BITS256;
2092 break;
2093 case IF_SZ:
2094 switch (bits) {
2095 case 16:
2096 asize = BITS16;
2097 break;
2098 case 32:
2099 asize = BITS32;
2100 break;
2101 case 64:
2102 asize = BITS64;
2103 break;
2104 default:
2105 asize = 0;
2106 break;
2107 }
2108 break;
2109 default:
2110 asize = 0;
2111 break;
2112 }
2113
2114 if (itemp->flags & IF_ARMASK) {
2115 /* S- flags only apply to a specific operand */
2116 i = ((itemp->flags & IF_ARMASK) >> IF_ARSHFT) - 1;
2117 memset(size, 0, sizeof size);
2118 size[i] = asize;
2119 } else {
2120 /* S- flags apply to all operands */
2121 for (i = 0; i < MAX_OPERANDS; i++)
2122 size[i] = asize;
2123 }
2124
2125 /*
2126 * Check that the operand flags all match up,
2127 * it's a bit tricky so lets be verbose:
2128 *
2129 * 1) Find out the size of operand. If instruction
2130 * doesn't have one specified -- we're trying to
2131 * guess it either from template (IF_S* flag) or
2132 * from code bits.
2133 *
2134 * 2) If template operand (i) has SAME_AS flag [used for registers only]
2135 * (ie the same operand as was specified somewhere in template, and
2136 * this referred operand index is being achieved via ~SAME_AS)
2137 * we are to be sure that both registers (in template and instruction)
2138 * do exactly match.
2139 *
2140 * 3) If template operand do not match the instruction OR
2141 * template has an operand size specified AND this size differ
2142 * from which instruction has (perhaps we got it from code bits)
2143 * we are:
2144 * a) Check that only size of instruction and operand is differ
2145 * other characteristics do match
2146 * b) Perhaps it's a register specified in instruction so
2147 * for such a case we just mark that operand as "size
2148 * missing" and this will turn on fuzzy operand size
2149 * logic facility (handled by a caller)
2150 */
2151 for (i = 0; i < itemp->operands; i++) {
2152 opflags_t type = instruction->oprs[i].type;
2153 if (!(type & SIZE_MASK))
2154 type |= size[i];
2155
2156 if (itemp->opd[i] & SAME_AS) {
2157 int j = itemp->opd[i] & ~SAME_AS;
2158 if (type != instruction->oprs[j].type ||
2159 instruction->oprs[i].basereg != instruction->oprs[j].basereg)
2160 return MERR_INVALOP;
2161 } else if (itemp->opd[i] & ~type ||
2162 ((itemp->opd[i] & SIZE_MASK) &&
2163 ((itemp->opd[i] ^ type) & SIZE_MASK))) {
2164 if ((itemp->opd[i] & ~type & ~SIZE_MASK) || (type & SIZE_MASK)) {
2165 return MERR_INVALOP;
2166 } else if (!is_class(REGISTER, type)) {
2167 /*
2168 * Note: we don't honor extrinsic operand sizes for registers,
2169 * so "missing operand size" for a register should be
2170 * considered a wildcard match rather than an error.
2171 */
2172 opsizemissing = true;
2173 }
2174 }
2175 }
2176
2177 if (opsizemissing)
2178 return MERR_OPSIZEMISSING;
2179
2180 /*
2181 * Check operand sizes
2182 */
2183 if (itemp->flags & (IF_SM | IF_SM2)) {
2184 oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands);
2185 for (i = 0; i < oprs; i++) {
2186 asize = itemp->opd[i] & SIZE_MASK;
2187 if (asize) {
2188 for (i = 0; i < oprs; i++)
2189 size[i] = asize;
2190 break;
2191 }
2192 }
2193 } else {
2194 oprs = itemp->operands;
2195 }
2196
2197 for (i = 0; i < itemp->operands; i++) {
2198 if (!(itemp->opd[i] & SIZE_MASK) &&
2199 (instruction->oprs[i].type & SIZE_MASK & ~size[i]))
2200 return MERR_OPSIZEMISMATCH;
2201 }
2202
2203 /*
2204 * Check template is okay at the set cpu level
2205 */
2206 if (((itemp->flags & IF_PLEVEL) > cpu))
2207 return MERR_BADCPU;
2208
2209 /*
2210 * Verify the appropriate long mode flag.
2211 */
2212 if ((itemp->flags & (bits == 64 ? IF_NOLONG : IF_LONG)))
2213 return MERR_BADMODE;
2214
2215 /*
2216 * Check if special handling needed for Jumps
2217 */
2218 if ((itemp->code[0] & 0374) == 0370)
2219 return MOK_JUMP;
2220
2221 return MOK_GOOD;
2222 }
2223
2224 static ea *process_ea(operand * input, ea * output, int bits,
2225 int addrbits, int rfield, opflags_t rflags)
2226 {
2227 bool forw_ref = !!(input->opflags & OPFLAG_UNKNOWN);
2228
2229 output->rip = false;
2230
2231 /* REX flags for the rfield operand */
2232 output->rex |= rexflags(rfield, rflags, REX_R | REX_P | REX_W | REX_H);
2233
2234 if (is_class(REGISTER, input->type)) { /* register direct */
2235 int i;
2236 opflags_t f;
2237
2238 if (!is_register(input->basereg))
2239 return NULL;
2240 f = regflag(input);
2241 i = nasm_regvals[input->basereg];
2242
2243 if (REG_EA & ~f)
2244 return NULL; /* Invalid EA register */
2245
2246 output->rex |= op_rexflags(input, REX_B | REX_P | REX_W | REX_H);
2247
2248 output->sib_present = false; /* no SIB necessary */
2249 output->bytes = 0; /* no offset necessary either */
2250 output->modrm = 0xC0 | ((rfield & 7) << 3) | (i & 7);
2251 } else { /* it's a memory reference */
2252 if (input->basereg == -1 &&
2253 (input->indexreg == -1 || input->scale == 0)) {
2254 /* it's a pure offset */
2255
2256 if (bits == 64 && ((input->type & IP_REL) == IP_REL) &&
2257 input->segment == NO_SEG) {
2258 nasm_error(ERR_WARNING | ERR_PASS1, "absolute address can not be RIP-relative");
2259 input->type &= ~IP_REL;
2260 input->type |= MEMORY;
2261 }
2262
2263 if (input->eaflags & EAF_BYTEOFFS ||
2264 (input->eaflags & EAF_WORDOFFS &&
2265 input->disp_size != (addrbits != 16 ? 32 : 16))) {
2266 nasm_error(ERR_WARNING | ERR_PASS1, "displacement size ignored on absolute address");
2267 }
2268
2269 if (bits == 64 && (~input->type & IP_REL)) {
2270 int scale, index, base;
2271 output->sib_present = true;
2272 scale = 0;
2273 index = 4;
2274 base = 5;
2275 output->sib = (scale << 6) | (index << 3) | base;
2276 output->bytes = 4;
2277 output->modrm = 4 | ((rfield & 7) << 3);
2278 output->rip = false;
2279 } else {
2280 output->sib_present = false;
2281 output->bytes = (addrbits != 16 ? 4 : 2);
2282 output->modrm = (addrbits != 16 ? 5 : 6) | ((rfield & 7) << 3);
2283 output->rip = bits == 64;
2284 }
2285 } else { /* it's an indirection */
2286 int i = input->indexreg, b = input->basereg, s = input->scale;
2287 int32_t seg = input->segment;
2288 int hb = input->hintbase, ht = input->hinttype;
2289 int t, it, bt; /* register numbers */
2290 opflags_t x, ix, bx; /* register flags */
2291
2292 if (s == 0)
2293 i = -1; /* make this easy, at least */
2294
2295 if (is_register(i)) {
2296 it = nasm_regvals[i];
2297 ix = nasm_reg_flags[i];
2298 } else {
2299 it = -1;
2300 ix = 0;
2301 }
2302
2303 if (is_register(b)) {
2304 bt = nasm_regvals[b];
2305 bx = nasm_reg_flags[b];
2306 } else {
2307 bt = -1;
2308 bx = 0;
2309 }
2310
2311 /* check for a 32/64-bit memory reference... */
2312 if ((ix|bx) & (BITS32|BITS64)) {
2313 /*
2314 * it must be a 32/64-bit memory reference. Firstly we have
2315 * to check that all registers involved are type E/Rxx.
2316 */
2317 int32_t sok = BITS32 | BITS64, o = input->offset;
2318
2319 if (it != -1) {
2320 if (!(REG64 & ~ix) || !(REG32 & ~ix))
2321 sok &= ix;
2322 else
2323 return NULL;
2324 }
2325
2326 if (bt != -1) {
2327 if (REG_GPR & ~bx)
2328 return NULL; /* Invalid register */
2329 if (~sok & bx & SIZE_MASK)
2330 return NULL; /* Invalid size */
2331 sok &= bx;
2332 }
2333
2334 /*
2335 * While we're here, ensure the user didn't specify
2336 * WORD or QWORD
2337 */
2338 if (input->disp_size == 16 || input->disp_size == 64)
2339 return NULL;
2340
2341 if (addrbits == 16 ||
2342 (addrbits == 32 && !(sok & BITS32)) ||
2343 (addrbits == 64 && !(sok & BITS64)))
2344 return NULL;
2345
2346 /* now reorganize base/index */
2347 if (s == 1 && bt != it && bt != -1 && it != -1 &&
2348 ((hb == b && ht == EAH_NOTBASE) ||
2349 (hb == i && ht == EAH_MAKEBASE))) {
2350 /* swap if hints say so */
2351 t = bt, bt = it, it = t;
2352 x = bx, bx = ix, ix = x;
2353 }
2354 if (bt == it) /* convert EAX+2*EAX to 3*EAX */
2355 bt = -1, bx = 0, s++;
2356 if (bt == -1 && s == 1 && !(hb == it && ht == EAH_NOTBASE)) {
2357 /* make single reg base, unless hint */
2358 bt = it, bx = ix, it = -1, ix = 0;
2359 }
2360 if (((s == 2 && it != REG_NUM_ESP && !(input->eaflags & EAF_TIMESTWO)) ||
2361 s == 3 || s == 5 || s == 9) && bt == -1)
2362 bt = it, bx = ix, s--; /* convert 3*EAX to EAX+2*EAX */
2363 if (it == -1 && (bt & 7) != REG_NUM_ESP &&
2364 (input->eaflags & EAF_TIMESTWO))
2365 it = bt, ix = bx, bt = -1, bx = 0, s = 1;
2366 /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */
2367 if (s == 1 && it == REG_NUM_ESP) {
2368 /* swap ESP into base if scale is 1 */
2369 t = it, it = bt, bt = t;
2370 x = ix, ix = bx, bx = x;
2371 }
2372 if (it == REG_NUM_ESP ||
2373 (s != 1 && s != 2 && s != 4 && s != 8 && it != -1))
2374 return NULL; /* wrong, for various reasons */
2375
2376 output->rex |= rexflags(it, ix, REX_X);
2377 output->rex |= rexflags(bt, bx, REX_B);
2378
2379 if (it == -1 && (bt & 7) != REG_NUM_ESP) {
2380 /* no SIB needed */
2381 int mod, rm;
2382
2383 if (bt == -1) {
2384 rm = 5;
2385 mod = 0;
2386 } else {
2387 rm = (bt & 7);
2388 if (rm != REG_NUM_EBP && o == 0 &&
2389 seg == NO_SEG && !forw_ref &&
2390 !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2391 mod = 0;
2392 else if (input->eaflags & EAF_BYTEOFFS ||
2393 (o >= -128 && o <= 127 &&
2394 seg == NO_SEG && !forw_ref &&
2395 !(input->eaflags & EAF_WORDOFFS)))
2396 mod = 1;
2397 else
2398 mod = 2;
2399 }
2400
2401 output->sib_present = false;
2402 output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
2403 output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
2404 } else {
2405 /* we need a SIB */
2406 int mod, scale, index, base;
2407
2408 if (it == -1)
2409 index = 4, s = 1;
2410 else
2411 index = (it & 7);
2412
2413 switch (s) {
2414 case 1:
2415 scale = 0;
2416 break;
2417 case 2:
2418 scale = 1;
2419 break;
2420 case 4:
2421 scale = 2;
2422 break;
2423 case 8:
2424 scale = 3;
2425 break;
2426 default: /* then what the smeg is it? */
2427 return NULL; /* panic */
2428 }
2429
2430 if (bt == -1) {
2431 base = 5;
2432 mod = 0;
2433 } else {
2434 base = (bt & 7);
2435 if (base != REG_NUM_EBP && o == 0 &&
2436 seg == NO_SEG && !forw_ref &&
2437 !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2438 mod = 0;
2439 else if (input->eaflags & EAF_BYTEOFFS ||
2440 (o >= -128 && o <= 127 &&
2441 seg == NO_SEG && !forw_ref &&
2442 !(input->eaflags & EAF_WORDOFFS)))
2443 mod = 1;
2444 else
2445 mod = 2;
2446 }
2447
2448 output->sib_present = true;
2449 output->bytes = (bt == -1 || mod == 2 ? 4 : mod);
2450 output->modrm = (mod << 6) | ((rfield & 7) << 3) | 4;
2451 output->sib = (scale << 6) | (index << 3) | base;
2452 }
2453 } else { /* it's 16-bit */
2454 int mod, rm;
2455 int16_t o = input->offset;
2456
2457 /* check for 64-bit long mode */
2458 if (addrbits == 64)
2459 return NULL;
2460
2461 /* check all registers are BX, BP, SI or DI */
2462 if ((b != -1 && b != R_BP && b != R_BX && b != R_SI && b != R_DI) ||
2463 (i != -1 && i != R_BP && i != R_BX && i != R_SI && i != R_DI))
2464 return NULL;
2465
2466 /* ensure the user didn't specify DWORD/QWORD */
2467 if (input->disp_size == 32 || input->disp_size == 64)
2468 return NULL;
2469
2470 if (s != 1 && i != -1)
2471 return NULL; /* no can do, in 16-bit EA */
2472 if (b == -1 && i != -1) {
2473 int tmp = b;
2474 b = i;
2475 i = tmp;
2476 } /* swap */
2477 if ((b == R_SI || b == R_DI) && i != -1) {
2478 int tmp = b;
2479 b = i;
2480 i = tmp;
2481 }
2482 /* have BX/BP as base, SI/DI index */
2483 if (b == i)
2484 return NULL; /* shouldn't ever happen, in theory */
2485 if (i != -1 && b != -1 &&
2486 (i == R_BP || i == R_BX || b == R_SI || b == R_DI))
2487 return NULL; /* invalid combinations */
2488 if (b == -1) /* pure offset: handled above */
2489 return NULL; /* so if it gets to here, panic! */
2490
2491 rm = -1;
2492 if (i != -1)
2493 switch (i * 256 + b) {
2494 case R_SI * 256 + R_BX:
2495 rm = 0;
2496 break;
2497 case R_DI * 256 + R_BX:
2498 rm = 1;
2499 break;
2500 case R_SI * 256 + R_BP:
2501 rm = 2;
2502 break;
2503 case R_DI * 256 + R_BP:
2504 rm = 3;
2505 break;
2506 } else
2507 switch (b) {
2508 case R_SI:
2509 rm = 4;
2510 break;
2511 case R_DI:
2512 rm = 5;
2513 break;
2514 case R_BP:
2515 rm = 6;
2516 break;
2517 case R_BX:
2518 rm = 7;
2519 break;
2520 }
2521 if (rm == -1) /* can't happen, in theory */
2522 return NULL; /* so panic if it does */
2523
2524 if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 &&
2525 !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS)))
2526 mod = 0;
2527 else if (input->eaflags & EAF_BYTEOFFS ||
2528 (o >= -128 && o <= 127 && seg == NO_SEG &&
2529 !forw_ref && !(input->eaflags & EAF_WORDOFFS)))
2530 mod = 1;
2531 else
2532 mod = 2;
2533
2534 output->sib_present = false; /* no SIB - it's 16-bit */
2535 output->bytes = mod; /* bytes of offset needed */
2536 output->modrm = (mod << 6) | ((rfield & 7) << 3) | rm;
2537 }
2538 }
2539 }
2540
2541 output->size = 1 + output->sib_present + output->bytes;
2542 return output;
2543 }
2544
2545 static void add_asp(insn *ins, int addrbits)
2546 {
2547 int j, valid;
2548 int defdisp;
2549
2550 valid = (addrbits == 64) ? 64|32 : 32|16;
2551
2552 switch (ins->prefixes[PPS_ASIZE]) {
2553 case P_A16:
2554 valid &= 16;
2555 break;
2556 case P_A32:
2557 valid &= 32;
2558 break;
2559 case P_A64:
2560 valid &= 64;
2561 break;
2562 case P_ASP:
2563 valid &= (addrbits == 32) ? 16 : 32;
2564 break;
2565 default:
2566 break;
2567 }
2568
2569 for (j = 0; j < ins->operands; j++) {
2570 if (is_class(MEMORY, ins->oprs[j].type)) {
2571 opflags_t i, b;
2572
2573 /* Verify as Register */
2574 if (!is_register(ins->oprs[j].indexreg))
2575 i = 0;
2576 else
2577 i = nasm_reg_flags[ins->oprs[j].indexreg];
2578
2579 /* Verify as Register */
2580 if (!is_register(ins->oprs[j].basereg))
2581 b = 0;
2582 else
2583 b = nasm_reg_flags[ins->oprs[j].basereg];
2584
2585 if (ins->oprs[j].scale == 0)
2586 i = 0;
2587
2588 if (!i && !b) {
2589 int ds = ins->oprs[j].disp_size;
2590 if ((addrbits != 64 && ds > 8) ||
2591 (addrbits == 64 && ds == 16))
2592 valid &= ds;
2593 } else {
2594 if (!(REG16 & ~b))
2595 valid &= 16;
2596 if (!(REG32 & ~b))
2597 valid &= 32;
2598 if (!(REG64 & ~b))
2599 valid &= 64;
2600
2601 if (!(REG16 & ~i))
2602 valid &= 16;
2603 if (!(REG32 & ~i))
2604 valid &= 32;
2605 if (!(REG64 & ~i))
2606 valid &= 64;
2607 }
2608 }
2609 }
2610
2611 if (valid & addrbits) {
2612 ins->addr_size = addrbits;
2613 } else if (valid & ((addrbits == 32) ? 16 : 32)) {
2614 /* Add an address size prefix */
2615 enum prefixes pref = (addrbits == 32) ? P_A16 : P_A32;
2616 ins->prefixes[PPS_ASIZE] = pref;
2617 ins->addr_size = (addrbits == 32) ? 16 : 32;
2618 } else {
2619 /* Impossible... */
2620 errfunc(ERR_NONFATAL, "impossible combination of address sizes");
2621 ins->addr_size = addrbits; /* Error recovery */
2622 }
2623
2624 defdisp = ins->addr_size == 16 ? 16 : 32;
2625
2626 for (j = 0; j < ins->operands; j++) {
2627 if (!(MEM_OFFS & ~ins->oprs[j].type) &&
2628 (ins->oprs[j].disp_size ? ins->oprs[j].disp_size : defdisp) != ins->addr_size) {
2629 /*
2630 * mem_offs sizes must match the address size; if not,
2631 * strip the MEM_OFFS bit and match only EA instructions
2632 */
2633 ins->oprs[j].type &= ~(MEM_OFFS & ~MEMORY);
2634 }
2635 }
2636 }
The Netwide Assembler