1 /* parser.c source line parser for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
8 * initial version 27/iii/95 by Simon Tatham
22 static long reg_flags
[] = { /* sizes and special flags */
23 0, REG8
, REG_AL
, REG_AX
, REG8
, REG8
, REG16
, REG16
, REG8
, REG_CL
,
24 REG_CREG
, REG_CREG
, REG_CREG
, REG_CR4
, REG_CS
, REG_CX
, REG8
,
25 REG16
, REG8
, REG_DREG
, REG_DREG
, REG_DREG
, REG_DREG
, REG_DREG
,
26 REG_DREG
, REG_DESS
, REG_DX
, REG_EAX
, REG32
, REG32
, REG_ECX
,
27 REG32
, REG32
, REG_DESS
, REG32
, REG32
, REG_FSGS
, REG_FSGS
,
28 MMXREG
, MMXREG
, MMXREG
, MMXREG
, MMXREG
, MMXREG
, MMXREG
, MMXREG
,
29 REG16
, REG16
, REG_DESS
, FPU0
, FPUREG
, FPUREG
, FPUREG
, FPUREG
,
30 FPUREG
, FPUREG
, FPUREG
, REG_TREG
, REG_TREG
, REG_TREG
, REG_TREG
,
32 XMMREG
, XMMREG
, XMMREG
, XMMREG
, XMMREG
, XMMREG
, XMMREG
, XMMREG
35 enum { /* special tokens */
36 S_BYTE
, S_DWORD
, S_FAR
, S_LONG
, S_NEAR
, S_NOSPLIT
, S_QWORD
,
37 S_SHORT
, S_STRICT
, S_TO
, S_TWORD
, S_WORD
40 static int is_comma_next (void);
43 static struct tokenval tokval
;
45 static struct ofmt
*outfmt
; /* Structure of addresses of output routines */
46 static loc_t
*location
; /* Pointer to current line's segment,offset */
48 void parser_global_info (struct ofmt
*output
, loc_t
*locp
)
54 insn
*parse_line (int pass
, char *buffer
, insn
*result
,
55 efunc errfunc
, evalfunc evaluate
, ldfunc ldef
)
59 struct eval_hints hints
;
61 result
->forw_ref
= FALSE
;
65 stdscan_bufptr
= buffer
;
66 i
= stdscan(NULL
, &tokval
);
68 result
->label
= NULL
; /* Assume no label */
69 result
->eops
= NULL
; /* must do this, whatever happens */
70 result
->operands
= 0; /* must initialise this */
72 if (i
==0) { /* blank line - ignore */
73 result
->opcode
= -1; /* and no instruction either */
76 if (i
!= TOKEN_ID
&& i
!= TOKEN_INSN
&& i
!= TOKEN_PREFIX
&&
77 (i
!=TOKEN_REG
|| (REG_SREG
& ~reg_flags
[tokval
.t_integer
]))) {
78 error (ERR_NONFATAL
, "label or instruction expected"
84 if (i
== TOKEN_ID
) { /* there's a label here */
85 result
->label
= tokval
.t_charptr
;
86 i
= stdscan(NULL
, &tokval
);
87 if (i
== ':') { /* skip over the optional colon */
88 i
= stdscan(NULL
, &tokval
);
90 error (ERR_WARNING
|ERR_WARN_OL
|ERR_PASS1
,
91 "label alone on a line without a colon might be in error");
93 if (i
!= TOKEN_INSN
|| tokval
.t_integer
!= I_EQU
)
96 * FIXME: location->segment could be NO_SEG, in which case
97 * it is possible we should be passing 'abs_seg'. Look into this.
98 * Work out whether that is *really* what we should be doing.
99 * Generally fix things. I think this is right as it is, but
100 * am still not certain.
102 ldef (result
->label
, location
->segment
,
103 location
->offset
, NULL
, TRUE
, FALSE
, outfmt
, errfunc
);
108 result
->opcode
= -1; /* this line contains just a label */
115 while (i
== TOKEN_PREFIX
||
116 (i
==TOKEN_REG
&& !(REG_SREG
& ~reg_flags
[tokval
.t_integer
])))
119 * Handle special case: the TIMES prefix.
121 if (i
== TOKEN_PREFIX
&& tokval
.t_integer
== P_TIMES
) {
124 i
= stdscan(NULL
, &tokval
);
125 value
= evaluate (stdscan
, NULL
, &tokval
, NULL
, pass0
, error
, NULL
);
127 if (!value
) { /* but, error in evaluator */
128 result
->opcode
= -1; /* unrecoverable parse error: */
129 return result
; /* ignore this instruction */
131 if (!is_simple (value
)) {
133 "non-constant argument supplied to TIMES");
136 result
->times
= value
->value
;
137 if (value
->value
< 0) {
138 error(ERR_NONFATAL
, "TIMES value %d is negative",
144 if (result
->nprefix
== MAXPREFIX
)
146 "instruction has more than %d prefixes", MAXPREFIX
);
148 result
->prefixes
[result
->nprefix
++] = tokval
.t_integer
;
149 i
= stdscan(NULL
, &tokval
);
153 if (i
!= TOKEN_INSN
) {
154 if (result
->nprefix
> 0 && i
== 0) {
156 * Instruction prefixes are present, but no actual
157 * instruction. This is allowed: at this point we
158 * invent a notional instruction of RESB 0.
160 result
->opcode
= I_RESB
;
161 result
->operands
= 1;
162 result
->oprs
[0].type
= IMMEDIATE
;
163 result
->oprs
[0].offset
= 0L;
164 result
->oprs
[0].segment
= result
->oprs
[0].wrt
= NO_SEG
;
167 error (ERR_NONFATAL
, "parser: instruction expected");
173 result
->opcode
= tokval
.t_integer
;
174 result
->condition
= tokval
.t_inttwo
;
177 * RESB, RESW and RESD cannot be satisfied with incorrectly
178 * evaluated operands, since the correct values _must_ be known
179 * on the first pass. Hence, even in pass one, we set the
180 * `critical' flag on calling evaluate(), so that it will bomb
181 * out on undefined symbols. Nasty, but there's nothing we can
184 * For the moment, EQU has the same difficulty, so we'll
187 if (result
->opcode
== I_RESB
||
188 result
->opcode
== I_RESW
||
189 result
->opcode
== I_RESD
||
190 result
->opcode
== I_RESQ
||
191 result
->opcode
== I_REST
||
192 result
->opcode
== I_EQU
||
193 result
->opcode
== I_INCBIN
) /* fbk */
198 critical
= (pass
==2 ? 2 : 0);
200 if (result
->opcode
== I_DB
||
201 result
->opcode
== I_DW
||
202 result
->opcode
== I_DD
||
203 result
->opcode
== I_DQ
||
204 result
->opcode
== I_DT
||
205 result
->opcode
== I_INCBIN
)
207 extop
*eop
, **tail
= &result
->eops
, **fixptr
;
210 result
->eops_float
= FALSE
;
213 * Begin to read the DB/DW/DD/DQ/DT/INCBIN operands.
216 i
= stdscan(NULL
, &tokval
);
220 eop
= *tail
= nasm_malloc(sizeof(extop
));
223 eop
->type
= EOT_NOTHING
;
226 if (i
== TOKEN_NUM
&& tokval
.t_charptr
&& is_comma_next()) {
227 eop
->type
= EOT_DB_STRING
;
228 eop
->stringval
= tokval
.t_charptr
;
229 eop
->stringlen
= tokval
.t_inttwo
;
230 i
= stdscan(NULL
, &tokval
); /* eat the comma */
234 if ((i
== TOKEN_FLOAT
&& is_comma_next()) || i
== '-') {
238 char *save
= stdscan_bufptr
;
239 i
= stdscan(NULL
, &tokval
);
241 if (i
!= TOKEN_FLOAT
|| !is_comma_next()) {
242 stdscan_bufptr
= save
;
243 i
= tokval
.t_type
= '-';
247 if (i
== TOKEN_FLOAT
) {
248 eop
->type
= EOT_DB_STRING
;
249 result
->eops_float
= TRUE
;
250 if (result
->opcode
== I_DD
)
252 else if (result
->opcode
== I_DQ
)
254 else if (result
->opcode
== I_DT
)
257 error(ERR_NONFATAL
, "floating-point constant"
258 " encountered in `D%c' instruction",
259 result
->opcode
== I_DW
? 'W' : 'B');
261 * fix suggested by Pedro Gimeno... original line
263 * eop->type = EOT_NOTHING;
267 eop
= nasm_realloc(eop
, sizeof(extop
)+eop
->stringlen
);
270 eop
->stringval
= (char *)eop
+ sizeof(extop
);
271 if (eop
->stringlen
< 4 ||
272 !float_const (tokval
.t_charptr
, sign
,
273 (unsigned char *)eop
->stringval
,
274 eop
->stringlen
, error
))
275 eop
->type
= EOT_NOTHING
;
276 i
= stdscan(NULL
, &tokval
); /* eat the comma */
284 value
= evaluate (stdscan
, NULL
, &tokval
, NULL
,
285 critical
, error
, NULL
);
287 if (!value
) { /* error in evaluator */
288 result
->opcode
= -1;/* unrecoverable parse error: */
289 return result
; /* ignore this instruction */
291 if (is_unknown(value
)) {
292 eop
->type
= EOT_DB_NUMBER
;
293 eop
->offset
= 0; /* doesn't matter what we put */
294 eop
->segment
= eop
->wrt
= NO_SEG
; /* likewise */
295 } else if (is_reloc(value
)) {
296 eop
->type
= EOT_DB_NUMBER
;
297 eop
->offset
= reloc_value(value
);
298 eop
->segment
= reloc_seg(value
);
299 eop
->wrt
= reloc_wrt(value
);
302 "operand %d: expression is not simple"
303 " or relocatable", oper_num
);
308 * We're about to call stdscan(), which will eat the
309 * comma that we're currently sitting on between
310 * arguments. However, we'd better check first that it
313 if (i
== 0) /* also could be EOL */
316 error (ERR_NONFATAL
, "comma expected after operand %d",
318 result
->opcode
= -1;/* unrecoverable parse error: */
319 return result
; /* ignore this instruction */
323 if (result
->opcode
== I_INCBIN
) {
325 * Correct syntax for INCBIN is that there should be
326 * one string operand, followed by one or two numeric
329 if (!result
->eops
|| result
->eops
->type
!= EOT_DB_STRING
)
330 error (ERR_NONFATAL
, "`incbin' expects a file name");
331 else if (result
->eops
->next
&&
332 result
->eops
->next
->type
!= EOT_DB_NUMBER
)
333 error (ERR_NONFATAL
, "`incbin': second parameter is",
335 else if (result
->eops
->next
&& result
->eops
->next
->next
&&
336 result
->eops
->next
->next
->type
!= EOT_DB_NUMBER
)
337 error (ERR_NONFATAL
, "`incbin': third parameter is",
339 else if (result
->eops
->next
&& result
->eops
->next
->next
&&
340 result
->eops
->next
->next
->next
)
341 error (ERR_NONFATAL
, "`incbin': more than three parameters");
345 * If we reach here, one of the above errors happened.
346 * Throw the instruction away.
352 error (ERR_WARNING
|ERR_PASS1
,
353 "no operand for data declaration");
355 result
->operands
= oper_num
;
360 /* right. Now we begin to parse the operands. There may be up to three
361 * of these, separated by commas, and terminated by a zero token. */
363 for (operand
= 0; operand
< 3; operand
++) {
364 expr
*value
; /* used most of the time */
365 int mref
; /* is this going to be a memory ref? */
366 int bracket
; /* is it a [] mref, or a & mref? */
369 result
->oprs
[operand
].addr_size
= 0;/* have to zero this whatever */
370 result
->oprs
[operand
].eaflags
= 0; /* and this */
371 result
->oprs
[operand
].opflags
= 0;
373 i
= stdscan(NULL
, &tokval
);
374 if (i
== 0) break; /* end of operands: get out of here */
375 result
->oprs
[operand
].type
= 0; /* so far, no override */
376 while (i
== TOKEN_SPECIAL
) {/* size specifiers */
377 switch ((int)tokval
.t_integer
) {
379 if (!setsize
) /* we want to use only the first */
380 result
->oprs
[operand
].type
|= BITS8
;
385 result
->oprs
[operand
].type
|= BITS16
;
391 result
->oprs
[operand
].type
|= BITS32
;
396 result
->oprs
[operand
].type
|= BITS64
;
401 result
->oprs
[operand
].type
|= BITS80
;
405 result
->oprs
[operand
].type
|= TO
;
408 result
->oprs
[operand
].type
|= STRICT
;
411 result
->oprs
[operand
].type
|= FAR
;
414 result
->oprs
[operand
].type
|= NEAR
;
417 result
->oprs
[operand
].type
|= SHORT
;
420 error (ERR_NONFATAL
, "invalid operand size specification");
422 i
= stdscan(NULL
, &tokval
);
425 if (i
== '[' || i
== '&') { /* memory reference */
427 bracket
= (i
== '[');
428 i
= stdscan(NULL
, &tokval
);
429 if (i
== TOKEN_SPECIAL
) { /* check for address size override */
430 if (tasm_compatible_mode
) {
431 switch ((int)tokval
.t_integer
) {
432 /* For TASM compatibility a size override inside the
433 * brackets changes the size of the operand, not the
434 * address type of the operand as it does in standard
435 * NASM syntax. Hence:
437 * mov eax,[DWORD val]
439 * is valid syntax in TASM compatibility mode. Note that
440 * you lose the ability to override the default address
441 * type for the instruction, but we never use anything
442 * but 32-bit flat model addressing in our code.
445 result
->oprs
[operand
].type
|= BITS8
;
448 result
->oprs
[operand
].type
|= BITS16
;
452 result
->oprs
[operand
].type
|= BITS32
;
455 result
->oprs
[operand
].type
|= BITS64
;
458 result
->oprs
[operand
].type
|= BITS80
;
461 error (ERR_NONFATAL
, "invalid operand size specification");
464 /* Standard NASM compatible syntax */
465 switch ((int)tokval
.t_integer
) {
467 result
->oprs
[operand
].eaflags
|= EAF_TIMESTWO
;
470 result
->oprs
[operand
].eaflags
|= EAF_BYTEOFFS
;
473 result
->oprs
[operand
].addr_size
= 16;
474 result
->oprs
[operand
].eaflags
|= EAF_WORDOFFS
;
478 result
->oprs
[operand
].addr_size
= 32;
479 result
->oprs
[operand
].eaflags
|= EAF_WORDOFFS
;
482 error (ERR_NONFATAL
, "invalid size specification in"
483 " effective address");
486 i
= stdscan(NULL
, &tokval
);
488 } else { /* immediate operand, or register */
490 bracket
= FALSE
; /* placate optimisers */
493 value
= evaluate (stdscan
, NULL
, &tokval
,
494 &result
->oprs
[operand
].opflags
,
495 critical
, error
, &hints
);
497 if (result
->oprs
[operand
].opflags
& OPFLAG_FORWARD
) {
498 result
->forw_ref
= TRUE
;
500 if (!value
) { /* error in evaluator */
501 result
->opcode
= -1; /* unrecoverable parse error: */
502 return result
; /* ignore this instruction */
504 if (i
== ':' && mref
) { /* it was seg:offset */
506 * Process the segment override.
508 if (value
[1].type
!=0 || value
->value
!=1 ||
509 REG_SREG
& ~reg_flags
[value
->type
])
510 error (ERR_NONFATAL
, "invalid segment override");
511 else if (result
->nprefix
== MAXPREFIX
)
513 "instruction has more than %d prefixes",
516 result
->prefixes
[result
->nprefix
++] = value
->type
;
518 i
= stdscan(NULL
, &tokval
); /* then skip the colon */
519 if (i
== TOKEN_SPECIAL
) { /* another check for size override */
520 switch ((int)tokval
.t_integer
) {
522 result
->oprs
[operand
].addr_size
= 16;
526 result
->oprs
[operand
].addr_size
= 32;
529 error (ERR_NONFATAL
, "invalid size specification in"
530 " effective address");
532 i
= stdscan(NULL
, &tokval
);
534 value
= evaluate (stdscan
, NULL
, &tokval
,
535 &result
->oprs
[operand
].opflags
,
536 critical
, error
, &hints
);
538 if (result
->oprs
[operand
].opflags
& OPFLAG_FORWARD
) {
539 result
->forw_ref
= TRUE
;
541 /* and get the offset */
542 if (!value
) { /* but, error in evaluator */
543 result
->opcode
= -1; /* unrecoverable parse error: */
544 return result
; /* ignore this instruction */
547 if (mref
&& bracket
) { /* find ] at the end */
549 error (ERR_NONFATAL
, "parser: expecting ]");
550 do { /* error recovery again */
551 i
= stdscan(NULL
, &tokval
);
552 } while (i
!= 0 && i
!= ',');
553 } else /* we got the required ] */
554 i
= stdscan(NULL
, &tokval
);
555 } else { /* immediate operand */
556 if (i
!= 0 && i
!= ',' && i
!= ':') {
557 error (ERR_NONFATAL
, "comma or end of line expected");
558 do { /* error recovery */
559 i
= stdscan(NULL
, &tokval
);
560 } while (i
!= 0 && i
!= ',');
561 } else if (i
== ':') {
562 result
->oprs
[operand
].type
|= COLON
;
566 /* now convert the exprs returned from evaluate() into operand
569 if (mref
) { /* it's a memory reference */
571 int b
, i
, s
; /* basereg, indexreg, scale */
574 b
= i
= -1, o
= s
= 0;
575 result
->oprs
[operand
].hintbase
= hints
.base
;
576 result
->oprs
[operand
].hinttype
= hints
.type
;
578 if (e
->type
<= EXPR_REG_END
) { /* this bit's a register */
579 if (e
->value
== 1) /* in fact it can be basereg */
581 else /* no, it has to be indexreg */
582 i
= e
->type
, s
= e
->value
;
585 if (e
->type
&& e
->type
<= EXPR_REG_END
) /* it's a 2nd register */
587 if (b
!= -1) /* If the first was the base, ... */
588 i
= e
->type
, s
= e
->value
; /* second has to be indexreg */
590 else if (e
->value
!= 1) /* If both want to be index */
592 error(ERR_NONFATAL
, "beroset-p-592-invalid effective address");
600 if (e
->type
!= 0) { /* is there an offset? */
601 if (e
->type
<= EXPR_REG_END
) /* in fact, is there an error? */
603 error (ERR_NONFATAL
, "beroset-p-603-invalid effective address");
609 if (e
->type
== EXPR_UNKNOWN
) {
610 o
= 0; /* doesn't matter what */
611 result
->oprs
[operand
].wrt
= NO_SEG
; /* nor this */
612 result
->oprs
[operand
].segment
= NO_SEG
; /* or this */
613 while (e
->type
) e
++; /* go to the end of the line */
617 if (e
->type
== EXPR_SIMPLE
) {
621 if (e
->type
== EXPR_WRT
) {
622 result
->oprs
[operand
].wrt
= e
->value
;
625 result
->oprs
[operand
].wrt
= NO_SEG
;
627 * Look for a segment base type.
629 if (e
->type
&& e
->type
< EXPR_SEGBASE
) {
630 error (ERR_NONFATAL
, "beroset-p-630-invalid effective address");
634 while (e
->type
&& e
->value
== 0)
636 if (e
->type
&& e
->value
!= 1) {
637 error (ERR_NONFATAL
, "beroset-p-637-invalid effective address");
642 result
->oprs
[operand
].segment
=
643 e
->type
- EXPR_SEGBASE
;
646 result
->oprs
[operand
].segment
= NO_SEG
;
647 while (e
->type
&& e
->value
== 0)
650 error (ERR_NONFATAL
, "beroset-p-650-invalid effective address");
658 result
->oprs
[operand
].wrt
= NO_SEG
;
659 result
->oprs
[operand
].segment
= NO_SEG
;
662 if (e
->type
!= 0) { /* there'd better be nothing left! */
663 error (ERR_NONFATAL
, "beroset-p-663-invalid effective address");
668 result
->oprs
[operand
].type
|= MEMORY
;
669 if (b
==-1 && (i
==-1 || s
==0))
670 result
->oprs
[operand
].type
|= MEM_OFFS
;
671 result
->oprs
[operand
].basereg
= b
;
672 result
->oprs
[operand
].indexreg
= i
;
673 result
->oprs
[operand
].scale
= s
;
674 result
->oprs
[operand
].offset
= o
;
676 else /* it's not a memory reference */
678 if (is_just_unknown(value
)) { /* it's immediate but unknown */
679 result
->oprs
[operand
].type
|= IMMEDIATE
;
680 result
->oprs
[operand
].offset
= 0; /* don't care */
681 result
->oprs
[operand
].segment
= NO_SEG
; /* don't care again */
682 result
->oprs
[operand
].wrt
= NO_SEG
;/* still don't care */
684 else if (is_reloc(value
)) /* it's immediate */
686 result
->oprs
[operand
].type
|= IMMEDIATE
;
687 result
->oprs
[operand
].offset
= reloc_value(value
);
688 result
->oprs
[operand
].segment
= reloc_seg(value
);
689 result
->oprs
[operand
].wrt
= reloc_wrt(value
);
690 if (is_simple(value
)) {
691 if (reloc_value(value
)==1)
692 result
->oprs
[operand
].type
|= UNITY
;
694 if (reloc_value(value
) >= -128 &&
695 reloc_value(value
) <= 127)
696 result
->oprs
[operand
].type
|= SBYTE
;
700 else /* it's a register */
702 if (value
->type
>=EXPR_SIMPLE
|| value
->value
!=1) {
703 error (ERR_NONFATAL
, "invalid operand type");
709 * check that its only 1 register, not an expression...
711 for (i
= 1; value
[i
].type
; i
++)
712 if (value
[i
].value
) {
713 error (ERR_NONFATAL
, "invalid operand type");
718 /* clear overrides, except TO which applies to FPU regs */
719 if (result
->oprs
[operand
].type
& ~TO
) {
721 * we want to produce a warning iff the specified size
722 * is different from the register size
724 i
= result
->oprs
[operand
].type
& SIZE_MASK
;
729 result
->oprs
[operand
].type
&= TO
;
730 result
->oprs
[operand
].type
|= REGISTER
;
731 result
->oprs
[operand
].type
|= reg_flags
[value
->type
];
732 result
->oprs
[operand
].basereg
= value
->type
;
734 if (i
&& (result
->oprs
[operand
].type
& SIZE_MASK
) != i
)
735 error (ERR_WARNING
|ERR_PASS1
,
736 "register size specification ignored");
741 result
->operands
= operand
; /* set operand count */
743 while (operand
<3) /* clear remaining operands */
744 result
->oprs
[operand
++].type
= 0;
747 * Transform RESW, RESD, RESQ, REST into RESB.
749 switch (result
->opcode
) {
750 case I_RESW
: result
->opcode
=I_RESB
; result
->oprs
[0].offset
*=2; break;
751 case I_RESD
: result
->opcode
=I_RESB
; result
->oprs
[0].offset
*=4; break;
752 case I_RESQ
: result
->opcode
=I_RESB
; result
->oprs
[0].offset
*=8; break;
753 case I_REST
: result
->opcode
=I_RESB
; result
->oprs
[0].offset
*=10; break;
759 static int is_comma_next (void)
766 i
= stdscan (NULL
, &tv
);
768 return (i
== ',' || i
== ';' || !i
);
771 void cleanup_insn (insn
*i
)
777 i
->eops
= i
->eops
->next
;