gas/expr.c

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