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