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