[binutils.git] / gas / config / m68k-parse.y

/* m68k.y -- bison grammar for m68k operand parsing
   Copyright 1995, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
   Written by Ken Raeburn and Ian Lance Taylor, Cygnus Support

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

/* This file holds a bison grammar to parse m68k operands.  The m68k
   has a complicated operand syntax, and gas supports two main
   variations of it.  Using a grammar is probably overkill, but at
   least it makes clear exactly what we do support.  */

%{

#include "as.h"
#include "tc-m68k.h"
#include "m68k-parse.h"
#include "safe-ctype.h"

/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
   etc), as well as gratuitiously global symbol names If other parser
   generators (bison, byacc, etc) produce additional global names that
   conflict at link time, then those parser generators need to be
   fixed instead of adding those names to this list. */

#define	yymaxdepth m68k_maxdepth
#define	yyparse	m68k_parse
#define	yylex	m68k_lex
#define	yyerror	m68k_error
#define	yylval	m68k_lval
#define	yychar	m68k_char
#define	yydebug	m68k_debug
#define	yypact	m68k_pact	
#define	yyr1	m68k_r1			
#define	yyr2	m68k_r2			
#define	yydef	m68k_def		
#define	yychk	m68k_chk		
#define	yypgo	m68k_pgo		
#define	yyact	m68k_act		
#define	yyexca	m68k_exca
#define yyerrflag m68k_errflag
#define yynerrs	m68k_nerrs
#define	yyps	m68k_ps
#define	yypv	m68k_pv
#define	yys	m68k_s
#define	yy_yys	m68k_yys
#define	yystate	m68k_state
#define	yytmp	m68k_tmp
#define	yyv	m68k_v
#define	yy_yyv	m68k_yyv
#define	yyval	m68k_val
#define	yylloc	m68k_lloc
#define yyreds	m68k_reds		/* With YYDEBUG defined */
#define yytoks	m68k_toks		/* With YYDEBUG defined */
#define yylhs	m68k_yylhs
#define yylen	m68k_yylen
#define yydefred m68k_yydefred
#define yydgoto	m68k_yydgoto
#define yysindex m68k_yysindex
#define yyrindex m68k_yyrindex
#define yygindex m68k_yygindex
#define yytable	 m68k_yytable
#define yycheck	 m68k_yycheck

#ifndef YYDEBUG
#define YYDEBUG 1
#endif

/* Internal functions.  */

static enum m68k_register m68k_reg_parse PARAMS ((char **));
static int yylex PARAMS ((void));
static void yyerror PARAMS ((const char *));

/* The parser sets fields pointed to by this global variable.  */
static struct m68k_op *op;

%}

%union
{
  struct m68k_indexreg indexreg;
  enum m68k_register reg;
  struct m68k_exp exp;
  unsigned long mask;
  int onereg;
}

%token <reg> DR AR FPR FPCR LPC ZAR ZDR LZPC CREG
%token <indexreg> INDEXREG
%token <exp> EXPR

%type <indexreg> zireg zdireg
%type <reg> zadr zdr apc zapc zpc optzapc optczapc
%type <exp> optcexpr optexprc
%type <mask> reglist ireglist reglistpair
%type <onereg> reglistreg

%%

/* An operand.  */

operand:
	  generic_operand
	| motorola_operand
	| mit_operand
	;

/* A generic operand.  */

generic_operand:
	  DR
		{
		  op->mode = DREG;
		  op->reg = $1;
		}
	| AR
		{
		  op->mode = AREG;
		  op->reg = $1;
		}
	| FPR
		{
		  op->mode = FPREG;
		  op->reg = $1;
		}
	| FPCR
		{
		  op->mode = CONTROL;
		  op->reg = $1;
		}
	| CREG
		{
		  op->mode = CONTROL;
		  op->reg = $1;
		}
	| EXPR
		{
		  op->mode = ABSL;
		  op->disp = $1;
		}
	| '#' EXPR
		{
		  op->mode = IMMED;
		  op->disp = $2;
		}
	| '&' EXPR
		{
		  op->mode = IMMED;
		  op->disp = $2;
		}
	| reglist
		{
		  op->mode = REGLST;
		  op->mask = $1;
		}
	;

/* An operand in Motorola syntax.  This includes MRI syntax as well,
   which may or may not be different in that it permits commutativity
   of index and base registers, and permits an offset expression to
   appear inside or outside of the parentheses.  */

motorola_operand:
	  '(' AR ')'
		{
		  op->mode = AINDR;
		  op->reg = $2;
		}
	| '(' AR ')' '+'
		{
		  op->mode = AINC;
		  op->reg = $2;
		}
	| '-' '(' AR ')'
		{
		  op->mode = ADEC;
		  op->reg = $3;
		}
	| '(' EXPR ',' zapc ')'
		{
		  op->reg = $4;
		  op->disp = $2;
		  if (($4 >= ZADDR0 && $4 <= ZADDR7)
		      || $4 == ZPC)
		    op->mode = BASE;
		  else
		    op->mode = DISP;
		}
	| '(' zapc ',' EXPR ')'
		{
		  op->reg = $2;
		  op->disp = $4;
		  if (($2 >= ZADDR0 && $2 <= ZADDR7)
		      || $2 == ZPC)
		    op->mode = BASE;
		  else
		    op->mode = DISP;
		}
	| EXPR '(' zapc ')'
		{
		  op->reg = $3;
		  op->disp = $1;
		  if (($3 >= ZADDR0 && $3 <= ZADDR7)
		      || $3 == ZPC)
		    op->mode = BASE;
		  else
		    op->mode = DISP;
		}
	| '(' LPC ')'
		{
		  op->mode = DISP;
		  op->reg = $2;
		}
	| '(' ZAR ')'
		{
		  op->mode = BASE;
		  op->reg = $2;
		}
	| '(' LZPC ')'
		{
		  op->mode = BASE;
		  op->reg = $2;
		}
	| '(' EXPR ',' zapc ',' zireg ')'
		{
		  op->mode = BASE;
		  op->reg = $4;
		  op->disp = $2;
		  op->index = $6;
		}
	| '(' EXPR ',' zapc ',' zpc ')'
		{
		  if ($4 == PC || $4 == ZPC)
		    yyerror (_("syntax error"));
		  op->mode = BASE;
		  op->reg = $6;
		  op->disp = $2;
		  op->index.reg = $4;
		  op->index.size = SIZE_UNSPEC;
		  op->index.scale = 1;
		}
	| '(' EXPR ',' zdireg optczapc ')'
		{
		  op->mode = BASE;
		  op->reg = $5;
		  op->disp = $2;
		  op->index = $4;
		}
	| '(' zdireg ',' EXPR ')'
		{
		  op->mode = BASE;
		  op->disp = $4;
		  op->index = $2;
		}
	| EXPR '(' zapc ',' zireg ')'
		{
		  op->mode = BASE;
		  op->reg = $3;
		  op->disp = $1;
		  op->index = $5;
		}
	| '(' zapc ',' zireg ')'
		{
		  op->mode = BASE;
		  op->reg = $2;
		  op->index = $4;
		}
	| EXPR '(' zapc ',' zpc ')'
		{
		  if ($3 == PC || $3 == ZPC)
		    yyerror (_("syntax error"));
		  op->mode = BASE;
		  op->reg = $5;
		  op->disp = $1;
		  op->index.reg = $3;
		  op->index.size = SIZE_UNSPEC;
		  op->index.scale = 1;
		}
	| '(' zapc ',' zpc ')'
		{
		  if ($2 == PC || $2 == ZPC)
		    yyerror (_("syntax error"));
		  op->mode = BASE;
		  op->reg = $4;
		  op->index.reg = $2;
		  op->index.size = SIZE_UNSPEC;
		  op->index.scale = 1;
		}
	| EXPR '(' zdireg optczapc ')'
		{
		  op->mode = BASE;
		  op->reg = $4;
		  op->disp = $1;
		  op->index = $3;
		}
	| '(' zdireg optczapc ')'
		{
		  op->mode = BASE;
		  op->reg = $3;
		  op->index = $2;
		}
	| '(' '[' EXPR optczapc ']' ',' zireg optcexpr ')'
		{
		  op->mode = POST;
		  op->reg = $4;
		  op->disp = $3;
		  op->index = $7;
		  op->odisp = $8;
		}
	| '(' '[' EXPR optczapc ']' optcexpr ')'
		{
		  op->mode = POST;
		  op->reg = $4;
		  op->disp = $3;
		  op->odisp = $6;
		}
	| '(' '[' zapc ']' ',' zireg optcexpr ')'
		{
		  op->mode = POST;
		  op->reg = $3;
		  op->index = $6;
		  op->odisp = $7;
		}
	| '(' '[' zapc ']' optcexpr ')'
		{
		  op->mode = POST;
		  op->reg = $3;
		  op->odisp = $5;
		}
	| '(' '[' EXPR ',' zapc ',' zireg ']' optcexpr ')'
		{
		  op->mode = PRE;
		  op->reg = $5;
		  op->disp = $3;
		  op->index = $7;
		  op->odisp = $9;
		}
	| '(' '[' zapc ',' zireg ']' optcexpr ')'
		{
		  op->mode = PRE;
		  op->reg = $3;
		  op->index = $5;
		  op->odisp = $7;
		}
	| '(' '[' EXPR ',' zapc ',' zpc ']' optcexpr ')'
		{
		  if ($5 == PC || $5 == ZPC)
		    yyerror (_("syntax error"));
		  op->mode = PRE;
		  op->reg = $7;
		  op->disp = $3;
		  op->index.reg = $5;
		  op->index.size = SIZE_UNSPEC;
		  op->index.scale = 1;
		  op->odisp = $9;
		}
	| '(' '[' zapc ',' zpc ']' optcexpr ')'
		{
		  if ($3 == PC || $3 == ZPC)
		    yyerror (_("syntax error"));
		  op->mode = PRE;
		  op->reg = $5;
		  op->index.reg = $3;
		  op->index.size = SIZE_UNSPEC;
		  op->index.scale = 1;
		  op->odisp = $7;
		}
	| '(' '[' optexprc zdireg optczapc ']' optcexpr ')'
		{
		  op->mode = PRE;
		  op->reg = $5;
		  op->disp = $3;
		  op->index = $4;
		  op->odisp = $7;
		}
	;

/* An operand in MIT syntax.  */

mit_operand:
	  optzapc '@'
		{
		  /* We use optzapc to avoid a shift/reduce conflict.  */
		  if ($1 < ADDR0 || $1 > ADDR7)
		    yyerror (_("syntax error"));
		  op->mode = AINDR;
		  op->reg = $1;
		}
	| optzapc '@' '+'
		{
		  /* We use optzapc to avoid a shift/reduce conflict.  */
		  if ($1 < ADDR0 || $1 > ADDR7)
		    yyerror (_("syntax error"));
		  op->mode = AINC;
		  op->reg = $1;
		}
	| optzapc '@' '-'
		{
		  /* We use optzapc to avoid a shift/reduce conflict.  */
		  if ($1 < ADDR0 || $1 > ADDR7)
		    yyerror (_("syntax error"));
		  op->mode = ADEC;
		  op->reg = $1;
		}
	| optzapc '@' '(' EXPR ')'
		{
		  op->reg = $1;
		  op->disp = $4;
		  if (($1 >= ZADDR0 && $1 <= ZADDR7)
		      || $1 == ZPC)
		    op->mode = BASE;
		  else
		    op->mode = DISP;
		}
	| optzapc '@' '(' optexprc zireg ')'
		{
		  op->mode = BASE;
		  op->reg = $1;
		  op->disp = $4;
		  op->index = $5;
		}
	| optzapc '@' '(' EXPR ')' '@' '(' optexprc zireg ')'
		{
		  op->mode = POST;
		  op->reg = $1;
		  op->disp = $4;
		  op->index = $9;
		  op->odisp = $8;
		}
	| optzapc '@' '(' EXPR ')' '@' '(' EXPR ')'
		{
		  op->mode = POST;
		  op->reg = $1;
		  op->disp = $4;
		  op->odisp = $8;
		}
	| optzapc '@' '(' optexprc zireg ')' '@' '(' EXPR ')'
		{
		  op->mode = PRE;
		  op->reg = $1;
		  op->disp = $4;
		  op->index = $5;
		  op->odisp = $9;
		}
	;

/* An index register, possibly suppressed, which need not have a size
   or scale.  */

zireg:
	  INDEXREG
	| zadr
		{
		  $$.reg = $1;
		  $$.size = SIZE_UNSPEC;
		  $$.scale = 1;
		}
	;

/* A register which may be an index register, but which may not be an
   address register.  This nonterminal is used to avoid ambiguity when
   trying to parse something like (0,d5,a6) as compared to (0,a6,d5).  */

zdireg:
	  INDEXREG
	| zdr
		{
		  $$.reg = $1;
		  $$.size = SIZE_UNSPEC;
		  $$.scale = 1;
		}
	;

/* An address or data register, or a suppressed address or data
   register.  */

zadr:
	  zdr
	| AR
	| ZAR
	;

/* A data register which may be suppressed.  */

zdr:
	  DR
	| ZDR
	;

/* Either an address register or the PC.  */

apc:
	  AR
	| LPC
	;

/* Either an address register, or the PC, or a suppressed address
   register, or a suppressed PC.  */

zapc:
	  apc
	| LZPC
	| ZAR
	;

/* An optional zapc.  */

optzapc:
	  /* empty */
		{
		  $$ = ZADDR0;
		}
	| zapc
	;

/* The PC, optionally suppressed.  */

zpc:
	  LPC
	| LZPC
	;

/* ',' zapc when it may be omitted.  */

optczapc:
	  /* empty */
		{
		  $$ = ZADDR0;
		}
	| ',' zapc
		{
		  $$ = $2;
		}
	;

/* ',' EXPR when it may be omitted.  */

optcexpr:
	  /* empty */
		{
		  $$.exp.X_op = O_absent;
		  $$.size = SIZE_UNSPEC;
		}
	| ',' EXPR
		{
		  $$ = $2;
		}
	;

/* EXPR ',' when it may be omitted.  */

optexprc:
	  /* empty */
		{
		  $$.exp.X_op = O_absent;
		  $$.size = SIZE_UNSPEC;
		}
	| EXPR ','
		{
		  $$ = $1;
		}
	;

/* A register list for the movem instruction.  */

reglist:
	  reglistpair
	| reglistpair '/' ireglist
		{
		  $$ = $1 | $3;
		}
	| reglistreg '/' ireglist
		{
		  $$ = (1 << $1) | $3;
		}
	;

/* We use ireglist when we know we are looking at a reglist, and we
   can safely reduce a simple register to reglistreg.  If we permitted
   reglist to reduce to reglistreg, it would be ambiguous whether a
   plain register were a DREG/AREG/FPREG or a REGLST.  */

ireglist:
	  reglistreg
		{
		  $$ = 1 << $1;
		}
	| reglistpair
	| reglistpair '/' ireglist
		{
		  $$ = $1 | $3;
		}
	| reglistreg '/' ireglist
		{
		  $$ = (1 << $1) | $3;
		}
	;

reglistpair:
	  reglistreg '-' reglistreg
		{
		  if ($1 <= $3)
		    $$ = (1 << ($3 + 1)) - 1 - ((1 << $1) - 1);
		  else
		    $$ = (1 << ($1 + 1)) - 1 - ((1 << $3) - 1);
		}
	;

reglistreg:
	  DR
		{
		  $$ = $1 - DATA0;
		}
	| AR
		{
		  $$ = $1 - ADDR0 + 8;
		}
	| FPR
		{
		  $$ = $1 - FP0 + 16;
		}
	| FPCR
		{
		  if ($1 == FPI)
		    $$ = 24;
		  else if ($1 == FPS)
		    $$ = 25;
		  else
		    $$ = 26;
		}
	;

%%

/* The string to parse is stored here, and modified by yylex.  */

static char *str;

/* The original string pointer.  */

static char *strorig;

/* If *CCP could be a register, return the register number and advance
   *CCP.  Otherwise don't change *CCP, and return 0.  */

static enum m68k_register
m68k_reg_parse (ccp)
     register char **ccp;
{
  char *start = *ccp;
  char c;
  char *p;
  symbolS *symbolp;

  if (flag_reg_prefix_optional)
    {
      if (*start == REGISTER_PREFIX)
	start++;
      p = start;
    }
  else
    {
      if (*start != REGISTER_PREFIX)
	return 0;
      p = start + 1;
    }

  if (! is_name_beginner (*p))
    return 0;

  p++;
  while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*')
    p++;

  c = *p;
  *p = 0;
  symbolp = symbol_find (start);
  *p = c;

  if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section)
    {
      *ccp = p;
      return S_GET_VALUE (symbolp);
    }

  /* In MRI mode, something like foo.bar can be equated to a register
     name.  */
  while (flag_mri && c == '.')
    {
      ++p;
      while (is_part_of_name (*p) && *p != '.' && *p != ':' && *p != '*')
	p++;
      c = *p;
      *p = '\0';
      symbolp = symbol_find (start);
      *p = c;
      if (symbolp != NULL && S_GET_SEGMENT (symbolp) == reg_section)
	{
	  *ccp = p;
	  return S_GET_VALUE (symbolp);
	}
    }

  return 0;
}

/* The lexer.  */

static int
yylex ()
{
  enum m68k_register reg;
  char *s;
  int parens;
  int c = 0;
  int tail = 0;
  char *hold;

  if (*str == ' ')
    ++str;

  if (*str == '\0')
    return 0;

  /* Various special characters are just returned directly.  */
  switch (*str)
    {
    case '@':
      /* In MRI mode, this can be the start of an octal number.  */
      if (flag_mri)
	{
	  if (ISDIGIT (str[1])
	      || ((str[1] == '+' || str[1] == '-')
		  && ISDIGIT (str[2])))
	    break;
	}
      /* Fall through.  */
    case '#':
    case '&':
    case ',':
    case ')':
    case '/':
    case '[':
    case ']':
      return *str++;
    case '+':
      /* It so happens that a '+' can only appear at the end of an
         operand.  If it appears anywhere else, it must be a unary
         plus on an expression.  */
      if (str[1] == '\0')
	return *str++;
      break;
    case '-':
      /* A '-' can only appear in -(ar), rn-rn, or ar@-.  If it
         appears anywhere else, it must be a unary minus on an
         expression.  */
      if (str[1] == '\0')
	return *str++;
      s = str + 1;
      if (*s == '(')
	++s;
      if (m68k_reg_parse (&s) != 0)
	return *str++;
      break;
    case '(':
      /* A '(' can only appear in `(reg)', `(expr,...', `([', `@(', or
         `)('.  If it appears anywhere else, it must be starting an
         expression.  */
      if (str[1] == '['
	  || (str > strorig
	      && (str[-1] == '@'
		  || str[-1] == ')')))
	return *str++;
      s = str + 1;
      if (m68k_reg_parse (&s) != 0)
	return *str++;
      /* Check for the case of '(expr,...' by scanning ahead.  If we
         find a comma outside of balanced parentheses, we return '('.
         If we find an unbalanced right parenthesis, then presumably
         the '(' really starts an expression.  */
      parens = 0;
      for (s = str + 1; *s != '\0'; s++)
	{
	  if (*s == '(')
	    ++parens;
	  else if (*s == ')')
	    {
	      if (parens == 0)
		break;
	      --parens;
	    }
	  else if (*s == ',' && parens == 0)
	    {
	      /* A comma can not normally appear in an expression, so
		 this is a case of '(expr,...'.  */
	      return *str++;
	    }
	}
    }

  /* See if it's a register.  */

  reg = m68k_reg_parse (&str);
  if (reg != 0)
    {
      int ret;

      yylval.reg = reg;

      if (reg >= DATA0 && reg <= DATA7)
	ret = DR;
      else if (reg >= ADDR0 && reg <= ADDR7)
	ret = AR;
      else if (reg >= FP0 && reg <= FP7)
	return FPR;
      else if (reg == FPI
	       || reg == FPS
	       || reg == FPC)
	return FPCR;
      else if (reg == PC)
	return LPC;
      else if (reg >= ZDATA0 && reg <= ZDATA7)
	ret = ZDR;
      else if (reg >= ZADDR0 && reg <= ZADDR7)
	ret = ZAR;
      else if (reg == ZPC)
	return LZPC;
      else
	return CREG;

      /* If we get here, we have a data or address register.  We
	 must check for a size or scale; if we find one, we must
	 return INDEXREG.  */

      s = str;

      if (*s != '.' && *s != ':' && *s != '*')
	return ret;

      yylval.indexreg.reg = reg;

      if (*s != '.' && *s != ':')
	yylval.indexreg.size = SIZE_UNSPEC;
      else
	{
	  ++s;
	  switch (*s)
	    {
	    case 'w':
	    case 'W':
	      yylval.indexreg.size = SIZE_WORD;
	      ++s;
	      break;
	    case 'l':
	    case 'L':
	      yylval.indexreg.size = SIZE_LONG;
	      ++s;
	      break;
	    default:
	      yyerror (_("illegal size specification"));
	      yylval.indexreg.size = SIZE_UNSPEC;
	      break;
	    }
	}

      yylval.indexreg.scale = 1;

      if (*s == '*' || *s == ':')
	{
	  expressionS scale;

	  ++s;

	  hold = input_line_pointer;
	  input_line_pointer = s;
	  expression (&scale);
	  s = input_line_pointer;
	  input_line_pointer = hold;

	  if (scale.X_op != O_constant)
	    yyerror (_("scale specification must resolve to a number"));
	  else
	    {
	      switch (scale.X_add_number)
		{
		case 1:
		case 2:
		case 4:
		case 8:
		  yylval.indexreg.scale = scale.X_add_number;
		  break;
		default:
		  yyerror (_("invalid scale value"));
		  break;
		}
	    }
	}

      str = s;

      return INDEXREG;
    }

  /* It must be an expression.  Before we call expression, we need to
     look ahead to see if there is a size specification.  We must do
     that first, because otherwise foo.l will be treated as the symbol
     foo.l, rather than as the symbol foo with a long size
     specification.  The grammar requires that all expressions end at
     the end of the operand, or with ',', '(', ']', ')'.  */

  parens = 0;
  for (s = str; *s != '\0'; s++)
    {
      if (*s == '(')
	{
	  if (parens == 0
	      && s > str
	      && (s[-1] == ')' || ISALNUM (s[-1])))
	    break;
	  ++parens;
	}
      else if (*s == ')')
	{
	  if (parens == 0)
	    break;
	  --parens;
	}
      else if (parens == 0
	       && (*s == ',' || *s == ']'))
	break;
    }

  yylval.exp.size = SIZE_UNSPEC;
  if (s <= str + 2
      || (s[-2] != '.' && s[-2] != ':'))
    tail = 0;
  else
    {
      switch (s[-1])
	{
	case 's':
	case 'S':
	case 'b':
	case 'B':
	  yylval.exp.size = SIZE_BYTE;
	  break;
	case 'w':
	case 'W':
	  yylval.exp.size = SIZE_WORD;
	  break;
	case 'l':
	case 'L':
	  yylval.exp.size = SIZE_LONG;
	  break;
	default:
	  break;
	}
      if (yylval.exp.size != SIZE_UNSPEC)
	tail = 2;
    }

#ifdef OBJ_ELF
  {
    /* Look for @PLTPC, etc.  */
    char *cp;

    yylval.exp.pic_reloc = pic_none;
    cp = s - tail;
    if (cp - 6 > str && cp[-6] == '@')
      {
	if (strncmp (cp - 6, "@PLTPC", 6) == 0)
	  {
	    yylval.exp.pic_reloc = pic_plt_pcrel;
	    tail += 6;
	  }
	else if (strncmp (cp - 6, "@GOTPC", 6) == 0)
	  {
	    yylval.exp.pic_reloc = pic_got_pcrel;
	    tail += 6;
	  }
      }
    else if (cp - 4 > str && cp[-4] == '@')
      {
	if (strncmp (cp - 4, "@PLT", 4) == 0)
	  {
	    yylval.exp.pic_reloc = pic_plt_off;
	    tail += 4;
	  }
	else if (strncmp (cp - 4, "@GOT", 4) == 0)
	  {
	    yylval.exp.pic_reloc = pic_got_off;
	    tail += 4;
	  }
      }
  }
#endif

  if (tail != 0)
    {
      c = s[-tail];
      s[-tail] = 0;
    }

  hold = input_line_pointer;
  input_line_pointer = str;
  expression (&yylval.exp.exp);
  str = input_line_pointer;
  input_line_pointer = hold;

  if (tail != 0)
    {
      s[-tail] = c;
      str = s;
    }

  return EXPR;
}

/* Parse an m68k operand.  This is the only function which is called
   from outside this file.  */

int
m68k_ip_op (s, oparg)
     char *s;
     struct m68k_op *oparg;
{
  memset (oparg, 0, sizeof *oparg);
  oparg->error = NULL;
  oparg->index.reg = ZDATA0;
  oparg->index.scale = 1;
  oparg->disp.exp.X_op = O_absent;
  oparg->odisp.exp.X_op = O_absent;

  str = strorig = s;
  op = oparg;

  return yyparse ();
}

/* The error handler.  */

static void
yyerror (s)
     const char *s;
{
  op->error = s;
}
Commit	Line	Data
252b5132	1	/* m68k.y -- bison grammar for m68k operand parsing
3882b010	2	Copyright 1995, 1996, 1997, 1998, 2001 Free Software Foundation, Inc.
252b5132 RH	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"
3882b010	32	#include "safe-ctype.h"
252b5132 RH	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	{
3882b010	747	if (ISDIGIT (str[1])
252b5132	748	\|\| ((str[1] == '+' \|\| str[1] == '-')
3882b010	749	&& ISDIGIT (str[2])))
252b5132 RH	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
3882b010	933	&& (s[-1] == ')' \|\| ISALNUM (s[-1])))
252b5132 RH	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	}