gas/config/m68k-parse.y

   1 /* m68k.y -- bison grammar for m68k operand parsing
   2    Copyright (C) 1995-2014 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
 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
 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
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
1111 yyerror (const char *s)
1112 {
1113   op->error = s;
1114 }