gas/expr.c

   1 /* expr.c -operands, expressions-
   2    Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 /*
  21  * This is really a branch office of as-read.c. I split it out to clearly
  22  * distinguish the world of expressions from the world of statements.
  23  * (It also gives smaller files to re-compile.)
  24  * Here, "operand"s are of expressions, not instructions.
  25  */
  26
  27 #include <ctype.h>
  28 #include <string.h>
  29
  30 #include "as.h"
  31
  32 #include "obstack.h"
  33
  34 #if __STDC__ == 1
  35 static void clean_up_expression (expressionS * expressionP);
  36 #else /* __STDC__ */
  37 static void clean_up_expression ();     /* Internal. */
  38 #endif /* not __STDC__ */
  39 extern const char EXP_CHARS[];  /* JF hide MD floating pt stuff all the same place */
  40 extern const char FLT_CHARS[];
  41
  42 /*
  43  * Build any floating-point literal here.
  44  * Also build any bignum literal here.
  45  */
  46
  47 /* LITTLENUM_TYPE       generic_buffer [6]; *//* JF this is a hack */
  48 /* Seems atof_machine can backscan through generic_bignum and hit whatever
  49    happens to be loaded before it in memory.  And its way too complicated
  50    for me to fix right.  Thus a hack.  JF:  Just make generic_bignum bigger,
  51    and never write into the early words, thus they'll always be zero.
  52    I hate Dean's floating-point code.  Bleh.
  53    */
  54 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
  55 FLONUM_TYPE generic_floating_point_number =
  56 {
  57   &generic_bignum[6],           /* low (JF: Was 0) */
  58   &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1],        /* high JF: (added +6) */
  59   0,                            /* leader */
  60   0,                            /* exponent */
  61   0                             /* sign */
  62 };
  63 /* If nonzero, we've been asked to assemble nan, +inf or -inf */
  64 int generic_floating_point_magic;
  65 \f
  66 floating_constant (expressionP)
  67      expressionS *expressionP;
  68 {
  69   /* input_line_pointer->*/
  70   /* floating-point constant. */
  71   int error_code;
  72
  73   error_code = atof_generic
  74     (&input_line_pointer, ".", EXP_CHARS,
  75      &generic_floating_point_number);
  76
  77   if (error_code)
  78     {
  79       if (error_code == ERROR_EXPONENT_OVERFLOW)
  80         {
  81           as_bad ("bad floating-point constant: exponent overflow, probably assembling junk");
  82         }
  83       else
  84         {
  85           as_bad ("bad floating-point constant: unknown error code=%d.", error_code);
  86         }
  87     }
  88   expressionP->X_seg = SEG_BIG;
  89   /* input_line_pointer->just after constant, */
  90   /* which may point to whitespace. */
  91   expressionP->X_add_number = -1;
  92 }
  93
  94
  95
  96 integer_constant (radix, expressionP)
  97      int radix;
  98      expressionS *expressionP;
  99 {
 100   register char *digit_2;       /*->2nd digit of number. */
 101   char c;
 102
 103   register valueT number;       /* offset or (absolute) value */
 104   register short int digit;     /* value of next digit in current radix */
 105   register short int maxdig = 0;/* highest permitted digit value. */
 106   register int too_many_digits = 0;     /* if we see >= this number of */
 107   register char *name;          /* points to name of symbol */
 108   register symbolS *symbolP;    /* points to symbol */
 109
 110   int small;                    /* true if fits in 32 bits. */
 111   extern char hex_value[];      /* in hex_value.c */
 112
 113   /* may be bignum, or may fit in 32 bits. */
 114   /*
 115    * most numbers fit into 32 bits, and we want this case to be fast.
 116    * so we pretend it will fit into 32 bits. if, after making up a 32
 117    * bit number, we realise that we have scanned more digits than
 118    * comfortably fit into 32 bits, we re-scan the digits coding
 119    * them into a bignum. for decimal and octal numbers we are conservative: some
 120    * numbers may be assumed bignums when in fact they do fit into 32 bits.
 121    * numbers of any radix can have excess leading zeros: we strive
 122    * to recognise this and cast them back into 32 bits.
 123    * we must check that the bignum really is more than 32
 124    * bits, and change it back to a 32-bit number if it fits.
 125    * the number we are looking for is expected to be positive, but
 126    * if it fits into 32 bits as an unsigned number, we let it be a 32-bit
 127    * number. the cavalier approach is for speed in ordinary cases.
 128    */
 129
 130   switch (radix)
 131     {
 132
 133     case 2:
 134       maxdig = 2;
 135       too_many_digits = 33;
 136       break;
 137     case 8:
 138       maxdig = radix = 8;
 139       too_many_digits = 11;
 140       break;
 141     case 16:
 142
 143
 144       maxdig = radix = 16;
 145       too_many_digits = 9;
 146       break;
 147     case 10:
 148       maxdig = radix = 10;
 149       too_many_digits = 11;
 150     }
 151   c = *input_line_pointer;
 152   input_line_pointer++;
 153   digit_2 = input_line_pointer;
 154   for (number = 0; (digit = hex_value[c]) < maxdig; c = *input_line_pointer++)
 155     {
 156       number = number * radix + digit;
 157     }
 158   /* c contains character after number. */
 159   /* input_line_pointer->char after c. */
 160   small = input_line_pointer - digit_2 < too_many_digits;
 161   if (!small)
 162     {
 163       /*
 164        * we saw a lot of digits. manufacture a bignum the hard way.
 165        */
 166       LITTLENUM_TYPE *leader;   /*->high order littlenum of the bignum. */
 167       LITTLENUM_TYPE *pointer;  /*->littlenum we are frobbing now. */
 168       long carry;
 169
 170       leader = generic_bignum;
 171       generic_bignum[0] = 0;
 172       generic_bignum[1] = 0;
 173       /* we could just use digit_2, but lets be mnemonic. */
 174       input_line_pointer = --digit_2;   /*->1st digit. */
 175       c = *input_line_pointer++;
 176       for (; (carry = hex_value[c]) < maxdig; c = *input_line_pointer++)
 177         {
 178           for (pointer = generic_bignum;
 179                pointer <= leader;
 180                pointer++)
 181             {
 182               long work;
 183
 184               work = carry + radix * *pointer;
 185               *pointer = work & LITTLENUM_MASK;
 186               carry = work >> LITTLENUM_NUMBER_OF_BITS;
 187             }
 188           if (carry)
 189             {
 190               if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
 191                 {               /* room to grow a longer bignum. */
 192                   *++leader = carry;
 193                 }
 194             }
 195         }
 196       /* again, c is char after number, */
 197       /* input_line_pointer->after c. */
 198       know (sizeof (int) * 8 == 32);
 199       know (LITTLENUM_NUMBER_OF_BITS == 16);
 200       /* hence the constant "2" in the next line. */
 201       if (leader < generic_bignum + 2)
 202         {                       /* will fit into 32 bits. */
 203           number =
 204             ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
 205             | (generic_bignum[0] & LITTLENUM_MASK);
 206           small = 1;
 207         }
 208       else
 209         {
 210           number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */
 211         }
 212     }
 213   if (small)
 214     {
 215       /*
 216        * here with number, in correct radix. c is the next char.
 217        * note that unlike un*x, we allow "011f" "0x9f" to
 218        * both mean the same as the (conventional) "9f". this is simply easier
 219        * than checking for strict canonical form. syntax sux!
 220        */
 221
 222       switch (c)
 223         {
 224
 225 #ifdef LOCAL_LABELS_FB
 226         case 'b':
 227           {
 228             /*
 229              * backward ref to local label.
 230              * because it is backward, expect it to be defined.
 231              */
 232             /* Construct a local label.  */
 233             name = fb_label_name ((int) number, 0);
 234
 235             /* seen before, or symbol is defined: ok */
 236             symbolP = symbol_find (name);
 237             if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
 238               {
 239
 240                 /* local labels are never absolute. don't waste time
 241                    checking absoluteness. */
 242                 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
 243
 244                 expressionP->X_add_symbol = symbolP;
 245                 expressionP->X_seg = S_GET_SEGMENT (symbolP);
 246
 247               }
 248             else
 249               {                 /* either not seen or not defined. */
 250                 as_bad ("backw. ref to unknown label \"%d:\", 0 assumed.", number);
 251                 expressionP->X_seg = SEG_ABSOLUTE;
 252               }
 253
 254             expressionP->X_add_number = 0;
 255             break;
 256           }                     /* case 'b' */
 257
 258         case 'f':
 259           {
 260             /*
 261              * forward reference. expect symbol to be undefined or
 262              * unknown. undefined: seen it before. unknown: never seen
 263              * it before.
 264              * construct a local label name, then an undefined symbol.
 265              * don't create a xseg frag for it: caller may do that.
 266              * just return it as never seen before.
 267              */
 268             name = fb_label_name ((int) number, 1);
 269             symbolP = symbol_find_or_make (name);
 270             /* we have no need to check symbol properties. */
 271 #ifndef many_segments
 272             /* since "know" puts its arg into a "string", we
 273                can't have newlines in the argument.  */
 274             know (S_GET_SEGMENT (symbolP) == SEG_UNKNOWN || S_GET_SEGMENT (symbolP) == SEG_TEXT || S_GET_SEGMENT (symbolP) == SEG_DATA);
 275 #endif
 276             expressionP->X_add_symbol = symbolP;
 277             expressionP->X_seg = SEG_UNKNOWN;
 278             expressionP->X_subtract_symbol = NULL;
 279             expressionP->X_add_number = 0;
 280
 281             break;
 282           }                     /* case 'f' */
 283
 284 #endif /* LOCAL_LABELS_FB */
 285
 286 #ifdef LOCAL_LABELS_DOLLAR
 287
 288         case '$':
 289           {
 290
 291             /* If the dollar label is *currently* defined, then this is just
 292                another reference to it.  If it is not *currently* defined,
 293                then this is a fresh instantiation of that number, so create
 294                it.  */
 295
 296             if (dollar_label_defined (number))
 297               {
 298                 name = dollar_label_name (number, 0);
 299                 symbolP = symbol_find (name);
 300                 know (symbolP != NULL);
 301               }
 302             else
 303               {
 304                 name = dollar_label_name (number, 1);
 305                 symbolP = symbol_find_or_make (name);
 306               }
 307
 308             expressionP->X_add_symbol = symbolP;
 309             expressionP->X_add_number = 0;
 310             expressionP->X_seg = S_GET_SEGMENT (symbolP);
 311
 312             break;
 313           }                     /* case '$' */
 314
 315 #endif /* LOCAL_LABELS_DOLLAR */
 316
 317         default:
 318           {
 319             expressionP->X_add_number = number;
 320             expressionP->X_seg = SEG_ABSOLUTE;
 321             input_line_pointer--;       /* restore following character. */
 322             break;
 323           }                     /* really just a number */
 324
 325         }                       /* switch on char following the number */
 326
 327
 328     }
 329   else
 330     {                           /* not a small number */
 331       expressionP->X_add_number = number;
 332       expressionP->X_seg = SEG_BIG;
 333       input_line_pointer--;     /*->char following number. */
 334     }                           /* if (small) */
 335 }                               /* integer_constant() */
 336
 337
 338 /*
 339  * Summary of operand().
 340  *
 341  * in:  Input_line_pointer points to 1st char of operand, which may
 342  *      be a space.
 343  *
 344  * out: A expressionS. X_seg determines how to understand the rest of the
 345  *      expressionS.
 346  *      The operand may have been empty: in this case X_seg == SEG_ABSENT.
 347  *      Input_line_pointer->(next non-blank) char after operand.
 348  *
 349  */
 350 \f
 351
 352
 353 static segT
 354 operand (expressionP)
 355      register expressionS *expressionP;
 356 {
 357   register char c;
 358   register symbolS *symbolP;    /* points to symbol */
 359   register char *name;          /* points to name of symbol */
 360   /* invented for humans only, hope */
 361   /* optimising compiler flushes it! */
 362   register short int radix;     /* 2, 8, 10 or 16, 0 when floating */
 363   /* 0 means we saw start of a floating- */
 364   /* point constant. */
 365
 366   /* digits, assume it is a bignum. */
 367
 368   SKIP_WHITESPACE ();           /* leading whitespace is part of operand. */
 369   c = *input_line_pointer++;    /* input_line_pointer->past char in c. */
 370
 371   switch (c)
 372     {
 373 #ifdef MRI
 374     case '%':
 375       integer_constant (2, expressionP);
 376       break;
 377     case '@':
 378       integer_constant (8, expressionP);
 379       break;
 380     case '$':
 381       integer_constant (16, expressionP);
 382       break;
 383 #endif
 384     case '1':
 385     case '2':
 386     case '3':
 387     case '4':
 388     case '5':
 389     case '6':
 390     case '7':
 391     case '8':
 392     case '9':
 393       input_line_pointer--;
 394
 395       integer_constant (10, expressionP);
 396       break;
 397
 398     case '0':
 399       /* non-decimal radix */
 400
 401
 402       c = *input_line_pointer;
 403       switch (c)
 404         {
 405
 406         default:
 407           if (c && strchr (FLT_CHARS, c))
 408             {
 409               input_line_pointer++;
 410               floating_constant (expressionP);
 411             }
 412           else
 413             {
 414               /* The string was only zero */
 415               expressionP->X_add_symbol = 0;
 416               expressionP->X_add_number = 0;
 417               expressionP->X_seg = SEG_ABSOLUTE;
 418             }
 419
 420           break;
 421
 422         case 'x':
 423         case 'X':
 424           input_line_pointer++;
 425           integer_constant (16, expressionP);
 426           break;
 427
 428         case 'b':
 429 #ifdef LOCAL_LABELS_FB
 430           if (!*input_line_pointer
 431               || (!strchr ("+-.0123456789", *input_line_pointer)
 432                   && !strchr (EXP_CHARS, *input_line_pointer)))
 433             {
 434               input_line_pointer--;
 435               integer_constant (10, expressionP);
 436               break;
 437             }
 438 #endif
 439         case 'B':
 440           input_line_pointer++;
 441           integer_constant (2, expressionP);
 442           break;
 443
 444         case '0':
 445         case '1':
 446         case '2':
 447         case '3':
 448         case '4':
 449         case '5':
 450         case '6':
 451         case '7':
 452           integer_constant (8, expressionP);
 453           break;
 454
 455         case 'f':
 456 #ifdef LOCAL_LABELS_FB
 457           /* if it says '0f' and the line ends or it doesn't look like
 458              a floating point #, its a local label ref.  dtrt */
 459           /* likewise for the b's.  xoxorich. */
 460           if (c == 'f'
 461               && (!*input_line_pointer ||
 462                   (!strchr ("+-.0123456789", *input_line_pointer) &&
 463                    !strchr (EXP_CHARS, *input_line_pointer))))
 464             {
 465               input_line_pointer -= 1;
 466               integer_constant (10, expressionP);
 467               break;
 468             }
 469 #endif
 470
 471         case 'd':
 472         case 'D':
 473         case 'F':
 474         case 'r':
 475         case 'e':
 476         case 'E':
 477         case 'g':
 478         case 'G':
 479
 480           input_line_pointer++;
 481           floating_constant (expressionP);
 482           break;
 483
 484 #ifdef LOCAL_LABELS_DOLLAR
 485         case '$':
 486           integer_constant (10, expressionP);
 487           break;
 488 #endif
 489         }
 490
 491       break;
 492     case '(':
 493       /* didn't begin with digit & not a name */
 494       {
 495         (void) expression (expressionP);
 496         /* Expression() will pass trailing whitespace */
 497         if (*input_line_pointer++ != ')')
 498           {
 499             as_bad ("Missing ')' assumed");
 500             input_line_pointer--;
 501           }
 502         /* here with input_line_pointer->char after "(...)" */
 503       }
 504       return expressionP->X_seg;
 505
 506
 507     case '\'':
 508       /* Warning: to conform to other people's assemblers NO ESCAPEMENT is
 509          permitted for a single quote. The next character, parity errors and
 510          all, is taken as the value of the operand. VERY KINKY.  */
 511       expressionP->X_add_number = *input_line_pointer++;
 512       expressionP->X_seg = SEG_ABSOLUTE;
 513       break;
 514
 515     case '~':
 516     case '-':
 517     case '+':
 518
 519       {
 520         /* unary operator: hope for SEG_ABSOLUTE */
 521         switch (operand (expressionP))
 522           {
 523           case SEG_ABSOLUTE:
 524             /* input_line_pointer -> char after operand */
 525             if (c == '-')
 526               {
 527                 expressionP->X_add_number = -expressionP->X_add_number;
 528                 /* Notice: '-' may overflow: no warning is given. This is
 529                    compatible with other people's assemblers. Sigh.  */
 530               }
 531             else
 532               {
 533                 expressionP->X_add_number = ~expressionP->X_add_number;
 534               }
 535             break;
 536
 537           case SEG_TEXT:
 538           case SEG_DATA:
 539           case SEG_BSS:
 540           case SEG_PASS1:
 541           case SEG_UNKNOWN:
 542             if (c == '-')
 543               {                 /* JF I hope this hack works */
 544                 expressionP->X_subtract_symbol = expressionP->X_add_symbol;
 545                 expressionP->X_add_symbol = 0;
 546                 expressionP->X_seg = SEG_DIFFERENCE;
 547                 break;
 548               }
 549           default:              /* unary on non-absolute is unsuported */
 550             as_warn ("Unary operator %c ignored because bad operand follows", c);
 551             break;
 552             /* Expression undisturbed from operand(). */
 553           }
 554       }
 555
 556
 557
 558       break;
 559
 560     case '.':
 561       if (!is_part_of_name (*input_line_pointer))
 562         {
 563           char *fake;
 564           extern struct obstack frags;
 565
 566           /* JF: '.' is pseudo symbol with value of current location
 567              in current segment.  */
 568 #ifdef DOT_LABEL_PREFIX
 569           fake = ".L0\001";
 570 #else
 571           fake = "L0\001";
 572 #endif
 573           symbolP = symbol_new (fake,
 574                                 now_seg,
 575                (valueT) (obstack_next_free (&frags) - frag_now->fr_literal),
 576                                 frag_now);
 577
 578           expressionP->X_add_number = 0;
 579           expressionP->X_add_symbol = symbolP;
 580           expressionP->X_seg = now_seg;
 581           break;
 582
 583         }
 584       else
 585         {
 586           goto isname;
 587
 588
 589         }
 590     case ',':
 591     case '\n':
 592     eol:
 593       /* can't imagine any other kind of operand */
 594       expressionP->X_seg = SEG_ABSENT;
 595       input_line_pointer--;
 596       md_operand (expressionP);
 597       break;
 598
 599     default:
 600       if (is_end_of_line[c])
 601         goto eol;
 602       if (is_name_beginner (c)) /* here if did not begin with a digit */
 603         {
 604           /*
 605            * Identifier begins here.
 606            * This is kludged for speed, so code is repeated.
 607            */
 608         isname:
 609           name = --input_line_pointer;
 610           c = get_symbol_end ();
 611           symbolP = symbol_find_or_make (name);
 612           /* If we have an absolute symbol or a reg, then we know its value
 613              now.  */
 614           expressionP->X_seg = S_GET_SEGMENT (symbolP);
 615           switch (expressionP->X_seg)
 616             {
 617             case SEG_ABSOLUTE:
 618             case SEG_REGISTER:
 619               expressionP->X_add_number = S_GET_VALUE (symbolP);
 620               break;
 621
 622             default:
 623               expressionP->X_add_number = 0;
 624               expressionP->X_add_symbol = symbolP;
 625             }
 626           *input_line_pointer = c;
 627           expressionP->X_subtract_symbol = NULL;
 628         }
 629       else
 630         {
 631           as_bad ("Bad expression");
 632           expressionP->X_add_number = 0;
 633           expressionP->X_seg = SEG_ABSOLUTE;
 634
 635         }
 636
 637     }
 638
 639
 640
 641
 642
 643
 644
 645   /*
 646    * It is more 'efficient' to clean up the expressionS when they are created.
 647    * Doing it here saves lines of code.
 648    */
 649   clean_up_expression (expressionP);
 650   SKIP_WHITESPACE ();           /*->1st char after operand. */
 651   know (*input_line_pointer != ' ');
 652   return (expressionP->X_seg);
 653 }                               /* operand() */
 654 \f
 655
 656 /* Internal. Simplify a struct expression for use by expr() */
 657
 658 /*
 659  * In:  address of a expressionS.
 660  *      The X_seg field of the expressionS may only take certain values.
 661  *      Now, we permit SEG_PASS1 to make code smaller & faster.
 662  *      Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
 663  * Out: expressionS may have been modified:
 664  *      'foo-foo' symbol references cancelled to 0,
 665  *              which changes X_seg from SEG_DIFFERENCE to SEG_ABSOLUTE;
 666  *      Unused fields zeroed to help expr().
 667  */
 668
 669 static void
 670 clean_up_expression (expressionP)
 671      register expressionS *expressionP;
 672 {
 673   switch (expressionP->X_seg)
 674     {
 675     case SEG_ABSENT:
 676     case SEG_PASS1:
 677       expressionP->X_add_symbol = NULL;
 678       expressionP->X_subtract_symbol = NULL;
 679       expressionP->X_add_number = 0;
 680       break;
 681
 682     case SEG_BIG:
 683     case SEG_ABSOLUTE:
 684       expressionP->X_subtract_symbol = NULL;
 685       expressionP->X_add_symbol = NULL;
 686       break;
 687
 688     case SEG_UNKNOWN:
 689       expressionP->X_subtract_symbol = NULL;
 690       break;
 691
 692     case SEG_DIFFERENCE:
 693       /*
 694          * It does not hurt to 'cancel' NULL==NULL
 695          * when comparing symbols for 'eq'ness.
 696          * It is faster to re-cancel them to NULL
 697          * than to check for this special case.
 698          */
 699       if (expressionP->X_subtract_symbol == expressionP->X_add_symbol
 700           || (expressionP->X_subtract_symbol
 701               && expressionP->X_add_symbol
 702               && expressionP->X_subtract_symbol->sy_frag == expressionP->X_add_symbol->sy_frag
 703               && S_GET_VALUE (expressionP->X_subtract_symbol) == S_GET_VALUE (expressionP->X_add_symbol)))
 704         {
 705           expressionP->X_subtract_symbol = NULL;
 706           expressionP->X_add_symbol = NULL;
 707           expressionP->X_seg = SEG_ABSOLUTE;
 708         }
 709       break;
 710
 711     case SEG_REGISTER:
 712       expressionP->X_add_symbol = NULL;
 713       expressionP->X_subtract_symbol = NULL;
 714       break;
 715
 716     default:
 717       if (SEG_NORMAL (expressionP->X_seg))
 718         {
 719           expressionP->X_subtract_symbol = NULL;
 720         }
 721       else
 722         {
 723           BAD_CASE (expressionP->X_seg);
 724         }
 725       break;
 726     }
 727 }                               /* clean_up_expression() */
 728 \f
 729 /*
 730  *                      expr_part ()
 731  *
 732  * Internal. Made a function because this code is used in 2 places.
 733  * Generate error or correct X_?????_symbol of expressionS.
 734  */
 735
 736 /*
 737  * symbol_1 += symbol_2 ... well ... sort of.
 738  */
 739
 740 static segT
 741 expr_part (symbol_1_PP, symbol_2_P)
 742      symbolS **symbol_1_PP;
 743      symbolS *symbol_2_P;
 744 {
 745   segT return_value;
 746 #ifndef MANY_SEGMENTS
 747   know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == SEG_TEXT) || (S_GET_SEGMENT (*symbol_1_PP) == SEG_DATA) || (S_GET_SEGMENT (*symbol_1_PP) == SEG_BSS) || (!S_IS_DEFINED (*symbol_1_PP)));
 748   know (symbol_2_P == NULL || (S_GET_SEGMENT (symbol_2_P) == SEG_TEXT) || (S_GET_SEGMENT (symbol_2_P) == SEG_DATA) || (S_GET_SEGMENT (symbol_2_P) == SEG_BSS) || (!S_IS_DEFINED (symbol_2_P)));
 749 #endif
 750   if (*symbol_1_PP)
 751     {
 752       if (!S_IS_DEFINED (*symbol_1_PP))
 753         {
 754           if (symbol_2_P)
 755             {
 756               return_value = SEG_PASS1;
 757               *symbol_1_PP = NULL;
 758             }
 759           else
 760             {
 761               know (!S_IS_DEFINED (*symbol_1_PP));
 762               return_value = SEG_UNKNOWN;
 763             }
 764         }
 765       else
 766         {
 767           if (symbol_2_P)
 768             {
 769               if (!S_IS_DEFINED (symbol_2_P))
 770                 {
 771                   *symbol_1_PP = NULL;
 772                   return_value = SEG_PASS1;
 773                 }
 774               else
 775                 {
 776                   /* {seg1} - {seg2} */
 777                   as_bad ("Expression too complex, 2 symbolS forgotten: \"%s\" \"%s\"",
 778                         S_GET_NAME (*symbol_1_PP), S_GET_NAME (symbol_2_P));
 779                   *symbol_1_PP = NULL;
 780                   return_value = SEG_ABSOLUTE;
 781                 }
 782             }
 783           else
 784             {
 785               return_value = S_GET_SEGMENT (*symbol_1_PP);
 786             }
 787         }
 788     }
 789   else
 790     {                           /* (* symbol_1_PP) == NULL */
 791       if (symbol_2_P)
 792         {
 793           *symbol_1_PP = symbol_2_P;
 794           return_value = S_GET_SEGMENT (symbol_2_P);
 795         }
 796       else
 797         {
 798           *symbol_1_PP = NULL;
 799           return_value = SEG_ABSOLUTE;
 800         }
 801     }
 802 #ifndef MANY_SEGMENTS
 803   know (return_value == SEG_ABSOLUTE || return_value == SEG_TEXT || return_value == SEG_DATA || return_value == SEG_BSS || return_value == SEG_UNKNOWN || return_value == SEG_PASS1);
 804 #endif
 805   know ((*symbol_1_PP) == NULL || (S_GET_SEGMENT (*symbol_1_PP) == return_value));
 806   return (return_value);
 807 }                               /* expr_part() */
 808 \f
 809 /* Expression parser. */
 810
 811 /*
 812  * We allow an empty expression, and just assume (absolute,0) silently.
 813  * Unary operators and parenthetical expressions are treated as operands.
 814  * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
 815  *
 816  * We used to do a aho/ullman shift-reduce parser, but the logic got so
 817  * warped that I flushed it and wrote a recursive-descent parser instead.
 818  * Now things are stable, would anybody like to write a fast parser?
 819  * Most expressions are either register (which does not even reach here)
 820  * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
 821  * So I guess it doesn't really matter how inefficient more complex expressions
 822  * are parsed.
 823  *
 824  * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
 825  * Also, we have consumed any leading or trailing spaces (operand does that)
 826  * and done all intervening operators.
 827  */
 828
 829 typedef enum
 830 {
 831   O_illegal,                    /* (0)  what we get for illegal op */
 832
 833   O_multiply,                   /* (1)  * */
 834   O_divide,                     /* (2)  / */
 835   O_modulus,                    /* (3)  % */
 836   O_left_shift,                 /* (4)  < */
 837   O_right_shift,                /* (5)  > */
 838   O_bit_inclusive_or,           /* (6)  | */
 839   O_bit_or_not,                 /* (7)  ! */
 840   O_bit_exclusive_or,           /* (8)  ^ */
 841   O_bit_and,                    /* (9)  & */
 842   O_add,                        /* (10) + */
 843   O_subtract                    /* (11) - */
 844 }
 845
 846 operatorT;
 847
 848 #define __ O_illegal
 849
 850 static const operatorT op_encoding[256] =
 851 {                               /* maps ASCII->operators */
 852
 853   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 854   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 855
 856   __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
 857   __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
 858   __, __, __, __, __, __, __, __,
 859   __, __, __, __, O_left_shift, __, O_right_shift, __,
 860   __, __, __, __, __, __, __, __,
 861   __, __, __, __, __, __, __, __,
 862   __, __, __, __, __, __, __, __,
 863   __, __, __, __, __, __, O_bit_exclusive_or, __,
 864   __, __, __, __, __, __, __, __,
 865   __, __, __, __, __, __, __, __,
 866   __, __, __, __, __, __, __, __,
 867   __, __, __, __, O_bit_inclusive_or, __, __, __,
 868
 869   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 870   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 871   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 872   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 873   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 874   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 875   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
 876   __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
 877 };
 878
 879
 880 /*
 881  *      Rank    Examples
 882  *      0       operand, (expression)
 883  *      1       + -
 884  *      2       & ^ ! |
 885  *      3       * / % << >>
 886  */
 887 static const operator_rankT
 888   op_rank[] =
 889 {0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1};
 890 \f
 891 /* Return resultP->X_seg. */
 892 segT
 893 expr (rank, resultP)
 894      register operator_rankT rank;      /* Larger # is higher rank. */
 895      register expressionS *resultP;     /* Deliver result here. */
 896 {
 897   expressionS right;
 898   register operatorT op_left;
 899   register char c_left;         /* 1st operator character. */
 900   register operatorT op_right;
 901   register char c_right;
 902
 903   know (rank >= 0);
 904   (void) operand (resultP);
 905   know (*input_line_pointer != ' ');    /* Operand() gobbles spaces. */
 906   c_left = *input_line_pointer; /* Potential operator character. */
 907   op_left = op_encoding[c_left];
 908   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
 909     {
 910       input_line_pointer++;     /*->after 1st character of operator. */
 911       /* Operators "<<" and ">>" have 2 characters. */
 912       if (*input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
 913         {
 914           input_line_pointer++;
 915         }                       /*->after operator. */
 916       if (SEG_ABSENT == expr (op_rank[(int) op_left], &right))
 917         {
 918           as_warn ("Missing operand value assumed absolute 0.");
 919           resultP->X_add_number = 0;
 920           resultP->X_subtract_symbol = NULL;
 921           resultP->X_add_symbol = NULL;
 922           resultP->X_seg = SEG_ABSOLUTE;
 923         }
 924       know (*input_line_pointer != ' ');
 925       c_right = *input_line_pointer;
 926       op_right = op_encoding[c_right];
 927       if (*input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
 928         {
 929           input_line_pointer++;
 930         }                       /*->after operator. */
 931       know ((int) op_right == 0 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
 932       /* input_line_pointer->after right-hand quantity. */
 933       /* left-hand quantity in resultP */
 934       /* right-hand quantity in right. */
 935       /* operator in op_left. */
 936       if (resultP->X_seg == SEG_PASS1 || right.X_seg == SEG_PASS1)
 937         {
 938           resultP->X_seg = SEG_PASS1;
 939         }
 940       else
 941         {
 942           if (resultP->X_seg == SEG_BIG)
 943             {
 944               as_warn ("Left operand of %c is a %s.  Integer 0 assumed.",
 945                     c_left, resultP->X_add_number > 0 ? "bignum" : "float");
 946               resultP->X_seg = SEG_ABSOLUTE;
 947               resultP->X_add_symbol = 0;
 948               resultP->X_subtract_symbol = 0;
 949               resultP->X_add_number = 0;
 950             }
 951           if (right.X_seg == SEG_BIG)
 952             {
 953               as_warn ("Right operand of %c is a %s.  Integer 0 assumed.",
 954                        c_left, right.X_add_number > 0 ? "bignum" : "float");
 955               right.X_seg = SEG_ABSOLUTE;
 956               right.X_add_symbol = 0;
 957               right.X_subtract_symbol = 0;
 958               right.X_add_number = 0;
 959             }
 960           if (op_left == O_subtract)
 961             {
 962               /*
 963                * Convert - into + by exchanging symbolS and negating number.
 964                * I know -infinity can't be negated in 2's complement:
 965                * but then it can't be subtracted either. This trick
 966                * does not cause any further inaccuracy.
 967                */
 968
 969               register symbolS *symbolP;
 970
 971               right.X_add_number = -right.X_add_number;
 972               symbolP = right.X_add_symbol;
 973               right.X_add_symbol = right.X_subtract_symbol;
 974               right.X_subtract_symbol = symbolP;
 975               if (symbolP)
 976                 {
 977                   right.X_seg = SEG_DIFFERENCE;
 978                 }
 979               op_left = O_add;
 980             }
 981 \f
 982           if (op_left == O_add)
 983             {
 984               segT seg1;
 985               segT seg2;
 986 #ifndef MANY_SEGMENTS
 987
 988               know (resultP->X_seg == SEG_DATA || resultP->X_seg == SEG_TEXT || resultP->X_seg == SEG_BSS || resultP->X_seg == SEG_UNKNOWN || resultP->X_seg == SEG_DIFFERENCE || resultP->X_seg == SEG_ABSOLUTE || resultP->X_seg == SEG_PASS1 || resultP->X_seg == SEG_REGISTER);
 989
 990               know (right.X_seg == SEG_DATA || right.X_seg == SEG_TEXT || right.X_seg == SEG_BSS || right.X_seg == SEG_UNKNOWN || right.X_seg == SEG_DIFFERENCE || right.X_seg == SEG_ABSOLUTE || right.X_seg == SEG_PASS1);
 991 #endif
 992               clean_up_expression (&right);
 993               clean_up_expression (resultP);
 994
 995               seg1 = expr_part (&resultP->X_add_symbol, right.X_add_symbol);
 996               seg2 = expr_part (&resultP->X_subtract_symbol, right.X_subtract_symbol);
 997               if (seg1 == SEG_PASS1 || seg2 == SEG_PASS1)
 998                 {
 999                   need_pass_2 = 1;
1000                   resultP->X_seg = SEG_PASS1;
1001                 }
1002               else if (seg2 == SEG_ABSOLUTE)
1003                 resultP->X_seg = seg1;
1004               else if (seg1 != SEG_UNKNOWN
1005                        && seg1 != SEG_ABSOLUTE
1006                        && seg2 != SEG_UNKNOWN
1007                        && seg1 != seg2)
1008                 {
1009                   know (seg2 != SEG_ABSOLUTE);
1010                   know (resultP->X_subtract_symbol);
1011 #ifndef MANY_SEGMENTS
1012                   know (seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1 == SEG_BSS);
1013                   know (seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2 == SEG_BSS);
1014 #endif
1015                   know (resultP->X_add_symbol);
1016                   know (resultP->X_subtract_symbol);
1017                   as_bad ("Expression too complex: forgetting %s - %s",
1018                           S_GET_NAME (resultP->X_add_symbol),
1019                           S_GET_NAME (resultP->X_subtract_symbol));
1020                   resultP->X_seg = SEG_ABSOLUTE;
1021                   /* Clean_up_expression() will do the rest. */
1022                 }
1023               else
1024                 resultP->X_seg = SEG_DIFFERENCE;
1025
1026               resultP->X_add_number += right.X_add_number;
1027               clean_up_expression (resultP);
1028             }
1029           else
1030             {                   /* Not +. */
1031               if (resultP->X_seg == SEG_UNKNOWN || right.X_seg == SEG_UNKNOWN)
1032                 {
1033                   resultP->X_seg = SEG_PASS1;
1034                   need_pass_2 = 1;
1035                 }
1036               else
1037                 {
1038                   resultP->X_subtract_symbol = NULL;
1039                   resultP->X_add_symbol = NULL;
1040                   /* Will be SEG_ABSOLUTE. */
1041                   if (resultP->X_seg != SEG_ABSOLUTE || right.X_seg != SEG_ABSOLUTE)
1042                     {
1043                       as_bad ("Relocation error. Absolute 0 assumed.");
1044                       resultP->X_seg = SEG_ABSOLUTE;
1045                       resultP->X_add_number = 0;
1046                     }
1047                   else
1048                     {
1049                       switch (op_left)
1050                         {
1051                         case O_bit_inclusive_or:
1052                           resultP->X_add_number |= right.X_add_number;
1053                           break;
1054
1055                         case O_modulus:
1056                           if (right.X_add_number)
1057                             {
1058                               resultP->X_add_number %= right.X_add_number;
1059                             }
1060                           else
1061                             {
1062                               as_warn ("Division by 0. 0 assumed.");
1063                               resultP->X_add_number = 0;
1064                             }
1065                           break;
1066
1067                         case O_bit_and:
1068                           resultP->X_add_number &= right.X_add_number;
1069                           break;
1070
1071                         case O_multiply:
1072                           resultP->X_add_number *= right.X_add_number;
1073                           break;
1074
1075                         case O_divide:
1076                           if (right.X_add_number)
1077                             {
1078                               resultP->X_add_number /= right.X_add_number;
1079                             }
1080                           else
1081                             {
1082                               as_warn ("Division by 0. 0 assumed.");
1083                               resultP->X_add_number = 0;
1084                             }
1085                           break;
1086
1087                         case O_left_shift:
1088                           resultP->X_add_number <<= right.X_add_number;
1089                           break;
1090
1091                         case O_right_shift:
1092                           resultP->X_add_number >>= right.X_add_number;
1093                           break;
1094
1095                         case O_bit_exclusive_or:
1096                           resultP->X_add_number ^= right.X_add_number;
1097                           break;
1098
1099                         case O_bit_or_not:
1100                           resultP->X_add_number |= ~right.X_add_number;
1101                           break;
1102
1103                         default:
1104                           BAD_CASE (op_left);
1105                           break;
1106                         }       /* switch(operator) */
1107                     }
1108                 }               /* If we have to force need_pass_2. */
1109             }                   /* If operator was +. */
1110         }                       /* If we didn't set need_pass_2. */
1111       op_left = op_right;
1112     }                           /* While next operator is >= this rank. */
1113   return (resultP->X_seg);
1114 }
1115 \f
1116 /*
1117  *                      get_symbol_end()
1118  *
1119  * This lives here because it belongs equally in expr.c & read.c.
1120  * Expr.c is just a branch office read.c anyway, and putting it
1121  * here lessens the crowd at read.c.
1122  *
1123  * Assume input_line_pointer is at start of symbol name.
1124  * Advance input_line_pointer past symbol name.
1125  * Turn that character into a '\0', returning its former value.
1126  * This allows a string compare (RMS wants symbol names to be strings)
1127  * of the symbol name.
1128  * There will always be a char following symbol name, because all good
1129  * lines end in end-of-line.
1130  */
1131 char
1132 get_symbol_end ()
1133 {
1134   register char c;
1135
1136   while (is_part_of_name (c = *input_line_pointer++))
1137     ;
1138   *--input_line_pointer = 0;
1139   return (c);
1140 }
1141
1142
1143 unsigned int
1144 get_single_number ()
1145 {
1146   expressionS exp;
1147   operand (&exp);
1148   return exp.X_add_number;
1149
1150 }
1151
1152 /* end of expr.c */