1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2017 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * parser.c source line parser for the Netwide Assembler
58 static int is_comma_next(void);
60 static struct tokenval tokval
;
62 static int prefix_slot(int prefix
)
101 nasm_panic(0, "Invalid value %d passed to prefix_slot()", prefix
);
106 static void process_size_override(insn
*result
, operand
*op
)
108 if (tasm_compatible_mode
) {
109 switch (tokval
.t_integer
) {
110 /* For TASM compatibility a size override inside the
111 * brackets changes the size of the operand, not the
112 * address type of the operand as it does in standard
113 * NASM syntax. Hence:
115 * mov eax,[DWORD val]
117 * is valid syntax in TASM compatibility mode. Note that
118 * you lose the ability to override the default address
119 * type for the instruction, but we never use anything
120 * but 32-bit flat model addressing in our code.
142 nasm_error(ERR_NONFATAL
,
143 "invalid operand size specification");
147 /* Standard NASM compatible syntax */
148 switch (tokval
.t_integer
) {
150 op
->eaflags
|= EAF_TIMESTWO
;
153 op
->eaflags
|= EAF_REL
;
156 op
->eaflags
|= EAF_ABS
;
160 op
->eaflags
|= EAF_BYTEOFFS
;
165 if (result
->prefixes
[PPS_ASIZE
] &&
166 result
->prefixes
[PPS_ASIZE
] != tokval
.t_integer
)
167 nasm_error(ERR_NONFATAL
,
168 "conflicting address size specifications");
170 result
->prefixes
[PPS_ASIZE
] = tokval
.t_integer
;
174 op
->eaflags
|= EAF_WORDOFFS
;
179 op
->eaflags
|= EAF_WORDOFFS
;
183 op
->eaflags
|= EAF_WORDOFFS
;
186 nasm_error(ERR_NONFATAL
, "invalid size specification in"
187 " effective address");
194 * Brace decorators are are parsed here. opmask and zeroing
195 * decorators can be placed in any order. e.g. zmm1 {k2}{z} or zmm2
196 * {z}{k3} decorator(s) are placed at the end of an operand.
198 static bool parse_braces(decoflags_t
*decoflags
)
207 if (*decoflags
& OPMASK_MASK
) {
208 nasm_error(ERR_NONFATAL
,
209 "opmask k%"PRIu64
" is already set",
210 *decoflags
& OPMASK_MASK
);
211 *decoflags
&= ~OPMASK_MASK
;
213 *decoflags
|= VAL_OPMASK(nasm_regvals
[tokval
.t_integer
]);
215 case TOKEN_DECORATOR
:
216 j
= tokval
.t_integer
;
219 *decoflags
|= Z_MASK
;
225 *decoflags
|= BRDCAST_MASK
| VAL_BRNUM(j
- BRC_1TO2
);
228 nasm_error(ERR_NONFATAL
,
229 "{%s} is not an expected decorator",
238 nasm_error(ERR_NONFATAL
,
239 "only a series of valid decorators expected");
242 i
= stdscan(NULL
, &tokval
);
246 static int parse_mref(operand
*op
, const expr
*e
)
248 int b
, i
, s
; /* basereg, indexreg, scale */
249 int64_t o
; /* offset */
253 op
->segment
= op
->wrt
= NO_SEG
;
255 if (e
->type
&& e
->type
<= EXPR_REG_END
) { /* this bit's a register */
256 bool is_gpr
= is_class(REG_GPR
,nasm_reg_flags
[e
->type
]);
258 if (is_gpr
&& e
->value
== 1)
259 b
= e
->type
; /* It can be basereg */
260 else /* No, it has to be indexreg */
261 i
= e
->type
, s
= e
->value
;
264 if (e
->type
&& e
->type
<= EXPR_REG_END
) { /* it's a 2nd register */
265 bool is_gpr
= is_class(REG_GPR
,nasm_reg_flags
[e
->type
]);
267 if (b
!= -1) /* If the first was the base, ... */
268 i
= e
->type
, s
= e
->value
; /* second has to be indexreg */
270 else if (!is_gpr
|| e
->value
!= 1) {
271 /* If both want to be index */
272 nasm_error(ERR_NONFATAL
,
273 "invalid effective address: two index registers");
280 if (e
->type
) { /* is there an offset? */
281 if (e
->type
<= EXPR_REG_END
) { /* in fact, is there an error? */
282 nasm_error(ERR_NONFATAL
,
283 "invalid effective address: impossible register");
286 if (e
->type
== EXPR_UNKNOWN
) {
287 op
->opflags
|= OPFLAG_UNKNOWN
;
288 o
= 0; /* doesn't matter what */
290 e
++; /* go to the end of the line */
292 if (e
->type
== EXPR_SIMPLE
) {
296 if (e
->type
== EXPR_WRT
) {
301 * Look for a segment base type.
303 for (; e
->type
; e
++) {
307 if (e
->type
<= EXPR_REG_END
) {
308 nasm_error(ERR_NONFATAL
,
309 "invalid effective address: too many registers");
311 } else if (e
->type
< EXPR_SEGBASE
) {
312 nasm_error(ERR_NONFATAL
,
313 "invalid effective address: bad subexpression type");
315 } else if (e
->value
== 1) {
316 if (op
->segment
!= NO_SEG
) {
317 nasm_error(ERR_NONFATAL
,
318 "invalid effective address: multiple base segments");
321 op
->segment
= e
->type
- EXPR_SEGBASE
;
322 } else if (e
->value
== -1 &&
323 e
->type
== location
.segment
+ EXPR_SEGBASE
&&
324 !(op
->opflags
& OPFLAG_RELATIVE
)) {
325 op
->opflags
|= OPFLAG_RELATIVE
;
327 nasm_error(ERR_NONFATAL
,
328 "invalid effective address: impossible segment base multiplier");
336 nasm_assert(!e
->type
); /* We should be at the end */
345 static void mref_set_optype(operand
*op
)
348 int i
= op
->indexreg
;
351 /* It is memory, but it can match any r/m operand */
352 op
->type
|= MEMORY_ANY
;
354 if (b
== -1 && (i
== -1 || s
== 0)) {
355 int is_rel
= globalbits
== 64 &&
356 !(op
->eaflags
& EAF_ABS
) &&
358 !(op
->eaflags
& EAF_FSGS
)) ||
359 (op
->eaflags
& EAF_REL
));
361 op
->type
|= is_rel
? IP_REL
: MEM_OFFS
;
365 opflags_t iclass
= nasm_reg_flags
[i
];
367 if (is_class(XMMREG
,iclass
))
369 else if (is_class(YMMREG
,iclass
))
371 else if (is_class(ZMMREG
,iclass
))
377 * Convert an expression vector returned from evaluate() into an
378 * extop structure. Return zero on success.
380 static int value_to_extop(expr
* vect
, extop
*eop
, int32_t myseg
)
382 eop
->type
= EOT_DB_NUMBER
;
384 eop
->segment
= eop
->wrt
= NO_SEG
;
385 eop
->relative
= false;
387 for (; vect
->type
; vect
++) {
388 if (!vect
->value
) /* zero term, safe to ignore */
391 if (vect
->type
<= EXPR_REG_END
) /* false if a register is present */
394 if (vect
->type
== EXPR_UNKNOWN
) /* something we can't resolve yet */
397 if (vect
->type
== EXPR_SIMPLE
) {
398 /* Simple number expression */
399 eop
->offset
+= vect
->value
;
402 if (eop
->wrt
== NO_SEG
&& !eop
->relative
&& vect
->type
== EXPR_WRT
) {
404 eop
->wrt
= vect
->value
;
408 if (!eop
->relative
&&
409 vect
->type
== EXPR_SEGBASE
+ myseg
&& vect
->value
== -1) {
410 /* Expression of the form: foo - $ */
411 eop
->relative
= true;
415 if (eop
->segment
== NO_SEG
&& vect
->type
>= EXPR_SEGBASE
&&
417 eop
->segment
= vect
->type
- EXPR_SEGBASE
;
421 /* Otherwise, badness */
425 /* We got to the end and it was all okay */
429 insn
*parse_line(int pass
, char *buffer
, insn
*result
, ldfunc ldef
)
431 bool insn_is_label
= false;
432 struct eval_hints hints
;
441 result
->forw_ref
= false;
445 i
= stdscan(NULL
, &tokval
);
447 nasm_static_assert(P_none
== 0);
448 memset(result
->prefixes
, P_none
, sizeof(result
->prefixes
));
449 result
->times
= 1; /* No TIMES either yet */
450 result
->label
= NULL
; /* Assume no label */
451 result
->eops
= NULL
; /* must do this, whatever happens */
452 result
->operands
= 0; /* must initialize this */
453 result
->evex_rm
= 0; /* Ensure EVEX rounding mode is reset */
454 result
->evex_brerop
= -1; /* Reset EVEX broadcasting/ER op position */
456 /* Ignore blank lines */
463 (i
!= TOKEN_REG
|| !IS_SREG(tokval
.t_integer
))) {
464 nasm_error(ERR_NONFATAL
,
465 "label or instruction expected at start of line");
469 if (i
== TOKEN_ID
|| (insn_is_label
&& i
== TOKEN_INSN
)) {
470 /* there's a label here */
472 result
->label
= tokval
.t_charptr
;
473 i
= stdscan(NULL
, &tokval
);
474 if (i
== ':') { /* skip over the optional colon */
475 i
= stdscan(NULL
, &tokval
);
477 nasm_error(ERR_WARNING
| ERR_WARN_OL
| ERR_PASS1
,
478 "label alone on a line without a colon might be in error");
480 if (i
!= TOKEN_INSN
|| tokval
.t_integer
!= I_EQU
) {
482 * FIXME: location.segment could be NO_SEG, in which case
483 * it is possible we should be passing 'absolute.segment'. Look into this.
484 * Work out whether that is *really* what we should be doing.
485 * Generally fix things. I think this is right as it is, but
486 * am still not certain.
488 ldef(result
->label
, in_absolute
? absolute
.segment
: location
.segment
,
489 location
.offset
, NULL
, true, false);
493 /* Just a label here */
497 while (i
== TOKEN_PREFIX
||
498 (i
== TOKEN_REG
&& IS_SREG(tokval
.t_integer
))) {
502 * Handle special case: the TIMES prefix.
504 if (i
== TOKEN_PREFIX
&& tokval
.t_integer
== P_TIMES
) {
507 i
= stdscan(NULL
, &tokval
);
508 value
= evaluate(stdscan
, NULL
, &tokval
, NULL
, pass0
, NULL
);
510 if (!value
) /* Error in evaluator */
512 if (!is_simple(value
)) {
513 nasm_error(ERR_NONFATAL
,
514 "non-constant argument supplied to TIMES");
517 result
->times
= value
->value
;
518 if (value
->value
< 0) {
519 nasm_error(ERR_NONFATAL
|ERR_PASS2
, "TIMES value %"PRId64
" is negative", value
->value
);
524 int slot
= prefix_slot(tokval
.t_integer
);
525 if (result
->prefixes
[slot
]) {
526 if (result
->prefixes
[slot
] == tokval
.t_integer
)
527 nasm_error(ERR_WARNING
| ERR_PASS1
,
528 "instruction has redundant prefixes");
530 nasm_error(ERR_NONFATAL
,
531 "instruction has conflicting prefixes");
533 result
->prefixes
[slot
] = tokval
.t_integer
;
534 i
= stdscan(NULL
, &tokval
);
538 if (i
!= TOKEN_INSN
) {
542 for (j
= 0; j
< MAXPREFIX
; j
++) {
543 if ((pfx
= result
->prefixes
[j
]) != P_none
)
547 if (i
== 0 && pfx
!= P_none
) {
549 * Instruction prefixes are present, but no actual
550 * instruction. This is allowed: at this point we
551 * invent a notional instruction of RESB 0.
553 result
->opcode
= I_RESB
;
554 result
->operands
= 1;
555 nasm_zero(result
->oprs
);
556 result
->oprs
[0].type
= IMMEDIATE
;
557 result
->oprs
[0].offset
= 0L;
558 result
->oprs
[0].segment
= result
->oprs
[0].wrt
= NO_SEG
;
561 nasm_error(ERR_NONFATAL
, "parser: instruction expected");
566 result
->opcode
= tokval
.t_integer
;
567 result
->condition
= tokval
.t_inttwo
;
570 * INCBIN cannot be satisfied with incorrectly
571 * evaluated operands, since the correct values _must_ be known
572 * on the first pass. Hence, even in pass one, we set the
573 * `critical' flag on calling evaluate(), so that it will bomb
574 * out on undefined symbols.
576 if (result
->opcode
== I_INCBIN
) {
577 critical
= (pass0
< 2 ? 1 : 2);
580 critical
= (pass
== 2 ? 2 : 0);
582 if (opcode_is_db(result
->opcode
) || result
->opcode
== I_INCBIN
) {
583 extop
*eop
, **tail
= &result
->eops
, **fixptr
;
587 result
->eops_float
= false;
590 * Begin to read the DB/DW/DD/DQ/DT/DO/DY/DZ/INCBIN operands.
593 i
= stdscan(NULL
, &tokval
);
596 else if (first
&& i
== ':') {
597 insn_is_label
= true;
602 eop
= *tail
= nasm_malloc(sizeof(extop
));
605 eop
->type
= EOT_NOTHING
;
610 * is_comma_next() here is to distinguish this from
611 * a string used as part of an expression...
613 if (i
== TOKEN_STR
&& is_comma_next()) {
614 eop
->type
= EOT_DB_STRING
;
615 eop
->stringval
= tokval
.t_charptr
;
616 eop
->stringlen
= tokval
.t_inttwo
;
617 i
= stdscan(NULL
, &tokval
); /* eat the comma */
618 } else if (i
== TOKEN_STRFUNC
) {
620 const char *funcname
= tokval
.t_charptr
;
621 enum strfunc func
= tokval
.t_integer
;
622 i
= stdscan(NULL
, &tokval
);
625 i
= stdscan(NULL
, &tokval
);
627 if (i
!= TOKEN_STR
) {
628 nasm_error(ERR_NONFATAL
,
629 "%s must be followed by a string constant",
631 eop
->type
= EOT_NOTHING
;
633 eop
->type
= EOT_DB_STRING_FREE
;
635 string_transform(tokval
.t_charptr
, tokval
.t_inttwo
,
636 &eop
->stringval
, func
);
637 if (eop
->stringlen
== (size_t)-1) {
638 nasm_error(ERR_NONFATAL
, "invalid string for transform");
639 eop
->type
= EOT_NOTHING
;
642 if (parens
&& i
&& i
!= ')') {
643 i
= stdscan(NULL
, &tokval
);
645 nasm_error(ERR_NONFATAL
, "unterminated %s function",
650 i
= stdscan(NULL
, &tokval
);
651 } else if (i
== '-' || i
== '+') {
652 char *save
= stdscan_get();
654 sign
= (i
== '-') ? -1 : 1;
655 i
= stdscan(NULL
, &tokval
);
656 if (i
!= TOKEN_FLOAT
) {
658 i
= tokval
.t_type
= token
;
663 } else if (i
== TOKEN_FLOAT
) {
665 eop
->type
= EOT_DB_STRING
;
666 result
->eops_float
= true;
668 eop
->stringlen
= db_bytes(result
->opcode
);
669 if (eop
->stringlen
> 16) {
670 nasm_error(ERR_NONFATAL
, "floating-point constant"
671 " encountered in DY or DZ instruction");
673 } else if (eop
->stringlen
< 1) {
674 nasm_error(ERR_NONFATAL
, "floating-point constant"
675 " encountered in unknown instruction");
677 * fix suggested by Pedro Gimeno... original line was:
678 * eop->type = EOT_NOTHING;
683 eop
= nasm_realloc(eop
, sizeof(extop
) + eop
->stringlen
);
686 eop
->stringval
= (char *)eop
+ sizeof(extop
);
687 if (!eop
->stringlen
||
688 !float_const(tokval
.t_charptr
, sign
,
689 (uint8_t *)eop
->stringval
, eop
->stringlen
))
690 eop
->type
= EOT_NOTHING
;
691 i
= stdscan(NULL
, &tokval
); /* eat the comma */
693 /* anything else, assume it is an expression */
697 value
= evaluate(stdscan
, NULL
, &tokval
, NULL
,
700 if (!value
) /* Error in evaluator */
702 if (value_to_extop(value
, eop
, location
.segment
)) {
703 nasm_error(ERR_NONFATAL
,
704 "operand %d: expression is not simple or relocatable",
710 * We're about to call stdscan(), which will eat the
711 * comma that we're currently sitting on between
712 * arguments. However, we'd better check first that it
715 if (i
== TOKEN_EOS
) /* also could be EOL */
718 nasm_error(ERR_NONFATAL
, "comma expected after operand %d",
724 if (result
->opcode
== I_INCBIN
) {
726 * Correct syntax for INCBIN is that there should be
727 * one string operand, followed by one or two numeric
730 if (!result
->eops
|| result
->eops
->type
!= EOT_DB_STRING
)
731 nasm_error(ERR_NONFATAL
, "`incbin' expects a file name");
732 else if (result
->eops
->next
&&
733 result
->eops
->next
->type
!= EOT_DB_NUMBER
)
734 nasm_error(ERR_NONFATAL
, "`incbin': second parameter is"
736 else if (result
->eops
->next
&& result
->eops
->next
->next
&&
737 result
->eops
->next
->next
->type
!= EOT_DB_NUMBER
)
738 nasm_error(ERR_NONFATAL
, "`incbin': third parameter is"
740 else if (result
->eops
->next
&& result
->eops
->next
->next
&&
741 result
->eops
->next
->next
->next
)
742 nasm_error(ERR_NONFATAL
,
743 "`incbin': more than three parameters");
747 * If we reach here, one of the above errors happened.
748 * Throw the instruction away.
751 } else /* DB ... */ if (oper_num
== 0)
752 nasm_error(ERR_WARNING
| ERR_PASS1
,
753 "no operand for data declaration");
755 result
->operands
= oper_num
;
761 * Now we begin to parse the operands. There may be up to four
762 * of these, separated by commas, and terminated by a zero token.
765 for (opnum
= 0; opnum
< MAX_OPERANDS
; opnum
++) {
766 operand
*op
= &result
->oprs
[opnum
];
767 expr
*value
; /* used most of the time */
768 bool mref
; /* is this going to be a memory ref? */
769 bool bracket
; /* is it a [] mref, or a & mref? */
770 bool mib
; /* compound (mib) mref? */
772 decoflags_t brace_flags
= 0; /* flags for decorators in braces */
774 op
->disp_size
= 0; /* have to zero this whatever */
775 op
->eaflags
= 0; /* and this */
779 i
= stdscan(NULL
, &tokval
);
781 break; /* end of operands: get out of here */
782 else if (first
&& i
== ':') {
783 insn_is_label
= true;
787 op
->type
= 0; /* so far, no override */
788 while (i
== TOKEN_SPECIAL
) { /* size specifiers */
789 switch (tokval
.t_integer
) {
791 if (!setsize
) /* we want to use only the first */
847 nasm_error(ERR_NONFATAL
, "invalid operand size specification");
849 i
= stdscan(NULL
, &tokval
);
852 if (i
== '[' || i
== '&') { /* memory reference */
854 bracket
= (i
== '[');
855 i
= stdscan(NULL
, &tokval
); /* then skip the colon */
856 while (i
== TOKEN_SPECIAL
|| i
== TOKEN_PREFIX
) {
857 process_size_override(result
, op
);
858 i
= stdscan(NULL
, &tokval
);
860 /* when a comma follows an opening bracket - [ , eax*4] */
862 /* treat as if there is a zero displacement virtually */
863 tokval
.t_type
= TOKEN_NUM
;
864 tokval
.t_integer
= 0;
865 stdscan_set(stdscan_get() - 1); /* rewind the comma */
867 } else { /* immediate operand, or register */
869 bracket
= false; /* placate optimisers */
872 if ((op
->type
& FAR
) && !mref
&&
873 result
->opcode
!= I_JMP
&& result
->opcode
!= I_CALL
) {
874 nasm_error(ERR_NONFATAL
, "invalid use of FAR operand specifier");
877 value
= evaluate(stdscan
, NULL
, &tokval
,
878 &op
->opflags
, critical
, &hints
);
880 if (op
->opflags
& OPFLAG_FORWARD
) {
881 result
->forw_ref
= true;
883 if (!value
) /* Error in evaluator */
885 if (i
== ':' && mref
) { /* it was seg:offset */
887 * Process the segment override.
889 if (value
[1].type
!= 0 ||
891 !IS_SREG(value
->type
))
892 nasm_error(ERR_NONFATAL
, "invalid segment override");
893 else if (result
->prefixes
[PPS_SEG
])
894 nasm_error(ERR_NONFATAL
,
895 "instruction has conflicting segment overrides");
897 result
->prefixes
[PPS_SEG
] = value
->type
;
898 if (IS_FSGS(value
->type
))
899 op
->eaflags
|= EAF_FSGS
;
902 i
= stdscan(NULL
, &tokval
); /* then skip the colon */
903 while (i
== TOKEN_SPECIAL
|| i
== TOKEN_PREFIX
) {
904 process_size_override(result
, op
);
905 i
= stdscan(NULL
, &tokval
);
907 value
= evaluate(stdscan
, NULL
, &tokval
,
908 &op
->opflags
, critical
, &hints
);
910 if (op
->opflags
& OPFLAG_FORWARD
) {
911 result
->forw_ref
= true;
913 /* and get the offset */
914 if (!value
) /* Error in evaluator */
919 if (mref
&& bracket
&& i
== ',') {
920 /* [seg:base+offset,index*scale] syntax (mib) */
922 operand o1
, o2
; /* Partial operands */
924 if (parse_mref(&o1
, value
))
927 i
= stdscan(NULL
, &tokval
); /* Eat comma */
928 value
= evaluate(stdscan
, NULL
, &tokval
, &op
->opflags
,
934 if (parse_mref(&o2
, value
))
937 if (o2
.basereg
!= -1 && o2
.indexreg
== -1) {
938 o2
.indexreg
= o2
.basereg
;
943 if (o1
.indexreg
!= -1 || o2
.basereg
!= -1 || o2
.offset
!= 0 ||
944 o2
.segment
!= NO_SEG
|| o2
.wrt
!= NO_SEG
) {
945 nasm_error(ERR_NONFATAL
, "invalid mib expression");
949 op
->basereg
= o1
.basereg
;
950 op
->indexreg
= o2
.indexreg
;
951 op
->scale
= o2
.scale
;
952 op
->offset
= o1
.offset
;
953 op
->segment
= o1
.segment
;
956 if (op
->basereg
!= -1) {
957 op
->hintbase
= op
->basereg
;
958 op
->hinttype
= EAH_MAKEBASE
;
959 } else if (op
->indexreg
!= -1) {
960 op
->hintbase
= op
->indexreg
;
961 op
->hinttype
= EAH_NOTBASE
;
964 op
->hinttype
= EAH_NOHINT
;
971 if (mref
&& bracket
) { /* find ] at the end */
973 nasm_error(ERR_NONFATAL
, "parser: expecting ]");
975 } else { /* we got the required ] */
976 i
= stdscan(NULL
, &tokval
);
977 if (i
== TOKEN_DECORATOR
|| i
== TOKEN_OPMASK
) {
978 /* parse opmask (and zeroing) after an operand */
979 recover
= parse_braces(&brace_flags
);
982 if (i
!= 0 && i
!= ',') {
983 nasm_error(ERR_NONFATAL
, "comma or end of line expected");
987 } else { /* immediate operand */
988 if (i
!= 0 && i
!= ',' && i
!= ':' &&
989 i
!= TOKEN_DECORATOR
&& i
!= TOKEN_OPMASK
) {
990 nasm_error(ERR_NONFATAL
, "comma, colon, decorator or end of "
991 "line expected after operand");
993 } else if (i
== ':') {
995 } else if (i
== TOKEN_DECORATOR
|| i
== TOKEN_OPMASK
) {
996 /* parse opmask (and zeroing) after an operand */
997 recover
= parse_braces(&brace_flags
);
1001 do { /* error recovery */
1002 i
= stdscan(NULL
, &tokval
);
1003 } while (i
!= 0 && i
!= ',');
1007 * now convert the exprs returned from evaluate()
1008 * into operand descriptions...
1010 op
->decoflags
|= brace_flags
;
1012 if (mref
) { /* it's a memory reference */
1013 /* A mib reference was fully parsed already */
1015 if (parse_mref(op
, value
))
1017 op
->hintbase
= hints
.base
;
1018 op
->hinttype
= hints
.type
;
1020 mref_set_optype(op
);
1021 } else { /* it's not a memory reference */
1022 if (is_just_unknown(value
)) { /* it's immediate but unknown */
1023 op
->type
|= IMMEDIATE
;
1024 op
->opflags
|= OPFLAG_UNKNOWN
;
1025 op
->offset
= 0; /* don't care */
1026 op
->segment
= NO_SEG
; /* don't care again */
1027 op
->wrt
= NO_SEG
; /* still don't care */
1029 if(optimizing
>= 0 && !(op
->type
& STRICT
)) {
1032 UNITY
| SBYTEWORD
| SBYTEDWORD
| UDWORD
| SDWORD
;
1034 } else if (is_reloc(value
)) { /* it's immediate */
1035 uint64_t n
= reloc_value(value
);
1037 op
->type
|= IMMEDIATE
;
1039 op
->segment
= reloc_seg(value
);
1040 op
->wrt
= reloc_wrt(value
);
1041 op
->opflags
|= is_self_relative(value
) ? OPFLAG_RELATIVE
: 0;
1043 if (is_simple(value
)) {
1046 if (optimizing
>= 0 && !(op
->type
& STRICT
)) {
1047 if ((uint32_t) (n
+ 128) <= 255)
1048 op
->type
|= SBYTEDWORD
;
1049 if ((uint16_t) (n
+ 128) <= 255)
1050 op
->type
|= SBYTEWORD
;
1051 if (n
<= UINT64_C(0xFFFFFFFF))
1053 if (n
+ UINT64_C(0x80000000) <= UINT64_C(0xFFFFFFFF))
1057 } else if (value
->type
== EXPR_RDSAE
) {
1059 * it's not an operand but a rounding or SAE decorator.
1060 * put the decorator information in the (opflag_t) type field
1061 * of previous operand.
1064 switch (value
->value
) {
1070 op
->decoflags
|= (value
->value
== BRC_SAE
? SAE
: ER
);
1071 result
->evex_rm
= value
->value
;
1074 nasm_error(ERR_NONFATAL
, "invalid decorator");
1077 } else { /* it's a register */
1080 if (value
->type
>= EXPR_SIMPLE
|| value
->value
!= 1) {
1081 nasm_error(ERR_NONFATAL
, "invalid operand type");
1086 * check that its only 1 register, not an expression...
1088 for (i
= 1; value
[i
].type
; i
++)
1089 if (value
[i
].value
) {
1090 nasm_error(ERR_NONFATAL
, "invalid operand type");
1094 /* clear overrides, except TO which applies to FPU regs */
1095 if (op
->type
& ~TO
) {
1097 * we want to produce a warning iff the specified size
1098 * is different from the register size
1100 rs
= op
->type
& SIZE_MASK
;
1105 op
->type
|= REGISTER
;
1106 op
->type
|= nasm_reg_flags
[value
->type
];
1107 op
->decoflags
|= brace_flags
;
1108 op
->basereg
= value
->type
;
1110 if (rs
&& (op
->type
& SIZE_MASK
) != rs
)
1111 nasm_error(ERR_WARNING
| ERR_PASS1
,
1112 "register size specification ignored");
1116 /* remember the position of operand having broadcasting/ER mode */
1117 if (op
->decoflags
& (BRDCAST_MASK
| ER
| SAE
))
1118 result
->evex_brerop
= opnum
;
1121 result
->operands
= opnum
; /* set operand count */
1123 /* clear remaining operands */
1124 while (opnum
< MAX_OPERANDS
)
1125 result
->oprs
[opnum
++].type
= 0;
1128 * Transform RESW, RESD, RESQ, REST, RESO, RESY, RESZ into RESB.
1130 if (opcode_is_resb(result
->opcode
)) {
1131 result
->oprs
[0].offset
*= resb_bytes(result
->opcode
);
1132 result
->oprs
[0].offset
*= result
->times
;
1134 result
->opcode
= I_RESB
;
1140 result
->opcode
= I_none
;
1144 static int is_comma_next(void)
1151 i
= stdscan(NULL
, &tv
);
1154 return (i
== ',' || i
== ';' || !i
);
1157 void cleanup_insn(insn
* i
)
1161 while ((e
= i
->eops
)) {
1163 if (e
->type
== EOT_DB_STRING_FREE
)
1164 nasm_free(e
->stringval
);