?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
parser: support split base,index effective address
[nasm/avx512.git] / parser.c
blob697c72704d0601da1a0ee7d8fca7c85afe81231f
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2013 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
10 *
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.
17 *
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.
31 *
32 * ----------------------------------------------------------------------- */
33
34 /*
35 * parser.c source line parser for the Netwide Assembler
36 */
37
38 #include "compiler.h"
39
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <stddef.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <inttypes.h>
46
47 #include "nasm.h"
48 #include "insns.h"
49 #include "nasmlib.h"
50 #include "stdscan.h"
51 #include "eval.h"
52 #include "parser.h"
53 #include "float.h"
54 #include "tables.h"
55
56 extern int in_abs_seg; /* ABSOLUTE segment flag */
57 extern int32_t abs_seg; /* ABSOLUTE segment */
58 extern int32_t abs_offset; /* ABSOLUTE segment offset */
59
60 static int is_comma_next(void);
61
62 static int i;
63 static struct tokenval tokval;
64 static struct location *location; /* Pointer to current line's segment,offset */
65
66 void parser_global_info(struct location * locp)
67 {
68 location = locp;
69 }
70
71 static int prefix_slot(int prefix)
72 {
73 switch (prefix) {
74 case P_WAIT:
75 return PPS_WAIT;
76 case R_CS:
77 case R_DS:
78 case R_SS:
79 case R_ES:
80 case R_FS:
81 case R_GS:
82 return PPS_SEG;
83 case P_LOCK:
84 return PPS_LOCK;
85 case P_REP:
86 case P_REPE:
87 case P_REPZ:
88 case P_REPNE:
89 case P_REPNZ:
90 case P_XACQUIRE:
91 case P_XRELEASE:
92 return PPS_REP;
93 case P_O16:
94 case P_O32:
95 case P_O64:
96 case P_OSP:
97 return PPS_OSIZE;
98 case P_A16:
99 case P_A32:
100 case P_A64:
101 case P_ASP:
102 return PPS_ASIZE;
103 default:
104 nasm_error(ERR_PANIC, "Invalid value %d passed to prefix_slot()", prefix);
105 return -1;
106 }
107 }
108
109 static void process_size_override(insn *result, operand *op)
110 {
111 if (tasm_compatible_mode) {
112 switch ((int)tokval.t_integer) {
113 /* For TASM compatibility a size override inside the
114 * brackets changes the size of the operand, not the
115 * address type of the operand as it does in standard
116 * NASM syntax. Hence:
117 *
118 * mov eax,[DWORD val]
119 *
120 * is valid syntax in TASM compatibility mode. Note that
121 * you lose the ability to override the default address
122 * type for the instruction, but we never use anything
123 * but 32-bit flat model addressing in our code.
124 */
125 case S_BYTE:
126 op->type |= BITS8;
127 break;
128 case S_WORD:
129 op->type |= BITS16;
130 break;
131 case S_DWORD:
132 case S_LONG:
133 op->type |= BITS32;
134 break;
135 case S_QWORD:
136 op->type |= BITS64;
137 break;
138 case S_TWORD:
139 op->type |= BITS80;
140 break;
141 case S_OWORD:
142 op->type |= BITS128;
143 break;
144 default:
145 nasm_error(ERR_NONFATAL,
146 "invalid operand size specification");
147 break;
148 }
149 } else {
150 /* Standard NASM compatible syntax */
151 switch ((int)tokval.t_integer) {
152 case S_NOSPLIT:
153 op->eaflags |= EAF_TIMESTWO;
154 break;
155 case S_REL:
156 op->eaflags |= EAF_REL;
157 break;
158 case S_ABS:
159 op->eaflags |= EAF_ABS;
160 break;
161 case S_BYTE:
162 op->disp_size = 8;
163 op->eaflags |= EAF_BYTEOFFS;
164 break;
165 case P_A16:
166 case P_A32:
167 case P_A64:
168 if (result->prefixes[PPS_ASIZE] &&
169 result->prefixes[PPS_ASIZE] != tokval.t_integer)
170 nasm_error(ERR_NONFATAL,
171 "conflicting address size specifications");
172 else
173 result->prefixes[PPS_ASIZE] = tokval.t_integer;
174 break;
175 case S_WORD:
176 op->disp_size = 16;
177 op->eaflags |= EAF_WORDOFFS;
178 break;
179 case S_DWORD:
180 case S_LONG:
181 op->disp_size = 32;
182 op->eaflags |= EAF_WORDOFFS;
183 break;
184 case S_QWORD:
185 op->disp_size = 64;
186 op->eaflags |= EAF_WORDOFFS;
187 break;
188 default:
189 nasm_error(ERR_NONFATAL, "invalid size specification in"
190 " effective address");
191 break;
192 }
193 }
194 }
195
196 /*
197 * when two or more decorators follow a register operand,
198 * consecutive decorators are parsed here.
199 * opmask and zeroing decorators can be placed in any order.
200 * e.g. zmm1 {k2}{z} or zmm2 {z,k3}
201 * decorator(s) are placed at the end of an operand.
202 */
203 static bool parse_braces(decoflags_t *decoflags)
204 {
205 int i;
206 bool recover = false;
207
208 i = tokval.t_type;
209 do {
210 if (i == TOKEN_OPMASK) {
211 if (*decoflags & OPMASK_MASK) {
212 nasm_error(ERR_NONFATAL, "opmask k%lu is already set",
213 *decoflags & OPMASK_MASK);
214 *decoflags &= ~OPMASK_MASK;
215 }
216 *decoflags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
217 } else if (i == TOKEN_DECORATOR) {
218 switch (tokval.t_integer) {
219 case BRC_Z:
220 /*
221 * according to AVX512 spec, only zeroing/merging decorator
222 * is supported with opmask
223 */
224 *decoflags |= GEN_Z(0);
225 break;
226 default:
227 nasm_error(ERR_NONFATAL, "{%s} is not an expected decorator",
228 tokval.t_charptr);
229 break;
230 }
231 } else if (i == ',' || i == TOKEN_EOS){
232 break;
233 } else {
234 nasm_error(ERR_NONFATAL, "only a series of valid decorators"
235 " expected");
236 recover = true;
237 break;
238 }
239 i = stdscan(NULL, &tokval);
240 } while(1);
241
242 return recover;
243 }
244
245 static int parse_mref(operand *op, const expr *e)
246 {
247 int b, i, s; /* basereg, indexreg, scale */
248 int64_t o; /* offset */
249
250 b = i = -1;
251 o = s = 0;
252
253 if (e->type && e->type <= EXPR_REG_END) { /* this bit's a register */
254 bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
255
256 if (is_gpr && e->value == 1)
257 b = e->type; /* It can be basereg */
258 else /* No, it has to be indexreg */
259 i = e->type, s = e->value;
260 e++;
261 }
262 if (e->type && e->type <= EXPR_REG_END) { /* it's a 2nd register */
263 bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
264
265 if (b != -1) /* If the first was the base, ... */
266 i = e->type, s = e->value; /* second has to be indexreg */
267
268 else if (!is_gpr || e->value != 1) {
269 /* If both want to be index */
270 nasm_error(ERR_NONFATAL,
271 "invalid effective address: two index registers");
272 return -1;
273 } else
274 b = e->type;
275 e++;
276 }
277 if (e->type != 0) { /* is there an offset? */
278 if (e->type <= EXPR_REG_END) { /* in fact, is there an error? */
279 nasm_error(ERR_NONFATAL,
280 "beroset-p-603-invalid effective address");
281 return -1;
282 } else {
283 if (e->type == EXPR_UNKNOWN) {
284 op->opflags |= OPFLAG_UNKNOWN;
285 o = 0; /* doesn't matter what */
286 op->wrt = NO_SEG; /* nor this */
287 op->segment = NO_SEG; /* or this */
288 while (e->type)
289 e++; /* go to the end of the line */
290 } else {
291 if (e->type == EXPR_SIMPLE) {
292 o = e->value;
293 e++;
294 }
295 if (e->type == EXPR_WRT) {
296 op->wrt = e->value;
297 e++;
298 } else
299 op->wrt = NO_SEG;
300 /*
301 * Look for a segment base type.
302 */
303 if (e->type && e->type < EXPR_SEGBASE) {
304 nasm_error(ERR_NONFATAL,
305 "beroset-p-630-invalid effective address");
306 return -1;
307 }
308 while (e->type && e->value == 0)
309 e++;
310 if (e->type && e->value != 1) {
311 nasm_error(ERR_NONFATAL,
312 "beroset-p-637-invalid effective address");
313 return -1;
314 }
315 if (e->type) {
316 op->segment = e->type - EXPR_SEGBASE;
317 e++;
318 } else
319 op->segment = NO_SEG;
320 while (e->type && e->value == 0)
321 e++;
322 if (e->type) {
323 nasm_error(ERR_NONFATAL,
324 "beroset-p-650-invalid effective address");
325 return -1;
326 }
327 }
328 }
329 } else {
330 o = 0;
331 op->wrt = NO_SEG;
332 op->segment = NO_SEG;
333 }
334
335 if (e->type != 0) { /* there'd better be nothing left! */
336 nasm_error(ERR_NONFATAL,
337 "beroset-p-663-invalid effective address");
338 return -1;
339 }
340
341 op->basereg = b;
342 op->indexreg = i;
343 op->scale = s;
344 op->offset = o;
345 return 0;
346 }
347
348 static void mref_set_optype(operand *op)
349 {
350 int b = op->basereg;
351 int i = op->indexreg;
352 int s = op->scale;
353
354 /* It is memory, but it can match any r/m operand */
355 op->type |= MEMORY_ANY;
356
357 if (b == -1 && (i == -1 || s == 0)) {
358 int is_rel = globalbits == 64 &&
359 !(op->eaflags & EAF_ABS) &&
360 ((globalrel &&
361 !(op->eaflags & EAF_FSGS)) ||
362 (op->eaflags & EAF_REL));
363
364 op->type |= is_rel ? IP_REL : MEM_OFFS;
365 }
366
367 if (i != -1) {
368 opflags_t iclass = nasm_reg_flags[i];
369
370 if (is_class(XMMREG,iclass))
371 op->type |= XMEM;
372 else if (is_class(YMMREG,iclass))
373 op->type |= YMEM;
374 else if (is_class(ZMMREG,iclass))
375 op->type |= ZMEM;
376 }
377 }
378
379 insn *parse_line(int pass, char *buffer, insn *result, ldfunc ldef)
380 {
381 bool insn_is_label = false;
382 struct eval_hints hints;
383 int opnum;
384 int critical;
385 bool first;
386 bool recover;
387
388 restart_parse:
389 first = true;
390 result->forw_ref = false;
391
392 stdscan_reset();
393 stdscan_set(buffer);
394 i = stdscan(NULL, &tokval);
395
396 result->label = NULL; /* Assume no label */
397 result->eops = NULL; /* must do this, whatever happens */
398 result->operands = 0; /* must initialize this */
399 result->evex_rm = 0; /* Ensure EVEX rounding mode is reset */
400 result->evex_brerop = -1; /* Reset EVEX broadcasting/ER op position */
401
402 /* Ignore blank lines */
403 if (i == TOKEN_EOS)
404 goto fail;
405
406 if (i != TOKEN_ID &&
407 i != TOKEN_INSN &&
408 i != TOKEN_PREFIX &&
409 (i != TOKEN_REG || !IS_SREG(tokval.t_integer))) {
410 nasm_error(ERR_NONFATAL,
411 "label or instruction expected at start of line");
412 goto fail;
413 }
414
415 if (i == TOKEN_ID || (insn_is_label && i == TOKEN_INSN)) {
416 /* there's a label here */
417 first = false;
418 result->label = tokval.t_charptr;
419 i = stdscan(NULL, &tokval);
420 if (i == ':') { /* skip over the optional colon */
421 i = stdscan(NULL, &tokval);
422 } else if (i == 0) {
423 nasm_error(ERR_WARNING | ERR_WARN_OL | ERR_PASS1,
424 "label alone on a line without a colon might be in error");
425 }
426 if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
427 /*
428 * FIXME: location->segment could be NO_SEG, in which case
429 * it is possible we should be passing 'abs_seg'. Look into this.
430 * Work out whether that is *really* what we should be doing.
431 * Generally fix things. I think this is right as it is, but
432 * am still not certain.
433 */
434 ldef(result->label, in_abs_seg ? abs_seg : location->segment,
435 location->offset, NULL, true, false);
436 }
437 }
438
439 /* Just a label here */
440 if (i == TOKEN_EOS)
441 goto fail;
442
443 nasm_build_assert(P_none != 0);
444 memset(result->prefixes, P_none, sizeof(result->prefixes));
445 result->times = 1L;
446
447 while (i == TOKEN_PREFIX ||
448 (i == TOKEN_REG && IS_SREG(tokval.t_integer))) {
449 first = false;
450
451 /*
452 * Handle special case: the TIMES prefix.
453 */
454 if (i == TOKEN_PREFIX && tokval.t_integer == P_TIMES) {
455 expr *value;
456
457 i = stdscan(NULL, &tokval);
458 value = evaluate(stdscan, NULL, &tokval, NULL, pass0, nasm_error, NULL);
459 i = tokval.t_type;
460 if (!value) /* Error in evaluator */
461 goto fail;
462 if (!is_simple(value)) {
463 nasm_error(ERR_NONFATAL,
464 "non-constant argument supplied to TIMES");
465 result->times = 1L;
466 } else {
467 result->times = value->value;
468 if (value->value < 0 && pass0 == 2) {
469 nasm_error(ERR_NONFATAL, "TIMES value %"PRId64" is negative",
470 value->value);
471 result->times = 0;
472 }
473 }
474 } else {
475 int slot = prefix_slot(tokval.t_integer);
476 if (result->prefixes[slot]) {
477 if (result->prefixes[slot] == tokval.t_integer)
478 nasm_error(ERR_WARNING | ERR_PASS1,
479 "instruction has redundant prefixes");
480 else
481 nasm_error(ERR_NONFATAL,
482 "instruction has conflicting prefixes");
483 }
484 result->prefixes[slot] = tokval.t_integer;
485 i = stdscan(NULL, &tokval);
486 }
487 }
488
489 if (i != TOKEN_INSN) {
490 int j;
491 enum prefixes pfx;
492
493 for (j = 0; j < MAXPREFIX; j++) {
494 if ((pfx = result->prefixes[j]) != P_none)
495 break;
496 }
497
498 if (i == 0 && pfx != P_none) {
499 /*
500 * Instruction prefixes are present, but no actual
501 * instruction. This is allowed: at this point we
502 * invent a notional instruction of RESB 0.
503 */
504 result->opcode = I_RESB;
505 result->operands = 1;
506 result->oprs[0].type = IMMEDIATE;
507 result->oprs[0].offset = 0L;
508 result->oprs[0].segment = result->oprs[0].wrt = NO_SEG;
509 return result;
510 } else {
511 nasm_error(ERR_NONFATAL, "parser: instruction expected");
512 goto fail;
513 }
514 }
515
516 result->opcode = tokval.t_integer;
517 result->condition = tokval.t_inttwo;
518
519 /*
520 * INCBIN cannot be satisfied with incorrectly
521 * evaluated operands, since the correct values _must_ be known
522 * on the first pass. Hence, even in pass one, we set the
523 * `critical' flag on calling evaluate(), so that it will bomb
524 * out on undefined symbols.
525 */
526 if (result->opcode == I_INCBIN) {
527 critical = (pass0 < 2 ? 1 : 2);
528
529 } else
530 critical = (pass == 2 ? 2 : 0);
531
532 if (result->opcode == I_DB || result->opcode == I_DW ||
533 result->opcode == I_DD || result->opcode == I_DQ ||
534 result->opcode == I_DT || result->opcode == I_DO ||
535 result->opcode == I_DY || result->opcode == I_INCBIN) {
536 extop *eop, **tail = &result->eops, **fixptr;
537 int oper_num = 0;
538 int32_t sign;
539
540 result->eops_float = false;
541
542 /*
543 * Begin to read the DB/DW/DD/DQ/DT/DO/INCBIN operands.
544 */
545 while (1) {
546 i = stdscan(NULL, &tokval);
547 if (i == TOKEN_EOS)
548 break;
549 else if (first && i == ':') {
550 insn_is_label = true;
551 goto restart_parse;
552 }
553 first = false;
554 fixptr = tail;
555 eop = *tail = nasm_malloc(sizeof(extop));
556 tail = &eop->next;
557 eop->next = NULL;
558 eop->type = EOT_NOTHING;
559 oper_num++;
560 sign = +1;
561
562 /*
563 * is_comma_next() here is to distinguish this from
564 * a string used as part of an expression...
565 */
566 if (i == TOKEN_STR && is_comma_next()) {
567 eop->type = EOT_DB_STRING;
568 eop->stringval = tokval.t_charptr;
569 eop->stringlen = tokval.t_inttwo;
570 i = stdscan(NULL, &tokval); /* eat the comma */
571 } else if (i == TOKEN_STRFUNC) {
572 bool parens = false;
573 const char *funcname = tokval.t_charptr;
574 enum strfunc func = tokval.t_integer;
575 i = stdscan(NULL, &tokval);
576 if (i == '(') {
577 parens = true;
578 i = stdscan(NULL, &tokval);
579 }
580 if (i != TOKEN_STR) {
581 nasm_error(ERR_NONFATAL,
582 "%s must be followed by a string constant",
583 funcname);
584 eop->type = EOT_NOTHING;
585 } else {
586 eop->type = EOT_DB_STRING_FREE;
587 eop->stringlen =
588 string_transform(tokval.t_charptr, tokval.t_inttwo,
589 &eop->stringval, func);
590 if (eop->stringlen == (size_t)-1) {
591 nasm_error(ERR_NONFATAL, "invalid string for transform");
592 eop->type = EOT_NOTHING;
593 }
594 }
595 if (parens && i && i != ')') {
596 i = stdscan(NULL, &tokval);
597 if (i != ')') {
598 nasm_error(ERR_NONFATAL, "unterminated %s function",
599 funcname);
600 }
601 }
602 if (i && i != ',')
603 i = stdscan(NULL, &tokval);
604 } else if (i == '-' || i == '+') {
605 char *save = stdscan_get();
606 int token = i;
607 sign = (i == '-') ? -1 : 1;
608 i = stdscan(NULL, &tokval);
609 if (i != TOKEN_FLOAT) {
610 stdscan_set(save);
611 i = tokval.t_type = token;
612 goto is_expression;
613 } else {
614 goto is_float;
615 }
616 } else if (i == TOKEN_FLOAT) {
617 is_float:
618 eop->type = EOT_DB_STRING;
619 result->eops_float = true;
620
621 eop->stringlen = idata_bytes(result->opcode);
622 if (eop->stringlen > 16) {
623 nasm_error(ERR_NONFATAL, "floating-point constant"
624 " encountered in DY instruction");
625 eop->stringlen = 0;
626 } else if (eop->stringlen < 1) {
627 nasm_error(ERR_NONFATAL, "floating-point constant"
628 " encountered in unknown instruction");
629 /*
630 * fix suggested by Pedro Gimeno... original line was:
631 * eop->type = EOT_NOTHING;
632 */
633 eop->stringlen = 0;
634 }
635
636 eop = nasm_realloc(eop, sizeof(extop) + eop->stringlen);
637 tail = &eop->next;
638 *fixptr = eop;
639 eop->stringval = (char *)eop + sizeof(extop);
640 if (!eop->stringlen ||
641 !float_const(tokval.t_charptr, sign,
642 (uint8_t *)eop->stringval,
643 eop->stringlen, nasm_error))
644 eop->type = EOT_NOTHING;
645 i = stdscan(NULL, &tokval); /* eat the comma */
646 } else {
647 /* anything else, assume it is an expression */
648 expr *value;
649
650 is_expression:
651 value = evaluate(stdscan, NULL, &tokval, NULL,
652 critical, nasm_error, NULL);
653 i = tokval.t_type;
654 if (!value) /* Error in evaluator */
655 goto fail;
656 if (is_unknown(value)) {
657 eop->type = EOT_DB_NUMBER;
658 eop->offset = 0; /* doesn't matter what we put */
659 eop->segment = eop->wrt = NO_SEG; /* likewise */
660 } else if (is_reloc(value)) {
661 eop->type = EOT_DB_NUMBER;
662 eop->offset = reloc_value(value);
663 eop->segment = reloc_seg(value);
664 eop->wrt = reloc_wrt(value);
665 } else {
666 nasm_error(ERR_NONFATAL,
667 "operand %d: expression is not simple"
668 " or relocatable", oper_num);
669 }
670 }
671
672 /*
673 * We're about to call stdscan(), which will eat the
674 * comma that we're currently sitting on between
675 * arguments. However, we'd better check first that it
676 * _is_ a comma.
677 */
678 if (i == TOKEN_EOS) /* also could be EOL */
679 break;
680 if (i != ',') {
681 nasm_error(ERR_NONFATAL, "comma expected after operand %d",
682 oper_num);
683 goto fail;
684 }
685 }
686
687 if (result->opcode == I_INCBIN) {
688 /*
689 * Correct syntax for INCBIN is that there should be
690 * one string operand, followed by one or two numeric
691 * operands.
692 */
693 if (!result->eops || result->eops->type != EOT_DB_STRING)
694 nasm_error(ERR_NONFATAL, "`incbin' expects a file name");
695 else if (result->eops->next &&
696 result->eops->next->type != EOT_DB_NUMBER)
697 nasm_error(ERR_NONFATAL, "`incbin': second parameter is"
698 " non-numeric");
699 else if (result->eops->next && result->eops->next->next &&
700 result->eops->next->next->type != EOT_DB_NUMBER)
701 nasm_error(ERR_NONFATAL, "`incbin': third parameter is"
702 " non-numeric");
703 else if (result->eops->next && result->eops->next->next &&
704 result->eops->next->next->next)
705 nasm_error(ERR_NONFATAL,
706 "`incbin': more than three parameters");
707 else
708 return result;
709 /*
710 * If we reach here, one of the above errors happened.
711 * Throw the instruction away.
712 */
713 goto fail;
714 } else /* DB ... */ if (oper_num == 0)
715 nasm_error(ERR_WARNING | ERR_PASS1,
716 "no operand for data declaration");
717 else
718 result->operands = oper_num;
719
720 return result;
721 }
722
723 /*
724 * Now we begin to parse the operands. There may be up to four
725 * of these, separated by commas, and terminated by a zero token.
726 */
727
728 for (opnum = 0; opnum < MAX_OPERANDS; opnum++) {
729 operand *op = &result->oprs[opnum];
730 expr *value; /* used most of the time */
731 bool mref; /* is this going to be a memory ref? */
732 bool bracket; /* is it a [] mref, or a & mref? */
733 bool mib; /* compound (mib) mref? */
734 int setsize = 0;
735 decoflags_t brace_flags = 0; /* flags for decorators in braces */
736
737 op->disp_size = 0; /* have to zero this whatever */
738 op->eaflags = 0; /* and this */
739 op->opflags = 0;
740 op->decoflags = 0;
741
742 i = stdscan(NULL, &tokval);
743 if (i == TOKEN_EOS)
744 break; /* end of operands: get out of here */
745 else if (first && i == ':') {
746 insn_is_label = true;
747 goto restart_parse;
748 }
749 first = false;
750 op->type = 0; /* so far, no override */
751 while (i == TOKEN_SPECIAL) { /* size specifiers */
752 switch ((int)tokval.t_integer) {
753 case S_BYTE:
754 if (!setsize) /* we want to use only the first */
755 op->type |= BITS8;
756 setsize = 1;
757 break;
758 case S_WORD:
759 if (!setsize)
760 op->type |= BITS16;
761 setsize = 1;
762 break;
763 case S_DWORD:
764 case S_LONG:
765 if (!setsize)
766 op->type |= BITS32;
767 setsize = 1;
768 break;
769 case S_QWORD:
770 if (!setsize)
771 op->type |= BITS64;
772 setsize = 1;
773 break;
774 case S_TWORD:
775 if (!setsize)
776 op->type |= BITS80;
777 setsize = 1;
778 break;
779 case S_OWORD:
780 if (!setsize)
781 op->type |= BITS128;
782 setsize = 1;
783 break;
784 case S_YWORD:
785 if (!setsize)
786 op->type |= BITS256;
787 setsize = 1;
788 break;
789 case S_ZWORD:
790 if (!setsize)
791 op->type |= BITS512;
792 setsize = 1;
793 break;
794 case S_TO:
795 op->type |= TO;
796 break;
797 case S_STRICT:
798 op->type |= STRICT;
799 break;
800 case S_FAR:
801 op->type |= FAR;
802 break;
803 case S_NEAR:
804 op->type |= NEAR;
805 break;
806 case S_SHORT:
807 op->type |= SHORT;
808 break;
809 default:
810 nasm_error(ERR_NONFATAL, "invalid operand size specification");
811 }
812 i = stdscan(NULL, &tokval);
813 }
814
815 if (i == '[' || i == '&') { /* memory reference */
816 mref = true;
817 bracket = (i == '[');
818 i = stdscan(NULL, &tokval); /* then skip the colon */
819 while (i == TOKEN_SPECIAL || i == TOKEN_PREFIX) {
820 process_size_override(result, op);
821 i = stdscan(NULL, &tokval);
822 }
823 } else { /* immediate operand, or register */
824 mref = false;
825 bracket = false; /* placate optimisers */
826 }
827
828 if ((op->type & FAR) && !mref &&
829 result->opcode != I_JMP && result->opcode != I_CALL) {
830 nasm_error(ERR_NONFATAL, "invalid use of FAR operand specifier");
831 }
832
833 value = evaluate(stdscan, NULL, &tokval,
834 &op->opflags,
835 critical, nasm_error, &hints);
836 i = tokval.t_type;
837 if (op->opflags & OPFLAG_FORWARD) {
838 result->forw_ref = true;
839 }
840 if (!value) /* Error in evaluator */
841 goto fail;
842 if (i == ':' && mref) { /* it was seg:offset */
843 /*
844 * Process the segment override.
845 */
846 if (value[1].type != 0 ||
847 value->value != 1 ||
848 !IS_SREG(value->type))
849 nasm_error(ERR_NONFATAL, "invalid segment override");
850 else if (result->prefixes[PPS_SEG])
851 nasm_error(ERR_NONFATAL,
852 "instruction has conflicting segment overrides");
853 else {
854 result->prefixes[PPS_SEG] = value->type;
855 if (IS_FSGS(value->type))
856 op->eaflags |= EAF_FSGS;
857 }
858
859 i = stdscan(NULL, &tokval); /* then skip the colon */
860 while (i == TOKEN_SPECIAL || i == TOKEN_PREFIX) {
861 process_size_override(result, op);
862 i = stdscan(NULL, &tokval);
863 }
864 value = evaluate(stdscan, NULL, &tokval,
865 &op->opflags,
866 critical, nasm_error, &hints);
867 i = tokval.t_type;
868 if (op->opflags & OPFLAG_FORWARD) {
869 result->forw_ref = true;
870 }
871 /* and get the offset */
872 if (!value) /* Error in evaluator */
873 goto fail;
874 }
875
876 mib = false;
877 if (mref && bracket && i == ',') {
878 /* [seg:base+offset,index*scale] syntax (mib) */
879
880 operand o1, o2; /* Partial operands */
881
882 if (parse_mref(&o1, value))
883 goto fail;
884
885 i = stdscan(NULL, &tokval); /* Eat comma */
886 value = evaluate(stdscan, NULL, &tokval, &op->opflags,
887 critical, nasm_error, &hints);
888 i = tokval.t_type;
889
890 if (parse_mref(&o2, value))
891 goto fail;
892
893 if (o2.basereg != -1 && o2.indexreg == -1) {
894 o2.indexreg = o2.basereg;
895 o2.scale = 1;
896 o2.basereg = -1;
897 }
898
899 if (o1.indexreg != -1 || o2.basereg != -1 || o2.offset != 0 ||
900 o2.segment != NO_SEG || o2.wrt != NO_SEG) {
901 nasm_error(ERR_NONFATAL, "invalid mib expression");
902 goto fail;
903 }
904
905 op->basereg = o1.basereg;
906 op->indexreg = o2.indexreg;
907 op->scale = o2.scale;
908 op->offset = o1.offset;
909 op->segment = o1.segment;
910 op->wrt = o1.wrt;
911
912 if (op->basereg != -1) {
913 op->hintbase = op->basereg;
914 op->hinttype = EAH_MAKEBASE;
915 } else if (op->indexreg != -1) {
916 op->hintbase = op->indexreg;
917 op->hinttype = EAH_NOTBASE;
918 } else {
919 op->hintbase = -1;
920 op->hinttype = EAH_NOHINT;
921 }
922
923 mib = true;
924 }
925
926 recover = false;
927 if (mref && bracket) { /* find ] at the end */
928 if (i != ']') {
929 nasm_error(ERR_NONFATAL, "parser: expecting ]");
930 recover = true;
931 } else { /* we got the required ] */
932 i = stdscan(NULL, &tokval);
933 if ((i == TOKEN_DECORATOR) || (i == TOKEN_OPMASK)) {
934 /*
935 * according to AVX512 spec, broacast or opmask decorator
936 * is expected for memory reference operands
937 */
938 if (tokval.t_flag & TFLAG_BRDCAST) {
939 brace_flags |= GEN_BRDCAST(0);
940 i = stdscan(NULL, &tokval);
941 } else if (i == TOKEN_OPMASK) {
942 brace_flags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
943 i = stdscan(NULL, &tokval);
944 } else {
945 nasm_error(ERR_NONFATAL, "broadcast or opmask "
946 "decorator expected inside braces");
947 recover = true;
948 }
949 }
950
951 if (i != 0 && i != ',') {
952 nasm_error(ERR_NONFATAL, "comma or end of line expected");
953 recover = true;
954 }
955 }
956 } else { /* immediate operand */
957 if (i != 0 && i != ',' && i != ':' &&
958 i != TOKEN_DECORATOR && i != TOKEN_OPMASK) {
959 nasm_error(ERR_NONFATAL, "comma, colon, decorator or end of "
960 "line expected after operand");
961 recover = true;
962 } else if (i == ':') {
963 op->type |= COLON;
964 } else if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
965 /* parse opmask (and zeroing) after an operand */
966 recover = parse_braces(&brace_flags);
967 }
968 }
969 if (recover) {
970 do { /* error recovery */
971 i = stdscan(NULL, &tokval);
972 } while (i != 0 && i != ',');
973 }
974
975 /*
976 * now convert the exprs returned from evaluate()
977 * into operand descriptions...
978 */
979 op->decoflags |= brace_flags;
980
981 if (mref) { /* it's a memory reference */
982 /* A mib reference was fully parsed already */
983 if (!mib) {
984 if (parse_mref(op, value))
985 goto fail;
986 op->hintbase = hints.base;
987 op->hinttype = hints.type;
988 }
989 mref_set_optype(op);
990 } else { /* it's not a memory reference */
991 if (is_just_unknown(value)) { /* it's immediate but unknown */
992 op->type |= IMMEDIATE;
993 op->opflags |= OPFLAG_UNKNOWN;
994 op->offset = 0; /* don't care */
995 op->segment = NO_SEG; /* don't care again */
996 op->wrt = NO_SEG; /* still don't care */
997
998 if(optimizing >= 0 && !(op->type & STRICT)) {
999 /* Be optimistic */
1000 op->type |=
1001 UNITY | SBYTEWORD | SBYTEDWORD | UDWORD | SDWORD;
1002 }
1003 } else if (is_reloc(value)) { /* it's immediate */
1004 op->type |= IMMEDIATE;
1005 op->offset = reloc_value(value);
1006 op->segment = reloc_seg(value);
1007 op->wrt = reloc_wrt(value);
1008
1009 if (is_simple(value)) {
1010 uint64_t n = reloc_value(value);
1011 if (n == 1)
1012 op->type |= UNITY;
1013 if (optimizing >= 0 &&
1014 !(op->type & STRICT)) {
1015 if ((uint32_t) (n + 128) <= 255)
1016 op->type |= SBYTEDWORD;
1017 if ((uint16_t) (n + 128) <= 255)
1018 op->type |= SBYTEWORD;
1019 if (n <= 0xFFFFFFFF)
1020 op->type |= UDWORD;
1021 if (n + 0x80000000 <= 0xFFFFFFFF)
1022 op->type |= SDWORD;
1023 }
1024 }
1025 } else if(value->type == EXPR_RDSAE) {
1026 /*
1027 * it's not an operand but a rounding or SAE decorator.
1028 * put the decorator information in the (opflag_t) type field
1029 * of previous operand.
1030 */
1031 opnum--; op--;
1032 switch (value->value) {
1033 case BRC_RN:
1034 case BRC_RU:
1035 case BRC_RD:
1036 case BRC_RZ:
1037 case BRC_SAE:
1038 op->decoflags |= (value->value == BRC_SAE ? SAE : ER);
1039 result->evex_rm = value->value;
1040 break;
1041 default:
1042 nasm_error(ERR_NONFATAL, "invalid decorator");
1043 break;
1044 }
1045 } else { /* it's a register */
1046 opflags_t rs;
1047
1048 if (value->type >= EXPR_SIMPLE || value->value != 1) {
1049 nasm_error(ERR_NONFATAL, "invalid operand type");
1050 goto fail;
1051 }
1052
1053 /*
1054 * check that its only 1 register, not an expression...
1055 */
1056 for (i = 1; value[i].type; i++)
1057 if (value[i].value) {
1058 nasm_error(ERR_NONFATAL, "invalid operand type");
1059 goto fail;
1060 }
1061
1062 /* clear overrides, except TO which applies to FPU regs */
1063 if (op->type & ~TO) {
1064 /*
1065 * we want to produce a warning iff the specified size
1066 * is different from the register size
1067 */
1068 rs = op->type & SIZE_MASK;
1069 } else
1070 rs = 0;
1071
1072 op->type &= TO;
1073 op->type |= REGISTER;
1074 op->type |= nasm_reg_flags[value->type];
1075 op->decoflags |= brace_flags;
1076 op->basereg = value->type;
1077
1078 if (rs && (op->type & SIZE_MASK) != rs)
1079 nasm_error(ERR_WARNING | ERR_PASS1,
1080 "register size specification ignored");
1081 }
1082 }
1083
1084 /* remember the position of operand having broadcasting/ER mode */
1085 if (op->decoflags & (BRDCAST_MASK | ER | SAE))
1086 result->evex_brerop = opnum;
1087 }
1088
1089 result->operands = opnum; /* set operand count */
1090
1091 /* clear remaining operands */
1092 while (opnum < MAX_OPERANDS)
1093 result->oprs[opnum++].type = 0;
1094
1095 /*
1096 * Transform RESW, RESD, RESQ, REST, RESO, RESY into RESB.
1097 */
1098 switch (result->opcode) {
1099 case I_RESW:
1100 result->opcode = I_RESB;
1101 result->oprs[0].offset *= 2;
1102 break;
1103 case I_RESD:
1104 result->opcode = I_RESB;
1105 result->oprs[0].offset *= 4;
1106 break;
1107 case I_RESQ:
1108 result->opcode = I_RESB;
1109 result->oprs[0].offset *= 8;
1110 break;
1111 case I_REST:
1112 result->opcode = I_RESB;
1113 result->oprs[0].offset *= 10;
1114 break;
1115 case I_RESO:
1116 result->opcode = I_RESB;
1117 result->oprs[0].offset *= 16;
1118 break;
1119 case I_RESY:
1120 result->opcode = I_RESB;
1121 result->oprs[0].offset *= 32;
1122 break;
1123 default:
1124 break;
1125 }
1126
1127 return result;
1128
1129 fail:
1130 result->opcode = I_none;
1131 return result;
1132 }
1133
1134 static int is_comma_next(void)
1135 {
1136 struct tokenval tv;
1137 char *p;
1138 int i;
1139
1140 p = stdscan_get();
1141 i = stdscan(NULL, &tv);
1142 stdscan_set(p);
1143
1144 return (i == ',' || i == ';' || !i);
1145 }
1146
1147 void cleanup_insn(insn * i)
1148 {
1149 extop *e;
1150
1151 while ((e = i->eops)) {
1152 i->eops = e->next;
1153 if (e->type == EOT_DB_STRING_FREE)
1154 nasm_free(e->stringval);
1155 nasm_free(e);
1156 }
1157 }
Adding AVX-512 features