gas/config/m68k-parse.y

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