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