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