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