Changeset 609 for branches/GNU/src/binutils/gas/expr.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/gas/expr.c (modified) (35 diffs, 1 prop)

branches/GNU/src/binutils/gas/expr.c

@@ -1 +1 @@
 /* expr.c -operands, expressions-
    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001
+   1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
@@ -26 +26 @@
    Here, "operand"s are of expressions, not instructions.  */
 
-#include <ctype.h>
 #include <string.h>
 #define min(a, b)       ((a) < (b) ? (a) : (b))
 
 #include "as.h"
+#include "safe-ctype.h"
 #include "obstack.h"
 
@@ -80 +80 @@
     {
       /* This won't work, because the actual value is stored in
-         generic_floating_point_number or generic_bignum, and we are
-         going to lose it if we haven't already.  */
+         generic_floating_point_number or generic_bignum, and we are
+         going to lose it if we haven't already.  */
       if (expressionP->X_add_number > 0)
-        as_bad (_("bignum invalid; zero assumed"));
+        as_bad (_("bignum invalid"));
       else
-        as_bad (_("floating point number invalid; zero assumed"));
+        as_bad (_("floating point number invalid"));
       zero.X_op = O_constant;
       zero.X_add_number = 0;
@@ -107 +107 @@
 
   if (expressionP->X_op == O_constant)
-    resolve_symbol_value (symbolP, 1);
+    resolve_symbol_value (symbolP);
 
   n = (struct expr_symbol_line *) xmalloc (sizeof *n);
@@ -248 +248 @@
       if (error_code == ERROR_EXPONENT_OVERFLOW)
         {
-          as_bad (_("bad floating-point constant: exponent overflow, probably assembling junk"));
+          as_bad (_("bad floating-point constant: exponent overflow"));
         }
       else
         {
-          as_bad (_("bad floating-point constant: unknown error code=%d."), error_code);
+          as_bad (_("bad floating-point constant: unknown error code=%d"),
+                  error_code);
         }
     }
@@ -333 +334 @@
 
       /* In MRI mode, the number may have a suffix indicating the
-         radix.  For that matter, it might actually be a floating
-         point constant.  */
-      for (suffix = input_line_pointer;
-           isalnum ((unsigned char) *suffix);
-           suffix++)
+         radix.  For that matter, it might actually be a floating
+         point constant.  */
+      for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
         {
           if (*suffix == 'e' || *suffix == 'E')
@@ -351 +350 @@
         {
           c = *--suffix;
-          if (islower ((unsigned char) c))
-            c = toupper (c);
+          c = TOUPPER (c);
           if (c == 'B')
             radix = 2;
@@ -408 +406 @@
     {
       /* This is literal of the form 0x333_0_12345678_1.
-         This example is equivalent to 0x00000333000000001234567800000001.  */
+         This example is equivalent to 0x00000333000000001234567800000001.  */
 
       int num_little_digits = 0;
@@ -432 +430 @@
           /* Check for 8 digit per word max.  */
           if (ndigit > 8)
-            as_bad (_("A bignum with underscores may not have more than 8 hex digits in any word."));
+            as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
 
           /* Add this chunk to the bignum.
@@ -455 +453 @@
 
       if (num_little_digits != 8)
-        as_bad (_("A bignum with underscores must have exactly 4 words."));
+        as_bad (_("a bignum with underscores must have exactly 4 words"));
 
       /* We might have some leading zeros.  These can be trimmed to give
@@ -578 +576 @@
               /* @@ Should print out the original string instead of
                  the parsed number.  */
-              as_bad (_("backw. ref to unknown label \"%d:\", 0 assumed."),
+              as_bad (_("backward ref to unknown label \"%d:\""),
                       (int) number);
               expressionP->X_op = O_constant;
@@ -688 +686 @@
         {
           /* If there is more than one littlenum, left justify the
-             last one to make it match the earlier ones.  If there is
-             only one, we can just use the value directly.  */
+             last one to make it match the earlier ones.  If there is
+             only one, we can just use the value directly.  */
           for (; j < CHARS_PER_LITTLENUM; j++)
             generic_bignum[i] <<= 8;
@@ -701 +699 @@
   if (i < 0)
     {
-      as_bad (_("Character constant too large"));
+      as_bad (_("character constant too large"));
       i = 0;
     }
@@ -766 +764 @@
         be a space.
 
-   Out: A expressionS.
+   Out: An expressionS.
         The operand may have been empty: in this case X_op == O_absent.
         Input_line_pointer->(next non-blank) char after operand.  */
@@ -810 +808 @@
       integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
                         ? 0 : 10,
-                        expressionP);
+                        expressionP);
       break;
 
 #ifdef LITERAL_PREFIXDOLLAR_HEX
     case '$':
+      /* $L is the start of a local label, not a hex constant.  */
+      if (* input_line_pointer == 'L')
+      goto isname;
       integer_constant (16, expressionP);
       break;
@@ -832 +833 @@
           char *s;
 
-          /* Check for a hex constant.  */
+          /* Check for a hex or float constant.  */
           for (s = input_line_pointer; hex_p (*s); s++)
             ;
-          if (*s == 'h' || *s == 'H')
+          if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
             {
               --input_line_pointer;
@@ -863 +864 @@
               input_line_pointer++;
               floating_constant (expressionP);
-              expressionP->X_add_number =
-                - (isupper ((unsigned char) c) ? tolower (c) : c);
+              expressionP->X_add_number = - TOLOWER (c);
             }
           else
@@ -986 +986 @@
           input_line_pointer++;
           floating_constant (expressionP);
-          expressionP->X_add_number =
-            - (isupper ((unsigned char) c) ? tolower (c) : c);
+          expressionP->X_add_number = - TOLOWER (c);
           break;
 
@@ -1015 +1014 @@
           if (c != '(')
 #endif
-            as_bad (_("Missing '%c' assumed"), c == '(' ? ')' : ']');
+            as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
         }
       else
@@ -1085 +1084 @@
               expressionP->X_add_number = ! expressionP->X_add_number;
           }
+        else if (expressionP->X_op == O_big
+                 && expressionP->X_add_number <= 0
+                 && c == '-'
+                 && (generic_floating_point_number.sign == '+'
+                     || generic_floating_point_number.sign == 'P'))
+          {
+            /* Negative flonum (eg, -1.000e0).  */
+            if (generic_floating_point_number.sign == '+')
+              generic_floating_point_number.sign = '-';
+            else
+              generic_floating_point_number.sign = 'N';
+          }
         else if (expressionP->X_op != O_illegal
                  && expressionP->X_op != O_absent)
@@ -1106 +1117 @@
     case '$':
       /* '$' is the program counter when in MRI mode, or when
-         DOLLAR_DOT is defined.  */
+         DOLLAR_DOT is defined.  */
 #ifndef DOLLAR_DOT
       if (! flag_m68k_mri)
@@ -1114 +1125 @@
         {
           /* In MRI mode, '$' is also used as the prefix for a
-             hexadecimal constant.  */
+             hexadecimal constant.  */
           integer_constant (16, expressionP);
           break;
@@ -1205 +1216 @@
 
       /* In MRI mode, this is a floating point constant represented
-         using hexadecimal digits.  */
+         using hexadecimal digits.  */
 
       ++input_line_pointer;
@@ -1233 +1244 @@
 #ifdef md_parse_name
           /* This is a hook for the backend to parse certain names
-             specially in certain contexts.  If a name always has a
-             specific value, it can often be handled by simply
-             entering it in the symbol table.  */
-          if (md_parse_name (name, expressionP))
+             specially in certain contexts.  If a name always has a
+             specific value, it can often be handled by simply
+             entering it in the symbol table.  */
+          if (md_parse_name (name, expressionP, &c))
             {
               *input_line_pointer = c;
@@ -1317 +1328 @@
             {
               ++input_line_pointer;
-              as_bad (_("Bad expression"));
+              as_bad (_("bad expression"));
               expressionP->X_op = O_constant;
               expressionP->X_add_number = 0;
@@ -1349 +1360 @@
 /* Internal.  Simplify a struct expression for use by expr ().  */
 
-/* In:  address of a expressionS.
+/* In:  address of an expressionS.
         The X_op field of the expressionS may only take certain values.
         Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
 
    Out: expressionS may have been modified:
-        'foo-foo' symbol references cancelled to 0, which changes X_op
-        from O_subtract to O_constant.
         Unused fields zeroed to help expr ().  */
 
@@ -1378 +1387 @@
       expressionP->X_op_symbol = NULL;
       break;
-    case O_subtract:
-      if (expressionP->X_op_symbol == expressionP->X_add_symbol
-          || ((symbol_get_frag (expressionP->X_op_symbol)
-               == symbol_get_frag (expressionP->X_add_symbol))
-              && SEG_NORMAL (S_GET_SEGMENT (expressionP->X_add_symbol))
-              && (S_GET_VALUE (expressionP->X_op_symbol)
-                  == S_GET_VALUE (expressionP->X_add_symbol))))
-        {
-          addressT diff = (S_GET_VALUE (expressionP->X_add_symbol)
-                           - S_GET_VALUE (expressionP->X_op_symbol));
-
-          expressionP->X_op = O_constant;
-          expressionP->X_add_symbol = NULL;
-          expressionP->X_op_symbol = NULL;
-          expressionP->X_add_number += diff;
-        }
-      break;
     default:
       break;
@@ -1407 +1399 @@
    As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
 
-   We used to do a aho/ullman shift-reduce parser, but the logic got so
+   We used to do an aho/ullman shift-reduce parser, but the logic got so
    warped that I flushed it and wrote a recursive-descent parser instead.
    Now things are stable, would anybody like to write a fast parser?
@@ -1463 +1455 @@
    1    ||
    2    &&
-   3    = <> < <= >= >
+   3    == <> < <= >= >
    4    + -
    5    used for * / % in MRI mode
@@ -1668 +1660 @@
   know (rank >= 0);
 
+  /* Save the value of dot for the fixup code.  */
+  if (rank == 0)
+    dot_value = frag_now_fix ();
+
   retval = operand (resultP);
 
@@ -1702 +1698 @@
             }
         }
-
-      if (retval == undefined_section)
-        {
-          if (SEG_NORMAL (rightseg))
-            retval = rightseg;
-        }
-      else if (! SEG_NORMAL (retval))
-        retval = rightseg;
-      else if (SEG_NORMAL (rightseg)
-               && retval != rightseg
-#ifdef DIFF_EXPR_OK
-               && op_left != O_subtract
-#endif
-               )
-        as_bad (_("operation combines symbols in different segments"));
 
       op_right = operator (&op_chars);
@@ -1773 +1754 @@
                && (symbol_get_frag (right.X_add_symbol)
                    == symbol_get_frag (resultP->X_add_symbol))
-               && SEG_NORMAL (S_GET_SEGMENT (right.X_add_symbol)))
-
+               && (SEG_NORMAL (rightseg)
+                   || right.X_add_symbol == resultP->X_add_symbol))
         {
           resultP->X_add_number -= right.X_add_number;
@@ -1814 +1795 @@
             case O_right_shift:
               /* We always use unsigned shifts, to avoid relying on
-                 characteristics of the compiler used to compile gas.  */
+                 characteristics of the compiler used to compile gas.  */
               resultP->X_add_number =
                 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
@@ -1869 +1850 @@
             resultP->X_add_number += right.X_add_number;
           else if (op_left == O_subtract)
-            resultP->X_add_number -= right.X_add_number;
+            {
+              resultP->X_add_number -= right.X_add_number;
+              if (retval == rightseg && SEG_NORMAL (retval))
+                {
+                  retval = absolute_section;
+                  rightseg = absolute_section;
+                }
+            }
         }
       else
@@ -1879 +1867 @@
           resultP->X_add_number = 0;
           resultP->X_unsigned = 1;
+        }
+
+      if (retval != rightseg)
+        {
+          if (! SEG_NORMAL (retval))
+            {
+              if (retval != undefined_section || SEG_NORMAL (rightseg))
+                retval = rightseg;
+            }
+          else if (SEG_NORMAL (rightseg)
+#ifdef DIFF_EXPR_OK
+                   && op_left != O_subtract
+#endif
+                   )
+            as_bad (_("operation combines symbols in different segments"));
         }