gas/expr.c

   1 /* expr.c -operands, expressions-
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 /* This is really a branch office of as-read.c. I split it out to clearly
  24    distinguish the world of expressions from the world of statements.
  25    (It also gives smaller files to re-compile.)
  26    Here, "operand"s are of expressions, not instructions.  */
  27
  28 #include <string.h>
  29 #define min(a, b)       ((a) < (b) ? (a) : (b))
  30
  31 #include "as.h"
  32 #include "safe-ctype.h"
  33 #include "obstack.h"
  34
  35 static void floating_constant PARAMS ((expressionS * expressionP));
  36 static valueT generic_bignum_to_int32 PARAMS ((void));
  37 #ifdef BFD64
  38 static valueT generic_bignum_to_int64 PARAMS ((void));
  39 #endif
  40 static void integer_constant PARAMS ((int radix, expressionS * expressionP));
  41 static void mri_char_constant PARAMS ((expressionS *));
  42 static void current_location PARAMS ((expressionS *));
  43 static void clean_up_expression PARAMS ((expressionS * expressionP));
  44 static segT operand PARAMS ((expressionS *));
  45 static operatorT operator PARAMS ((int *));
  46
  47 extern const char EXP_CHARS[], FLT_CHARS[];
  48
  49 /* We keep a mapping of expression symbols to file positions, so that
  50    we can provide better error messages.  */
  51
  52 struct expr_symbol_line {
  53   struct expr_symbol_line *next;
  54   symbolS *sym;
  55   char *file;
  56   unsigned int line;
  57 };
  58
  59 static struct expr_symbol_line *expr_symbol_lines;
  60 \f
  61 /* Build a dummy symbol to hold a complex expression.  This is how we
  62    build expressions up out of other expressions.  The symbol is put
  63    into the fake section expr_section.  */
  64
  65 symbolS *
  66 make_expr_symbol (expressionP)
  67      expressionS *expressionP;
  68 {
  69   expressionS zero;
  70   const char *fake;
  71   symbolS *symbolP;
  72   struct expr_symbol_line *n;
  73
  74   if (expressionP->X_op == O_symbol
  75       && expressionP->X_add_number == 0)
  76     return expressionP->X_add_symbol;
  77
  78   if (expressionP->X_op == O_big)
  79     {
  80       /* This won't work, because the actual value is stored in
  81          generic_floating_point_number or generic_bignum, and we are
  82          going to lose it if we haven't already.  */
  83       if (expressionP->X_add_number > 0)
  84         as_bad (_("bignum invalid"));
  85       else
  86         as_bad (_("floating point number invalid"));
  87       zero.X_op = O_constant;
  88       zero.X_add_number = 0;
  89       zero.X_unsigned = 0;
  90       clean_up_expression (&zero);
  91       expressionP = &zero;
  92     }
  93
  94   fake = FAKE_LABEL_NAME;
  95
  96   /* Putting constant symbols in absolute_section rather than
  97      expr_section is convenient for the old a.out code, for which
  98      S_GET_SEGMENT does not always retrieve the value put in by
  99      S_SET_SEGMENT.  */
 100   symbolP = symbol_create (fake,
 101                            (expressionP->X_op == O_constant
 102                             ? absolute_section
 103                             : expr_section),
 104                            0, &zero_address_frag);
 105   symbol_set_value_expression (symbolP, expressionP);
 106
 107   if (expressionP->X_op == O_constant)
 108     resolve_symbol_value (symbolP);
 109
 110   n = (struct expr_symbol_line *) xmalloc (sizeof *n);
 111   n->sym = symbolP;
 112   as_where (&n->file, &n->line);
 113   n->next = expr_symbol_lines;
 114   expr_symbol_lines = n;
 115
 116   return symbolP;
 117 }
 118
 119 /* Return the file and line number for an expr symbol.  Return
 120    non-zero if something was found, 0 if no information is known for
 121    the symbol.  */
 122
 123 int
 124 expr_symbol_where (sym, pfile, pline)
 125      symbolS *sym;
 126      char **pfile;
 127      unsigned int *pline;
 128 {
 129   register struct expr_symbol_line *l;
 130
 131   for (l = expr_symbol_lines; l != NULL; l = l->next)
 132     {
 133       if (l->sym == sym)
 134         {
 135           *pfile = l->file;
 136           *pline = l->line;
 137           return 1;
 138         }
 139     }
 140
 141   return 0;
 142 }
 143 \f
 144 /* Utilities for building expressions.
 145    Since complex expressions are recorded as symbols for use in other
 146    expressions these return a symbolS * and not an expressionS *.
 147    These explicitly do not take an "add_number" argument.  */
 148 /* ??? For completeness' sake one might want expr_build_symbol.
 149    It would just return its argument.  */
 150
 151 /* Build an expression for an unsigned constant.
 152    The corresponding one for signed constants is missing because
 153    there's currently no need for it.  One could add an unsigned_p flag
 154    but that seems more clumsy.  */
 155
 156 symbolS *
 157 expr_build_uconstant (value)
 158      offsetT value;
 159 {
 160   expressionS e;
 161
 162   e.X_op = O_constant;
 163   e.X_add_number = value;
 164   e.X_unsigned = 1;
 165   return make_expr_symbol (&e);
 166 }
 167
 168 /* Build an expression for OP s1.  */
 169
 170 symbolS *
 171 expr_build_unary (op, s1)
 172      operatorT op;
 173      symbolS *s1;
 174 {
 175   expressionS e;
 176
 177   e.X_op = op;
 178   e.X_add_symbol = s1;
 179   e.X_add_number = 0;
 180   return make_expr_symbol (&e);
 181 }
 182
 183 /* Build an expression for s1 OP s2.  */
 184
 185 symbolS *
 186 expr_build_binary (op, s1, s2)
 187      operatorT op;
 188      symbolS *s1;
 189      symbolS *s2;
 190 {
 191   expressionS e;
 192
 193   e.X_op = op;
 194   e.X_add_symbol = s1;
 195   e.X_op_symbol = s2;
 196   e.X_add_number = 0;
 197   return make_expr_symbol (&e);
 198 }
 199
 200 /* Build an expression for the current location ('.').  */
 201
 202 symbolS *
 203 expr_build_dot ()
 204 {
 205   expressionS e;
 206
 207   current_location (&e);
 208   return make_expr_symbol (&e);
 209 }
 210 \f
 211 /* Build any floating-point literal here.
 212    Also build any bignum literal here.  */
 213
 214 /* Seems atof_machine can backscan through generic_bignum and hit whatever
 215    happens to be loaded before it in memory.  And its way too complicated
 216    for me to fix right.  Thus a hack.  JF:  Just make generic_bignum bigger,
 217    and never write into the early words, thus they'll always be zero.
 218    I hate Dean's floating-point code.  Bleh.  */
 219 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
 220
 221 FLONUM_TYPE generic_floating_point_number = {
 222   &generic_bignum[6],           /* low.  (JF: Was 0)  */
 223   &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high.  JF: (added +6)  */
 224   0,                            /* leader.  */
 225   0,                            /* exponent.  */
 226   0                             /* sign.  */
 227 };
 228
 229 /* If nonzero, we've been asked to assemble nan, +inf or -inf.  */
 230 int generic_floating_point_magic;
 231 \f
 232 static void
 233 floating_constant (expressionP)
 234      expressionS *expressionP;
 235 {
 236   /* input_line_pointer -> floating-point constant.  */
 237   int error_code;
 238
 239   error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
 240                              &generic_floating_point_number);
 241
 242   if (error_code)
 243     {
 244       if (error_code == ERROR_EXPONENT_OVERFLOW)
 245         {
 246           as_bad (_("bad floating-point constant: exponent overflow"));
 247         }
 248       else
 249         {
 250           as_bad (_("bad floating-point constant: unknown error code=%d"),
 251                   error_code);
 252         }
 253     }
 254   expressionP->X_op = O_big;
 255   /* input_line_pointer -> just after constant, which may point to
 256      whitespace.  */
 257   expressionP->X_add_number = -1;
 258 }
 259
 260 static valueT
 261 generic_bignum_to_int32 ()
 262 {
 263   valueT number =
 264            ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
 265            | (generic_bignum[0] & LITTLENUM_MASK);
 266   number &= 0xffffffff;
 267   return number;
 268 }
 269
 270 #ifdef BFD64
 271 static valueT
 272 generic_bignum_to_int64 ()
 273 {
 274   valueT number =
 275     ((((((((valueT) generic_bignum[3] & LITTLENUM_MASK)
 276           << LITTLENUM_NUMBER_OF_BITS)
 277          | ((valueT) generic_bignum[2] & LITTLENUM_MASK))
 278         << LITTLENUM_NUMBER_OF_BITS)
 279        | ((valueT) generic_bignum[1] & LITTLENUM_MASK))
 280       << LITTLENUM_NUMBER_OF_BITS)
 281      | ((valueT) generic_bignum[0] & LITTLENUM_MASK));
 282   return number;
 283 }
 284 #endif
 285
 286 static void
 287 integer_constant (radix, expressionP)
 288      int radix;
 289      expressionS *expressionP;
 290 {
 291   char *start;          /* Start of number.  */
 292   char *suffix = NULL;
 293   char c;
 294   valueT number;        /* Offset or (absolute) value.  */
 295   short int digit;      /* Value of next digit in current radix.  */
 296   short int maxdig = 0; /* Highest permitted digit value.  */
 297   int too_many_digits = 0;      /* If we see >= this number of.  */
 298   char *name;           /* Points to name of symbol.  */
 299   symbolS *symbolP;     /* Points to symbol.  */
 300
 301   int small;                    /* True if fits in 32 bits.  */
 302
 303   /* May be bignum, or may fit in 32 bits.  */
 304   /* Most numbers fit into 32 bits, and we want this case to be fast.
 305      so we pretend it will fit into 32 bits.  If, after making up a 32
 306      bit number, we realise that we have scanned more digits than
 307      comfortably fit into 32 bits, we re-scan the digits coding them
 308      into a bignum.  For decimal and octal numbers we are
 309      conservative: Some numbers may be assumed bignums when in fact
 310      they do fit into 32 bits.  Numbers of any radix can have excess
 311      leading zeros: We strive to recognise this and cast them back
 312      into 32 bits.  We must check that the bignum really is more than
 313      32 bits, and change it back to a 32-bit number if it fits.  The
 314      number we are looking for is expected to be positive, but if it
 315      fits into 32 bits as an unsigned number, we let it be a 32-bit
 316      number.  The cavalier approach is for speed in ordinary cases.  */
 317   /* This has been extended for 64 bits.  We blindly assume that if
 318      you're compiling in 64-bit mode, the target is a 64-bit machine.
 319      This should be cleaned up.  */
 320
 321 #ifdef BFD64
 322 #define valuesize 64
 323 #else /* includes non-bfd case, mostly */
 324 #define valuesize 32
 325 #endif
 326
 327   if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
 328     {
 329       int flt = 0;
 330
 331       /* In MRI mode, the number may have a suffix indicating the
 332          radix.  For that matter, it might actually be a floating
 333          point constant.  */
 334       for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
 335         {
 336           if (*suffix == 'e' || *suffix == 'E')
 337             flt = 1;
 338         }
 339
 340       if (suffix == input_line_pointer)
 341         {
 342           radix = 10;
 343           suffix = NULL;
 344         }
 345       else
 346         {
 347           c = *--suffix;
 348           c = TOUPPER (c);
 349           if (c == 'B')
 350             radix = 2;
 351           else if (c == 'D')
 352             radix = 10;
 353           else if (c == 'O' || c == 'Q')
 354             radix = 8;
 355           else if (c == 'H')
 356             radix = 16;
 357           else if (suffix[1] == '.' || c == 'E' || flt)
 358             {
 359               floating_constant (expressionP);
 360               return;
 361             }
 362           else
 363             {
 364               radix = 10;
 365               suffix = NULL;
 366             }
 367         }
 368     }
 369
 370   switch (radix)
 371     {
 372     case 2:
 373       maxdig = 2;
 374       too_many_digits = valuesize + 1;
 375       break;
 376     case 8:
 377       maxdig = radix = 8;
 378       too_many_digits = (valuesize + 2) / 3 + 1;
 379       break;
 380     case 16:
 381       maxdig = radix = 16;
 382       too_many_digits = (valuesize + 3) / 4 + 1;
 383       break;
 384     case 10:
 385       maxdig = radix = 10;
 386       too_many_digits = (valuesize + 11) / 4; /* Very rough.  */
 387     }
 388 #undef valuesize
 389   start = input_line_pointer;
 390   c = *input_line_pointer++;
 391   for (number = 0;
 392        (digit = hex_value (c)) < maxdig;
 393        c = *input_line_pointer++)
 394     {
 395       number = number * radix + digit;
 396     }
 397   /* c contains character after number.  */
 398   /* input_line_pointer->char after c.  */
 399   small = (input_line_pointer - start - 1) < too_many_digits;
 400
 401   if (radix == 16 && c == '_')
 402     {
 403       /* This is literal of the form 0x333_0_12345678_1.
 404          This example is equivalent to 0x00000333000000001234567800000001.  */
 405
 406       int num_little_digits = 0;
 407       int i;
 408       input_line_pointer = start;       /* -> 1st digit.  */
 409
 410       know (LITTLENUM_NUMBER_OF_BITS == 16);
 411
 412       for (c = '_'; c == '_'; num_little_digits += 2)
 413         {
 414
 415           /* Convert one 64-bit word.  */
 416           int ndigit = 0;
 417           number = 0;
 418           for (c = *input_line_pointer++;
 419                (digit = hex_value (c)) < maxdig;
 420                c = *(input_line_pointer++))
 421             {
 422               number = number * radix + digit;
 423               ndigit++;
 424             }
 425
 426           /* Check for 8 digit per word max.  */
 427           if (ndigit > 8)
 428             as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
 429
 430           /* Add this chunk to the bignum.
 431              Shift things down 2 little digits.  */
 432           know (LITTLENUM_NUMBER_OF_BITS == 16);
 433           for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1);
 434                i >= 2;
 435                i--)
 436             generic_bignum[i] = generic_bignum[i - 2];
 437
 438           /* Add the new digits as the least significant new ones.  */
 439           generic_bignum[0] = number & 0xffffffff;
 440           generic_bignum[1] = number >> 16;
 441         }
 442
 443       /* Again, c is char after number, input_line_pointer->after c.  */
 444
 445       if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
 446         num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
 447
 448       assert (num_little_digits >= 4);
 449
 450       if (num_little_digits != 8)
 451         as_bad (_("a bignum with underscores must have exactly 4 words"));
 452
 453       /* We might have some leading zeros.  These can be trimmed to give
 454          us a change to fit this constant into a small number.  */
 455       while (generic_bignum[num_little_digits - 1] == 0
 456              && num_little_digits > 1)
 457         num_little_digits--;
 458
 459       if (num_little_digits <= 2)
 460         {
 461           /* will fit into 32 bits.  */
 462           number = generic_bignum_to_int32 ();
 463           small = 1;
 464         }
 465 #ifdef BFD64
 466       else if (num_little_digits <= 4)
 467         {
 468           /* Will fit into 64 bits.  */
 469           number = generic_bignum_to_int64 ();
 470           small = 1;
 471         }
 472 #endif
 473       else
 474         {
 475           small = 0;
 476
 477           /* Number of littlenums in the bignum.  */
 478           number = num_little_digits;
 479         }
 480     }
 481   else if (!small)
 482     {
 483       /* We saw a lot of digits. manufacture a bignum the hard way.  */
 484       LITTLENUM_TYPE *leader;   /* -> high order littlenum of the bignum.  */
 485       LITTLENUM_TYPE *pointer;  /* -> littlenum we are frobbing now.  */
 486       long carry;
 487
 488       leader = generic_bignum;
 489       generic_bignum[0] = 0;
 490       generic_bignum[1] = 0;
 491       generic_bignum[2] = 0;
 492       generic_bignum[3] = 0;
 493       input_line_pointer = start;       /* -> 1st digit.  */
 494       c = *input_line_pointer++;
 495       for (; (carry = hex_value (c)) < maxdig; c = *input_line_pointer++)
 496         {
 497           for (pointer = generic_bignum; pointer <= leader; pointer++)
 498             {
 499               long work;
 500
 501               work = carry + radix * *pointer;
 502               *pointer = work & LITTLENUM_MASK;
 503               carry = work >> LITTLENUM_NUMBER_OF_BITS;
 504             }
 505           if (carry)
 506             {
 507               if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
 508                 {
 509                   /* Room to grow a longer bignum.  */
 510                   *++leader = carry;
 511                 }
 512             }
 513         }
 514       /* Again, c is char after number.  */
 515       /* input_line_pointer -> after c.  */
 516       know (LITTLENUM_NUMBER_OF_BITS == 16);
 517       if (leader < generic_bignum + 2)
 518         {
 519           /* Will fit into 32 bits.  */
 520           number = generic_bignum_to_int32 ();
 521           small = 1;
 522         }
 523 #ifdef BFD64
 524       else if (leader < generic_bignum + 4)
 525         {
 526           /* Will fit into 64 bits.  */
 527           number = generic_bignum_to_int64 ();
 528           small = 1;
 529         }
 530 #endif
 531       else
 532         {
 533           /* Number of littlenums in the bignum.  */
 534           number = leader - generic_bignum + 1;
 535         }
 536     }
 537
 538   if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
 539       && suffix != NULL
 540       && input_line_pointer - 1 == suffix)
 541     c = *input_line_pointer++;
 542
 543   if (small)
 544     {
 545       /* Here with number, in correct radix. c is the next char.
 546          Note that unlike un*x, we allow "011f" "0x9f" to both mean
 547          the same as the (conventional) "9f".
 548          This is simply easier than checking for strict canonical
 549          form.  Syntax sux!  */
 550
 551       if (LOCAL_LABELS_FB && c == 'b')
 552         {
 553           /* Backward ref to local label.
 554              Because it is backward, expect it to be defined.  */
 555           /* Construct a local label.  */
 556           name = fb_label_name ((int) number, 0);
 557
 558           /* Seen before, or symbol is defined: OK.  */
 559           symbolP = symbol_find (name);
 560           if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
 561             {
 562               /* Local labels are never absolute.  Don't waste time
 563                  checking absoluteness.  */
 564               know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
 565
 566               expressionP->X_op = O_symbol;
 567               expressionP->X_add_symbol = symbolP;
 568             }
 569           else
 570             {
 571               /* Either not seen or not defined.  */
 572               /* @@ Should print out the original string instead of
 573                  the parsed number.  */
 574               as_bad (_("backward ref to unknown label \"%d:\""),
 575                       (int) number);
 576               expressionP->X_op = O_constant;
 577             }
 578
 579           expressionP->X_add_number = 0;
 580         }                       /* case 'b' */
 581       else if (LOCAL_LABELS_FB && c == 'f')
 582         {
 583           /* Forward reference.  Expect symbol to be undefined or
 584              unknown.  undefined: seen it before.  unknown: never seen
 585              it before.
 586
 587              Construct a local label name, then an undefined symbol.
 588              Don't create a xseg frag for it: caller may do that.
 589              Just return it as never seen before.  */
 590           name = fb_label_name ((int) number, 1);
 591           symbolP = symbol_find_or_make (name);
 592           /* We have no need to check symbol properties.  */
 593 #ifndef many_segments
 594           /* Since "know" puts its arg into a "string", we
 595              can't have newlines in the argument.  */
 596           know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
 597 #endif
 598           expressionP->X_op = O_symbol;
 599           expressionP->X_add_symbol = symbolP;
 600           expressionP->X_add_number = 0;
 601         }                       /* case 'f' */
 602       else if (LOCAL_LABELS_DOLLAR && c == '$')
 603         {
 604           /* If the dollar label is *currently* defined, then this is just
 605              another reference to it.  If it is not *currently* defined,
 606              then this is a fresh instantiation of that number, so create
 607              it.  */
 608
 609           if (dollar_label_defined ((long) number))
 610             {
 611               name = dollar_label_name ((long) number, 0);
 612               symbolP = symbol_find (name);
 613               know (symbolP != NULL);
 614             }
 615           else
 616             {
 617               name = dollar_label_name ((long) number, 1);
 618               symbolP = symbol_find_or_make (name);
 619             }
 620
 621           expressionP->X_op = O_symbol;
 622           expressionP->X_add_symbol = symbolP;
 623           expressionP->X_add_number = 0;
 624         }                       /* case '$' */
 625       else
 626         {
 627           expressionP->X_op = O_constant;
 628 #ifdef TARGET_WORD_SIZE
 629           /* Sign extend NUMBER.  */
 630           number |= (-(number >> (TARGET_WORD_SIZE - 1))) << (TARGET_WORD_SIZE - 1);
 631 #endif
 632           expressionP->X_add_number = number;
 633           input_line_pointer--; /* Restore following character.  */
 634         }                       /* Really just a number.  */
 635     }
 636   else
 637     {
 638       /* Not a small number.  */
 639       expressionP->X_op = O_big;
 640       expressionP->X_add_number = number;       /* Number of littlenums.  */
 641       input_line_pointer--;     /* -> char following number.  */
 642     }
 643 }
 644
 645 /* Parse an MRI multi character constant.  */
 646
 647 static void
 648 mri_char_constant (expressionP)
 649      expressionS *expressionP;
 650 {
 651   int i;
 652
 653   if (*input_line_pointer == '\''
 654       && input_line_pointer[1] != '\'')
 655     {
 656       expressionP->X_op = O_constant;
 657       expressionP->X_add_number = 0;
 658       return;
 659     }
 660
 661   /* In order to get the correct byte ordering, we must build the
 662      number in reverse.  */
 663   for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
 664     {
 665       int j;
 666
 667       generic_bignum[i] = 0;
 668       for (j = 0; j < CHARS_PER_LITTLENUM; j++)
 669         {
 670           if (*input_line_pointer == '\'')
 671             {
 672               if (input_line_pointer[1] != '\'')
 673                 break;
 674               ++input_line_pointer;
 675             }
 676           generic_bignum[i] <<= 8;
 677           generic_bignum[i] += *input_line_pointer;
 678           ++input_line_pointer;
 679         }
 680
 681       if (i < SIZE_OF_LARGE_NUMBER - 1)
 682         {
 683           /* If there is more than one littlenum, left justify the
 684              last one to make it match the earlier ones.  If there is
 685              only one, we can just use the value directly.  */
 686           for (; j < CHARS_PER_LITTLENUM; j++)
 687             generic_bignum[i] <<= 8;
 688         }
 689
 690       if (*input_line_pointer == '\''
 691           && input_line_pointer[1] != '\'')
 692         break;
 693     }
 694
 695   if (i < 0)
 696     {
 697       as_bad (_("character constant too large"));
 698       i = 0;
 699     }
 700
 701   if (i > 0)
 702     {
 703       int c;
 704       int j;
 705
 706       c = SIZE_OF_LARGE_NUMBER - i;
 707       for (j = 0; j < c; j++)
 708         generic_bignum[j] = generic_bignum[i + j];
 709       i = c;
 710     }
 711
 712   know (LITTLENUM_NUMBER_OF_BITS == 16);
 713   if (i > 2)
 714     {
 715       expressionP->X_op = O_big;
 716       expressionP->X_add_number = i;
 717     }
 718   else
 719     {
 720       expressionP->X_op = O_constant;
 721       if (i < 2)
 722         expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
 723       else
 724         expressionP->X_add_number =
 725           (((generic_bignum[1] & LITTLENUM_MASK)
 726             << LITTLENUM_NUMBER_OF_BITS)
 727            | (generic_bignum[0] & LITTLENUM_MASK));
 728     }
 729
 730   /* Skip the final closing quote.  */
 731   ++input_line_pointer;
 732 }
 733
 734 /* Return an expression representing the current location.  This
 735    handles the magic symbol `.'.  */
 736
 737 static void
 738 current_location (expressionp)
 739      expressionS *expressionp;
 740 {
 741   if (now_seg == absolute_section)
 742     {
 743       expressionp->X_op = O_constant;
 744       expressionp->X_add_number = abs_section_offset;
 745     }
 746   else
 747     {
 748       symbolS *symbolp;
 749
 750       symbolp = symbol_new (FAKE_LABEL_NAME, now_seg,
 751                             (valueT) frag_now_fix (),
 752                             frag_now);
 753       expressionp->X_op = O_symbol;
 754       expressionp->X_add_symbol = symbolp;
 755       expressionp->X_add_number = 0;
 756     }
 757 }
 758
 759 /* In:  Input_line_pointer points to 1st char of operand, which may
 760         be a space.
 761
 762    Out: An expressionS.
 763         The operand may have been empty: in this case X_op == O_absent.
 764         Input_line_pointer->(next non-blank) char after operand.  */
 765
 766 static segT
 767 operand (expressionP)
 768      expressionS *expressionP;
 769 {
 770   char c;
 771   symbolS *symbolP;     /* Points to symbol.  */
 772   char *name;           /* Points to name of symbol.  */
 773   segT segment;
 774
 775   /* All integers are regarded as unsigned unless they are negated.
 776      This is because the only thing which cares whether a number is
 777      unsigned is the code in emit_expr which extends constants into
 778      bignums.  It should only sign extend negative numbers, so that
 779      something like ``.quad 0x80000000'' is not sign extended even
 780      though it appears negative if valueT is 32 bits.  */
 781   expressionP->X_unsigned = 1;
 782
 783   /* Digits, assume it is a bignum.  */
 784
 785   SKIP_WHITESPACE ();           /* Leading whitespace is part of operand.  */
 786   c = *input_line_pointer++;    /* input_line_pointer -> past char in c.  */
 787
 788   if (is_end_of_line[(unsigned char) c])
 789     goto eol;
 790
 791   switch (c)
 792     {
 793     case '1':
 794     case '2':
 795     case '3':
 796     case '4':
 797     case '5':
 798     case '6':
 799     case '7':
 800     case '8':
 801     case '9':
 802       input_line_pointer--;
 803
 804       integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
 805                         ? 0 : 10,
 806                         expressionP);
 807       break;
 808
 809 #ifdef LITERAL_PREFIXDOLLAR_HEX
 810     case '$':
 811       /* $L is the start of a local label, not a hex constant.  */
 812       if (* input_line_pointer == 'L')
 813       goto isname;
 814       integer_constant (16, expressionP);
 815       break;
 816 #endif
 817
 818 #ifdef LITERAL_PREFIXPERCENT_BIN
 819     case '%':
 820       integer_constant (2, expressionP);
 821       break;
 822 #endif
 823
 824     case '0':
 825       /* Non-decimal radix.  */
 826
 827       if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
 828         {
 829           char *s;
 830
 831           /* Check for a hex constant.  */
 832           for (s = input_line_pointer; hex_p (*s); s++)
 833             ;
 834           if (*s == 'h' || *s == 'H')
 835             {
 836               --input_line_pointer;
 837               integer_constant (0, expressionP);
 838               break;
 839             }
 840         }
 841       c = *input_line_pointer;
 842       switch (c)
 843         {
 844         case 'o':
 845         case 'O':
 846         case 'q':
 847         case 'Q':
 848         case '8':
 849         case '9':
 850           if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
 851             {
 852               integer_constant (0, expressionP);
 853               break;
 854             }
 855           /* Fall through.  */
 856         default:
 857         default_case:
 858           if (c && strchr (FLT_CHARS, c))
 859             {
 860               input_line_pointer++;
 861               floating_constant (expressionP);
 862               expressionP->X_add_number = - TOLOWER (c);
 863             }
 864           else
 865             {
 866               /* The string was only zero.  */
 867               expressionP->X_op = O_constant;
 868               expressionP->X_add_number = 0;
 869             }
 870
 871           break;
 872
 873         case 'x':
 874         case 'X':
 875           if (flag_m68k_mri)
 876             goto default_case;
 877           input_line_pointer++;
 878           integer_constant (16, expressionP);
 879           break;
 880
 881         case 'b':
 882           if (LOCAL_LABELS_FB && ! (flag_m68k_mri || NUMBERS_WITH_SUFFIX))
 883             {
 884               /* This code used to check for '+' and '-' here, and, in
 885                  some conditions, fall through to call
 886                  integer_constant.  However, that didn't make sense,
 887                  as integer_constant only accepts digits.  */
 888               /* Some of our code elsewhere does permit digits greater
 889                  than the expected base; for consistency, do the same
 890                  here.  */
 891               if (input_line_pointer[1] < '0'
 892                   || input_line_pointer[1] > '9')
 893                 {
 894                   /* Parse this as a back reference to label 0.  */
 895                   input_line_pointer--;
 896                   integer_constant (10, expressionP);
 897                   break;
 898                 }
 899               /* Otherwise, parse this as a binary number.  */
 900             }
 901           /* Fall through.  */
 902         case 'B':
 903           input_line_pointer++;
 904           if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
 905             goto default_case;
 906           integer_constant (2, expressionP);
 907           break;
 908
 909         case '0':
 910         case '1':
 911         case '2':
 912         case '3':
 913         case '4':
 914         case '5':
 915         case '6':
 916         case '7':
 917           integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX)
 918                             ? 0 : 8,
 919                             expressionP);
 920           break;
 921
 922         case 'f':
 923           if (LOCAL_LABELS_FB)
 924             {
 925               /* If it says "0f" and it could possibly be a floating point
 926                  number, make it one.  Otherwise, make it a local label,
 927                  and try to deal with parsing the rest later.  */
 928               if (!input_line_pointer[1]
 929                   || (is_end_of_line[0xff & input_line_pointer[1]])
 930                   || strchr (FLT_CHARS, 'f') == NULL)
 931                 goto is_0f_label;
 932               {
 933                 char *cp = input_line_pointer + 1;
 934                 int r = atof_generic (&cp, ".", EXP_CHARS,
 935                                       &generic_floating_point_number);
 936                 switch (r)
 937                   {
 938                   case 0:
 939                   case ERROR_EXPONENT_OVERFLOW:
 940                     if (*cp == 'f' || *cp == 'b')
 941                       /* Looks like a difference expression.  */
 942                       goto is_0f_label;
 943                     else if (cp == input_line_pointer + 1)
 944                       /* No characters has been accepted -- looks like
 945                          end of operand.  */
 946                       goto is_0f_label;
 947                     else
 948                       goto is_0f_float;
 949                   default:
 950                     as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
 951                               r);
 952                   }
 953               }
 954
 955               /* Okay, now we've sorted it out.  We resume at one of these
 956                  two labels, depending on what we've decided we're probably
 957                  looking at.  */
 958             is_0f_label:
 959               input_line_pointer--;
 960               integer_constant (10, expressionP);
 961               break;
 962
 963             is_0f_float:
 964               /* Fall through.  */
 965               ;
 966             }
 967
 968         case 'd':
 969         case 'D':
 970           if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
 971             {
 972               integer_constant (0, expressionP);
 973               break;
 974             }
 975           /* Fall through.  */
 976         case 'F':
 977         case 'r':
 978         case 'e':
 979         case 'E':
 980         case 'g':
 981         case 'G':
 982           input_line_pointer++;
 983           floating_constant (expressionP);
 984           expressionP->X_add_number = - TOLOWER (c);
 985           break;
 986
 987         case '$':
 988           if (LOCAL_LABELS_DOLLAR)
 989             {
 990               integer_constant (10, expressionP);
 991               break;
 992             }
 993           else
 994             goto default_case;
 995         }
 996
 997       break;
 998
 999     case '(':
1000 #ifndef NEED_INDEX_OPERATOR
1001     case '[':
1002 #endif
1003       /* Didn't begin with digit & not a name.  */
1004       segment = expression (expressionP);
1005       /* expression () will pass trailing whitespace.  */
1006       if ((c == '(' && *input_line_pointer != ')')
1007           || (c == '[' && *input_line_pointer != ']'))
1008         {
1009 #ifdef RELAX_PAREN_GROUPING
1010           if (c != '(')
1011 #endif
1012             as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
1013         }
1014       else
1015         input_line_pointer++;
1016       SKIP_WHITESPACE ();
1017       /* Here with input_line_pointer -> char after "(...)".  */
1018       return segment;
1019
1020 #ifdef TC_M68K
1021     case 'E':
1022       if (! flag_m68k_mri || *input_line_pointer != '\'')
1023         goto de_fault;
1024       as_bad (_("EBCDIC constants are not supported"));
1025       /* Fall through.  */
1026     case 'A':
1027       if (! flag_m68k_mri || *input_line_pointer != '\'')
1028         goto de_fault;
1029       ++input_line_pointer;
1030       /* Fall through.  */
1031 #endif
1032     case '\'':
1033       if (! flag_m68k_mri)
1034         {
1035           /* Warning: to conform to other people's assemblers NO
1036              ESCAPEMENT is permitted for a single quote.  The next
1037              character, parity errors and all, is taken as the value
1038              of the operand.  VERY KINKY.  */
1039           expressionP->X_op = O_constant;
1040           expressionP->X_add_number = *input_line_pointer++;
1041           break;
1042         }
1043
1044       mri_char_constant (expressionP);
1045       break;
1046
1047     case '+':
1048       (void) operand (expressionP);
1049       break;
1050
1051 #ifdef TC_M68K
1052     case '"':
1053       /* Double quote is the bitwise not operator in MRI mode.  */
1054       if (! flag_m68k_mri)
1055         goto de_fault;
1056       /* Fall through.  */
1057 #endif
1058     case '~':
1059       /* '~' is permitted to start a label on the Delta.  */
1060       if (is_name_beginner (c))
1061         goto isname;
1062     case '!':
1063     case '-':
1064       {
1065         operand (expressionP);
1066         if (expressionP->X_op == O_constant)
1067           {
1068             /* input_line_pointer -> char after operand.  */
1069             if (c == '-')
1070               {
1071                 expressionP->X_add_number = - expressionP->X_add_number;
1072                 /* Notice: '-' may overflow: no warning is given.
1073                    This is compatible with other people's
1074                    assemblers.  Sigh.  */
1075                 expressionP->X_unsigned = 0;
1076               }
1077             else if (c == '~' || c == '"')
1078               expressionP->X_add_number = ~ expressionP->X_add_number;
1079             else
1080               expressionP->X_add_number = ! expressionP->X_add_number;
1081           }
1082         else if (expressionP->X_op != O_illegal
1083                  && expressionP->X_op != O_absent)
1084           {
1085             expressionP->X_add_symbol = make_expr_symbol (expressionP);
1086             if (c == '-')
1087               expressionP->X_op = O_uminus;
1088             else if (c == '~' || c == '"')
1089               expressionP->X_op = O_bit_not;
1090             else
1091               expressionP->X_op = O_logical_not;
1092             expressionP->X_add_number = 0;
1093           }
1094         else
1095           as_warn (_("Unary operator %c ignored because bad operand follows"),
1096                    c);
1097       }
1098       break;
1099
1100 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1101     case '$':
1102       /* '$' is the program counter when in MRI mode, or when
1103          DOLLAR_DOT is defined.  */
1104 #ifndef DOLLAR_DOT
1105       if (! flag_m68k_mri)
1106         goto de_fault;
1107 #endif
1108       if (flag_m68k_mri && hex_p (*input_line_pointer))
1109         {
1110           /* In MRI mode, '$' is also used as the prefix for a
1111              hexadecimal constant.  */
1112           integer_constant (16, expressionP);
1113           break;
1114         }
1115
1116       if (is_part_of_name (*input_line_pointer))
1117         goto isname;
1118
1119       current_location (expressionP);
1120       break;
1121 #endif
1122
1123     case '.':
1124       if (!is_part_of_name (*input_line_pointer))
1125         {
1126           current_location (expressionP);
1127           break;
1128         }
1129       else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1130                 && ! is_part_of_name (input_line_pointer[8]))
1131                || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1132                    && ! is_part_of_name (input_line_pointer[7])))
1133         {
1134           int start;
1135
1136           start = (input_line_pointer[1] == 't'
1137                    || input_line_pointer[1] == 'T');
1138           input_line_pointer += start ? 8 : 7;
1139           SKIP_WHITESPACE ();
1140           if (*input_line_pointer != '(')
1141             as_bad (_("syntax error in .startof. or .sizeof."));
1142           else
1143             {
1144               char *buf;
1145
1146               ++input_line_pointer;
1147               SKIP_WHITESPACE ();
1148               name = input_line_pointer;
1149               c = get_symbol_end ();
1150
1151               buf = (char *) xmalloc (strlen (name) + 10);
1152               if (start)
1153                 sprintf (buf, ".startof.%s", name);
1154               else
1155                 sprintf (buf, ".sizeof.%s", name);
1156               symbolP = symbol_make (buf);
1157               free (buf);
1158
1159               expressionP->X_op = O_symbol;
1160               expressionP->X_add_symbol = symbolP;
1161               expressionP->X_add_number = 0;
1162
1163               *input_line_pointer = c;
1164               SKIP_WHITESPACE ();
1165               if (*input_line_pointer != ')')
1166                 as_bad (_("syntax error in .startof. or .sizeof."));
1167               else
1168                 ++input_line_pointer;
1169             }
1170           break;
1171         }
1172       else
1173         {
1174           goto isname;
1175         }
1176
1177     case ',':
1178     eol:
1179       /* Can't imagine any other kind of operand.  */
1180       expressionP->X_op = O_absent;
1181       input_line_pointer--;
1182       break;
1183
1184 #ifdef TC_M68K
1185     case '%':
1186       if (! flag_m68k_mri)
1187         goto de_fault;
1188       integer_constant (2, expressionP);
1189       break;
1190
1191     case '@':
1192       if (! flag_m68k_mri)
1193         goto de_fault;
1194       integer_constant (8, expressionP);
1195       break;
1196
1197     case ':':
1198       if (! flag_m68k_mri)
1199         goto de_fault;
1200
1201       /* In MRI mode, this is a floating point constant represented
1202          using hexadecimal digits.  */
1203
1204       ++input_line_pointer;
1205       integer_constant (16, expressionP);
1206       break;
1207
1208     case '*':
1209       if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1210         goto de_fault;
1211
1212       current_location (expressionP);
1213       break;
1214 #endif
1215
1216     default:
1217 #ifdef TC_M68K
1218     de_fault:
1219 #endif
1220       if (is_name_beginner (c)) /* Here if did not begin with a digit.  */
1221         {
1222           /* Identifier begins here.
1223              This is kludged for speed, so code is repeated.  */
1224         isname:
1225           name = --input_line_pointer;
1226           c = get_symbol_end ();
1227
1228 #ifdef md_parse_name
1229           /* This is a hook for the backend to parse certain names
1230              specially in certain contexts.  If a name always has a
1231              specific value, it can often be handled by simply
1232              entering it in the symbol table.  */
1233           if (md_parse_name (name, expressionP, &c))
1234             {
1235               *input_line_pointer = c;
1236               break;
1237             }
1238 #endif
1239
1240 #ifdef TC_I960
1241           /* The MRI i960 assembler permits
1242                  lda sizeof code,g13
1243              FIXME: This should use md_parse_name.  */
1244           if (flag_mri
1245               && (strcasecmp (name, "sizeof") == 0
1246                   || strcasecmp (name, "startof") == 0))
1247             {
1248               int start;
1249               char *buf;
1250
1251               start = (name[1] == 't'
1252                        || name[1] == 'T');
1253
1254               *input_line_pointer = c;
1255               SKIP_WHITESPACE ();
1256
1257               name = input_line_pointer;
1258               c = get_symbol_end ();
1259
1260               buf = (char *) xmalloc (strlen (name) + 10);
1261               if (start)
1262                 sprintf (buf, ".startof.%s", name);
1263               else
1264                 sprintf (buf, ".sizeof.%s", name);
1265               symbolP = symbol_make (buf);
1266               free (buf);
1267
1268               expressionP->X_op = O_symbol;
1269               expressionP->X_add_symbol = symbolP;
1270               expressionP->X_add_number = 0;
1271
1272               *input_line_pointer = c;
1273               SKIP_WHITESPACE ();
1274
1275               break;
1276             }
1277 #endif
1278
1279           symbolP = symbol_find_or_make (name);
1280
1281           /* If we have an absolute symbol or a reg, then we know its
1282              value now.  */
1283           segment = S_GET_SEGMENT (symbolP);
1284           if (segment == absolute_section)
1285             {
1286               expressionP->X_op = O_constant;
1287               expressionP->X_add_number = S_GET_VALUE (symbolP);
1288             }
1289           else if (segment == reg_section)
1290             {
1291               expressionP->X_op = O_register;
1292               expressionP->X_add_number = S_GET_VALUE (symbolP);
1293             }
1294           else
1295             {
1296               expressionP->X_op = O_symbol;
1297               expressionP->X_add_symbol = symbolP;
1298               expressionP->X_add_number = 0;
1299             }
1300           *input_line_pointer = c;
1301         }
1302       else
1303         {
1304           /* Let the target try to parse it.  Success is indicated by changing
1305              the X_op field to something other than O_absent and pointing
1306              input_line_pointer past the expression.  If it can't parse the
1307              expression, X_op and input_line_pointer should be unchanged.  */
1308           expressionP->X_op = O_absent;
1309           --input_line_pointer;
1310           md_operand (expressionP);
1311           if (expressionP->X_op == O_absent)
1312             {
1313               ++input_line_pointer;
1314               as_bad (_("bad expression"));
1315               expressionP->X_op = O_constant;
1316               expressionP->X_add_number = 0;
1317             }
1318         }
1319       break;
1320     }
1321
1322   /* It is more 'efficient' to clean up the expressionS when they are
1323      created.  Doing it here saves lines of code.  */
1324   clean_up_expression (expressionP);
1325   SKIP_WHITESPACE ();           /* -> 1st char after operand.  */
1326   know (*input_line_pointer != ' ');
1327
1328   /* The PA port needs this information.  */
1329   if (expressionP->X_add_symbol)
1330     symbol_mark_used (expressionP->X_add_symbol);
1331
1332   switch (expressionP->X_op)
1333     {
1334     default:
1335       return absolute_section;
1336     case O_symbol:
1337       return S_GET_SEGMENT (expressionP->X_add_symbol);
1338     case O_register:
1339       return reg_section;
1340     }
1341 }
1342 \f
1343 /* Internal.  Simplify a struct expression for use by expr ().  */
1344
1345 /* In:  address of an expressionS.
1346         The X_op field of the expressionS may only take certain values.
1347         Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1348
1349    Out: expressionS may have been modified:
1350         'foo-foo' symbol references cancelled to 0, which changes X_op
1351         from O_subtract to O_constant.
1352         Unused fields zeroed to help expr ().  */
1353
1354 static void
1355 clean_up_expression (expressionP)
1356      expressionS *expressionP;
1357 {
1358   switch (expressionP->X_op)
1359     {
1360     case O_illegal:
1361     case O_absent:
1362       expressionP->X_add_number = 0;
1363       /* Fall through.  */
1364     case O_big:
1365     case O_constant:
1366     case O_register:
1367       expressionP->X_add_symbol = NULL;
1368       /* Fall through.  */
1369     case O_symbol:
1370     case O_uminus:
1371     case O_bit_not:
1372       expressionP->X_op_symbol = NULL;
1373       break;
1374     case O_subtract:
1375       if (expressionP->X_op_symbol == expressionP->X_add_symbol
1376           || ((symbol_get_frag (expressionP->X_op_symbol)
1377                == symbol_get_frag (expressionP->X_add_symbol))
1378               && SEG_NORMAL (S_GET_SEGMENT (expressionP->X_add_symbol))
1379               && (S_GET_VALUE (expressionP->X_op_symbol)
1380                   == S_GET_VALUE (expressionP->X_add_symbol))))
1381         {
1382           addressT diff = (S_GET_VALUE (expressionP->X_add_symbol)
1383                            - S_GET_VALUE (expressionP->X_op_symbol));
1384
1385           expressionP->X_op = O_constant;
1386           expressionP->X_add_symbol = NULL;
1387           expressionP->X_op_symbol = NULL;
1388           expressionP->X_add_number += diff;
1389         }
1390       break;
1391     default:
1392       break;
1393     }
1394 }
1395 \f
1396 /* Expression parser.  */
1397
1398 /* We allow an empty expression, and just assume (absolute,0) silently.
1399    Unary operators and parenthetical expressions are treated as operands.
1400    As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1401
1402    We used to do an aho/ullman shift-reduce parser, but the logic got so
1403    warped that I flushed it and wrote a recursive-descent parser instead.
1404    Now things are stable, would anybody like to write a fast parser?
1405    Most expressions are either register (which does not even reach here)
1406    or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1407    So I guess it doesn't really matter how inefficient more complex expressions
1408    are parsed.
1409
1410    After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1411    Also, we have consumed any leading or trailing spaces (operand does that)
1412    and done all intervening operators.
1413
1414    This returns the segment of the result, which will be
1415    absolute_section or the segment of a symbol.  */
1416
1417 #undef __
1418 #define __ O_illegal
1419
1420 /* Maps ASCII -> operators.  */
1421 static const operatorT op_encoding[256] = {
1422   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1423   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1424
1425   __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1426   __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1427   __, __, __, __, __, __, __, __,
1428   __, __, __, __, O_lt, __, O_gt, __,
1429   __, __, __, __, __, __, __, __,
1430   __, __, __, __, __, __, __, __,
1431   __, __, __, __, __, __, __, __,
1432   __, __, __,
1433 #ifdef NEED_INDEX_OPERATOR
1434   O_index,
1435 #else
1436   __,
1437 #endif
1438   __, __, O_bit_exclusive_or, __,
1439   __, __, __, __, __, __, __, __,
1440   __, __, __, __, __, __, __, __,
1441   __, __, __, __, __, __, __, __,
1442   __, __, __, __, O_bit_inclusive_or, __, __, __,
1443
1444   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1445   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1446   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1447   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1448   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1449   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1450   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1451   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1452 };
1453
1454 /* Rank Examples
1455    0    operand, (expression)
1456    1    ||
1457    2    &&
1458    3    == <> < <= >= >
1459    4    + -
1460    5    used for * / % in MRI mode
1461    6    & ^ ! |
1462    7    * / % << >>
1463    8    unary - unary ~
1464 */
1465 static operator_rankT op_rank[] = {
1466   0,    /* O_illegal */
1467   0,    /* O_absent */
1468   0,    /* O_constant */
1469   0,    /* O_symbol */
1470   0,    /* O_symbol_rva */
1471   0,    /* O_register */
1472   0,    /* O_big */
1473   9,    /* O_uminus */
1474   9,    /* O_bit_not */
1475   9,    /* O_logical_not */
1476   8,    /* O_multiply */
1477   8,    /* O_divide */
1478   8,    /* O_modulus */
1479   8,    /* O_left_shift */
1480   8,    /* O_right_shift */
1481   7,    /* O_bit_inclusive_or */
1482   7,    /* O_bit_or_not */
1483   7,    /* O_bit_exclusive_or */
1484   7,    /* O_bit_and */
1485   5,    /* O_add */
1486   5,    /* O_subtract */
1487   4,    /* O_eq */
1488   4,    /* O_ne */
1489   4,    /* O_lt */
1490   4,    /* O_le */
1491   4,    /* O_ge */
1492   4,    /* O_gt */
1493   3,    /* O_logical_and */
1494   2,    /* O_logical_or */
1495   1,    /* O_index */
1496   0,    /* O_md1 */
1497   0,    /* O_md2 */
1498   0,    /* O_md3 */
1499   0,    /* O_md4 */
1500   0,    /* O_md5 */
1501   0,    /* O_md6 */
1502   0,    /* O_md7 */
1503   0,    /* O_md8 */
1504   0,    /* O_md9 */
1505   0,    /* O_md10 */
1506   0,    /* O_md11 */
1507   0,    /* O_md12 */
1508   0,    /* O_md13 */
1509   0,    /* O_md14 */
1510   0,    /* O_md15 */
1511   0,    /* O_md16 */
1512 };
1513
1514 /* Unfortunately, in MRI mode for the m68k, multiplication and
1515    division have lower precedence than the bit wise operators.  This
1516    function sets the operator precedences correctly for the current
1517    mode.  Also, MRI uses a different bit_not operator, and this fixes
1518    that as well.  */
1519
1520 #define STANDARD_MUL_PRECEDENCE 8
1521 #define MRI_MUL_PRECEDENCE 6
1522
1523 void
1524 expr_set_precedence ()
1525 {
1526   if (flag_m68k_mri)
1527     {
1528       op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1529       op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1530       op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1531     }
1532   else
1533     {
1534       op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1535       op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1536       op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1537     }
1538 }
1539
1540 /* Initialize the expression parser.  */
1541
1542 void
1543 expr_begin ()
1544 {
1545   expr_set_precedence ();
1546
1547   /* Verify that X_op field is wide enough.  */
1548   {
1549     expressionS e;
1550     e.X_op = O_max;
1551     assert (e.X_op == O_max);
1552   }
1553 }
1554 \f
1555 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1556    sets NUM_CHARS to the number of characters in the operator.
1557    Does not advance INPUT_LINE_POINTER.  */
1558
1559 static inline operatorT
1560 operator (num_chars)
1561      int *num_chars;
1562 {
1563   int c;
1564   operatorT ret;
1565
1566   c = *input_line_pointer & 0xff;
1567   *num_chars = 1;
1568
1569   if (is_end_of_line[c])
1570     return O_illegal;
1571
1572   switch (c)
1573     {
1574     default:
1575       return op_encoding[c];
1576
1577     case '<':
1578       switch (input_line_pointer[1])
1579         {
1580         default:
1581           return op_encoding[c];
1582         case '<':
1583           ret = O_left_shift;
1584           break;
1585         case '>':
1586           ret = O_ne;
1587           break;
1588         case '=':
1589           ret = O_le;
1590           break;
1591         }
1592       *num_chars = 2;
1593       return ret;
1594
1595     case '=':
1596       if (input_line_pointer[1] != '=')
1597         return op_encoding[c];
1598
1599       *num_chars = 2;
1600       return O_eq;
1601
1602     case '>':
1603       switch (input_line_pointer[1])
1604         {
1605         default:
1606           return op_encoding[c];
1607         case '>':
1608           ret = O_right_shift;
1609           break;
1610         case '=':
1611           ret = O_ge;
1612           break;
1613         }
1614       *num_chars = 2;
1615       return ret;
1616
1617     case '!':
1618       /* We accept !! as equivalent to ^ for MRI compatibility.  */
1619       if (input_line_pointer[1] != '!')
1620         {
1621           if (flag_m68k_mri)
1622             return O_bit_inclusive_or;
1623           return op_encoding[c];
1624         }
1625       *num_chars = 2;
1626       return O_bit_exclusive_or;
1627
1628     case '|':
1629       if (input_line_pointer[1] != '|')
1630         return op_encoding[c];
1631
1632       *num_chars = 2;
1633       return O_logical_or;
1634
1635     case '&':
1636       if (input_line_pointer[1] != '&')
1637         return op_encoding[c];
1638
1639       *num_chars = 2;
1640       return O_logical_and;
1641     }
1642
1643   /* NOTREACHED  */
1644 }
1645
1646 /* Parse an expression.  */
1647
1648 segT
1649 expr (rankarg, resultP)
1650      int rankarg;       /* Larger # is higher rank.  */
1651      expressionS *resultP;      /* Deliver result here.  */
1652 {
1653   operator_rankT rank = (operator_rankT) rankarg;
1654   segT retval;
1655   expressionS right;
1656   operatorT op_left;
1657   operatorT op_right;
1658   int op_chars;
1659
1660   know (rank >= 0);
1661
1662   retval = operand (resultP);
1663
1664   /* operand () gobbles spaces.  */
1665   know (*input_line_pointer != ' ');
1666
1667   op_left = operator (&op_chars);
1668   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1669     {
1670       segT rightseg;
1671
1672       input_line_pointer += op_chars;   /* -> after operator.  */
1673
1674       rightseg = expr (op_rank[(int) op_left], &right);
1675       if (right.X_op == O_absent)
1676         {
1677           as_warn (_("missing operand; zero assumed"));
1678           right.X_op = O_constant;
1679           right.X_add_number = 0;
1680           right.X_add_symbol = NULL;
1681           right.X_op_symbol = NULL;
1682         }
1683
1684       know (*input_line_pointer != ' ');
1685
1686       if (op_left == O_index)
1687         {
1688           if (*input_line_pointer != ']')
1689             as_bad ("missing right bracket");
1690           else
1691             {
1692               ++input_line_pointer;
1693               SKIP_WHITESPACE ();
1694             }
1695         }
1696
1697       op_right = operator (&op_chars);
1698
1699       know (op_right == O_illegal
1700             || op_rank[(int) op_right] <= op_rank[(int) op_left]);
1701       know ((int) op_left >= (int) O_multiply
1702             && (int) op_left <= (int) O_logical_or);
1703
1704       /* input_line_pointer->after right-hand quantity.  */
1705       /* left-hand quantity in resultP.  */
1706       /* right-hand quantity in right.  */
1707       /* operator in op_left.  */
1708
1709       if (resultP->X_op == O_big)
1710         {
1711           if (resultP->X_add_number > 0)
1712             as_warn (_("left operand is a bignum; integer 0 assumed"));
1713           else
1714             as_warn (_("left operand is a float; integer 0 assumed"));
1715           resultP->X_op = O_constant;
1716           resultP->X_add_number = 0;
1717           resultP->X_add_symbol = NULL;
1718           resultP->X_op_symbol = NULL;
1719         }
1720       if (right.X_op == O_big)
1721         {
1722           if (right.X_add_number > 0)
1723             as_warn (_("right operand is a bignum; integer 0 assumed"));
1724           else
1725             as_warn (_("right operand is a float; integer 0 assumed"));
1726           right.X_op = O_constant;
1727           right.X_add_number = 0;
1728           right.X_add_symbol = NULL;
1729           right.X_op_symbol = NULL;
1730         }
1731
1732       /* Optimize common cases.  */
1733 #ifdef md_optimize_expr
1734       if (md_optimize_expr (resultP, op_left, &right))
1735         {
1736           /* Skip.  */
1737           ;
1738         }
1739       else
1740 #endif
1741       if (op_left == O_add && right.X_op == O_constant)
1742         {
1743           /* X + constant.  */
1744           resultP->X_add_number += right.X_add_number;
1745         }
1746       /* This case comes up in PIC code.  */
1747       else if (op_left == O_subtract
1748                && right.X_op == O_symbol
1749                && resultP->X_op == O_symbol
1750                && (symbol_get_frag (right.X_add_symbol)
1751                    == symbol_get_frag (resultP->X_add_symbol))
1752                && SEG_NORMAL (rightseg))
1753         {
1754           resultP->X_add_number -= right.X_add_number;
1755           resultP->X_add_number += (S_GET_VALUE (resultP->X_add_symbol)
1756                                     - S_GET_VALUE (right.X_add_symbol));
1757           resultP->X_op = O_constant;
1758           resultP->X_add_symbol = 0;
1759         }
1760       else if (op_left == O_subtract && right.X_op == O_constant)
1761         {
1762           /* X - constant.  */
1763           resultP->X_add_number -= right.X_add_number;
1764         }
1765       else if (op_left == O_add && resultP->X_op == O_constant)
1766         {
1767           /* Constant + X.  */
1768           resultP->X_op = right.X_op;
1769           resultP->X_add_symbol = right.X_add_symbol;
1770           resultP->X_op_symbol = right.X_op_symbol;
1771           resultP->X_add_number += right.X_add_number;
1772           retval = rightseg;
1773         }
1774       else if (resultP->X_op == O_constant && right.X_op == O_constant)
1775         {
1776           /* Constant OP constant.  */
1777           offsetT v = right.X_add_number;
1778           if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1779             {
1780               as_warn (_("division by zero"));
1781               v = 1;
1782             }
1783           switch (op_left)
1784             {
1785             default:                    abort ();
1786             case O_multiply:            resultP->X_add_number *= v; break;
1787             case O_divide:              resultP->X_add_number /= v; break;
1788             case O_modulus:             resultP->X_add_number %= v; break;
1789             case O_left_shift:          resultP->X_add_number <<= v; break;
1790             case O_right_shift:
1791               /* We always use unsigned shifts, to avoid relying on
1792                  characteristics of the compiler used to compile gas.  */
1793               resultP->X_add_number =
1794                 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1795               break;
1796             case O_bit_inclusive_or:    resultP->X_add_number |= v; break;
1797             case O_bit_or_not:          resultP->X_add_number |= ~v; break;
1798             case O_bit_exclusive_or:    resultP->X_add_number ^= v; break;
1799             case O_bit_and:             resultP->X_add_number &= v; break;
1800             case O_add:                 resultP->X_add_number += v; break;
1801             case O_subtract:            resultP->X_add_number -= v; break;
1802             case O_eq:
1803               resultP->X_add_number =
1804                 resultP->X_add_number == v ? ~ (offsetT) 0 : 0;
1805               break;
1806             case O_ne:
1807               resultP->X_add_number =
1808                 resultP->X_add_number != v ? ~ (offsetT) 0 : 0;
1809               break;
1810             case O_lt:
1811               resultP->X_add_number =
1812                 resultP->X_add_number <  v ? ~ (offsetT) 0 : 0;
1813               break;
1814             case O_le:
1815               resultP->X_add_number =
1816                 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
1817               break;
1818             case O_ge:
1819               resultP->X_add_number =
1820                 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
1821               break;
1822             case O_gt:
1823               resultP->X_add_number =
1824                 resultP->X_add_number >  v ? ~ (offsetT) 0 : 0;
1825               break;
1826             case O_logical_and:
1827               resultP->X_add_number = resultP->X_add_number && v;
1828               break;
1829             case O_logical_or:
1830               resultP->X_add_number = resultP->X_add_number || v;
1831               break;
1832             }
1833         }
1834       else if (resultP->X_op == O_symbol
1835                && right.X_op == O_symbol
1836                && (op_left == O_add
1837                    || op_left == O_subtract
1838                    || (resultP->X_add_number == 0
1839                        && right.X_add_number == 0)))
1840         {
1841           /* Symbol OP symbol.  */
1842           resultP->X_op = op_left;
1843           resultP->X_op_symbol = right.X_add_symbol;
1844           if (op_left == O_add)
1845             resultP->X_add_number += right.X_add_number;
1846           else if (op_left == O_subtract)
1847             {
1848               resultP->X_add_number -= right.X_add_number;
1849               if (retval == rightseg && SEG_NORMAL (retval))
1850                 {
1851                   retval = absolute_section;
1852                   rightseg = absolute_section;
1853                 }
1854             }
1855         }
1856       else
1857         {
1858           /* The general case.  */
1859           resultP->X_add_symbol = make_expr_symbol (resultP);
1860           resultP->X_op_symbol = make_expr_symbol (&right);
1861           resultP->X_op = op_left;
1862           resultP->X_add_number = 0;
1863           resultP->X_unsigned = 1;
1864         }
1865
1866       if (retval != rightseg)
1867         {
1868           if (! SEG_NORMAL (retval))
1869             {
1870               if (retval != undefined_section || SEG_NORMAL (rightseg))
1871                 retval = rightseg;
1872             }
1873           else if (SEG_NORMAL (rightseg)
1874 #ifdef DIFF_EXPR_OK
1875                    && op_left != O_subtract
1876 #endif
1877                    )
1878             as_bad (_("operation combines symbols in different segments"));
1879         }
1880
1881       op_left = op_right;
1882     }                           /* While next operator is >= this rank.  */
1883
1884   /* The PA port needs this information.  */
1885   if (resultP->X_add_symbol)
1886     symbol_mark_used (resultP->X_add_symbol);
1887
1888   return resultP->X_op == O_constant ? absolute_section : retval;
1889 }
1890 \f
1891 /* This lives here because it belongs equally in expr.c & read.c.
1892    expr.c is just a branch office read.c anyway, and putting it
1893    here lessens the crowd at read.c.
1894
1895    Assume input_line_pointer is at start of symbol name.
1896    Advance input_line_pointer past symbol name.
1897    Turn that character into a '\0', returning its former value.
1898    This allows a string compare (RMS wants symbol names to be strings)
1899    of the symbol name.
1900    There will always be a char following symbol name, because all good
1901    lines end in end-of-line.  */
1902
1903 char
1904 get_symbol_end ()
1905 {
1906   char c;
1907
1908   /* We accept \001 in a name in case this is being called with a
1909      constructed string.  */
1910   if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
1911     {
1912       while (is_part_of_name (c = *input_line_pointer++)
1913              || c == '\001')
1914         ;
1915       if (is_name_ender (c))
1916         c = *input_line_pointer++;
1917     }
1918   *--input_line_pointer = 0;
1919   return (c);
1920 }
1921
1922 unsigned int
1923 get_single_number ()
1924 {
1925   expressionS exp;
1926   operand (&exp);
1927   return exp.X_add_number;
1928 }