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