1 /* assemble.c code generation for the Netwide Assembler
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.
8 * the actual codes (C syntax, i.e. octal):
9 * \0 - terminates the code. (Unless it's a literal of course.)
10 * \1..\4 - that many literal bytes follow in the code stream
11 * \5 - add 4 to the primary operand number (b, low octdigit)
12 * \6 - add 4 to the secondary operand number (a, middle octdigit)
13 * \7 - add 4 to both the primary and the secondary operand number
14 * \10..\13 - a literal byte follows in the code stream, to be added
15 * to the register value of operand 0..3
16 * \14..\17 - a signed byte immediate operand, from operand 0..3
17 * \20..\23 - a byte immediate operand, from operand 0..3
18 * \24..\27 - an unsigned byte immediate operand, from operand 0..3
19 * \30..\33 - a word immediate operand, from operand 0..3
20 * \34..\37 - select between \3[0-3] and \4[0-3] depending on 16/32 bit
21 * assembly mode or the operand-size override on the operand
22 * \40..\43 - a long immediate operand, from operand 0..3
23 * \44..\47 - select between \3[0-3], \4[0-3] and \5[4-7]
24 * depending on the address size of the instruction.
25 * \50..\53 - a byte relative operand, from operand 0..3
26 * \54..\57 - a qword immediate operand, from operand 0..3
27 * \60..\63 - a word relative operand, from operand 0..3
28 * \64..\67 - select between \6[0-3] and \7[0-3] depending on 16/32 bit
29 * assembly mode or the operand-size override on the operand
30 * \70..\73 - a long relative operand, from operand 0..3
31 * \74..\77 - a word constant, from the _segment_ part of operand 0..3
32 * \1ab - a ModRM, calculated on EA in operand a, with the spare
33 * field the register value of operand b.
34 * \140..\143 - an immediate word or signed byte for operand 0..3
35 * \144..\147 - or 2 (s-field) into opcode byte if operand 0..3
36 * is a signed byte rather than a word. Opcode byte follows.
37 * \150..\153 - an immediate dword or signed byte for operand 0..3
38 * \154..\157 - or 2 (s-field) into opcode byte if operand 0..3
39 * is a signed byte rather than a dword. Opcode byte follows.
40 * \160..\163 - this instruction uses DREX rather than REX, with the
41 * OC0 field set to 0, and the dest field taken from
43 * \164..\167 - this instruction uses DREX rather than REX, with the
44 * OC0 field set to 1, and the dest field taken from
46 * \171 - placement of DREX suffix in the absence of an EA
47 * \172\ab - the register number from operand a in bits 7..4, with
48 * the 4-bit immediate from operand b in bits 3..0.
49 * \173\xab - the register number from operand a in bits 7..4, with
50 * the value b in bits 3..0.
51 * \174\a - the register number from operand a in bits 7..4, and
52 * an arbitrary value in bits 3..0 (assembled as zero.)
53 * \2ab - a ModRM, calculated on EA in operand a, with the spare
54 * field equal to digit b.
55 * \250..\253 - same as \150..\153, except warn if the 64-bit operand
56 * is not equal to the truncated and sign-extended 32-bit
57 * operand; used for 32-bit immediates in 64-bit mode.
58 * \254..\257 - a signed 32-bit operand to be extended to 64 bits.
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.
64 * VEX prefixes are followed by the sequence:
65 * \mm\wlp where mm is the M field; and wlp is:
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
73 * \274..\277 - a signed byte immediate operand, from operand 0..3,
74 * which is to be extended to the operand size.
75 * \310 - indicates fixed 16-bit address size, i.e. optional 0x67.
76 * \311 - indicates fixed 32-bit address size, i.e. optional 0x67.
77 * \312 - (disassembler only) marker on LOOP, LOOPxx instructions.
78 * \313 - indicates fixed 64-bit address size, 0x67 invalid.
79 * \314 - (disassembler only) invalid with REX.B
80 * \315 - (disassembler only) invalid with REX.X
81 * \316 - (disassembler only) invalid with REX.R
82 * \317 - (disassembler only) invalid with REX.W
83 * \320 - indicates fixed 16-bit operand size, i.e. optional 0x66.
84 * \321 - indicates fixed 32-bit operand size, i.e. optional 0x66.
85 * \322 - indicates that this instruction is only valid when the
86 * operand size is the default (instruction to disassembler,
87 * generates no code in the assembler)
88 * \323 - indicates fixed 64-bit operand size, REX on extensions only.
89 * \324 - indicates 64-bit operand size requiring REX prefix.
90 * \330 - a literal byte follows in the code stream, to be added
91 * to the condition code value of the instruction.
92 * \331 - instruction not valid with REP prefix. Hint for
93 * disassembler only; for SSE instructions.
94 * \332 - REP prefix (0xF2 byte) used as opcode extension.
95 * \333 - REP prefix (0xF3 byte) used as opcode extension.
96 * \334 - LOCK prefix used instead of REX.R
97 * \335 - disassemble a rep (0xF3 byte) prefix as repe not rep.
98 * \336 - force a REP(E) prefix (0xF2) even if not specified.
99 * \337 - force a REPNE prefix (0xF3) even if not specified.
100 * \336-\337 are still listed as prefixes in the disassembler.
101 * \340 - reserve <operand 0> bytes of uninitialized storage.
102 * Operand 0 had better be a segmentless constant.
103 * \344,\345 - the PUSH/POP (respectively) codes for CS, DS, ES, SS
104 * (POP is never used for CS) depending on operand 0
105 * \346,\347 - the second byte of PUSH/POP codes for FS, GS, depending
107 * \360 - no SSE prefix (== \364\331)
108 * \361 - 66 SSE prefix (== \366\331)
109 * \362 - F2 SSE prefix (== \364\332)
110 * \363 - F3 SSE prefix (== \364\333)
111 * \364 - operand-size prefix (0x66) not permitted
112 * \365 - address-size prefix (0x67) not permitted
113 * \366 - operand-size prefix (0x66) used as opcode extension
114 * \367 - address-size prefix (0x67) used as opcode extension
115 * \370,\371,\372 - match only if operand 0 meets byte jump criteria.
116 * 370 is used for Jcc, 371 is used for JMP.
117 * \373 - assemble 0x03 if bits==16, 0x05 if bits==32;
118 * used for conditional jump over longer jump
121 #include "compiler.h"
125 #include <inttypes.h>
129 #include "assemble.h"
133 /* Initialized to zero by the C standard */
134 static const uint8_t const_zero_buf
[256];
137 int sib_present
; /* is a SIB byte necessary? */
138 int bytes
; /* # of bytes of offset needed */
139 int size
; /* lazy - this is sib+bytes+1 */
140 uint8_t modrm
, sib
, rex
, rip
; /* the bytes themselves */
143 static uint32_t cpu
; /* cpu level received from nasm.c */
144 static efunc errfunc
;
145 static struct ofmt
*outfmt
;
146 static ListGen
*list
;
148 static int64_t calcsize(int32_t, int64_t, int, insn
*, const uint8_t *);
149 static void gencode(int32_t segment
, int64_t offset
, int bits
,
150 insn
* ins
, const struct itemplate
*temp
,
152 static int matches(const struct itemplate
*, insn
*, int bits
);
153 static int32_t regflag(const operand
*);
154 static int32_t regval(const operand
*);
155 static int rexflags(int, int32_t, int);
156 static int op_rexflags(const operand
*, int);
157 static ea
*process_ea(operand
*, ea
*, int, int, int, int32_t);
158 static void add_asp(insn
*, int);
160 static int has_prefix(insn
* ins
, enum prefix_pos pos
, enum prefixes prefix
)
162 return ins
->prefixes
[pos
] == prefix
;
165 static void assert_no_prefix(insn
* ins
, enum prefix_pos pos
)
167 if (ins
->prefixes
[pos
])
168 errfunc(ERR_NONFATAL
, "invalid %s prefix",
169 prefix_name(ins
->prefixes
[pos
]));
172 static const char *size_name(int size
)
194 static void warn_overflow(int size
, const struct operand
*o
)
196 if (size
< 8 && o
->wrt
== NO_SEG
&& o
->segment
== NO_SEG
) {
197 int64_t lim
= ((int64_t)1 << (size
*8))-1;
198 int64_t data
= o
->offset
;
200 if (data
< ~lim
|| data
> lim
)
201 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
202 "%s data exceeds bounds", size_name(size
));
206 * This routine wrappers the real output format's output routine,
207 * in order to pass a copy of the data off to the listing file
208 * generator at the same time.
210 static void out(int64_t offset
, int32_t segto
, const void *data
,
211 enum out_type type
, uint64_t size
,
212 int32_t segment
, int32_t wrt
)
214 static int32_t lineno
= 0; /* static!!! */
215 static char *lnfname
= NULL
;
218 if (type
== OUT_ADDRESS
&& segment
== NO_SEG
&& wrt
== NO_SEG
) {
220 * This is a non-relocated address, and we're going to
221 * convert it into RAWDATA format.
226 errfunc(ERR_PANIC
, "OUT_ADDRESS with size > 8");
230 WRITEADDR(q
, *(int64_t *)data
, size
);
235 list
->output(offset
, data
, type
, size
);
238 * this call to src_get determines when we call the
239 * debug-format-specific "linenum" function
240 * it updates lineno and lnfname to the current values
241 * returning 0 if "same as last time", -2 if lnfname
242 * changed, and the amount by which lineno changed,
243 * if it did. thus, these variables must be static
246 if (src_get(&lineno
, &lnfname
)) {
247 outfmt
->current_dfmt
->linenum(lnfname
, lineno
, segto
);
250 outfmt
->output(segto
, data
, type
, size
, segment
, wrt
);
253 static bool jmp_match(int32_t segment
, int64_t offset
, int bits
,
254 insn
* ins
, const uint8_t *code
)
259 if ((c
!= 0370 && c
!= 0371) || (ins
->oprs
[0].type
& STRICT
))
263 if (optimizing
< 0 && c
== 0371)
266 isize
= calcsize(segment
, offset
, bits
, ins
, code
);
267 if (ins
->oprs
[0].segment
!= segment
)
270 isize
= ins
->oprs
[0].offset
- offset
- isize
; /* isize is delta */
271 return (isize
>= -128 && isize
<= 127); /* is it byte size? */
274 int64_t assemble(int32_t segment
, int64_t offset
, int bits
, uint32_t cp
,
275 insn
* instruction
, struct ofmt
*output
, efunc error
,
278 const struct itemplate
*temp
;
283 int64_t start
= offset
;
284 int64_t wsize
= 0; /* size for DB etc. */
286 errfunc
= error
; /* to pass to other functions */
288 outfmt
= output
; /* likewise */
289 list
= listgen
; /* and again */
291 switch (instruction
->opcode
) {
321 int32_t t
= instruction
->times
;
324 "instruction->times < 0 (%ld) in assemble()", t
);
326 while (t
--) { /* repeat TIMES times */
327 for (e
= instruction
->eops
; e
; e
= e
->next
) {
328 if (e
->type
== EOT_DB_NUMBER
) {
330 if (e
->segment
!= NO_SEG
)
331 errfunc(ERR_NONFATAL
,
332 "one-byte relocation attempted");
334 uint8_t out_byte
= e
->offset
;
335 out(offset
, segment
, &out_byte
,
336 OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
338 } else if (wsize
> 8) {
339 errfunc(ERR_NONFATAL
,
340 "integer supplied to a DT, DO or DY"
343 out(offset
, segment
, &e
->offset
,
344 OUT_ADDRESS
, wsize
, e
->segment
, e
->wrt
);
346 } else if (e
->type
== EOT_DB_STRING
||
347 e
->type
== EOT_DB_STRING_FREE
) {
350 out(offset
, segment
, e
->stringval
,
351 OUT_RAWDATA
, e
->stringlen
, NO_SEG
, NO_SEG
);
352 align
= e
->stringlen
% wsize
;
355 align
= wsize
- align
;
356 out(offset
, segment
, const_zero_buf
,
357 OUT_RAWDATA
, align
, NO_SEG
, NO_SEG
);
359 offset
+= e
->stringlen
+ align
;
362 if (t
> 0 && t
== instruction
->times
- 1) {
364 * Dummy call to list->output to give the offset to the
367 list
->output(offset
, NULL
, OUT_RAWDATA
, 0);
368 list
->uplevel(LIST_TIMES
);
371 if (instruction
->times
> 1)
372 list
->downlevel(LIST_TIMES
);
373 return offset
- start
;
376 if (instruction
->opcode
== I_INCBIN
) {
377 const char *fname
= instruction
->eops
->stringval
;
380 fp
= fopen(fname
, "rb");
382 error(ERR_NONFATAL
, "`incbin': unable to open file `%s'",
384 } else if (fseek(fp
, 0L, SEEK_END
) < 0) {
385 error(ERR_NONFATAL
, "`incbin': unable to seek on file `%s'",
388 static char buf
[4096];
389 size_t t
= instruction
->times
;
394 if (instruction
->eops
->next
) {
395 base
= instruction
->eops
->next
->offset
;
397 if (instruction
->eops
->next
->next
&&
398 len
> (size_t)instruction
->eops
->next
->next
->offset
)
399 len
= (size_t)instruction
->eops
->next
->next
->offset
;
402 * Dummy call to list->output to give the offset to the
405 list
->output(offset
, NULL
, OUT_RAWDATA
, 0);
406 list
->uplevel(LIST_INCBIN
);
410 fseek(fp
, base
, SEEK_SET
);
414 fread(buf
, 1, (l
> (int32_t) sizeof(buf
) ? (int32_t) sizeof(buf
) : l
),
418 * This shouldn't happen unless the file
419 * actually changes while we are reading
423 "`incbin': unexpected EOF while"
424 " reading file `%s'", fname
);
425 t
= 0; /* Try to exit cleanly */
428 out(offset
, segment
, buf
, OUT_RAWDATA
, m
,
433 list
->downlevel(LIST_INCBIN
);
434 if (instruction
->times
> 1) {
436 * Dummy call to list->output to give the offset to the
439 list
->output(offset
, NULL
, OUT_RAWDATA
, 0);
440 list
->uplevel(LIST_TIMES
);
441 list
->downlevel(LIST_TIMES
);
444 return instruction
->times
* len
;
446 return 0; /* if we're here, there's an error */
449 /* Check to see if we need an address-size prefix */
450 add_asp(instruction
, bits
);
454 for (temp
= nasm_instructions
[instruction
->opcode
]; temp
->opcode
!= -1; temp
++){
455 int m
= matches(temp
, instruction
, bits
);
457 (m
== 99 && jmp_match(segment
, offset
, bits
,
458 instruction
, temp
->code
))) {
460 int64_t insn_size
= calcsize(segment
, offset
, bits
,
461 instruction
, temp
->code
);
462 itimes
= instruction
->times
;
463 if (insn_size
< 0) /* shouldn't be, on pass two */
464 error(ERR_PANIC
, "errors made it through from pass one");
467 for (j
= 0; j
< MAXPREFIX
; j
++) {
469 switch (instruction
->prefixes
[j
]) {
484 error(ERR_WARNING
| ERR_PASS2
,
485 "cs segment base generated, but will be ignored in 64-bit mode");
491 error(ERR_WARNING
| ERR_PASS2
,
492 "ds segment base generated, but will be ignored in 64-bit mode");
498 error(ERR_WARNING
| ERR_PASS2
,
499 "es segment base generated, but will be ignored in 64-bit mode");
511 error(ERR_WARNING
| ERR_PASS2
,
512 "ss segment base generated, but will be ignored in 64-bit mode");
519 "segr6 and segr7 cannot be used as prefixes");
524 "16-bit addressing is not supported "
526 } else if (bits
!= 16)
536 "64-bit addressing is only supported "
560 error(ERR_PANIC
, "invalid instruction prefix");
563 out(offset
, segment
, &c
, OUT_RAWDATA
, 1,
568 insn_end
= offset
+ insn_size
;
569 gencode(segment
, offset
, bits
, instruction
,
572 if (itimes
> 0 && itimes
== instruction
->times
- 1) {
574 * Dummy call to list->output to give the offset to the
577 list
->output(offset
, NULL
, OUT_RAWDATA
, 0);
578 list
->uplevel(LIST_TIMES
);
581 if (instruction
->times
> 1)
582 list
->downlevel(LIST_TIMES
);
583 return offset
- start
;
584 } else if (m
> 0 && m
> size_prob
) {
589 if (temp
->opcode
== -1) { /* didn't match any instruction */
592 error(ERR_NONFATAL
, "operation size not specified");
595 error(ERR_NONFATAL
, "mismatch in operand sizes");
598 error(ERR_NONFATAL
, "no instruction for this cpu level");
601 error(ERR_NONFATAL
, "instruction not supported in 64-bit mode");
605 "invalid combination of opcode and operands");
612 int64_t insn_size(int32_t segment
, int64_t offset
, int bits
, uint32_t cp
,
613 insn
* instruction
, efunc error
)
615 const struct itemplate
*temp
;
617 errfunc
= error
; /* to pass to other functions */
620 if (instruction
->opcode
== -1)
623 if (instruction
->opcode
== I_DB
|| instruction
->opcode
== I_DW
||
624 instruction
->opcode
== I_DD
|| instruction
->opcode
== I_DQ
||
625 instruction
->opcode
== I_DT
|| instruction
->opcode
== I_DO
||
626 instruction
->opcode
== I_DY
) {
628 int32_t isize
, osize
, wsize
= 0; /* placate gcc */
631 switch (instruction
->opcode
) {
657 for (e
= instruction
->eops
; e
; e
= e
->next
) {
661 if (e
->type
== EOT_DB_NUMBER
)
663 else if (e
->type
== EOT_DB_STRING
||
664 e
->type
== EOT_DB_STRING_FREE
)
665 osize
= e
->stringlen
;
667 align
= (-osize
) % wsize
;
670 isize
+= osize
+ align
;
672 return isize
* instruction
->times
;
675 if (instruction
->opcode
== I_INCBIN
) {
676 const char *fname
= instruction
->eops
->stringval
;
680 fp
= fopen(fname
, "rb");
682 error(ERR_NONFATAL
, "`incbin': unable to open file `%s'",
684 else if (fseek(fp
, 0L, SEEK_END
) < 0)
685 error(ERR_NONFATAL
, "`incbin': unable to seek on file `%s'",
690 if (instruction
->eops
->next
) {
691 len
-= instruction
->eops
->next
->offset
;
692 if (instruction
->eops
->next
->next
&&
693 len
> (size_t)instruction
->eops
->next
->next
->offset
) {
694 len
= (size_t)instruction
->eops
->next
->next
->offset
;
697 return instruction
->times
* len
;
699 return 0; /* if we're here, there's an error */
702 /* Check to see if we need an address-size prefix */
703 add_asp(instruction
, bits
);
705 for (temp
= nasm_instructions
[instruction
->opcode
]; temp
->opcode
!= -1; temp
++) {
706 int m
= matches(temp
, instruction
, bits
);
708 (m
== 99 && jmp_match(segment
, offset
, bits
,
709 instruction
, temp
->code
))) {
710 /* we've matched an instruction. */
712 const uint8_t *codes
= temp
->code
;
715 isize
= calcsize(segment
, offset
, bits
, instruction
, codes
);
718 for (j
= 0; j
< MAXPREFIX
; j
++) {
719 switch (instruction
->prefixes
[j
]) {
745 return isize
* instruction
->times
;
748 return -1; /* didn't match any instruction */
751 static bool possible_sbyte(operand
*o
)
753 return o
->wrt
== NO_SEG
&& o
->segment
== NO_SEG
&&
754 !(o
->opflags
& OPFLAG_FORWARD
) &&
755 optimizing
>= 0 && !(o
->type
& STRICT
);
758 /* check that opn[op] is a signed byte of size 16 or 32 */
759 static bool is_sbyte16(operand
*o
)
763 if (!possible_sbyte(o
))
767 return v
>= -128 && v
<= 127;
770 static bool is_sbyte32(operand
*o
)
774 if (!possible_sbyte(o
))
778 return v
>= -128 && v
<= 127;
781 /* Common construct */
782 #define case4(x) case (x): case (x)+1: case (x)+2: case (x)+3
784 static int64_t calcsize(int32_t segment
, int64_t offset
, int bits
,
785 insn
* ins
, const uint8_t *codes
)
794 ins
->rex
= 0; /* Ensure REX is reset */
796 if (ins
->prefixes
[PPS_OSIZE
] == P_O64
)
799 (void)segment
; /* Don't warn that this parameter is unused */
800 (void)offset
; /* Don't warn that this parameter is unused */
804 op1
= (c
& 3) + ((opex
& 1) << 2);
805 op2
= ((c
>> 3) & 3) + ((opex
& 2) << 1);
806 opx
= &ins
->oprs
[op1
];
807 opex
= 0; /* For the next iteration */
814 codes
+= c
, length
+= c
;
825 op_rexflags(opx
, REX_B
|REX_H
|REX_P
|REX_W
);
840 if (opx
->type
& (BITS16
| BITS32
| BITS64
))
841 length
+= (opx
->type
& BITS16
) ? 2 : 4;
843 length
+= (bits
== 16) ? 2 : 4;
851 length
+= ins
->addr_size
>> 3;
859 length
+= 8; /* MOV reg64/imm */
867 if (opx
->type
& (BITS16
| BITS32
| BITS64
))
868 length
+= (opx
->type
& BITS16
) ? 2 : 4;
870 length
+= (bits
== 16) ? 2 : 4;
882 length
+= is_sbyte16(opx
) ? 1 : 2;
891 length
+= is_sbyte32(opx
) ? 1 : 4;
902 ins
->drexdst
= regval(opx
);
907 ins
->rex
|= REX_D
|REX_OC
;
908 ins
->drexdst
= regval(opx
);
922 length
+= is_sbyte32(opx
) ? 1 : 4;
931 ins
->drexdst
= regval(opx
);
932 ins
->vex_m
= *codes
++;
933 ins
->vex_wlp
= *codes
++;
939 ins
->vex_m
= *codes
++;
940 ins
->vex_wlp
= *codes
++;
953 length
+= (bits
!= 16) && !has_prefix(ins
, PPS_ASIZE
, P_A16
);
957 length
+= (bits
!= 32) && !has_prefix(ins
, PPS_ASIZE
, P_A32
);
964 if (bits
!= 64 || has_prefix(ins
, PPS_ASIZE
, P_A16
) ||
965 has_prefix(ins
, PPS_ASIZE
, P_A32
))
973 length
+= (bits
!= 16);
977 length
+= (bits
== 16);
1011 if (!ins
->prefixes
[PPS_LREP
])
1012 ins
->prefixes
[PPS_LREP
] = P_REP
;
1016 if (!ins
->prefixes
[PPS_LREP
])
1017 ins
->prefixes
[PPS_LREP
] = P_REPNE
;
1021 if (ins
->oprs
[0].segment
!= NO_SEG
)
1022 errfunc(ERR_NONFATAL
, "attempt to reserve non-constant"
1023 " quantity of BSS space");
1025 length
+= ins
->oprs
[0].offset
;
1075 ea_data
.rex
= 0; /* Ensure ea.REX is initially 0 */
1078 /* pick rfield from operand b */
1079 rflags
= regflag(&ins
->oprs
[op1
]);
1080 rfield
= nasm_regvals
[ins
->oprs
[op1
].basereg
];
1085 if (!process_ea(&ins
->oprs
[op2
], &ea_data
, bits
,
1086 ins
->addr_size
, rfield
, rflags
)) {
1087 errfunc(ERR_NONFATAL
, "invalid effective address");
1090 ins
->rex
|= ea_data
.rex
;
1091 length
+= ea_data
.size
;
1097 errfunc(ERR_PANIC
, "internal instruction table corrupt"
1098 ": instruction code 0x%02X given", c
);
1103 ins
->rex
&= rex_mask
;
1105 if (ins
->rex
& REX_V
) {
1106 int bad32
= REX_R
|REX_W
|REX_X
|REX_B
;
1108 if (ins
->rex
& REX_H
) {
1109 errfunc(ERR_NONFATAL
, "cannot use high register in vex instruction");
1112 switch (ins
->vex_wlp
& 030) {
1126 if (bits
!= 64 && ((ins
->rex
& bad32
) || ins
->drexdst
> 7)) {
1127 errfunc(ERR_NONFATAL
, "invalid operands in non-64-bit mode");
1130 if (ins
->vex_m
!= 1 || (ins
->rex
& (REX_W
|REX_R
|REX_B
)))
1134 } else if (ins
->rex
& REX_D
) {
1135 if (ins
->rex
& REX_H
) {
1136 errfunc(ERR_NONFATAL
, "cannot use high register in drex instruction");
1139 if (bits
!= 64 && ((ins
->rex
& (REX_R
|REX_W
|REX_X
|REX_B
)) ||
1140 ins
->drexdst
> 7)) {
1141 errfunc(ERR_NONFATAL
, "invalid operands in non-64-bit mode");
1145 } else if (ins
->rex
& REX_REAL
) {
1146 if (ins
->rex
& REX_H
) {
1147 errfunc(ERR_NONFATAL
, "cannot use high register in rex instruction");
1149 } else if (bits
== 64) {
1151 } else if ((ins
->rex
& REX_L
) &&
1152 !(ins
->rex
& (REX_P
|REX_W
|REX_X
|REX_B
)) &&
1155 assert_no_prefix(ins
, PPS_LREP
);
1158 errfunc(ERR_NONFATAL
, "invalid operands in non-64-bit mode");
1166 #define EMIT_REX() \
1167 if (!(ins->rex & (REX_D|REX_V)) && (ins->rex & REX_REAL) && (bits == 64)) { \
1168 ins->rex = (ins->rex & REX_REAL)|REX_P; \
1169 out(offset, segment, &ins->rex, OUT_RAWDATA, 1, NO_SEG, NO_SEG); \
1174 static void gencode(int32_t segment
, int64_t offset
, int bits
,
1175 insn
* ins
, const struct itemplate
*temp
,
1178 static char condval
[] = { /* conditional opcodes */
1179 0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2,
1180 0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5,
1181 0x0, 0xA, 0xA, 0xB, 0x8, 0x4
1188 struct operand
*opx
;
1189 const uint8_t *codes
= temp
->code
;
1194 op1
= (c
& 3) + ((opex
& 1) << 2);
1195 op2
= ((c
>> 3) & 3) + ((opex
& 2) << 1);
1196 opx
= &ins
->oprs
[op1
];
1197 opex
= 0; /* For the next iteration */
1205 out(offset
, segment
, codes
, OUT_RAWDATA
, c
, NO_SEG
, NO_SEG
);
1218 bytes
[0] = *codes
++ + (regval(opx
) & 7);
1219 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1224 /* The test for BITS8 and SBYTE here is intended to avoid
1225 warning on optimizer actions due to SBYTE, while still
1226 warn on explicit BYTE directives. Also warn, obviously,
1227 if the optimizer isn't enabled. */
1228 if (((opx
->type
& BITS8
) ||
1229 !(opx
->type
& temp
->opd
[op1
] & BYTENESS
)) &&
1230 (opx
->offset
< -128 || opx
->offset
> 127)) {
1231 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1232 "signed byte value exceeds bounds");
1234 if (opx
->segment
!= NO_SEG
) {
1236 out(offset
, segment
, &data
, OUT_ADDRESS
, 1,
1237 opx
->segment
, opx
->wrt
);
1239 bytes
[0] = opx
->offset
;
1240 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1247 if (opx
->offset
< -256 || opx
->offset
> 255) {
1248 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1249 "byte value exceeds bounds");
1251 if (opx
->segment
!= NO_SEG
) {
1253 out(offset
, segment
, &data
, OUT_ADDRESS
, 1,
1254 opx
->segment
, opx
->wrt
);
1256 bytes
[0] = opx
->offset
;
1257 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1264 if (opx
->offset
< 0 || opx
->offset
> 255)
1265 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1266 "unsigned byte value exceeds bounds");
1267 if (opx
->segment
!= NO_SEG
) {
1269 out(offset
, segment
, &data
, OUT_ADDRESS
, 1,
1270 opx
->segment
, opx
->wrt
);
1272 bytes
[0] = opx
->offset
;
1273 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1280 warn_overflow(2, opx
);
1282 out(offset
, segment
, &data
, OUT_ADDRESS
, 2,
1283 opx
->segment
, opx
->wrt
);
1288 if (opx
->type
& (BITS16
| BITS32
))
1289 size
= (opx
->type
& BITS16
) ? 2 : 4;
1291 size
= (bits
== 16) ? 2 : 4;
1292 warn_overflow(size
, opx
);
1294 out(offset
, segment
, &data
, OUT_ADDRESS
, size
,
1295 opx
->segment
, opx
->wrt
);
1300 warn_overflow(4, opx
);
1302 out(offset
, segment
, &data
, OUT_ADDRESS
, 4,
1303 opx
->segment
, opx
->wrt
);
1309 size
= ins
->addr_size
>> 3;
1310 warn_overflow(size
, opx
);
1311 out(offset
, segment
, &data
, OUT_ADDRESS
, size
,
1312 opx
->segment
, opx
->wrt
);
1317 if (opx
->segment
!= segment
)
1318 errfunc(ERR_NONFATAL
,
1319 "short relative jump outside segment");
1320 data
= opx
->offset
- insn_end
;
1321 if (data
> 127 || data
< -128)
1322 errfunc(ERR_NONFATAL
, "short jump is out of range");
1324 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1329 data
= (int64_t)opx
->offset
;
1330 out(offset
, segment
, &data
, OUT_ADDRESS
, 8,
1331 opx
->segment
, opx
->wrt
);
1336 if (opx
->segment
!= segment
) {
1338 out(offset
, segment
, &data
,
1339 OUT_REL2ADR
, insn_end
- offset
,
1340 opx
->segment
, opx
->wrt
);
1342 data
= opx
->offset
- insn_end
;
1343 out(offset
, segment
, &data
,
1344 OUT_ADDRESS
, 2, NO_SEG
, NO_SEG
);
1350 if (opx
->type
& (BITS16
| BITS32
| BITS64
))
1351 size
= (opx
->type
& BITS16
) ? 2 : 4;
1353 size
= (bits
== 16) ? 2 : 4;
1354 if (opx
->segment
!= segment
) {
1356 out(offset
, segment
, &data
,
1357 size
== 2 ? OUT_REL2ADR
: OUT_REL4ADR
,
1358 insn_end
- offset
, opx
->segment
, opx
->wrt
);
1360 data
= opx
->offset
- insn_end
;
1361 out(offset
, segment
, &data
,
1362 OUT_ADDRESS
, size
, NO_SEG
, NO_SEG
);
1368 if (opx
->segment
!= segment
) {
1370 out(offset
, segment
, &data
,
1371 OUT_REL4ADR
, insn_end
- offset
,
1372 opx
->segment
, opx
->wrt
);
1374 data
= opx
->offset
- insn_end
;
1375 out(offset
, segment
, &data
,
1376 OUT_ADDRESS
, 4, NO_SEG
, NO_SEG
);
1382 if (opx
->segment
== NO_SEG
)
1383 errfunc(ERR_NONFATAL
, "value referenced by FAR is not"
1386 out(offset
, segment
, &data
, OUT_ADDRESS
, 2,
1387 outfmt
->segbase(1 + opx
->segment
),
1394 warn_overflow(2, opx
);
1395 if (is_sbyte16(opx
)) {
1397 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1401 out(offset
, segment
, &data
, OUT_ADDRESS
, 2,
1402 opx
->segment
, opx
->wrt
);
1409 bytes
[0] = *codes
++;
1410 if (is_sbyte16(opx
))
1411 bytes
[0] |= 2; /* s-bit */
1412 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1418 warn_overflow(4, opx
);
1419 if (is_sbyte32(opx
)) {
1421 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1425 out(offset
, segment
, &data
, OUT_ADDRESS
, 4,
1426 opx
->segment
, opx
->wrt
);
1433 bytes
[0] = *codes
++;
1434 if (is_sbyte32(opx
))
1435 bytes
[0] |= 2; /* s-bit */
1436 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1446 (ins
->drexdst
<< 4) |
1447 (ins
->rex
& REX_OC
? 0x08 : 0) |
1448 (ins
->rex
& (REX_R
|REX_X
|REX_B
));
1450 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1456 opx
= &ins
->oprs
[c
>> 3];
1457 bytes
[0] = nasm_regvals
[opx
->basereg
] << 4;
1458 opx
= &ins
->oprs
[c
& 7];
1459 if (opx
->segment
!= NO_SEG
|| opx
->wrt
!= NO_SEG
) {
1460 errfunc(ERR_NONFATAL
,
1461 "non-absolute expression not permitted as argument %d",
1464 if (opx
->offset
& ~15) {
1465 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1466 "four-bit argument exceeds bounds");
1468 bytes
[0] |= opx
->offset
& 15;
1470 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1476 opx
= &ins
->oprs
[c
>> 4];
1477 bytes
[0] = nasm_regvals
[opx
->basereg
] << 4;
1479 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1485 opx
= &ins
->oprs
[c
];
1486 bytes
[0] = nasm_regvals
[opx
->basereg
] << 4;
1487 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1493 if (opx
->wrt
== NO_SEG
&& opx
->segment
== NO_SEG
&&
1494 (int32_t)data
!= (int64_t)data
) {
1495 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1496 "signed dword immediate exceeds bounds");
1498 if (is_sbyte32(opx
)) {
1500 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1504 out(offset
, segment
, &data
, OUT_ADDRESS
, 4,
1505 opx
->segment
, opx
->wrt
);
1512 if (opx
->wrt
== NO_SEG
&& opx
->segment
== NO_SEG
&&
1513 (int32_t)data
!= (int64_t)data
) {
1514 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1515 "signed dword immediate exceeds bounds");
1517 out(offset
, segment
, &data
, OUT_ADDRESS
, 4,
1518 opx
->segment
, opx
->wrt
);
1525 if (ins
->vex_m
!= 1 || (ins
->rex
& (REX_W
|REX_X
|REX_B
))) {
1527 bytes
[1] = ins
->vex_m
| ((~ins
->rex
& 7) << 5);
1528 bytes
[2] = ((ins
->rex
& REX_W
) << (7-3)) |
1529 ((~ins
->drexdst
& 15)<< 3) | (ins
->vex_wlp
& 07);
1530 out(offset
, segment
, &bytes
, OUT_RAWDATA
, 3, NO_SEG
, NO_SEG
);
1534 bytes
[1] = ((~ins
->rex
& REX_R
) << (7-2)) |
1535 ((~ins
->drexdst
& 15) << 3) | (ins
->vex_wlp
& 07);
1536 out(offset
, segment
, &bytes
, OUT_RAWDATA
, 2, NO_SEG
, NO_SEG
);
1546 if (ins
->rex
& REX_W
)
1548 else if (ins
->prefixes
[PPS_OSIZE
] == P_O16
)
1550 else if (ins
->prefixes
[PPS_OSIZE
] == P_O32
)
1555 um
= (uint64_t)2 << (s
-1);
1558 if (uv
> 127 && uv
< (uint64_t)-128 &&
1559 (uv
< um
-128 || uv
> um
-1)) {
1560 errfunc(ERR_WARNING
| ERR_PASS2
| ERR_WARN_NOV
,
1561 "signed byte value exceeds bounds");
1563 if (opx
->segment
!= NO_SEG
) {
1565 out(offset
, segment
, &data
, OUT_ADDRESS
, 1,
1566 opx
->segment
, opx
->wrt
);
1569 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
,
1580 if (bits
== 32 && !has_prefix(ins
, PPS_ASIZE
, P_A16
)) {
1582 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1589 if (bits
!= 32 && !has_prefix(ins
, PPS_ASIZE
, P_A32
)) {
1591 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1610 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1619 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1634 *bytes
= *codes
++ ^ condval
[ins
->condition
];
1635 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1644 *bytes
= c
- 0332 + 0xF2;
1645 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1650 if (ins
->rex
& REX_R
) {
1652 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1655 ins
->rex
&= ~(REX_L
|REX_R
);
1666 if (ins
->oprs
[0].segment
!= NO_SEG
)
1667 errfunc(ERR_PANIC
, "non-constant BSS size in pass two");
1669 int64_t size
= ins
->oprs
[0].offset
;
1671 out(offset
, segment
, NULL
,
1672 OUT_RESERVE
, size
, NO_SEG
, NO_SEG
);
1680 switch (ins
->oprs
[0].basereg
) {
1695 "bizarre 8086 segment register received");
1697 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1704 switch (ins
->oprs
[0].basereg
) {
1713 "bizarre 386 segment register received");
1715 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1724 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1730 bytes
[0] = c
- 0362 + 0xf2;
1731 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1741 *bytes
= c
- 0366 + 0x66;
1742 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1752 *bytes
= bits
== 16 ? 3 : 5;
1753 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1, NO_SEG
, NO_SEG
);
1778 /* pick rfield from operand b */
1779 rflags
= regflag(&ins
->oprs
[op1
]);
1780 rfield
= nasm_regvals
[ins
->oprs
[op1
].basereg
];
1782 /* rfield is constant */
1788 (&ins
->oprs
[op2
], &ea_data
, bits
,
1789 ins
->addr_size
, rfield
, rflags
)) {
1790 errfunc(ERR_NONFATAL
, "invalid effective address");
1795 *p
++ = ea_data
.modrm
;
1796 if (ea_data
.sib_present
)
1799 /* DREX suffixes come between the SIB and the displacement */
1800 if (ins
->rex
& REX_D
) {
1802 (ins
->drexdst
<< 4) |
1803 (ins
->rex
& REX_OC
? 0x08 : 0) |
1804 (ins
->rex
& (REX_R
|REX_X
|REX_B
));
1809 out(offset
, segment
, bytes
, OUT_RAWDATA
, s
, NO_SEG
, NO_SEG
);
1812 * Make sure the address gets the right offset in case
1813 * the line breaks in the .lst file (BR 1197827)
1818 switch (ea_data
.bytes
) {
1822 if (ins
->oprs
[(c
>> 3) & 7].segment
!= NO_SEG
) {
1823 data
= ins
->oprs
[(c
>> 3) & 7].offset
;
1824 out(offset
, segment
, &data
, OUT_ADDRESS
, 1,
1825 ins
->oprs
[(c
>> 3) & 7].segment
,
1826 ins
->oprs
[(c
>> 3) & 7].wrt
);
1828 *bytes
= ins
->oprs
[(c
>> 3) & 7].offset
;
1829 out(offset
, segment
, bytes
, OUT_RAWDATA
, 1,
1837 data
= ins
->oprs
[(c
>> 3) & 7].offset
;
1838 warn_overflow(ea_data
.bytes
, &ins
->oprs
[(c
>> 3) & 7]);
1841 if (ins
->oprs
[(c
>> 3) & 7].segment
== segment
) {
1843 out(offset
, segment
, &data
,
1844 OUT_ADDRESS
, ea_data
.bytes
,
1847 out(offset
, segment
, &data
,
1848 OUT_REL4ADR
, insn_end
- offset
,
1849 ins
->oprs
[(c
>> 3) & 7].segment
,
1850 ins
->oprs
[(c
>> 3) & 7].wrt
);
1854 out(offset
, segment
, &data
,
1855 OUT_ADDRESS
, ea_data
.bytes
,
1856 ins
->oprs
[(c
>> 3) & 7].segment
,
1857 ins
->oprs
[(c
>> 3) & 7].wrt
);
1866 errfunc(ERR_PANIC
, "internal instruction table corrupt"
1867 ": instruction code 0x%02X given", c
);
1873 static int32_t regflag(const operand
* o
)
1875 if (o
->basereg
< EXPR_REG_START
|| o
->basereg
>= REG_ENUM_LIMIT
) {
1876 errfunc(ERR_PANIC
, "invalid operand passed to regflag()");
1878 return nasm_reg_flags
[o
->basereg
];
1881 static int32_t regval(const operand
* o
)
1883 if (o
->basereg
< EXPR_REG_START
|| o
->basereg
>= REG_ENUM_LIMIT
) {
1884 errfunc(ERR_PANIC
, "invalid operand passed to regval()");
1886 return nasm_regvals
[o
->basereg
];
1889 static int op_rexflags(const operand
* o
, int mask
)
1894 if (o
->basereg
< EXPR_REG_START
|| o
->basereg
>= REG_ENUM_LIMIT
) {
1895 errfunc(ERR_PANIC
, "invalid operand passed to op_rexflags()");
1898 flags
= nasm_reg_flags
[o
->basereg
];
1899 val
= nasm_regvals
[o
->basereg
];
1901 return rexflags(val
, flags
, mask
);
1904 static int rexflags(int val
, int32_t flags
, int mask
)
1909 rex
|= REX_B
|REX_X
|REX_R
;
1912 if (!(REG_HIGH
& ~flags
)) /* AH, CH, DH, BH */
1914 else if (!(REG8
& ~flags
) && val
>= 4) /* SPL, BPL, SIL, DIL */
1920 static int matches(const struct itemplate
*itemp
, insn
* instruction
, int bits
)
1922 int i
, size
[MAX_OPERANDS
], asize
, oprs
, ret
;
1929 if (itemp
->opcode
!= instruction
->opcode
)
1933 * Count the operands
1935 if (itemp
->operands
!= instruction
->operands
)
1939 * Check that no spurious colons or TOs are present
1941 for (i
= 0; i
< itemp
->operands
; i
++)
1942 if (instruction
->oprs
[i
].type
& ~itemp
->opd
[i
] & (COLON
| TO
))
1946 * Process size flags
1948 if (itemp
->flags
& IF_ARMASK
) {
1949 memset(size
, 0, sizeof size
);
1951 i
= ((itemp
->flags
& IF_ARMASK
) >> IF_ARSHFT
) - 1;
1953 switch (itemp
->flags
& IF_SMASK
) {
1990 switch (itemp
->flags
& IF_SMASK
) {
2025 for (i
= 0; i
< MAX_OPERANDS
; i
++)
2030 * Check that the operand flags all match up
2032 for (i
= 0; i
< itemp
->operands
; i
++) {
2033 int32_t type
= instruction
->oprs
[i
].type
;
2034 if (!(type
& SIZE_MASK
))
2037 if (itemp
->opd
[i
] & SAME_AS
) {
2038 int j
= itemp
->opd
[i
] & ~SAME_AS
;
2039 if (type
!= instruction
->oprs
[j
].type
||
2040 instruction
->oprs
[i
].basereg
!= instruction
->oprs
[j
].basereg
)
2042 } else if (itemp
->opd
[i
] & ~type
||
2043 ((itemp
->opd
[i
] & SIZE_MASK
) &&
2044 ((itemp
->opd
[i
] ^ type
) & SIZE_MASK
))) {
2045 if ((itemp
->opd
[i
] & ~type
& ~SIZE_MASK
) ||
2054 * Check operand sizes
2056 if (itemp
->flags
& (IF_SM
| IF_SM2
)) {
2057 oprs
= (itemp
->flags
& IF_SM2
? 2 : itemp
->operands
);
2059 for (i
= 0; i
< oprs
; i
++) {
2060 if ((asize
= itemp
->opd
[i
] & SIZE_MASK
) != 0) {
2062 for (j
= 0; j
< oprs
; j
++)
2068 oprs
= itemp
->operands
;
2071 for (i
= 0; i
< itemp
->operands
; i
++) {
2072 if (!(itemp
->opd
[i
] & SIZE_MASK
) &&
2073 (instruction
->oprs
[i
].type
& SIZE_MASK
& ~size
[i
]))
2078 * Check template is okay at the set cpu level
2080 if (((itemp
->flags
& IF_PLEVEL
) > cpu
))
2084 * Check if instruction is available in long mode
2086 if ((itemp
->flags
& IF_NOLONG
) && (bits
== 64))
2090 * Check if special handling needed for Jumps
2092 if ((uint8_t)(itemp
->code
[0]) >= 0370)
2098 static ea
*process_ea(operand
* input
, ea
* output
, int bits
,
2099 int addrbits
, int rfield
, int32_t rflags
)
2101 bool forw_ref
= !!(input
->opflags
& OPFLAG_FORWARD
);
2103 output
->rip
= false;
2105 /* REX flags for the rfield operand */
2106 output
->rex
|= rexflags(rfield
, rflags
, REX_R
|REX_P
|REX_W
|REX_H
);
2108 if (!(REGISTER
& ~input
->type
)) { /* register direct */
2112 if (input
->basereg
< EXPR_REG_START
/* Verify as Register */
2113 || input
->basereg
>= REG_ENUM_LIMIT
)
2116 i
= nasm_regvals
[input
->basereg
];
2119 return NULL
; /* Invalid EA register */
2121 output
->rex
|= op_rexflags(input
, REX_B
|REX_P
|REX_W
|REX_H
);
2123 output
->sib_present
= false; /* no SIB necessary */
2124 output
->bytes
= 0; /* no offset necessary either */
2125 output
->modrm
= 0xC0 | ((rfield
& 7) << 3) | (i
& 7);
2126 } else { /* it's a memory reference */
2127 if (input
->basereg
== -1
2128 && (input
->indexreg
== -1 || input
->scale
== 0)) {
2129 /* it's a pure offset */
2130 if (bits
== 64 && (~input
->type
& IP_REL
)) {
2131 int scale
, index
, base
;
2132 output
->sib_present
= true;
2136 output
->sib
= (scale
<< 6) | (index
<< 3) | base
;
2138 output
->modrm
= 4 | ((rfield
& 7) << 3);
2139 output
->rip
= false;
2141 output
->sib_present
= false;
2142 output
->bytes
= (addrbits
!= 16 ? 4 : 2);
2143 output
->modrm
= (addrbits
!= 16 ? 5 : 6) | ((rfield
& 7) << 3);
2144 output
->rip
= bits
== 64;
2146 } else { /* it's an indirection */
2147 int i
= input
->indexreg
, b
= input
->basereg
, s
= input
->scale
;
2148 int32_t o
= input
->offset
, seg
= input
->segment
;
2149 int hb
= input
->hintbase
, ht
= input
->hinttype
;
2152 int32_t ix
, bx
; /* register flags */
2155 i
= -1; /* make this easy, at least */
2157 if (i
>= EXPR_REG_START
&& i
< REG_ENUM_LIMIT
) {
2158 it
= nasm_regvals
[i
];
2159 ix
= nasm_reg_flags
[i
];
2165 if (b
>= EXPR_REG_START
&& b
< REG_ENUM_LIMIT
) {
2166 bt
= nasm_regvals
[b
];
2167 bx
= nasm_reg_flags
[b
];
2173 /* check for a 32/64-bit memory reference... */
2174 if ((ix
|bx
) & (BITS32
|BITS64
)) {
2175 /* it must be a 32/64-bit memory reference. Firstly we have
2176 * to check that all registers involved are type E/Rxx. */
2177 int32_t sok
= BITS32
|BITS64
;
2180 if (!(REG64
& ~ix
) || !(REG32
& ~ix
))
2188 return NULL
; /* Invalid register */
2189 if (~sok
& bx
& SIZE_MASK
)
2190 return NULL
; /* Invalid size */
2194 /* While we're here, ensure the user didn't specify
2196 if (input
->disp_size
== 16 || input
->disp_size
== 64)
2199 if (addrbits
== 16 ||
2200 (addrbits
== 32 && !(sok
& BITS32
)) ||
2201 (addrbits
== 64 && !(sok
& BITS64
)))
2204 /* now reorganize base/index */
2205 if (s
== 1 && bt
!= it
&& bt
!= -1 && it
!= -1 &&
2206 ((hb
== b
&& ht
== EAH_NOTBASE
)
2207 || (hb
== i
&& ht
== EAH_MAKEBASE
))) {
2208 /* swap if hints say so */
2209 t
= bt
, bt
= it
, it
= t
;
2210 t
= bx
, bx
= ix
, ix
= t
;
2212 if (bt
== it
) /* convert EAX+2*EAX to 3*EAX */
2213 bt
= -1, bx
= 0, s
++;
2214 if (bt
== -1 && s
== 1 && !(hb
== it
&& ht
== EAH_NOTBASE
)) {
2215 /* make single reg base, unless hint */
2216 bt
= it
, bx
= ix
, it
= -1, ix
= 0;
2218 if (((s
== 2 && it
!= REG_NUM_ESP
2219 && !(input
->eaflags
& EAF_TIMESTWO
)) || s
== 3
2220 || s
== 5 || s
== 9) && bt
== -1)
2221 bt
= it
, bx
= ix
, s
--; /* convert 3*EAX to EAX+2*EAX */
2222 if (it
== -1 && (bt
& 7) != REG_NUM_ESP
2223 && (input
->eaflags
& EAF_TIMESTWO
))
2224 it
= bt
, ix
= bx
, bt
= -1, bx
= 0, s
= 1;
2225 /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */
2226 if (s
== 1 && it
== REG_NUM_ESP
) {
2227 /* swap ESP into base if scale is 1 */
2228 t
= it
, it
= bt
, bt
= t
;
2229 t
= ix
, ix
= bx
, bx
= t
;
2231 if (it
== REG_NUM_ESP
2232 || (s
!= 1 && s
!= 2 && s
!= 4 && s
!= 8 && it
!= -1))
2233 return NULL
; /* wrong, for various reasons */
2235 output
->rex
|= rexflags(it
, ix
, REX_X
);
2236 output
->rex
|= rexflags(bt
, bx
, REX_B
);
2238 if (it
== -1 && (bt
& 7) != REG_NUM_ESP
) {
2247 if (rm
!= REG_NUM_EBP
&& o
== 0 &&
2248 seg
== NO_SEG
&& !forw_ref
&&
2250 (EAF_BYTEOFFS
| EAF_WORDOFFS
)))
2252 else if (input
->eaflags
& EAF_BYTEOFFS
||
2253 (o
>= -128 && o
<= 127 && seg
== NO_SEG
2255 && !(input
->eaflags
& EAF_WORDOFFS
)))
2261 output
->sib_present
= false;
2262 output
->bytes
= (bt
== -1 || mod
== 2 ? 4 : mod
);
2263 output
->modrm
= (mod
<< 6) | ((rfield
& 7) << 3) | rm
;
2266 int mod
, scale
, index
, base
;
2286 default: /* then what the smeg is it? */
2287 return NULL
; /* panic */
2295 if (base
!= REG_NUM_EBP
&& o
== 0 &&
2296 seg
== NO_SEG
&& !forw_ref
&&
2298 (EAF_BYTEOFFS
| EAF_WORDOFFS
)))
2300 else if (input
->eaflags
& EAF_BYTEOFFS
||
2301 (o
>= -128 && o
<= 127 && seg
== NO_SEG
2303 && !(input
->eaflags
& EAF_WORDOFFS
)))
2309 output
->sib_present
= true;
2310 output
->bytes
= (bt
== -1 || mod
== 2 ? 4 : mod
);
2311 output
->modrm
= (mod
<< 6) | ((rfield
& 7) << 3) | 4;
2312 output
->sib
= (scale
<< 6) | (index
<< 3) | base
;
2314 } else { /* it's 16-bit */
2317 /* check for 64-bit long mode */
2321 /* check all registers are BX, BP, SI or DI */
2322 if ((b
!= -1 && b
!= R_BP
&& b
!= R_BX
&& b
!= R_SI
2323 && b
!= R_DI
) || (i
!= -1 && i
!= R_BP
&& i
!= R_BX
2324 && i
!= R_SI
&& i
!= R_DI
))
2327 /* ensure the user didn't specify DWORD/QWORD */
2328 if (input
->disp_size
== 32 || input
->disp_size
== 64)
2331 if (s
!= 1 && i
!= -1)
2332 return NULL
; /* no can do, in 16-bit EA */
2333 if (b
== -1 && i
!= -1) {
2338 if ((b
== R_SI
|| b
== R_DI
) && i
!= -1) {
2343 /* have BX/BP as base, SI/DI index */
2345 return NULL
; /* shouldn't ever happen, in theory */
2346 if (i
!= -1 && b
!= -1 &&
2347 (i
== R_BP
|| i
== R_BX
|| b
== R_SI
|| b
== R_DI
))
2348 return NULL
; /* invalid combinations */
2349 if (b
== -1) /* pure offset: handled above */
2350 return NULL
; /* so if it gets to here, panic! */
2354 switch (i
* 256 + b
) {
2355 case R_SI
* 256 + R_BX
:
2358 case R_DI
* 256 + R_BX
:
2361 case R_SI
* 256 + R_BP
:
2364 case R_DI
* 256 + R_BP
:
2382 if (rm
== -1) /* can't happen, in theory */
2383 return NULL
; /* so panic if it does */
2385 if (o
== 0 && seg
== NO_SEG
&& !forw_ref
&& rm
!= 6 &&
2386 !(input
->eaflags
& (EAF_BYTEOFFS
| EAF_WORDOFFS
)))
2388 else if (input
->eaflags
& EAF_BYTEOFFS
||
2389 (o
>= -128 && o
<= 127 && seg
== NO_SEG
2391 && !(input
->eaflags
& EAF_WORDOFFS
)))
2396 output
->sib_present
= false; /* no SIB - it's 16-bit */
2397 output
->bytes
= mod
; /* bytes of offset needed */
2398 output
->modrm
= (mod
<< 6) | ((rfield
& 7) << 3) | rm
;
2403 output
->size
= 1 + output
->sib_present
+ output
->bytes
;
2407 static void add_asp(insn
*ins
, int addrbits
)
2412 valid
= (addrbits
== 64) ? 64|32 : 32|16;
2414 switch (ins
->prefixes
[PPS_ASIZE
]) {
2425 valid
&= (addrbits
== 32) ? 16 : 32;
2431 for (j
= 0; j
< ins
->operands
; j
++) {
2432 if (!(MEMORY
& ~ins
->oprs
[j
].type
)) {
2435 /* Verify as Register */
2436 if (ins
->oprs
[j
].indexreg
< EXPR_REG_START
2437 || ins
->oprs
[j
].indexreg
>= REG_ENUM_LIMIT
)
2440 i
= nasm_reg_flags
[ins
->oprs
[j
].indexreg
];
2442 /* Verify as Register */
2443 if (ins
->oprs
[j
].basereg
< EXPR_REG_START
2444 || ins
->oprs
[j
].basereg
>= REG_ENUM_LIMIT
)
2447 b
= nasm_reg_flags
[ins
->oprs
[j
].basereg
];
2449 if (ins
->oprs
[j
].scale
== 0)
2453 int ds
= ins
->oprs
[j
].disp_size
;
2454 if ((addrbits
!= 64 && ds
> 8) ||
2455 (addrbits
== 64 && ds
== 16))
2475 if (valid
& addrbits
) {
2476 ins
->addr_size
= addrbits
;
2477 } else if (valid
& ((addrbits
== 32) ? 16 : 32)) {
2478 /* Add an address size prefix */
2479 enum prefixes pref
= (addrbits
== 32) ? P_A16
: P_A32
;
2480 ins
->prefixes
[PPS_ASIZE
] = pref
;
2481 ins
->addr_size
= (addrbits
== 32) ? 16 : 32;
2484 errfunc(ERR_NONFATAL
, "impossible combination of address sizes");
2485 ins
->addr_size
= addrbits
; /* Error recovery */
2488 defdisp
= ins
->addr_size
== 16 ? 16 : 32;
2490 for (j
= 0; j
< ins
->operands
; j
++) {
2491 if (!(MEM_OFFS
& ~ins
->oprs
[j
].type
) &&
2492 (ins
->oprs
[j
].disp_size
? ins
->oprs
[j
].disp_size
: defdisp
)
2493 != ins
->addr_size
) {
2494 /* mem_offs sizes must match the address size; if not,
2495 strip the MEM_OFFS bit and match only EA instructions */
2496 ins
->oprs
[j
].type
&= ~(MEM_OFFS
& ~MEMORY
);