Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* m68k.y -- bison grammar for m68k operand parsing |
f7e42eb4 | 2 | Copyright 1995, 1996, 1997, 1998 Free Software Foundation, Inc. |
252b5132 RH |
3 | Written by Ken Raeburn and Ian Lance Taylor, Cygnus Support |
4 | ||
5 | This file is part of GAS, the GNU Assembler. | |
6 | ||
7 | GAS is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2, or (at your option) | |
10 | any later version. | |
11 | ||
12 | GAS is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with GAS; see the file COPYING. If not, write to the Free | |
19 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA | |
20 | 02111-1307, USA. */ | |
21 | ||
22 | /* This file holds a bison grammar to parse m68k operands. The m68k | |
23 | has a complicated operand syntax, and gas supports two main | |
24 | variations of it. Using a grammar is probably overkill, but at | |
25 | least it makes clear exactly what we do support. */ | |
26 | ||
27 | %{ | |
28 | ||
29 | #include "as.h" | |
30 | #include "tc-m68k.h" | |
31 | #include "m68k-parse.h" | |
32 | ||
33 | /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, | |
34 | etc), as well as gratuitiously global symbol names If other parser | |
35 | generators (bison, byacc, etc) produce additional global names that | |
36 | conflict at link time, then those parser generators need to be | |
37 | fixed instead of adding those names to this list. */ | |
38 | ||
39 | #define yymaxdepth m68k_maxdepth | |
40 | #define yyparse m68k_parse | |
41 | #define yylex m68k_lex | |
42 | #define yyerror m68k_error | |
43 | #define yylval m68k_lval | |
44 | #define yychar m68k_char | |
45 | #define yydebug m68k_debug | |
46 | #define yypact m68k_pact | |
47 | #define yyr1 m68k_r1 | |
48 | #define yyr2 m68k_r2 | |
49 | #define yydef m68k_def | |
50 | #define yychk m68k_chk | |
51 | #define yypgo m68k_pgo | |
52 | #define yyact m68k_act | |
53 | #define yyexca m68k_exca | |
54 | #define yyerrflag m68k_errflag | |
55 | #define yynerrs m68k_nerrs | |
56 | #define yyps m68k_ps | |
57 | #define yypv m68k_pv | |
58 | #define yys m68k_s | |
59 | #define yy_yys m68k_yys | |
60 | #define yystate m68k_state | |
61 | #define yytmp m68k_tmp | |
62 | #define yyv m68k_v | |
63 | #define yy_yyv m68k_yyv | |
64 | #define yyval m68k_val | |
65 | #define yylloc m68k_lloc | |
66 | #define yyreds m68k_reds /* With YYDEBUG defined */ | |
67 | #define yytoks m68k_toks /* With YYDEBUG defined */ | |
68 | #define yylhs m68k_yylhs | |
69 | #define yylen m68k_yylen | |
70 | #define yydefred m68k_yydefred | |
71 | #define yydgoto m68k_yydgoto | |
72 | #define yysindex m68k_yysindex | |
73 | #define yyrindex m68k_yyrindex | |
74 | #define yygindex m68k_yygindex | |
75 | #define yytable m68k_yytable | |
76 | #define yycheck m68k_yycheck | |
77 | ||
78 | #ifndef YYDEBUG | |
79 | #define YYDEBUG 1 | |
80 | #endif | |
81 | ||
82 | /* Internal functions. */ | |
83 | ||
84 | static enum m68k_register m68k_reg_parse PARAMS ((char **)); | |
85 | static int yylex PARAMS ((void)); | |
86 | static void yyerror PARAMS ((const char *)); | |
87 | ||
88 | /* The parser sets fields pointed to by this global variable. */ | |
89 | static struct m68k_op *op; | |
90 | ||
91 | %} | |
92 | ||
93 | %union | |
94 | { | |
95 | struct m68k_indexreg indexreg; | |
96 | enum m68k_register reg; | |
97 | struct m68k_exp exp; | |
98 | unsigned long mask; | |
99 | int onereg; | |
100 | } | |
101 | ||
102 | %token <reg> DR AR FPR FPCR LPC ZAR ZDR LZPC CREG | |
103 | %token <indexreg> INDEXREG | |
104 | %token <exp> EXPR | |
105 | ||
106 | %type <indexreg> zireg zdireg | |
107 | %type <reg> zadr zdr apc zapc zpc optzapc optczapc | |
108 | %type <exp> optcexpr optexprc | |
109 | %type <mask> reglist ireglist reglistpair | |
110 | %type <onereg> reglistreg | |
111 | ||
112 | %% | |
113 | ||
114 | /* An operand. */ | |
115 | ||
116 | operand: | |
117 | generic_operand | |
118 | | motorola_operand | |
119 | | mit_operand | |
120 | ; | |
121 | ||
122 | /* A generic operand. */ | |
123 | ||
124 | generic_operand: | |
125 | DR | |
126 | { | |
127 | op->mode = DREG; | |
128 | op->reg = $1; | |
129 | } | |
130 | | AR | |
131 | { | |
132 | op->mode = AREG; | |
133 | op->reg = $1; | |
134 | } | |
135 | | FPR | |
136 | { | |
137 | op->mode = FPREG; | |
138 | op->reg = $1; | |
139 | } | |
140 | | FPCR | |
141 | { | |
142 | op->mode = CONTROL; | |
143 | op->reg = $1; | |
144 | } | |
145 | | CREG | |
146 | { | |
147 | op->mode = CONTROL; | |
148 | op->reg = $1; | |
149 | } | |
150 | | EXPR | |
151 | { | |
152 | op->mode = ABSL; | |
153 | op->disp = $1; | |
154 | } | |
155 | | '#' EXPR | |
156 | { | |
157 | op->mode = IMMED; | |
158 | op->disp = $2; | |
159 | } | |
160 | | '&' EXPR | |
161 | { | |
162 | op->mode = IMMED; | |
163 | op->disp = $2; | |
164 | } | |
165 | | reglist | |
166 | { | |
167 | op->mode = REGLST; | |
168 | op->mask = $1; | |
169 | } | |
170 | ; | |
171 | ||
172 | /* An operand in Motorola syntax. This includes MRI syntax as well, | |
173 | which may or may not be different in that it permits commutativity | |
174 | of index and base registers, and permits an offset expression to | |
175 | appear inside or outside of the parentheses. */ | |
176 | ||
177 | motorola_operand: | |
178 | '(' AR ')' | |
179 | { | |
180 | op->mode = AINDR; | |
181 | op->reg = $2; | |
182 | } | |
183 | | '(' AR ')' '+' | |
184 | { | |
185 | op->mode = AINC; | |
186 | op->reg = $2; | |
187 | } | |
188 | | '-' '(' AR ')' | |
189 | { | |
190 | op->mode = ADEC; | |
191 | op->reg = $3; | |
192 | } | |
193 | | '(' EXPR ',' zapc ')' | |
194 | { | |
195 | op->reg = $4; | |
196 | op->disp = $2; | |
197 | if (($4 >= ZADDR0 && $4 <= ZADDR7) | |
198 | || $4 == ZPC) | |
199 | op->mode = BASE; | |
200 | else | |
201 | op->mode = DISP; | |
202 | } | |
203 | | '(' zapc ',' EXPR ')' | |
204 | { | |
205 | op->reg = $2; | |
206 | op->disp = $4; | |
207 | if (($2 >= ZADDR0 && $2 <= ZADDR7) | |
208 | || $2 == ZPC) | |
209 | op->mode = BASE; | |
210 | else | |
211 | op->mode = DISP; | |
212 | } | |
213 | | EXPR '(' zapc ')' | |
214 | { | |
215 | op->reg = $3; | |
216 | op->disp = $1; | |
217 | if (($3 >= ZADDR0 && $3 <= ZADDR7) | |
218 | || $3 == ZPC) | |
219 | op->mode = BASE; | |
220 | else | |
221 | op->mode = DISP; | |
222 | } | |
223 | | '(' LPC ')' | |
224 | { | |
225 | op->mode = DISP; | |
226 | op->reg = $2; | |
227 | } | |
228 | | '(' ZAR ')' | |
229 | { | |
230 | op->mode = BASE; | |
231 | op->reg = $2; | |
232 | } | |
233 | | '(' LZPC ')' | |
234 | { | |
235 | op->mode = BASE; | |
236 | op->reg = $2; | |
237 | } | |
238 | | '(' EXPR ',' zapc ',' zireg ')' | |
239 | { | |
240 | op->mode = BASE; | |
241 | op->reg = $4; | |
242 | op->disp = $2; | |
243 | op->index = $6; | |
244 | } | |
245 | | '(' EXPR ',' zapc ',' zpc ')' | |
246 | { | |
247 | if ($4 == PC || $4 == ZPC) | |
248 | yyerror (_("syntax error")); | |
249 | op->mode = BASE; | |
250 | op->reg = $6; | |
251 | op->disp = $2; | |
252 | op->index.reg = $4; | |
253 | op->index.size = SIZE_UNSPEC; | |
254 | op->index.scale = 1; | |
255 | } | |
256 | | '(' EXPR ',' zdireg optczapc ')' | |
257 | { | |
258 | op->mode = BASE; | |
259 | op->reg = $5; | |
260 | op->disp = $2; | |
261 | op->index = $4; | |
262 | } | |
263 | | '(' zdireg ',' EXPR ')' | |
264 | { | |
265 | op->mode = BASE; | |
266 | op->disp = $4; | |
267 | op->index = $2; | |
268 | } | |
269 | | EXPR '(' zapc ',' zireg ')' | |
270 | { | |
271 | op->mode = BASE; | |
272 | op->reg = $3; | |
273 | op->disp = $1; | |
274 | op->index = $5; | |
275 | } | |
276 | | '(' zapc ',' zireg ')' | |
277 | { | |
278 | op->mode = BASE; | |
279 | op->reg = $2; | |
280 | op->index = $4; | |
281 | } | |
282 | | EXPR '(' zapc ',' zpc ')' | |
283 | { | |
284 | if ($3 == PC || $3 == ZPC) | |
285 | yyerror (_("syntax error")); | |
286 | op->mode = BASE; | |
287 | op->reg = $5; | |
288 | op->disp = $1; | |
289 | op->index.reg = $3; | |
290 | op->index.size = SIZE_UNSPEC; | |
291 | op->index.scale = 1; | |
292 | } | |
293 | | '(' zapc ',' zpc ')' | |
294 | { | |
295 | if ($2 == PC || $2 == ZPC) | |
296 | yyerror (_("syntax error")); | |
297 | op->mode = BASE; | |
298 | op->reg = $4; | |
299 | op->index.reg = $2; | |
300 | op->index.size = SIZE_UNSPEC; | |
301 | op->index.scale = 1; | |
302 | } | |
303 | | EXPR '(' zdireg optczapc ')' | |
304 | { | |
305 | op->mode = BASE; | |
306 | op->reg = $4; | |
307 | op->disp = $1; | |
308 | op->index = $3; | |
309 | } | |
310 | | '(' zdireg optczapc ')' | |
311 | { | |
312 | op->mode = BASE; | |
313 | op->reg = $3; | |
314 | op->index = $2; | |
315 | } | |
316 | | '(' '[' EXPR optczapc ']' ',' zireg optcexpr ')' | |
317 | { | |
318 | op->mode = POST; | |
319 | op->reg = $4; | |
320 | op->disp = $3; | |
321 | op->index = $7; | |
322 | op->odisp = $8; | |
323 | } | |
324 | | '(' '[' EXPR optczapc ']' optcexpr ')' | |
325 | { | |
326 | op->mode = POST; | |
327 | op->reg = $4; | |
328 | op->disp = $3; | |
329 | op->odisp = $6; | |
330 | } | |
331 | | '(' '[' zapc ']' ',' zireg optcexpr ')' | |
332 | { | |
333 | op->mode = POST; | |
334 | op->reg = $3; | |
335 | op->index = $6; | |
336 | op->odisp = $7; | |
337 | } | |
338 | | '(' '[' zapc ']' optcexpr ')' | |
339 | { | |
340 | op->mode = POST; | |
341 | op->reg = $3; | |
342 | op->odisp = $5; | |
343 | } | |
344 | | '(' '[' EXPR ',' zapc ',' zireg ']' optcexpr ')' | |
345 | { | |
346 | op->mode = PRE; | |
347 | op->reg = $5; | |
348 | op->disp = $3; | |
349 | op->index = $7; | |
350 | op->odisp = $9; | |
351 | } | |
352 | | '(' '[' zapc ',' zireg ']' optcexpr ')' | |
353 | { | |
354 | op->mode = PRE; | |
355 | op->reg = $3; | |
356 | op->index = $5; | |
357 | op->odisp = $7; | |
358 | } | |
359 | | '(' '[' EXPR ',' zapc ',' zpc ']' optcexpr ')' | |
360 | { | |
361 | if ($5 == PC || $5 == ZPC) | |
362 | yyerror (_("syntax error")); | |
363 | op->mode = PRE; | |
364 | op->reg = $7; | |
365 | op->disp = $3; | |
366 | op->index.reg = $5; | |
367 | op->index.size = SIZE_UNSPEC; | |
368 | op->index.scale = 1; | |
369 | op->odisp = $9; | |
370 | } | |
371 | | '(' '[' zapc ',' zpc ']' optcexpr ')' | |
372 | { | |
373 | if ($3 == PC || $3 == ZPC) | |
374 | yyerror (_("syntax error")); | |
375 | op->mode = PRE; | |
376 | op->reg = $5; | |
377 | op->index.reg = $3; | |
378 | op->index.size = SIZE_UNSPEC; | |
379 | op->index.scale = 1; | |
380 | op->odisp = $7; | |
381 | } | |
382 | | '(' '[' optexprc zdireg optczapc ']' optcexpr ')' | |
383 | { | |
384 | op->mode = PRE; | |
385 | op->reg = $5; | |
386 | op->disp = $3; | |
387 | op->index = $4; | |
388 | op->odisp = $7; | |
389 | } | |
390 | ; | |
391 | ||
392 | /* An operand in MIT syntax. */ | |
393 | ||
394 | mit_operand: | |
395 | optzapc '@' | |
396 | { | |
397 | /* We use optzapc to avoid a shift/reduce conflict. */ | |
398 | if ($1 < ADDR0 || $1 > ADDR7) | |
399 | yyerror (_("syntax error")); | |
400 | op->mode = AINDR; | |
401 | op->reg = $1; | |
402 | } | |
403 | | optzapc '@' '+' | |
404 | { | |
405 | /* We use optzapc to avoid a shift/reduce conflict. */ | |
406 | if ($1 < ADDR0 || $1 > ADDR7) | |
407 | yyerror (_("syntax error")); | |
408 | op->mode = AINC; | |
409 | op->reg = $1; | |
410 | } | |
411 | | optzapc '@' '-' | |
412 | { | |
413 | /* We use optzapc to avoid a shift/reduce conflict. */ | |
414 | if ($1 < ADDR0 || $1 > ADDR7) | |
415 | yyerror (_("syntax error")); | |
416 | op->mode = ADEC; | |
417 | op->reg = $1; | |
418 | } | |
419 | | optzapc '@' '(' EXPR ')' | |
420 | { | |
421 | op->reg = $1; | |
422 | op->disp = $4; | |
423 | if (($1 >= ZADDR0 && $1 <= ZADDR7) | |
424 | || $1 == ZPC) | |
425 | op->mode = BASE; | |
426 | else | |
427 | op->mode = DISP; | |
428 | } | |
429 | | optzapc '@' '(' optexprc zireg ')' | |
430 | { | |
431 | op->mode = BASE; | |
432 | op->reg = $1; | |
433 | op->disp = $4; | |
434 | op->index = $5; | |
435 | } | |
436 | | optzapc '@' '(' EXPR ')' '@' '(' optexprc zireg ')' | |
437 | { | |
438 | op->mode = POST; | |
439 | op->reg = $1; | |
440 | op->disp = $4; | |
441 | op->index = $9; | |
442 | op->odisp = $8; | |
443 | } | |
444 | | optzapc '@' '(' EXPR ')' '@' '(' EXPR ')' | |
445 | { | |
446 | op->mode = POST; | |
447 | op->reg = $1; | |
448 | op->disp = $4; | |
449 | op->odisp = $8; | |
450 | } | |
451 | | optzapc '@' '(' optexprc zireg ')' '@' '(' EXPR ')' | |
452 | { | |
453 | op->mode = PRE; | |
454 | op->reg = $1; | |
455 | op->disp = $4; | |
456 | op->index = $5; | |
457 | op->odisp = $9; | |
458 | } | |
459 | ; | |
460 | ||
461 | /* An index register, possibly suppressed, which need not have a size | |
462 | or scale. */ | |
463 | ||
464 | zireg: | |
465 | INDEXREG | |
466 | | zadr | |
467 | { | |
468 | $$.reg = $1; | |
469 | $$.size = SIZE_UNSPEC; | |
470 | $$.scale = 1; | |
471 | } | |
472 | ; | |
473 | ||
474 | /* A register which may be an index register, but which may not be an | |
475 | address register. This nonterminal is used to avoid ambiguity when | |
476 | trying to parse something like (0,d5,a6) as compared to (0,a6,d5). */ | |
477 | ||
478 | zdireg: | |
479 | INDEXREG | |
480 | | zdr | |
481 | { | |
482 | $$.reg = $1; | |
483 | $$.size = SIZE_UNSPEC; | |
484 | $$.scale = 1; | |
485 | } | |
486 | ; | |
487 | ||
488 | /* An address or data register, or a suppressed address or data | |
489 | register. */ | |
490 | ||
491 | zadr: | |
492 | zdr | |
493 | | AR | |
494 | | ZAR | |
495 | ; | |
496 | ||
497 | /* A data register which may be suppressed. */ | |
498 | ||
499 | zdr: | |
500 | DR | |
501 | | ZDR | |
502 | ; | |
503 | ||
504 | /* Either an address register or the PC. */ | |
505 | ||
506 | apc: | |
507 | AR | |
508 | | LPC | |
509 | ; | |
510 | ||
511 | /* Either an address register, or the PC, or a suppressed address | |
512 | register, or a suppressed PC. */ | |
513 | ||
514 | zapc: | |
515 | apc | |
516 | | LZPC | |
517 | | ZAR | |
518 | ; | |
519 | ||
520 | /* An optional zapc. */ | |
521 | ||
522 | optzapc: | |
523 | /* empty */ | |
524 | { | |
525 | $$ = ZADDR0; | |
526 | } | |
527 | | zapc | |
528 | ; | |
529 | ||
530 | /* The PC, optionally suppressed. */ | |
531 | ||
532 | zpc: | |
533 | LPC | |
534 | | LZPC | |
535 | ; | |
536 | ||
537 | /* ',' zapc when it may be omitted. */ | |
538 | ||
539 | optczapc: | |
540 | /* empty */ | |
541 | { | |
542 | $$ = ZADDR0; | |
543 | } | |
544 | | ',' zapc | |
545 | { | |
546 | $$ = $2; | |
547 | } | |
548 | ; | |
549 | ||
550 | /* ',' EXPR when it may be omitted. */ | |
551 | ||
552 | optcexpr: | |
553 | /* empty */ | |
554 | { | |
555 | $$.exp.X_op = O_absent; | |
556 | $$.size = SIZE_UNSPEC; | |
557 | } | |
558 | | ',' EXPR | |
559 | { | |
560 | $$ = $2; | |
561 | } | |
562 | ; | |
563 | ||
564 | /* EXPR ',' when it may be omitted. */ | |
565 | ||
566 | optexprc: | |
567 | /* empty */ | |
568 | { | |
569 | $$.exp.X_op = O_absent; | |
570 | $$.size = SIZE_UNSPEC; | |
571 | } | |
572 | | EXPR ',' | |
573 | { | |
574 | $$ = $1; | |
575 | } | |
576 | ; | |
577 | ||
578 | /* A register list for the movem instruction. */ | |
579 | ||
580 | reglist: | |
581 | reglistpair | |
582 | | reglistpair '/' ireglist | |
583 | { | |
584 | $$ = $1 | $3; | |
585 | } | |
586 | | reglistreg '/' ireglist | |
587 | { | |
588 | $$ = (1 << $1) | $3; | |
589 | } | |
590 | ; | |
591 | ||
592 | /* We use ireglist when we know we are looking at a reglist, and we | |
593 | can safely reduce a simple register to reglistreg. If we permitted | |
594 | reglist to reduce to reglistreg, it would be ambiguous whether a | |
595 | plain register were a DREG/AREG/FPREG or a REGLST. */ | |
596 | ||
597 | ireglist: | |
598 | reglistreg | |
599 | { | |
600 | $$ = 1 << $1; | |
601 | } | |
602 | | reglistpair | |
603 | | reglistpair '/' ireglist | |
604 | { | |
605 | $$ = $1 | $3; | |
606 | } | |
607 | | reglistreg '/' ireglist | |
608 | { | |
609 | $$ = (1 << $1) | $3; | |
610 | } | |
611 | ; | |
612 | ||
613 | reglistpair: | |
614 | reglistreg '-' reglistreg | |
615 | { | |
616 | if ($1 <= $3) | |
617 | $$ = (1 << ($3 + 1)) - 1 - ((1 << $1) - 1); | |
618 | else | |
619 | $$ = (1 << ($1 + 1)) - 1 - ((1 << $3) - 1); | |
620 | } | |
621 | ; | |
622 | ||
623 | reglistreg: | |
624 | DR | |
625 | { | |
626 | $$ = $1 - DATA0; | |
627 | } | |
628 | | AR | |
629 | { | |
630 | $$ = $1 - ADDR0 + 8; | |
631 | } | |
632 | | FPR | |
633 | { | |
634 | $$ = $1 - FP0 + 16; | |
635 | } | |
636 | | FPCR | |
637 | { | |
638 | if ($1 == FPI) | |
639 | $$ = 24; | |
640 | else if ($1 == FPS) | |
641 | $$ = 25; | |
642 | else | |
643 | $$ = 26; | |
644 | } | |
645 | ; | |
646 | ||
647 | %% | |
648 | ||
649 | /* The string to parse is stored here, and modified by yylex. */ | |
650 | ||
651 | static char *str; | |
652 | ||
653 | /* The original string pointer. */ | |
654 | ||
655 | static char *strorig; | |
656 | ||
657 | /* If *CCP could be a register, return the register number and advance | |
658 | *CCP. Otherwise don't change *CCP, and return 0. */ | |
659 | ||
660 | static enum m68k_register | |
661 | m68k_reg_parse (ccp) | |
662 | register char **ccp; | |
663 | { | |
664 | char *start = *ccp; | |
665 | char c; | |
666 | char *p; | |
667 | symbolS *symbolp; | |
668 | ||
669 | if (flag_reg_prefix_optional) | |
670 | { | |
671 | if (*start == REGISTER_PREFIX) | |
672 | start++; | |
673 | p = start; | |
674 | } | |
675 | else | |
676 | { | |
677 | if (*start != REGISTER_PREFIX) | |
678 | return 0; | |
679 | p = start + 1; | |
680 | } | |
681 | ||
682 | if (! is_name_beginner (*p)) | |
683 | return 0; | |
684 | ||
685 | p++; | |
686 | while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') | |
687 | p++; | |
688 | ||
689 | c = *p; | |
690 | *p = 0; | |
691 | symbolp = symbol_find (start); | |
692 | *p = c; | |
693 | ||
694 | if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) | |
695 | { | |
696 | *ccp = p; | |
697 | return S_GET_VALUE (symbolp); | |
698 | } | |
699 | ||
700 | /* In MRI mode, something like foo.bar can be equated to a register | |
701 | name. */ | |
702 | while (flag_mri && c == '.') | |
703 | { | |
704 | ++p; | |
705 | while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*') | |
706 | p++; | |
707 | c = *p; | |
708 | *p = '\0'; | |
709 | symbolp = symbol_find (start); | |
710 | *p = c; | |
711 | if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section) | |
712 | { | |
713 | *ccp = p; | |
714 | return S_GET_VALUE (symbolp); | |
715 | } | |
716 | } | |
717 | ||
718 | return 0; | |
719 | } | |
720 | ||
721 | /* The lexer. */ | |
722 | ||
723 | static int | |
724 | yylex () | |
725 | { | |
726 | enum m68k_register reg; | |
727 | char *s; | |
728 | int parens; | |
729 | int c = 0; | |
730 | int tail = 0; | |
731 | char *hold; | |
732 | ||
733 | if (*str == ' ') | |
734 | ++str; | |
735 | ||
736 | if (*str == '\0') | |
737 | return 0; | |
738 | ||
739 | /* Various special characters are just returned directly. */ | |
740 | switch (*str) | |
741 | { | |
742 | case '@': | |
743 | /* In MRI mode, this can be the start of an octal number. */ | |
744 | if (flag_mri) | |
745 | { | |
746 | if (isdigit (str[1]) | |
747 | || ((str[1] == '+' || str[1] == '-') | |
748 | && isdigit (str[2]))) | |
749 | break; | |
750 | } | |
751 | /* Fall through. */ | |
752 | case '#': | |
753 | case '&': | |
754 | case ',': | |
755 | case ')': | |
756 | case '/': | |
757 | case '[': | |
758 | case ']': | |
759 | return *str++; | |
760 | case '+': | |
761 | /* It so happens that a '+' can only appear at the end of an | |
762 | operand. If it appears anywhere else, it must be a unary | |
763 | plus on an expression. */ | |
764 | if (str[1] == '\0') | |
765 | return *str++; | |
766 | break; | |
767 | case '-': | |
768 | /* A '-' can only appear in -(ar), rn-rn, or ar@-. If it | |
769 | appears anywhere else, it must be a unary minus on an | |
770 | expression. */ | |
771 | if (str[1] == '\0') | |
772 | return *str++; | |
773 | s = str + 1; | |
774 | if (*s == '(') | |
775 | ++s; | |
776 | if (m68k_reg_parse (&s) != 0) | |
777 | return *str++; | |
778 | break; | |
779 | case '(': | |
780 | /* A '(' can only appear in `(reg)', `(expr,...', `([', `@(', or | |
781 | `)('. If it appears anywhere else, it must be starting an | |
782 | expression. */ | |
783 | if (str[1] == '[' | |
784 | || (str > strorig | |
785 | && (str[-1] == '@' | |
786 | || str[-1] == ')'))) | |
787 | return *str++; | |
788 | s = str + 1; | |
789 | if (m68k_reg_parse (&s) != 0) | |
790 | return *str++; | |
791 | /* Check for the case of '(expr,...' by scanning ahead. If we | |
792 | find a comma outside of balanced parentheses, we return '('. | |
793 | If we find an unbalanced right parenthesis, then presumably | |
794 | the '(' really starts an expression. */ | |
795 | parens = 0; | |
796 | for (s = str + 1; *s != '\0'; s++) | |
797 | { | |
798 | if (*s == '(') | |
799 | ++parens; | |
800 | else if (*s == ')') | |
801 | { | |
802 | if (parens == 0) | |
803 | break; | |
804 | --parens; | |
805 | } | |
806 | else if (*s == ',' && parens == 0) | |
807 | { | |
808 | /* A comma can not normally appear in an expression, so | |
809 | this is a case of '(expr,...'. */ | |
810 | return *str++; | |
811 | } | |
812 | } | |
813 | } | |
814 | ||
815 | /* See if it's a register. */ | |
816 | ||
817 | reg = m68k_reg_parse (&str); | |
818 | if (reg != 0) | |
819 | { | |
820 | int ret; | |
821 | ||
822 | yylval.reg = reg; | |
823 | ||
824 | if (reg >= DATA0 && reg <= DATA7) | |
825 | ret = DR; | |
826 | else if (reg >= ADDR0 && reg <= ADDR7) | |
827 | ret = AR; | |
828 | else if (reg >= FP0 && reg <= FP7) | |
829 | return FPR; | |
830 | else if (reg == FPI | |
831 | || reg == FPS | |
832 | || reg == FPC) | |
833 | return FPCR; | |
834 | else if (reg == PC) | |
835 | return LPC; | |
836 | else if (reg >= ZDATA0 && reg <= ZDATA7) | |
837 | ret = ZDR; | |
838 | else if (reg >= ZADDR0 && reg <= ZADDR7) | |
839 | ret = ZAR; | |
840 | else if (reg == ZPC) | |
841 | return LZPC; | |
842 | else | |
843 | return CREG; | |
844 | ||
845 | /* If we get here, we have a data or address register. We | |
846 | must check for a size or scale; if we find one, we must | |
847 | return INDEXREG. */ | |
848 | ||
849 | s = str; | |
850 | ||
851 | if (*s != '.' && *s != ':' && *s != '*') | |
852 | return ret; | |
853 | ||
854 | yylval.indexreg.reg = reg; | |
855 | ||
856 | if (*s != '.' && *s != ':') | |
857 | yylval.indexreg.size = SIZE_UNSPEC; | |
858 | else | |
859 | { | |
860 | ++s; | |
861 | switch (*s) | |
862 | { | |
863 | case 'w': | |
864 | case 'W': | |
865 | yylval.indexreg.size = SIZE_WORD; | |
866 | ++s; | |
867 | break; | |
868 | case 'l': | |
869 | case 'L': | |
870 | yylval.indexreg.size = SIZE_LONG; | |
871 | ++s; | |
872 | break; | |
873 | default: | |
874 | yyerror (_("illegal size specification")); | |
875 | yylval.indexreg.size = SIZE_UNSPEC; | |
876 | break; | |
877 | } | |
878 | } | |
879 | ||
880 | yylval.indexreg.scale = 1; | |
881 | ||
882 | if (*s == '*' || *s == ':') | |
883 | { | |
884 | expressionS scale; | |
885 | ||
886 | ++s; | |
887 | ||
888 | hold = input_line_pointer; | |
889 | input_line_pointer = s; | |
890 | expression (&scale); | |
891 | s = input_line_pointer; | |
892 | input_line_pointer = hold; | |
893 | ||
894 | if (scale.X_op != O_constant) | |
895 | yyerror (_("scale specification must resolve to a number")); | |
896 | else | |
897 | { | |
898 | switch (scale.X_add_number) | |
899 | { | |
900 | case 1: | |
901 | case 2: | |
902 | case 4: | |
903 | case 8: | |
904 | yylval.indexreg.scale = scale.X_add_number; | |
905 | break; | |
906 | default: | |
907 | yyerror (_("invalid scale value")); | |
908 | break; | |
909 | } | |
910 | } | |
911 | } | |
912 | ||
913 | str = s; | |
914 | ||
915 | return INDEXREG; | |
916 | } | |
917 | ||
918 | /* It must be an expression. Before we call expression, we need to | |
919 | look ahead to see if there is a size specification. We must do | |
920 | that first, because otherwise foo.l will be treated as the symbol | |
921 | foo.l, rather than as the symbol foo with a long size | |
922 | specification. The grammar requires that all expressions end at | |
923 | the end of the operand, or with ',', '(', ']', ')'. */ | |
924 | ||
925 | parens = 0; | |
926 | for (s = str; *s != '\0'; s++) | |
927 | { | |
928 | if (*s == '(') | |
929 | { | |
930 | if (parens == 0 | |
931 | && s > str | |
932 | && (s[-1] == ')' || isalnum ((unsigned char) s[-1]))) | |
933 | break; | |
934 | ++parens; | |
935 | } | |
936 | else if (*s == ')') | |
937 | { | |
938 | if (parens == 0) | |
939 | break; | |
940 | --parens; | |
941 | } | |
942 | else if (parens == 0 | |
943 | && (*s == ',' || *s == ']')) | |
944 | break; | |
945 | } | |
946 | ||
947 | yylval.exp.size = SIZE_UNSPEC; | |
948 | if (s <= str + 2 | |
949 | || (s[-2] != '.' && s[-2] != ':')) | |
950 | tail = 0; | |
951 | else | |
952 | { | |
953 | switch (s[-1]) | |
954 | { | |
955 | case 's': | |
956 | case 'S': | |
957 | case 'b': | |
958 | case 'B': | |
959 | yylval.exp.size = SIZE_BYTE; | |
960 | break; | |
961 | case 'w': | |
962 | case 'W': | |
963 | yylval.exp.size = SIZE_WORD; | |
964 | break; | |
965 | case 'l': | |
966 | case 'L': | |
967 | yylval.exp.size = SIZE_LONG; | |
968 | break; | |
969 | default: | |
970 | break; | |
971 | } | |
972 | if (yylval.exp.size != SIZE_UNSPEC) | |
973 | tail = 2; | |
974 | } | |
975 | ||
976 | #ifdef OBJ_ELF | |
977 | { | |
978 | /* Look for @PLTPC, etc. */ | |
979 | char *cp; | |
980 | ||
981 | yylval.exp.pic_reloc = pic_none; | |
982 | cp = s - tail; | |
983 | if (cp - 6 > str && cp[-6] == '@') | |
984 | { | |
985 | if (strncmp (cp - 6, "@PLTPC", 6) == 0) | |
986 | { | |
987 | yylval.exp.pic_reloc = pic_plt_pcrel; | |
988 | tail += 6; | |
989 | } | |
990 | else if (strncmp (cp - 6, "@GOTPC", 6) == 0) | |
991 | { | |
992 | yylval.exp.pic_reloc = pic_got_pcrel; | |
993 | tail += 6; | |
994 | } | |
995 | } | |
996 | else if (cp - 4 > str && cp[-4] == '@') | |
997 | { | |
998 | if (strncmp (cp - 4, "@PLT", 4) == 0) | |
999 | { | |
1000 | yylval.exp.pic_reloc = pic_plt_off; | |
1001 | tail += 4; | |
1002 | } | |
1003 | else if (strncmp (cp - 4, "@GOT", 4) == 0) | |
1004 | { | |
1005 | yylval.exp.pic_reloc = pic_got_off; | |
1006 | tail += 4; | |
1007 | } | |
1008 | } | |
1009 | } | |
1010 | #endif | |
1011 | ||
1012 | if (tail != 0) | |
1013 | { | |
1014 | c = s[-tail]; | |
1015 | s[-tail] = 0; | |
1016 | } | |
1017 | ||
1018 | hold = input_line_pointer; | |
1019 | input_line_pointer = str; | |
1020 | expression (&yylval.exp.exp); | |
1021 | str = input_line_pointer; | |
1022 | input_line_pointer = hold; | |
1023 | ||
1024 | if (tail != 0) | |
1025 | { | |
1026 | s[-tail] = c; | |
1027 | str = s; | |
1028 | } | |
1029 | ||
1030 | return EXPR; | |
1031 | } | |
1032 | ||
1033 | /* Parse an m68k operand. This is the only function which is called | |
1034 | from outside this file. */ | |
1035 | ||
1036 | int | |
1037 | m68k_ip_op (s, oparg) | |
1038 | char *s; | |
1039 | struct m68k_op *oparg; | |
1040 | { | |
1041 | memset (oparg, 0, sizeof *oparg); | |
1042 | oparg->error = NULL; | |
1043 | oparg->index.reg = ZDATA0; | |
1044 | oparg->index.scale = 1; | |
1045 | oparg->disp.exp.X_op = O_absent; | |
1046 | oparg->odisp.exp.X_op = O_absent; | |
1047 | ||
1048 | str = strorig = s; | |
1049 | op = oparg; | |
1050 | ||
1051 | return yyparse (); | |
1052 | } | |
1053 | ||
1054 | /* The error handler. */ | |
1055 | ||
1056 | static void | |
1057 | yyerror (s) | |
1058 | const char *s; | |
1059 | { | |
1060 | op->error = s; | |
1061 | } |