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