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