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