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