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