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