gas/config/m68k-parse.y

   1 /* m68k.y -- bison grammar for m68k operand parsing
   2    Copyright 1995, 1996, 1997, 1998, 2001, 2004 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 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 #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 PARAMS ((char **));
  86 static int yylex PARAMS ((void));
  87 static void yyerror PARAMS ((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
 688 m68k_reg_parse (ccp)
 689      register char **ccp;
 690 {
 691   char *start = *ccp;
 692   char c;
 693   char *p;
 694   symbolS *symbolp;
 695
 696   if (flag_reg_prefix_optional)
 697     {
 698       if (*start == REGISTER_PREFIX)
 699         start++;
 700       p = start;
 701     }
 702   else
 703     {
 704       if (*start != REGISTER_PREFIX)
 705         return 0;
 706       p = start + 1;
 707     }
 708
 709   if (! is_name_beginner (*p))
 710     return 0;
 711
 712   p++;
 713   while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*')
 714     p++;
 715
 716   c = *p;
 717   *p = 0;
 718   symbolp = symbol_find (start);
 719   *p = c;
 720
 721   if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section)
 722     {
 723       *ccp = p;
 724       return S_GET_VALUE (symbolp);
 725     }
 726
 727   /* In MRI mode, something like foo.bar can be equated to a register
 728      name.  */
 729   while (flag_mri && c == '.')
 730     {
 731       ++p;
 732       while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*')
 733         p++;
 734       c = *p;
 735       *p = '\0';
 736       symbolp = symbol_find (start);
 737       *p = c;
 738       if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section)
 739         {
 740           *ccp = p;
 741           return S_GET_VALUE (symbolp);
 742         }
 743     }
 744
 745   return 0;
 746 }
 747
 748 /* The lexer.  */
 749
 750 static int
 751 yylex ()
 752 {
 753   enum m68k_register reg;
 754   char *s;
 755   int parens;
 756   int c = 0;
 757   int tail = 0;
 758   char *hold;
 759
 760   if (*str == ' ')
 761     ++str;
 762
 763   if (*str == '\0')
 764     return 0;
 765
 766   /* Various special characters are just returned directly.  */
 767   switch (*str)
 768     {
 769     case '@':
 770       /* In MRI mode, this can be the start of an octal number.  */
 771       if (flag_mri)
 772         {
 773           if (ISDIGIT (str[1])
 774               || ((str[1] == '+' || str[1] == '-')
 775                   && ISDIGIT (str[2])))
 776             break;
 777         }
 778       /* Fall through.  */
 779     case '#':
 780     case '&':
 781     case ',':
 782     case ')':
 783     case '/':
 784     case '[':
 785     case ']':
 786     case '<':
 787     case '>':
 788       return *str++;
 789     case '+':
 790       /* It so happens that a '+' can only appear at the end of an
 791          operand, or if it is trailed by an '&'(see mac load insn).
 792          If it appears anywhere else, it must be a unary.  */
 793       if (str[1] == '\0' || (str[1] == '&' && str[2] == '\0'))
 794         return *str++;
 795       break;
 796     case '-':
 797       /* A '-' can only appear in -(ar), rn-rn, or ar@-.  If it
 798          appears anywhere else, it must be a unary minus on an
 799          expression, unless it it trailed by a '&'(see mac load insn).  */
 800       if (str[1] == '\0' || (str[1] == '&' && str[2] == '\0'))
 801         return *str++;
 802       s = str + 1;
 803       if (*s == '(')
 804         ++s;
 805       if (m68k_reg_parse (&s) != 0)
 806         return *str++;
 807       break;
 808     case '(':
 809       /* A '(' can only appear in `(reg)', `(expr,...', `([', `@(', or
 810          `)('.  If it appears anywhere else, it must be starting an
 811          expression.  */
 812       if (str[1] == '['
 813           || (str > strorig
 814               && (str[-1] == '@'
 815                   || str[-1] == ')')))
 816         return *str++;
 817       s = str + 1;
 818       if (m68k_reg_parse (&s) != 0)
 819         return *str++;
 820       /* Check for the case of '(expr,...' by scanning ahead.  If we
 821          find a comma outside of balanced parentheses, we return '('.
 822          If we find an unbalanced right parenthesis, then presumably
 823          the '(' really starts an expression.  */
 824       parens = 0;
 825       for (s = str + 1; *s != '\0'; s++)
 826         {
 827           if (*s == '(')
 828             ++parens;
 829           else if (*s == ')')
 830             {
 831               if (parens == 0)
 832                 break;
 833               --parens;
 834             }
 835           else if (*s == ',' && parens == 0)
 836             {
 837               /* A comma can not normally appear in an expression, so
 838                  this is a case of '(expr,...'.  */
 839               return *str++;
 840             }
 841         }
 842     }
 843
 844   /* See if it's a register.  */
 845
 846   reg = m68k_reg_parse (&str);
 847   if (reg != 0)
 848     {
 849       int ret;
 850
 851       yylval.reg = reg;
 852
 853       if (reg >= DATA0 && reg <= DATA7)
 854         ret = DR;
 855       else if (reg >= ADDR0 && reg <= ADDR7)
 856         ret = AR;
 857       else if (reg >= FP0 && reg <= FP7)
 858         return FPR;
 859       else if (reg == FPI
 860                || reg == FPS
 861                || reg == FPC)
 862         return FPCR;
 863       else if (reg == PC)
 864         return LPC;
 865       else if (reg >= ZDATA0 && reg <= ZDATA7)
 866         ret = ZDR;
 867       else if (reg >= ZADDR0 && reg <= ZADDR7)
 868         ret = ZAR;
 869       else if (reg == ZPC)
 870         return LZPC;
 871       else
 872         return CREG;
 873
 874       /* If we get here, we have a data or address register.  We
 875          must check for a size or scale; if we find one, we must
 876          return INDEXREG.  */
 877
 878       s = str;
 879
 880       if (*s != '.' && *s != ':' && *s != '*')
 881         return ret;
 882
 883       yylval.indexreg.reg = reg;
 884
 885       if (*s != '.' && *s != ':')
 886         yylval.indexreg.size = SIZE_UNSPEC;
 887       else
 888         {
 889           ++s;
 890           switch (*s)
 891             {
 892             case 'w':
 893             case 'W':
 894               yylval.indexreg.size = SIZE_WORD;
 895               ++s;
 896               break;
 897             case 'l':
 898             case 'L':
 899               yylval.indexreg.size = SIZE_LONG;
 900               ++s;
 901               break;
 902             default:
 903               yyerror (_("illegal size specification"));
 904               yylval.indexreg.size = SIZE_UNSPEC;
 905               break;
 906             }
 907         }
 908
 909       yylval.indexreg.scale = 1;
 910
 911       if (*s == '*' || *s == ':')
 912         {
 913           expressionS scale;
 914
 915           ++s;
 916
 917           hold = input_line_pointer;
 918           input_line_pointer = s;
 919           expression (&scale);
 920           s = input_line_pointer;
 921           input_line_pointer = hold;
 922
 923           if (scale.X_op != O_constant)
 924             yyerror (_("scale specification must resolve to a number"));
 925           else
 926             {
 927               switch (scale.X_add_number)
 928                 {
 929                 case 1:
 930                 case 2:
 931                 case 4:
 932                 case 8:
 933                   yylval.indexreg.scale = scale.X_add_number;
 934                   break;
 935                 default:
 936                   yyerror (_("invalid scale value"));
 937                   break;
 938                 }
 939             }
 940         }
 941
 942       str = s;
 943
 944       return INDEXREG;
 945     }
 946
 947   /* It must be an expression.  Before we call expression, we need to
 948      look ahead to see if there is a size specification.  We must do
 949      that first, because otherwise foo.l will be treated as the symbol
 950      foo.l, rather than as the symbol foo with a long size
 951      specification.  The grammar requires that all expressions end at
 952      the end of the operand, or with ',', '(', ']', ')'.  */
 953
 954   parens = 0;
 955   for (s = str; *s != '\0'; s++)
 956     {
 957       if (*s == '(')
 958         {
 959           if (parens == 0
 960               && s > str
 961               && (s[-1] == ')' || ISALNUM (s[-1])))
 962             break;
 963           ++parens;
 964         }
 965       else if (*s == ')')
 966         {
 967           if (parens == 0)
 968             break;
 969           --parens;
 970         }
 971       else if (parens == 0
 972                && (*s == ',' || *s == ']'))
 973         break;
 974     }
 975
 976   yylval.exp.size = SIZE_UNSPEC;
 977   if (s <= str + 2
 978       || (s[-2] != '.' && s[-2] != ':'))
 979     tail = 0;
 980   else
 981     {
 982       switch (s[-1])
 983         {
 984         case 's':
 985         case 'S':
 986         case 'b':
 987         case 'B':
 988           yylval.exp.size = SIZE_BYTE;
 989           break;
 990         case 'w':
 991         case 'W':
 992           yylval.exp.size = SIZE_WORD;
 993           break;
 994         case 'l':
 995         case 'L':
 996           yylval.exp.size = SIZE_LONG;
 997           break;
 998         default:
 999           break;
1000         }
1001       if (yylval.exp.size != SIZE_UNSPEC)
1002         tail = 2;
1003     }
1004
1005 #ifdef OBJ_ELF
1006   {
1007     /* Look for @PLTPC, etc.  */
1008     char *cp;
1009
1010     yylval.exp.pic_reloc = pic_none;
1011     cp = s - tail;
1012     if (cp - 6 > str && cp[-6] == '@')
1013       {
1014         if (strncmp (cp - 6, "@PLTPC", 6) == 0)
1015           {
1016             yylval.exp.pic_reloc = pic_plt_pcrel;
1017             tail += 6;
1018           }
1019         else if (strncmp (cp - 6, "@GOTPC", 6) == 0)
1020           {
1021             yylval.exp.pic_reloc = pic_got_pcrel;
1022             tail += 6;
1023           }
1024       }
1025     else if (cp - 4 > str && cp[-4] == '@')
1026       {
1027         if (strncmp (cp - 4, "@PLT", 4) == 0)
1028           {
1029             yylval.exp.pic_reloc = pic_plt_off;
1030             tail += 4;
1031           }
1032         else if (strncmp (cp - 4, "@GOT", 4) == 0)
1033           {
1034             yylval.exp.pic_reloc = pic_got_off;
1035             tail += 4;
1036           }
1037       }
1038   }
1039 #endif
1040
1041   if (tail != 0)
1042     {
1043       c = s[-tail];
1044       s[-tail] = 0;
1045     }
1046
1047   hold = input_line_pointer;
1048   input_line_pointer = str;
1049   expression (&yylval.exp.exp);
1050   str = input_line_pointer;
1051   input_line_pointer = hold;
1052
1053   if (tail != 0)
1054     {
1055       s[-tail] = c;
1056       str = s;
1057     }
1058
1059   return EXPR;
1060 }
1061
1062 /* Parse an m68k operand.  This is the only function which is called
1063    from outside this file.  */
1064
1065 int
1066 m68k_ip_op (s, oparg)
1067      char *s;
1068      struct m68k_op *oparg;
1069 {
1070   memset (oparg, 0, sizeof *oparg);
1071   oparg->error = NULL;
1072   oparg->index.reg = ZDATA0;
1073   oparg->index.scale = 1;
1074   oparg->disp.exp.X_op = O_absent;
1075   oparg->odisp.exp.X_op = O_absent;
1076
1077   str = strorig = s;
1078   op = oparg;
1079
1080   return yyparse ();
1081 }
1082
1083 /* The error handler.  */
1084
1085 static void
1086 yyerror (s)
1087      const char *s;
1088 {
1089   op->error = s;
1090 }