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