* gas/config/tc-avr.c: Add support for

[deliverable/binutils-gdb.git] / gas / symbols.c

diff --git a/gas/symbols.c b/gas/symbols.c
index 68c50bbbaa04063cf1dec912f587863df53caa85..8caaf4a441eaf5de12d914b3a20a7d9e09df1b6a 100644 (file)
--- a/gas/symbols.c
+++ b/gas/symbols.c
@@ -1,5 +1,6 @@
 /* symbols.c -symbol table-
 /* symbols.c -symbol table-

-   Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
+   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+   1999, 2000, 2001, 2002, 2003, 2004

    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.


@@ -19,12 +20,11 @@
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.  */
 
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.  */
 

-/* #define DEBUG_SYMS / * to debug symbol list maintenance */
-
-#include <ctype.h>
+/* #define DEBUG_SYMS / * to debug symbol list maintenance.  */

 
 #include "as.h"
 
 
 #include "as.h"
 

+#include "safe-ctype.h"

 #include "obstack.h"           /* For "symbols.h" */
 #include "subsegs.h"
 
 #include "obstack.h"           /* For "symbols.h" */
 #include "subsegs.h"
 


@@ -44,7 +44,7 @@ static struct hash_control *sy_hash;
 /* Table of local symbols.  */
 static struct hash_control *local_hash;
 
 /* Table of local symbols.  */
 static struct hash_control *local_hash;
 

-/* Below are commented in "symbols.h". */
+/* Below are commented in "symbols.h".  */

 symbolS *symbol_rootP;
 symbolS *symbol_lastP;
 symbolS abs_symbol;
 symbolS *symbol_rootP;
 symbolS *symbol_lastP;
 symbolS abs_symbol;


@@ -55,37 +55,34 @@ symbolS abs_symbol;
 #define debug_verify_symchain(root, last) ((void) 0)
 #endif
 
 #define debug_verify_symchain(root, last) ((void) 0)
 #endif
 

+#define DOLLAR_LABEL_CHAR      '\001'
+#define LOCAL_LABEL_CHAR       '\002'
+

 struct obstack notes;
 
 struct obstack notes;
 

-static void fb_label_init PARAMS ((void));
-static long dollar_label_instance PARAMS ((long));
-static long fb_label_instance PARAMS ((long));
+static char *save_symbol_name (const char *);
+static void fb_label_init (void);
+static long dollar_label_instance (long);
+static long fb_label_instance (long);

 
 

-static void print_binary PARAMS ((FILE *, const char *, expressionS *));
+static void print_binary (FILE *, const char *, expressionS *);
+static void report_op_error (symbolS *, symbolS *, symbolS *);

 
 

-/* symbol_new()
-  
-   Return a pointer to a new symbol.  Die if we can't make a new
+/* Return a pointer to a new symbol.  Die if we can't make a new

    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
    chain.
    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
    chain.

- 
+

    This function should be called in the general case of creating a
    symbol.  However, if the output file symbol table has already been
    set, and you are certain that this symbol won't be wanted in the
    output file, you can call symbol_create.  */
 
 symbolS *
    This function should be called in the general case of creating a
    symbol.  However, if the output file symbol table has already been
    set, and you are certain that this symbol won't be wanted in the
    output file, you can call symbol_create.  */
 
 symbolS *

-symbol_new (name, segment, valu, frag)
-     const char *name;
-     segT segment;
-     valueT valu;
-     fragS *frag;
+symbol_new (const char *name, segT segment, valueT valu, fragS *frag)

 {
   symbolS *symbolP = symbol_create (name, segment, valu, frag);
 
 {
   symbolS *symbolP = symbol_create (name, segment, valu, frag);
 

-  /*
-   * Link to end of symbol chain.
-   */
+  /* Link to end of symbol chain.  */

 #ifdef BFD_ASSEMBLER
   {
     extern int symbol_table_frozen;
 #ifdef BFD_ASSEMBLER
   {
     extern int symbol_table_frozen;


@@ -102,13 +99,12 @@ symbol_new (name, segment, valu, frag)
    to the object file format.  */
 
 static char *
    to the object file format.  */
 
 static char *

-save_symbol_name (name)
-     const char *name;
+save_symbol_name (const char *name)

 {
   unsigned int name_length;
   char *ret;
 
 {
   unsigned int name_length;
   char *ret;
 

-  name_length = strlen (name) + 1;     /* +1 for \0 */
+  name_length = strlen (name) + 1;     /* +1 for \0.  */

   obstack_grow (&notes, name, name_length);
   ret = obstack_finish (&notes);
 
   obstack_grow (&notes, name, name_length);
   ret = obstack_finish (&notes);
 


@@ -123,22 +119,20 @@ save_symbol_name (name)
 
   if (! symbols_case_sensitive)
     {
 
   if (! symbols_case_sensitive)
     {

-      unsigned char *s;
+      char *s;

 
 

-      for (s = (unsigned char *) ret; *s != '\0'; s++)
-       if (islower (*s))
-         *s = toupper (*s);
+      for (s = ret; *s != '\0'; s++)
+       *s = TOUPPER (*s);

     }
 
   return ret;
 }
 
 symbolS *
     }
 
   return ret;
 }
 
 symbolS *

-symbol_create (name, segment, valu, frag)
-     const char *name;         /* It is copied, the caller can destroy/modify */
-     segT segment;             /* Segment identifier (SEG_<something>) */
-     valueT valu;              /* Symbol value */
-     fragS *frag;              /* Associated fragment */
+symbol_create (const char *name, /* It is copied, the caller can destroy/modify.  */
+              segT segment,    /* Segment identifier (SEG_<something>).  */
+              valueT valu,     /* Symbol value.  */
+              fragS *frag      /* Associated fragment.  */)

 {
   char *preserved_copy_of_name;
   symbolS *symbolP;
 {
   char *preserved_copy_of_name;
   symbolS *symbolP;


@@ -147,7 +141,7 @@ symbol_create (name, segment, valu, frag)
 
   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 
 
   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 

-  /* symbol must be born in some fixed state.  This seems as good as any. */
+  /* symbol must be born in some fixed state.  This seems as good as any.  */

   memset (symbolP, 0, sizeof (symbolS));
 
 #ifdef BFD_ASSEMBLER
   memset (symbolP, 0, sizeof (symbolS));
 
 #ifdef BFD_ASSEMBLER


@@ -182,9 +176,7 @@ symbol_create (name, segment, valu, frag)
 /* Local symbol support.  If we can get away with it, we keep only a
    small amount of information for local symbols.  */
 
 /* Local symbol support.  If we can get away with it, we keep only a
    small amount of information for local symbols.  */
 

-static struct local_symbol *local_symbol_make PARAMS ((const char *, segT,
-                                                      valueT, fragS *));
-static symbolS *local_symbol_convert PARAMS ((struct local_symbol *));
+static symbolS *local_symbol_convert (struct local_symbol *);

 
 /* Used for statistics.  */
 
 
 /* Used for statistics.  */
 


@@ -205,12 +197,8 @@ static unsigned long local_symbol_conversion_count;
 
 /* Create a local symbol and insert it into the local hash table.  */
 
 
 /* Create a local symbol and insert it into the local hash table.  */
 

-static struct local_symbol *
-local_symbol_make (name, section, offset, frag)
-     const char *name;
-     segT section;
-     valueT offset;
-     fragS *frag;
+struct local_symbol *
+local_symbol_make (const char *name, segT section, valueT value, fragS *frag)

 {
   char *name_copy;
   struct local_symbol *ret;
 {
   char *name_copy;
   struct local_symbol *ret;


@@ -224,7 +212,7 @@ local_symbol_make (name, section, offset, frag)
   ret->lsy_name = name_copy;
   ret->lsy_section = section;
   local_symbol_set_frag (ret, frag);
   ret->lsy_name = name_copy;
   ret->lsy_section = section;
   local_symbol_set_frag (ret, frag);

-  ret->lsy_offset = offset;
+  ret->lsy_value = value;

 
   hash_jam (local_hash, name_copy, (PTR) ret);
 
 
   hash_jam (local_hash, name_copy, (PTR) ret);
 


@@ -235,8 +223,7 @@ local_symbol_make (name, section, offset, frag)
    reclaim the space used by the local symbol.  */
 
 static symbolS *
    reclaim the space used by the local symbol.  */
 
 static symbolS *

-local_symbol_convert (locsym)
-     struct local_symbol *locsym;
+local_symbol_convert (struct local_symbol *locsym)

 {
   symbolS *ret;
 
 {
   symbolS *ret;
 


@@ -246,7 +233,7 @@ local_symbol_convert (locsym)
 
   ++local_symbol_conversion_count;
 
 
   ++local_symbol_conversion_count;
 

-  ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_offset,
+  ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,

                    local_symbol_get_frag (locsym));
 
   if (local_symbol_resolved_p (locsym))
                    local_symbol_get_frag (locsym));
 
   if (local_symbol_resolved_p (locsym))


@@ -255,6 +242,10 @@ local_symbol_convert (locsym)
   /* Local symbols are always either defined or used.  */
   ret->sy_used = 1;
 
   /* Local symbols are always either defined or used.  */
   ret->sy_used = 1;
 

+#ifdef TC_LOCAL_SYMFIELD_CONVERT
+  TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
+#endif
+

   symbol_table_insert (ret);
 
   local_symbol_mark_converted (locsym);
   symbol_table_insert (ret);
 
   local_symbol_mark_converted (locsym);


@@ -272,22 +263,17 @@ local_symbol_convert (locsym)
 
 #endif /* ! BFD_ASSEMBLER */
 \f
 
 #endif /* ! BFD_ASSEMBLER */
 \f

+/* We have just seen "<name>:".
+   Creates a struct symbol unless it already exists.
+
+   Gripes if we are redefining a symbol incompatibly (and ignores it).  */

 
 

-/*
- *                     colon()
- *
- * We have just seen "<name>:".
- * Creates a struct symbol unless it already exists.
- *
- * Gripes if we are redefining a symbol incompatibly (and ignores it).
- *
- */

 symbolS *
 symbolS *

-colon (sym_name)               /* just seen "x:" - rattle symbols & frags */
-     const char *sym_name;     /* symbol name, as a cannonical string */
-     /* We copy this string: OK to alter later. */
+colon (/* Just seen "x:" - rattle symbols & frags.  */
+       const char *sym_name    /* Symbol name, as a cannonical string.  */
+       /* We copy this string: OK to alter later.  */)

 {
 {

-  register symbolS *symbolP;   /* symbol we are working with */
+  register symbolS *symbolP;   /* Symbol we are working with.  */

 
   /* Sun local labels go out of scope whenever a non-local symbol is
      defined.  */
 
   /* Sun local labels go out of scope whenever a non-local symbol is
      defined.  */


@@ -315,6 +301,13 @@ colon (sym_name)           /* just seen "x:" - rattle symbols & frags */
 
       extern const int md_short_jump_size;
       extern const int md_long_jump_size;
 
       extern const int md_short_jump_size;
       extern const int md_long_jump_size;

+
+      if (now_seg == absolute_section)
+       {
+         as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
+         return NULL;
+       }
+

       possible_bytes = (md_short_jump_size
                        + new_broken_words * md_long_jump_size);
 
       possible_bytes = (md_short_jump_size
                        + new_broken_words * md_long_jump_size);
 


@@ -327,9 +320,9 @@ colon (sym_name)            /* just seen "x:" - rattle symbols & frags */
                              (offsetT) 0,
                              NULL);
 
                              (offsetT) 0,
                              NULL);
 

-      /* We want to store the pointer to where to insert the jump table in the
-        fr_opcode of the rs_broken_word frag.  This requires a little
-        hackery.  */
+      /* We want to store the pointer to where to insert the jump
+        table in the fr_opcode of the rs_broken_word frag.  This
+        requires a little hackery.  */

       while (frag_tmp
             && (frag_tmp->fr_type != rs_broken_word
                 || frag_tmp->fr_opcode))
       while (frag_tmp
             && (frag_tmp->fr_type != rs_broken_word
                 || frag_tmp->fr_opcode))


@@ -349,9 +342,7 @@ colon (sym_name)            /* just seen "x:" - rattle symbols & frags */
       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
        return symbolP;
 #endif
       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
        return symbolP;
 #endif

-      /*
-       *       Now check for undefined symbols
-       */
+      /* Now check for undefined symbols.  */

       if (LOCAL_SYMBOL_CHECK (symbolP))
        {
 #ifdef BFD_ASSEMBLER
       if (LOCAL_SYMBOL_CHECK (symbolP))
        {
 #ifdef BFD_ASSEMBLER


@@ -360,15 +351,15 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
          if (locsym->lsy_section != undefined_section
              && (local_symbol_get_frag (locsym) != frag_now
                  || locsym->lsy_section != now_seg
          if (locsym->lsy_section != undefined_section
              && (local_symbol_get_frag (locsym) != frag_now
                  || locsym->lsy_section != now_seg

-                 || locsym->lsy_offset != frag_now_fix ()))
+                 || locsym->lsy_value != frag_now_fix ()))

            {
            {

-             as_bad (_("Symbol %s already defined."), sym_name);
+             as_bad (_("symbol `%s' is already defined"), sym_name);

              return symbolP;
            }
 
          locsym->lsy_section = now_seg;
          local_symbol_set_frag (locsym, frag_now);
              return symbolP;
            }
 
          locsym->lsy_section = now_seg;
          local_symbol_set_frag (locsym, frag_now);

-         locsym->lsy_offset = frag_now_fix ();
+         locsym->lsy_value = frag_now_fix ();

 #endif
        }
       else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
 #endif
        }
       else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))


@@ -377,27 +368,27 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
            {
              symbolP->sy_frag = frag_now;
 #ifdef OBJ_VMS
            {
              symbolP->sy_frag = frag_now;
 #ifdef OBJ_VMS

-             S_SET_OTHER(symbolP, const_flag);
+             S_SET_OTHER (symbolP, const_flag);

 #endif
              S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
              S_SET_SEGMENT (symbolP, now_seg);
 #ifdef N_UNDF
              know (N_UNDF == 0);
 #endif
              S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
              S_SET_SEGMENT (symbolP, now_seg);
 #ifdef N_UNDF
              know (N_UNDF == 0);

-#endif /* if we have one, it better be zero. */
+#endif /* if we have one, it better be zero.  */

 
            }
          else
            {
 
            }
          else
            {

-             /*
-              *        There are still several cases to check:
-              *                A .comm/.lcomm symbol being redefined as
-              *                        initialized data is OK
-              *                A .comm/.lcomm symbol being redefined with
-              *                        a larger size is also OK
-              *
-              * This only used to be allowed on VMS gas, but Sun cc
-              * on the sparc also depends on it.
-              */
+             /* There are still several cases to check:
+
+                A .comm/.lcomm symbol being redefined as initialized
+                data is OK
+
+                A .comm/.lcomm symbol being redefined with a larger
+                size is also OK
+
+                This only used to be allowed on VMS gas, but Sun cc
+                on the sparc also depends on it.  */

 
              if (((!S_IS_DEBUG (symbolP)
                    && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
 
              if (((!S_IS_DEBUG (symbolP)
                    && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))


@@ -406,17 +397,14 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
                  && (now_seg == data_section
                      || now_seg == S_GET_SEGMENT (symbolP)))
                {
                  && (now_seg == data_section
                      || now_seg == S_GET_SEGMENT (symbolP)))
                {

-                 /*
-                  *    Select which of the 2 cases this is
-                  */
+                 /* Select which of the 2 cases this is.  */

                  if (now_seg != data_section)
                    {
                  if (now_seg != data_section)
                    {

-                     /*
-                      *   New .comm for prev .comm symbol.
-                      *        If the new size is larger we just
-                      *        change its value.  If the new size
-                      *        is smaller, we ignore this symbol
-                      */
+                     /* New .comm for prev .comm symbol.
+
+                        If the new size is larger we just change its
+                        value.  If the new size is smaller, we ignore
+                        this symbol.  */

                      if (S_GET_VALUE (symbolP)
                          < ((unsigned) frag_now_fix ()))
                        {
                      if (S_GET_VALUE (symbolP)
                          < ((unsigned) frag_now_fix ()))
                        {


@@ -429,10 +417,10 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
                         data.  */
                      symbolP->sy_frag = frag_now;
 #ifdef OBJ_VMS
                         data.  */
                      symbolP->sy_frag = frag_now;
 #ifdef OBJ_VMS

-                     S_SET_OTHER(symbolP, const_flag);
+                     S_SET_OTHER (symbolP, const_flag);

 #endif
                      S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 #endif
                      S_SET_VALUE (symbolP, (valueT) frag_now_fix ());

-                     S_SET_SEGMENT (symbolP, now_seg); /* keep N_EXT bit */
+                     S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit.  */

                    }
                }
              else
                    }
                }
              else


@@ -446,26 +434,26 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
 #ifdef BFD_ASSEMBLER
                  if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
 #endif
 #ifdef BFD_ASSEMBLER
                  if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
 #endif

-                   sprintf(od_buf, "%d.%d.",
-                           S_GET_OTHER (symbolP),
-                           S_GET_DESC (symbolP));
+                   sprintf (od_buf, "%d.%d.",
+                            S_GET_OTHER (symbolP),
+                            S_GET_DESC (symbolP));

 #endif
 #endif

-                 as_fatal (_("Symbol \"%s\" is already defined as \"%s\"/%s%ld."),
+                 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),

                            sym_name,
                            segment_name (S_GET_SEGMENT (symbolP)),
                            od_buf,
                            (long) S_GET_VALUE (symbolP));
                }
                            sym_name,
                            segment_name (S_GET_SEGMENT (symbolP)),
                            od_buf,
                            (long) S_GET_VALUE (symbolP));
                }

-           }                   /* if the undefined symbol has no value */
+           }                   /* if the undefined symbol has no value  */

        }
       else
        {
        }
       else
        {

-         /* Don't blow up if the definition is the same */
+         /* Don't blow up if the definition is the same.  */

          if (!(frag_now == symbolP->sy_frag
                && S_GET_VALUE (symbolP) == frag_now_fix ()
                && S_GET_SEGMENT (symbolP) == now_seg))
          if (!(frag_now == symbolP->sy_frag
                && S_GET_VALUE (symbolP) == frag_now_fix ()
                && S_GET_SEGMENT (symbolP) == now_seg))

-           as_fatal (_("Symbol %s already defined."), sym_name);
-       }                       /* if this symbol is not yet defined */
+           as_bad (_("symbol `%s' is already defined"), sym_name);
+       }

 
     }
 #ifdef BFD_ASSEMBLER
 
     }
 #ifdef BFD_ASSEMBLER


@@ -485,12 +473,12 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
 #endif /* OBJ_VMS */
 
       symbol_table_insert (symbolP);
 #endif /* OBJ_VMS */
 
       symbol_table_insert (symbolP);

-    }                          /* if we have seen this symbol before */
+    }

 
   if (mri_common_symbol != NULL)
     {
       /* This symbol is actually being defined within an MRI common
 
   if (mri_common_symbol != NULL)
     {
       /* This symbol is actually being defined within an MRI common

-         section.  This requires special handling.  */
+        section.  This requires special handling.  */

       if (LOCAL_SYMBOL_CHECK (symbolP))
        symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
       symbolP->sy_value.X_op = O_symbol;
       if (LOCAL_SYMBOL_CHECK (symbolP))
        symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
       symbolP->sy_value.X_op = O_symbol;


@@ -511,17 +499,10 @@ colon (sym_name)          /* just seen "x:" - rattle symbols & frags */
   return symbolP;
 }
 \f
   return symbolP;
 }
 \f

+/* Die if we can't insert the symbol.  */

 
 

-/*
- *                     symbol_table_insert()
- *
- * Die if we can't insert the symbol.
- *
- */
-
-void 
-symbol_table_insert (symbolP)
-     symbolS *symbolP;
+void
+symbol_table_insert (symbolS *symbolP)

 {
   register const char *error_string;
 
 {
   register const char *error_string;
 


@@ -533,27 +514,23 @@ symbol_table_insert (symbolP)
       error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
                               (PTR) symbolP);
       if (error_string != NULL)
       error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
                               (PTR) symbolP);
       if (error_string != NULL)

-       as_fatal (_("Inserting \"%s\" into symbol table failed: %s"),
+       as_fatal (_("inserting \"%s\" into symbol table failed: %s"),

                  S_GET_NAME (symbolP), error_string);
       return;
     }
 
   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
     {
                  S_GET_NAME (symbolP), error_string);
       return;
     }
 
   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
     {

-      as_fatal (_("Inserting \"%s\" into symbol table failed: %s"),
+      as_fatal (_("inserting \"%s\" into symbol table failed: %s"),

                S_GET_NAME (symbolP), error_string);
                S_GET_NAME (symbolP), error_string);

-    }                          /* on error */
-}                              /* symbol_table_insert() */
+    }                          /* on error  */
+}

 \f
 \f

-/*
- *                     symbol_find_or_make()
- *
- * If a symbol name does not exist, create it as undefined, and insert
- * it into the symbol table. Return a pointer to it.
- */
+/* If a symbol name does not exist, create it as undefined, and insert
+   it into the symbol table.  Return a pointer to it.  */
+

 symbolS *
 symbolS *

-symbol_find_or_make (name)
-     const char *name;
+symbol_find_or_make (const char *name)

 {
   register symbolS *symbolP;
 
 {
   register symbolS *symbolP;
 


@@ -581,47 +558,73 @@ symbol_find_or_make (name)
     }                          /* if symbol wasn't found */
 
   return (symbolP);
     }                          /* if symbol wasn't found */
 
   return (symbolP);

-}                              /* symbol_find_or_make() */
+}

 
 symbolS *
 
 symbolS *

-symbol_make (name)
-     CONST char *name;
+symbol_make (const char *name)

 {
   symbolS *symbolP;
 
 {
   symbolS *symbolP;
 

-  /* Let the machine description default it, e.g. for register names. */
+  /* Let the machine description default it, e.g. for register names.  */

   symbolP = md_undefined_symbol ((char *) name);
 
   if (!symbolP)
     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
 
   return (symbolP);
   symbolP = md_undefined_symbol ((char *) name);
 
   if (!symbolP)
     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
 
   return (symbolP);

-}                              /* symbol_make() */
+}

 
 

-/*
- *                     symbol_find()
- *
- * Implement symbol table lookup.
- * In: A symbol's name as a string: '\0' can't be part of a symbol name.
- * Out:        NULL if the name was not in the symbol table, else the address
- *     of a struct symbol associated with that name.
- */
+symbolS *
+symbol_temp_new (segT seg, valueT ofs, fragS *frag)
+{
+  return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
+}

 
 symbolS *
 
 symbolS *

-symbol_find (name)
-     CONST char *name;
+symbol_temp_new_now (void)
+{
+  return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
+}
+
+symbolS *
+symbol_temp_make (void)
+{
+  return symbol_make (FAKE_LABEL_NAME);
+}
+
+/* Implement symbol table lookup.
+   In: A symbol's name as a string: '\0' can't be part of a symbol name.
+   Out:        NULL if the name was not in the symbol table, else the address
+   of a struct symbol associated with that name.  */
+
+symbolS *
+symbol_find (const char *name)

 {
 #ifdef STRIP_UNDERSCORE
   return (symbol_find_base (name, 1));
 #else /* STRIP_UNDERSCORE */
   return (symbol_find_base (name, 0));
 #endif /* STRIP_UNDERSCORE */
 {
 #ifdef STRIP_UNDERSCORE
   return (symbol_find_base (name, 1));
 #else /* STRIP_UNDERSCORE */
   return (symbol_find_base (name, 0));
 #endif /* STRIP_UNDERSCORE */

-}                              /* symbol_find() */
+}

 
 symbolS *
 
 symbolS *

-symbol_find_base (name, strip_underscore)
-     CONST char *name;
-     int strip_underscore;
+symbol_find_exact (const char *name)
+{
+#ifdef BFD_ASSEMBLER
+  {
+    struct local_symbol *locsym;
+
+    locsym = (struct local_symbol *) hash_find (local_hash, name);
+    if (locsym != NULL)
+      return (symbolS *) locsym;
+  }
+#endif
+
+  return ((symbolS *) hash_find (sy_hash, name));
+}
+
+symbolS *
+symbol_find_base (const char *name, int strip_underscore)

 {
   if (strip_underscore && *name == '_')
     name++;
 {
   if (strip_underscore && *name == '_')
     name++;


@@ -648,41 +651,25 @@ symbol_find_base (name, strip_underscore)
 
       while ((c = *orig++) != '\0')
        {
 
       while ((c = *orig++) != '\0')
        {

-         if (islower (c))
-           c = toupper (c);
-         *copy++ = c;
+         *copy++ = TOUPPER (c);

        }
       *copy = '\0';
     }
 
        }
       *copy = '\0';
     }
 

-#ifdef BFD_ASSEMBLER
-  {
-    struct local_symbol *locsym;
-
-    locsym = (struct local_symbol *) hash_find (local_hash, name);
-    if (locsym != NULL)
-      return (symbolS *) locsym;
-  }
-#endif
-
-  return ((symbolS *) hash_find (sy_hash, name));
+  return symbol_find_exact (name);

 }
 
 }
 

-/*
- * Once upon a time, symbols were kept in a singly linked list.  At
- * least coff needs to be able to rearrange them from time to time, for
- * which a doubly linked list is much more convenient.  Loic did these
- * as macros which seemed dangerous to me so they're now functions.
- * xoxorich.
- */
+/* Once upon a time, symbols were kept in a singly linked list.  At
+   least coff needs to be able to rearrange them from time to time, for
+   which a doubly linked list is much more convenient.  Loic did these
+   as macros which seemed dangerous to me so they're now functions.
+   xoxorich.  */

 
 

-/* Link symbol ADDME after symbol TARGET in the chain. */
-void 
-symbol_append (addme, target, rootPP, lastPP)
-     symbolS *addme;
-     symbolS *target;
-     symbolS **rootPP;
-     symbolS **lastPP;
+/* Link symbol ADDME after symbol TARGET in the chain.  */
+
+void
+symbol_append (symbolS *addme, symbolS *target,
+              symbolS **rootPP, symbolS **lastPP)

 {
   if (LOCAL_SYMBOL_CHECK (addme))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (addme))
     abort ();


@@ -700,7 +687,7 @@ symbol_append (addme, target, rootPP, lastPP)
       *rootPP = addme;
       *lastPP = addme;
       return;
       *rootPP = addme;
       *lastPP = addme;
       return;

-    }                          /* if the list is empty */
+    }                          /* if the list is empty  */

 
   if (target->sy_next != NULL)
     {
 
   if (target->sy_next != NULL)
     {


@@ -712,7 +699,7 @@ symbol_append (addme, target, rootPP, lastPP)
     {
       know (*lastPP == target);
       *lastPP = addme;
     {
       know (*lastPP == target);
       *lastPP = addme;

-    }                          /* if we have a next */
+    }                          /* if we have a next  */

 
   addme->sy_next = target->sy_next;
   target->sy_next = addme;
 
   addme->sy_next = target->sy_next;
   target->sy_next = addme;


@@ -724,10 +711,10 @@ symbol_append (addme, target, rootPP, lastPP)
   debug_verify_symchain (symbol_rootP, symbol_lastP);
 }
 
   debug_verify_symchain (symbol_rootP, symbol_lastP);
 }
 

-/* Set the chain pointers of SYMBOL to null. */
-void 
-symbol_clear_list_pointers (symbolP)
-     symbolS *symbolP;
+/* Set the chain pointers of SYMBOL to null.  */
+
+void
+symbol_clear_list_pointers (symbolS *symbolP)

 {
   if (LOCAL_SYMBOL_CHECK (symbolP))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (symbolP))
     abort ();


@@ -738,12 +725,10 @@ symbol_clear_list_pointers (symbolP)
 }
 
 #ifdef SYMBOLS_NEED_BACKPOINTERS
 }
 
 #ifdef SYMBOLS_NEED_BACKPOINTERS

-/* Remove SYMBOLP from the list. */
-void 
-symbol_remove (symbolP, rootPP, lastPP)
-     symbolS *symbolP;
-     symbolS **rootPP;
-     symbolS **lastPP;
+/* Remove SYMBOLP from the list.  */
+
+void
+symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)

 {
   if (LOCAL_SYMBOL_CHECK (symbolP))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (symbolP))
     abort ();


@@ -751,33 +736,31 @@ symbol_remove (symbolP, rootPP, lastPP)
   if (symbolP == *rootPP)
     {
       *rootPP = symbolP->sy_next;
   if (symbolP == *rootPP)
     {
       *rootPP = symbolP->sy_next;

-    }                          /* if it was the root */
+    }                          /* if it was the root  */

 
   if (symbolP == *lastPP)
     {
       *lastPP = symbolP->sy_previous;
 
   if (symbolP == *lastPP)
     {
       *lastPP = symbolP->sy_previous;

-    }                          /* if it was the tail */
+    }                          /* if it was the tail  */

 
   if (symbolP->sy_next != NULL)
     {
       symbolP->sy_next->sy_previous = symbolP->sy_previous;
 
   if (symbolP->sy_next != NULL)
     {
       symbolP->sy_next->sy_previous = symbolP->sy_previous;

-    }                          /* if not last */
+    }                          /* if not last  */

 
   if (symbolP->sy_previous != NULL)
     {
       symbolP->sy_previous->sy_next = symbolP->sy_next;
 
   if (symbolP->sy_previous != NULL)
     {
       symbolP->sy_previous->sy_next = symbolP->sy_next;

-    }                          /* if not first */
+    }                          /* if not first  */

 
   debug_verify_symchain (*rootPP, *lastPP);
 }
 
 
   debug_verify_symchain (*rootPP, *lastPP);
 }
 

-/* Link symbol ADDME before symbol TARGET in the chain. */
-void 
-symbol_insert (addme, target, rootPP, lastPP)
-     symbolS *addme;
-     symbolS *target;
-     symbolS **rootPP;
-     symbolS **lastPP ATTRIBUTE_UNUSED;
+/* Link symbol ADDME before symbol TARGET in the chain.  */
+
+void
+symbol_insert (symbolS *addme, symbolS *target,
+              symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)

 {
   if (LOCAL_SYMBOL_CHECK (addme))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (addme))
     abort ();


@@ -792,7 +775,7 @@ symbol_insert (addme, target, rootPP, lastPP)
     {
       know (*rootPP == target);
       *rootPP = addme;
     {
       know (*rootPP == target);
       *rootPP = addme;

-    }                          /* if not first */
+    }                          /* if not first  */

 
   addme->sy_previous = target->sy_previous;
   target->sy_previous = addme;
 
   addme->sy_previous = target->sy_previous;
   target->sy_previous = addme;


@@ -803,10 +786,8 @@ symbol_insert (addme, target, rootPP, lastPP)
 
 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 
 
 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 

-void 
-verify_symbol_chain (rootP, lastP)
-     symbolS *rootP;
-     symbolS *lastP;
+void
+verify_symbol_chain (symbolS *rootP, symbolS *lastP)

 {
   symbolS *symbolP = rootP;
 
 {
   symbolS *symbolP = rootP;
 


@@ -830,8 +811,7 @@ verify_symbol_chain (rootP, lastP)
 }
 
 void
 }
 
 void

-verify_symbol_chain_2 (sym)
-     symbolS *sym;
+verify_symbol_chain_2 (symbolS *sym)

 {
   symbolS *p = sym, *n = sym;
 #ifdef SYMBOLS_NEED_BACKPOINTERS
 {
   symbolS *p = sym, *n = sym;
 #ifdef SYMBOLS_NEED_BACKPOINTERS


@@ -843,17 +823,70 @@ verify_symbol_chain_2 (sym)
   verify_symbol_chain (p, n);
 }
 
   verify_symbol_chain (p, n);
 }
 

+static void
+report_op_error (symbolS *symp, symbolS *left, symbolS *right)
+{
+  char *file;
+  unsigned int line;
+  segT seg_left = S_GET_SEGMENT (left);
+  segT seg_right = right ? S_GET_SEGMENT (right) : 0;
+
+  if (expr_symbol_where (symp, &file, &line))
+    {
+      if (seg_left == undefined_section)
+       as_bad_where (file, line,
+                     _("undefined symbol `%s' in operation"),
+                     S_GET_NAME (left));
+      if (seg_right == undefined_section)
+       as_bad_where (file, line,
+                     _("undefined symbol `%s' in operation"),
+                     S_GET_NAME (right));
+      if (seg_left != undefined_section
+         && seg_right != undefined_section)
+       {
+         if (right)
+           as_bad_where (file, line,
+                         _("invalid sections for operation on `%s' and `%s'"),
+                         S_GET_NAME (left), S_GET_NAME (right));
+         else
+           as_bad_where (file, line,
+                         _("invalid section for operation on `%s'"),
+                         S_GET_NAME (left));
+       }
+
+    }
+  else
+    {
+      if (seg_left == undefined_section)
+       as_bad (_("undefined symbol `%s' in operation setting `%s'"),
+               S_GET_NAME (left), S_GET_NAME (symp));
+      if (seg_right == undefined_section)
+       as_bad (_("undefined symbol `%s' in operation setting `%s'"),
+               S_GET_NAME (right), S_GET_NAME (symp));
+      if (seg_left != undefined_section
+         && seg_right != undefined_section)
+       {
+         if (right)
+           as_bad_where (file, line,
+                         _("invalid sections for operation on `%s' and `%s' setting `%s'"),
+                         S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
+         else
+           as_bad_where (file, line,
+                         _("invalid section for operation on `%s' setting `%s'"),
+                         S_GET_NAME (left), S_GET_NAME (symp));
+       }
+    }
+}
+

 /* Resolve the value of a symbol.  This is called during the final
    pass over the symbol table to resolve any symbols with complex
    values.  */
 
 valueT
 /* Resolve the value of a symbol.  This is called during the final
    pass over the symbol table to resolve any symbols with complex
    values.  */
 
 valueT

-resolve_symbol_value (symp, finalize)
-     symbolS *symp;
-     int finalize;
+resolve_symbol_value (symbolS *symp)

 {
   int resolved;
 {
   int resolved;

-  valueT final_val;
+  valueT final_val = 0;

   segT final_seg;
 
 #ifdef BFD_ASSEMBLER
   segT final_seg;
 
 #ifdef BFD_ASSEMBLER


@@ -861,15 +894,15 @@ resolve_symbol_value (symp, finalize)
     {
       struct local_symbol *locsym = (struct local_symbol *) symp;
 
     {
       struct local_symbol *locsym = (struct local_symbol *) symp;
 

+      final_val = locsym->lsy_value;

       if (local_symbol_resolved_p (locsym))
       if (local_symbol_resolved_p (locsym))

-       return locsym->lsy_offset / bfd_octets_per_byte (stdoutput);
+       return final_val;

 
 

-      final_val = (local_symbol_get_frag (locsym)->fr_address
-                  + locsym->lsy_offset) / bfd_octets_per_byte (stdoutput);
+      final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;

 
 

-      if (finalize)
+      if (finalize_syms)

        {
        {

-         locsym->lsy_offset = final_val;
+         locsym->lsy_value = final_val;

          local_symbol_mark_resolved (locsym);
        }
 
          local_symbol_mark_resolved (locsym);
        }
 


@@ -890,8 +923,9 @@ resolve_symbol_value (symp, finalize)
 
   if (symp->sy_resolving)
     {
 
   if (symp->sy_resolving)
     {

-      if (finalize)
-       as_bad (_("Symbol definition loop encountered at %s"), S_GET_NAME (symp));
+      if (finalize_syms)
+       as_bad (_("symbol definition loop encountered at `%s'"),
+               S_GET_NAME (symp));

       final_val = 0;
       resolved = 1;
     }
       final_val = 0;
       resolved = 1;
     }


@@ -929,19 +963,22 @@ resolve_symbol_value (symp, finalize)
 
        case O_symbol:
        case O_symbol_rva:
 
        case O_symbol:
        case O_symbol_rva:

-         left = resolve_symbol_value (add_symbol, finalize);
-       do_symbol:
+         left = resolve_symbol_value (add_symbol);
+         seg_left = S_GET_SEGMENT (add_symbol);
+         if (finalize_syms)
+           symp->sy_value.X_op_symbol = NULL;

 
 

+       do_symbol:

          if (symp->sy_mri_common)
            {
              /* This is a symbol inside an MRI common section.  The
          if (symp->sy_mri_common)
            {
              /* This is a symbol inside an MRI common section.  The

-                 relocation routines are going to handle it specially.
-                 Don't change the value.  */
+                relocation routines are going to handle it specially.
+                Don't change the value.  */

              resolved = symbol_resolved_p (add_symbol);
              break;
            }
 
              resolved = symbol_resolved_p (add_symbol);
              break;
            }
 

-         if (finalize && final_val == 0)
+         if (finalize_syms && final_val == 0)

            {
              if (LOCAL_SYMBOL_CHECK (add_symbol))
                add_symbol = local_symbol_convert ((struct local_symbol *)
            {
              if (LOCAL_SYMBOL_CHECK (add_symbol))
                add_symbol = local_symbol_convert ((struct local_symbol *)


@@ -949,30 +986,51 @@ resolve_symbol_value (symp, finalize)
              copy_symbol_attributes (symp, add_symbol);
            }
 
              copy_symbol_attributes (symp, add_symbol);
            }
 

-         /* If we have equated this symbol to an undefined symbol, we
-             keep X_op set to O_symbol, and we don't change
-             X_add_number.  This permits the routine which writes out
-             relocation to detect this case, and convert the
-             relocation to be against the symbol to which this symbol
-             is equated.  */
+         /* If we have equated this symbol to an undefined or common
+            symbol, keep X_op set to O_symbol, and don't change
+            X_add_number.  This permits the routine which writes out
+            relocation to detect this case, and convert the
+            relocation to be against the symbol to which this symbol
+            is equated.  */

          if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol))
            {
          if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol))
            {

-             if (finalize)
+             if (finalize_syms)

                {
                {

-                 S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol));

                  symp->sy_value.X_op = O_symbol;
                  symp->sy_value.X_add_symbol = add_symbol;
                  symp->sy_value.X_add_number = final_val;
                  symp->sy_value.X_op = O_symbol;
                  symp->sy_value.X_add_symbol = add_symbol;
                  symp->sy_value.X_add_number = final_val;

+                 /* Use X_op_symbol as a flag.  */
+                 symp->sy_value.X_op_symbol = add_symbol;
+                 final_seg = seg_left;

                }
              final_val = 0;
              resolved = symbol_resolved_p (add_symbol);
                }
              final_val = 0;
              resolved = symbol_resolved_p (add_symbol);

+             symp->sy_resolving = 0;
+             goto exit_dont_set_value;
+           }
+         else if (finalize_syms && final_seg == expr_section
+                  && seg_left != expr_section)
+           {
+             /* If the symbol is an expression symbol, do similarly
+                as for undefined and common syms above.  Handles
+                "sym +/- expr" where "expr" cannot be evaluated
+                immediately, and we want relocations to be against
+                "sym", eg. because it is weak.  */
+             symp->sy_value.X_op = O_symbol;
+             symp->sy_value.X_add_symbol = add_symbol;
+             symp->sy_value.X_add_number = final_val;
+             symp->sy_value.X_op_symbol = add_symbol;
+             final_seg = seg_left;
+             final_val += symp->sy_frag->fr_address + left;
+             resolved = symbol_resolved_p (add_symbol);
+             symp->sy_resolving = 0;

              goto exit_dont_set_value;
            }
          else
            {
              final_val += symp->sy_frag->fr_address + left;
              if (final_seg == expr_section || final_seg == undefined_section)
              goto exit_dont_set_value;
            }
          else
            {
              final_val += symp->sy_frag->fr_address + left;
              if (final_seg == expr_section || final_seg == undefined_section)

-               final_seg = S_GET_SEGMENT (add_symbol);
+               final_seg = seg_left;

            }
 
          resolved = symbol_resolved_p (add_symbol);
            }
 
          resolved = symbol_resolved_p (add_symbol);


@@ -981,7 +1039,19 @@ resolve_symbol_value (symp, finalize)
        case O_uminus:
        case O_bit_not:
        case O_logical_not:
        case O_uminus:
        case O_bit_not:
        case O_logical_not:

-         left = resolve_symbol_value (add_symbol, finalize);
+         left = resolve_symbol_value (add_symbol);
+         seg_left = S_GET_SEGMENT (add_symbol);
+
+         /* By reducing these to the relevant dyadic operator, we get
+               !S -> S == 0    permitted on anything,
+               -S -> 0 - S     only permitted on absolute
+               ~S -> S ^ ~0    only permitted on absolute  */
+         if (op != O_logical_not && seg_left != absolute_section
+             && finalize_syms)
+           report_op_error (symp, add_symbol, NULL);
+
+         if (final_seg == expr_section || final_seg == undefined_section)
+           final_seg = absolute_section;

 
          if (op == O_uminus)
            left = -left;
 
          if (op == O_uminus)
            left = -left;


@@ -991,8 +1061,6 @@ resolve_symbol_value (symp, finalize)
            left = ~left;
 
          final_val += left + symp->sy_frag->fr_address;
            left = ~left;
 
          final_val += left + symp->sy_frag->fr_address;

-         if (final_seg == expr_section || final_seg == undefined_section)
-           final_seg = absolute_section;

 
          resolved = symbol_resolved_p (add_symbol);
          break;
 
          resolved = symbol_resolved_p (add_symbol);
          break;


@@ -1016,91 +1084,68 @@ resolve_symbol_value (symp, finalize)
        case O_gt:
        case O_logical_and:
        case O_logical_or:
        case O_gt:
        case O_logical_and:
        case O_logical_or:

-         left = resolve_symbol_value (add_symbol, finalize);
-         right = resolve_symbol_value (op_symbol, finalize);
+         left = resolve_symbol_value (add_symbol);
+         right = resolve_symbol_value (op_symbol);

          seg_left = S_GET_SEGMENT (add_symbol);
          seg_right = S_GET_SEGMENT (op_symbol);
 
          /* Simplify addition or subtraction of a constant by folding the
             constant into X_add_number.  */
          seg_left = S_GET_SEGMENT (add_symbol);
          seg_right = S_GET_SEGMENT (op_symbol);
 
          /* Simplify addition or subtraction of a constant by folding the
             constant into X_add_number.  */

-         if (op == O_add || op == O_subtract)
+         if (op == O_add)

            {
              if (seg_right == absolute_section)
                {
            {
              if (seg_right == absolute_section)
                {

-                 if (op == O_add)
-                   final_val += right;
-                 else
-                   final_val -= right;
-                 op = O_symbol;
-                 op_symbol = NULL;
+                 final_val += right;

                  goto do_symbol;
                }
                  goto do_symbol;
                }

-             else if (seg_left == absolute_section && op == O_add)
+             else if (seg_left == absolute_section)

                {
                {

-                 op = O_symbol;

                  final_val += left;
                  add_symbol = op_symbol;
                  left = right;
                  final_val += left;
                  add_symbol = op_symbol;
                  left = right;

-                 op_symbol = NULL;
+                 seg_left = seg_right;

                  goto do_symbol;
                }
            }
                  goto do_symbol;
                }
            }

-
-         /* Subtraction is permitted if both operands are in the same
-            section.  Otherwise, both operands must be absolute.  We
-            already handled the case of addition or subtraction of a
-            constant above.  This will probably need to be changed
-            for an object file format which supports arbitrary
-            expressions, such as IEEE-695.  */
-         /* Don't emit messages unless we're finalizing the symbol value,
-            otherwise we may get the same message multiple times.  */
-         if ((seg_left != absolute_section
-              || seg_right != absolute_section)
-             && (op != O_subtract
-                 || seg_left != seg_right
-                 || seg_left == undefined_section)
-             && finalize)
+         else if (op == O_subtract)

            {
            {

-             char *file;
-             unsigned int line;
-
-             if (expr_symbol_where (symp, &file, &line))
-               {
-                 if (seg_left == undefined_section)
-                   as_bad_where (file, line,
-                                 _("undefined symbol %s in operation"),
-                                 S_GET_NAME (symp->sy_value.X_add_symbol));
-                 if (seg_right == undefined_section)
-                   as_bad_where (file, line,
-                                 _("undefined symbol %s in operation"),
-                                 S_GET_NAME (symp->sy_value.X_op_symbol));
-                 if (seg_left != undefined_section
-                     && seg_right != undefined_section)
-                   as_bad_where (file, line, _("invalid section for operation"));
-               }
-             else
+             if (seg_right == absolute_section)

                {
                {

-                 if (seg_left == undefined_section)
-                   as_bad (_("undefined symbol %s in operation setting %s"),
-                           S_GET_NAME (symp->sy_value.X_add_symbol),
-                           S_GET_NAME (symp));
-                 if (seg_right == undefined_section)
-                   as_bad (_("undefined symbol %s in operation setting %s"),
-                           S_GET_NAME (symp->sy_value.X_op_symbol),
-                           S_GET_NAME (symp));
-                 if (seg_left != undefined_section
-                     && seg_right != undefined_section)
-                   as_bad (_("invalid section for operation setting %s"),
-                           S_GET_NAME (symp));
+                 final_val -= right;
+                 goto do_symbol;

                }
            }
 
                }
            }
 

+         /* Equality and non-equality tests are permitted on anything.
+            Subtraction, and other comparison operators are permitted if
+            both operands are in the same section.  Otherwise, both
+            operands must be absolute.  We already handled the case of
+            addition or subtraction of a constant above.  This will
+            probably need to be changed for an object file format which
+            supports arbitrary expressions, such as IEEE-695.
+
+            Don't emit messages unless we're finalizing the symbol value,
+            otherwise we may get the same message multiple times.  */
+         if (finalize_syms
+             && !(seg_left == absolute_section
+                  && seg_right == absolute_section)
+             && !(op == O_eq || op == O_ne)
+             && !((op == O_subtract
+                   || op == O_lt || op == O_le || op == O_ge || op == O_gt)
+                  && seg_left == seg_right
+                  && (seg_left != undefined_section
+                      || add_symbol == op_symbol)))
+           report_op_error (symp, add_symbol, op_symbol);
+
+         if (final_seg == expr_section || final_seg == undefined_section)
+           final_seg = absolute_section;
+

          /* Check for division by zero.  */
          if ((op == O_divide || op == O_modulus) && right == 0)
            {
              /* If seg_right is not absolute_section, then we've
          /* Check for division by zero.  */
          if ((op == O_divide || op == O_modulus) && right == 0)
            {
              /* If seg_right is not absolute_section, then we've

-                 already issued a warning about using a bad symbol.  */
-             if (seg_right == absolute_section && finalize)
+                already issued a warning about using a bad symbol.  */
+             if (seg_right == absolute_section && finalize_syms)

                {
                  char *file;
                  unsigned int line;
                {
                  char *file;
                  unsigned int line;


@@ -1108,7 +1153,7 @@ resolve_symbol_value (symp, finalize)
                  if (expr_symbol_where (symp, &file, &line))
                    as_bad_where (file, line, _("division by zero"));
                  else
                  if (expr_symbol_where (symp, &file, &line))
                    as_bad_where (file, line, _("division by zero"));
                  else

-                   as_bad (_("division by zero when setting %s"),
+                   as_bad (_("division by zero when setting `%s'"),

                            S_GET_NAME (symp));
                }
 
                            S_GET_NAME (symp));
                }
 


@@ -1128,8 +1173,15 @@ resolve_symbol_value (symp, finalize)
            case O_bit_and:             left &= right; break;
            case O_add:                 left += right; break;
            case O_subtract:            left -= right; break;
            case O_bit_and:             left &= right; break;
            case O_add:                 left += right; break;
            case O_subtract:            left -= right; break;

-           case O_eq:  left = left == right ? ~ (offsetT) 0 : 0; break;
-           case O_ne:  left = left != right ? ~ (offsetT) 0 : 0; break;
+           case O_eq:
+           case O_ne:
+             left = (left == right && seg_left == seg_right
+                     && (seg_left != undefined_section
+                         || add_symbol == op_symbol)
+                     ? ~ (offsetT) 0 : 0);
+             if (symp->sy_value.X_op == O_ne)
+               left = ~left;
+             break;

            case O_lt:  left = left <  right ? ~ (offsetT) 0 : 0; break;
            case O_le:  left = left <= right ? ~ (offsetT) 0 : 0; break;
            case O_ge:  left = left >= right ? ~ (offsetT) 0 : 0; break;
            case O_lt:  left = left <  right ? ~ (offsetT) 0 : 0; break;
            case O_le:  left = left <= right ? ~ (offsetT) 0 : 0; break;
            case O_ge:  left = left >= right ? ~ (offsetT) 0 : 0; break;


@@ -1141,10 +1193,18 @@ resolve_symbol_value (symp, finalize)
 
          final_val += symp->sy_frag->fr_address + left;
          if (final_seg == expr_section || final_seg == undefined_section)
 
          final_val += symp->sy_frag->fr_address + left;
          if (final_seg == expr_section || final_seg == undefined_section)

-           final_seg = absolute_section;
+           {
+             if (seg_left == undefined_section
+                 || seg_right == undefined_section)
+               final_seg = undefined_section;
+             else if (seg_left == absolute_section)
+               final_seg = seg_right;
+             else
+               final_seg = seg_left;
+           }

          resolved = (symbol_resolved_p (add_symbol)
                      && symbol_resolved_p (op_symbol));
          resolved = (symbol_resolved_p (add_symbol)
                      && symbol_resolved_p (op_symbol));

-         break;
+         break;

 
        case O_register:
        case O_big:
 
        case O_register:
        case O_big:


@@ -1160,27 +1220,28 @@ resolve_symbol_value (symp, finalize)
       symp->sy_resolving = 0;
     }
 
       symp->sy_resolving = 0;
     }
 

-  if (finalize)
-    {
-      S_SET_VALUE (symp, final_val);
+  if (finalize_syms)
+    S_SET_VALUE (symp, final_val);

 
 

+exit_dont_set_value:
+  /* Always set the segment, even if not finalizing the value.
+     The segment is used to determine whether a symbol is defined.  */

 #if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)
 #if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)

-      /* The old a.out backend does not handle S_SET_SEGMENT correctly
-         for a stab symbol, so we use this bad hack.  */
-      if (final_seg != S_GET_SEGMENT (symp))
+  /* The old a.out backend does not handle S_SET_SEGMENT correctly
+     for a stab symbol, so we use this bad hack.  */
+  if (final_seg != S_GET_SEGMENT (symp))

 #endif
 #endif

-       S_SET_SEGMENT (symp, final_seg);
-    }
+    S_SET_SEGMENT (symp, final_seg);

 
 

-exit_dont_set_value:

   /* Don't worry if we can't resolve an expr_section symbol.  */
   /* Don't worry if we can't resolve an expr_section symbol.  */

-  if (finalize)
+  if (finalize_syms)

     {
       if (resolved)
        symp->sy_resolved = 1;
       else if (S_GET_SEGMENT (symp) != expr_section)
        {
     {
       if (resolved)
        symp->sy_resolved = 1;
       else if (S_GET_SEGMENT (symp) != expr_section)
        {

-         as_bad (_("can't resolve value for symbol \"%s\""), S_GET_NAME (symp));
+         as_bad (_("can't resolve value for symbol `%s'"),
+                 S_GET_NAME (symp));

          symp->sy_resolved = 1;
        }
     }
          symp->sy_resolved = 1;
        }
     }


@@ -1190,17 +1251,15 @@ exit_dont_set_value:
 
 #ifdef BFD_ASSEMBLER
 
 
 #ifdef BFD_ASSEMBLER
 

-static void resolve_local_symbol PARAMS ((const char *, PTR));
+static void resolve_local_symbol (const char *, PTR);

 
 /* A static function passed to hash_traverse.  */
 
 static void
 
 /* A static function passed to hash_traverse.  */
 
 static void

-resolve_local_symbol (key, value)
-     const char *key ATTRIBUTE_UNUSED;
-     PTR value;
+resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)

 {
   if (value != NULL)
 {
   if (value != NULL)

-    resolve_symbol_value (value, 1);
+    resolve_symbol_value (value);

 }
 
 #endif
 }
 
 #endif


@@ -1208,7 +1267,7 @@ resolve_local_symbol (key, value)
 /* Resolve all local symbols.  */
 
 void
 /* Resolve all local symbols.  */
 
 void

-resolve_local_symbol_values ()
+resolve_local_symbol_values (void)

 {
 #ifdef BFD_ASSEMBLER
   hash_traverse (local_hash, resolve_local_symbol);
 {
 #ifdef BFD_ASSEMBLER
   hash_traverse (local_hash, resolve_local_symbol);


@@ -1228,9 +1287,8 @@ static char *dollar_label_defines;
 static unsigned long dollar_label_count;
 static unsigned long dollar_label_max;
 
 static unsigned long dollar_label_count;
 static unsigned long dollar_label_max;
 

-int 
-dollar_label_defined (label)
-     long label;
+int
+dollar_label_defined (long label)

 {
   long *i;
 
 {
   long *i;
 


@@ -1240,13 +1298,12 @@ dollar_label_defined (label)
     if (*i == label)
       return dollar_label_defines[i - dollar_labels];
 
     if (*i == label)
       return dollar_label_defines[i - dollar_labels];
 

-  /* if we get here, label isn't defined */
+  /* If we get here, label isn't defined.  */

   return 0;
   return 0;

-}                              /* dollar_label_defined() */
+}

 
 static long
 
 static long

-dollar_label_instance (label)
-     long label;
+dollar_label_instance (long label)

 {
   long *i;
 
 {
   long *i;
 


@@ -1256,22 +1313,21 @@ dollar_label_instance (label)
     if (*i == label)
       return (dollar_label_instances[i - dollar_labels]);
 
     if (*i == label)
       return (dollar_label_instances[i - dollar_labels]);
 

-  /* If we get here, we haven't seen the label before, therefore its instance
-     count is zero.  */
+  /* If we get here, we haven't seen the label before.
+     Therefore its instance count is zero.  */

   return 0;
 }
 
   return 0;
 }
 

-void 
-dollar_label_clear ()
+void
+dollar_label_clear (void)

 {
   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
 }
 
 #define DOLLAR_LABEL_BUMP_BY 10
 
 {
   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
 }
 
 #define DOLLAR_LABEL_BUMP_BY 10
 

-void 
-define_dollar_label (label)
-     long label;
+void
+define_dollar_label (long label)

 {
   long *i;
 
 {
   long *i;
 


@@ -1283,7 +1339,7 @@ define_dollar_label (label)
        return;
       }
 
        return;
       }
 

-  /* if we get to here, we don't have label listed yet. */
+  /* If we get to here, we don't have label listed yet.  */

 
   if (dollar_labels == NULL)
     {
 
   if (dollar_labels == NULL)
     {


@@ -1301,7 +1357,7 @@ define_dollar_label (label)
       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
                                          dollar_label_max * sizeof (long));
       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
                                          dollar_label_max * sizeof (long));
       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);

-    }                          /* if we needed to grow */
+    }                          /* if we needed to grow  */

 
   dollar_labels[dollar_label_count] = label;
   dollar_label_instances[dollar_label_count] = 1;
 
   dollar_labels[dollar_label_count] = label;
   dollar_label_instances[dollar_label_count] = 1;


@@ -1309,31 +1365,27 @@ define_dollar_label (label)
   ++dollar_label_count;
 }
 
   ++dollar_label_count;
 }
 

-/*
- *                     dollar_label_name()
- *
- * Caller must copy returned name: we re-use the area for the next name.
- *
- * The mth occurence of label n: is turned into the symbol "Ln^Am"
- * where n is the label number and m is the instance number. "L" makes
- * it a label discarded unless debugging and "^A"('\1') ensures no
- * ordinary symbol SHOULD get the same name as a local label
- * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
- *
- * fb labels get the same treatment, except that ^B is used in place of ^A.
- */
-
-char *                         /* Return local label name. */
-dollar_label_name (n, augend)
-     register long n;          /* we just saw "n$:" : n a number */
-     register int augend;      /* 0 for current instance, 1 for new instance */
+/* Caller must copy returned name: we re-use the area for the next name.
+
+   The mth occurence of label n: is turned into the symbol "Ln^Am"
+   where n is the label number and m is the instance number. "L" makes
+   it a label discarded unless debugging and "^A"('\1') ensures no
+   ordinary symbol SHOULD get the same name as a local label
+   symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
+
+   fb labels get the same treatment, except that ^B is used in place
+   of ^A.  */
+
+char *                         /* Return local label name.  */
+dollar_label_name (register long n,    /* we just saw "n$:" : n a number.  */
+                  register int augend  /* 0 for current instance, 1 for new instance.  */)

 {
   long i;
 {
   long i;

-  /* Returned to caller, then copied.  used for created names ("4f") */
+  /* Returned to caller, then copied.  Used for created names ("4f").  */

   static char symbol_name_build[24];
   register char *p;
   register char *q;
   static char symbol_name_build[24];
   register char *p;
   register char *q;

-  char symbol_name_temporary[20];      /* build up a number, BACKWARDS */
+  char symbol_name_temporary[20];      /* Build up a number, BACKWARDS.  */

 
   know (n >= 0);
   know (augend == 0 || augend == 1);
 
   know (n >= 0);
   know (augend == 0 || augend == 1);


@@ -1343,8 +1395,8 @@ dollar_label_name (n, augend)
 #endif
   *p++ = 'L';
 
 #endif
   *p++ = 'L';
 

-  /* Next code just does sprintf( {}, "%d", n); */
-  /* label number */
+  /* Next code just does sprintf( {}, "%d", n);  */
+  /* Label number.  */

   q = symbol_name_temporary;
   for (*q++ = 0, i = n; i; ++q)
     {
   q = symbol_name_temporary;
   for (*q++ = 0, i = n; i; ++q)
     {


@@ -1354,9 +1406,9 @@ dollar_label_name (n, augend)
   while ((*p = *--q) != '\0')
     ++p;
 
   while ((*p = *--q) != '\0')
     ++p;
 

-  *p++ = 1;                    /* ^A */
+  *p++ = DOLLAR_LABEL_CHAR;            /* ^A  */

 
 

-  /* instance number */
+  /* Instance number.  */

   q = symbol_name_temporary;
   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
     {
   q = symbol_name_temporary;
   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
     {


@@ -1365,27 +1417,26 @@ dollar_label_name (n, augend)
     }
   while ((*p++ = *--q) != '\0');;
 
     }
   while ((*p++ = *--q) != '\0');;
 

-  /* The label, as a '\0' ended string, starts at symbol_name_build. */
+  /* The label, as a '\0' ended string, starts at symbol_name_build.  */

   return symbol_name_build;
 }
 
   return symbol_name_build;
 }
 

-/*
- * Sombody else's idea of local labels. They are made by "n:" where n
- * is any decimal digit. Refer to them with
- *  "nb" for previous (backward) n:
- *  or "nf" for next (forward) n:.
- *
- * We do a little better and let n be any number, not just a single digit, but
- * since the other guy's assembler only does ten, we treat the first ten
- * specially.
- *
- * Like someone else's assembler, we have one set of local label counters for
- * entire assembly, not one set per (sub)segment like in most assemblers. This
- * implies that one can refer to a label in another segment, and indeed some
- * crufty compilers have done just that.
- *
- * Since there could be a LOT of these things, treat them as a sparse array.
- */
+/* Somebody else's idea of local labels. They are made by "n:" where n
+   is any decimal digit. Refer to them with
+    "nb" for previous (backward) n:
+   or "nf" for next (forward) n:.
+
+   We do a little better and let n be any number, not just a single digit, but
+   since the other guy's assembler only does ten, we treat the first ten
+   specially.
+
+   Like someone else's assembler, we have one set of local label counters for
+   entire assembly, not one set per (sub)segment like in most assemblers. This
+   implies that one can refer to a label in another segment, and indeed some
+   crufty compilers have done just that.
+
+   Since there could be a LOT of these things, treat them as a sparse
+   array.  */

 
 #define FB_LABEL_SPECIAL (10)
 
 
 #define FB_LABEL_SPECIAL (10)
 


@@ -1395,19 +1446,19 @@ static long *fb_label_instances;
 static long fb_label_count;
 static long fb_label_max;
 
 static long fb_label_count;
 static long fb_label_max;
 

-/* this must be more than FB_LABEL_SPECIAL */
+/* This must be more than FB_LABEL_SPECIAL.  */

 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
 
 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
 

-static void 
-fb_label_init ()
+static void
+fb_label_init (void)

 {
   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
 {
   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));

-}                              /* fb_label_init() */
+}

 
 

-/* add one to the instance number of this fb label */
-void 
-fb_label_instance_inc (label)
-     long label;
+/* Add one to the instance number of this fb label.  */
+
+void
+fb_label_instance_inc (long label)

 {
   long *i;
 
 {
   long *i;
 


@@ -1426,11 +1477,11 @@ fb_label_instance_inc (label)
            {
              ++fb_label_instances[i - fb_labels];
              return;
            {
              ++fb_label_instances[i - fb_labels];
              return;

-           }                   /* if we find it */
-       }                       /* for each existing label */
+           }                   /* if we find it  */
+       }                       /* for each existing label  */

     }
 
     }
 

-  /* if we get to here, we don't have label listed yet. */
+  /* If we get to here, we don't have label listed yet.  */

 
   if (fb_labels == NULL)
     {
 
   if (fb_labels == NULL)
     {


@@ -1447,16 +1498,15 @@ fb_label_instance_inc (label)
                                     fb_label_max * sizeof (long));
       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
                                              fb_label_max * sizeof (long));
                                     fb_label_max * sizeof (long));
       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
                                              fb_label_max * sizeof (long));

-    }                          /* if we needed to grow */
+    }                          /* if we needed to grow  */

 
   fb_labels[fb_label_count] = label;
   fb_label_instances[fb_label_count] = 1;
   ++fb_label_count;
 }
 
 
   fb_labels[fb_label_count] = label;
   fb_label_instances[fb_label_count] = 1;
   ++fb_label_count;
 }
 

-static long 
-fb_label_instance (label)
-     long label;
+static long
+fb_label_instance (long label)

 {
   long *i;
 
 {
   long *i;
 


@@ -1473,8 +1523,8 @@ fb_label_instance (label)
          if (*i == label)
            {
              return (fb_label_instances[i - fb_labels]);
          if (*i == label)
            {
              return (fb_label_instances[i - fb_labels]);

-           }                   /* if we find it */
-       }                       /* for each existing label */
+           }                   /* if we find it  */
+       }                       /* for each existing label  */

     }
 
   /* We didn't find the label, so this must be a reference to the
     }
 
   /* We didn't find the label, so this must be a reference to the


@@ -1482,38 +1532,38 @@ fb_label_instance (label)
   return 0;
 }
 
   return 0;
 }
 

-/*
- *                     fb_label_name()
- *
- * Caller must copy returned name: we re-use the area for the next name.
- *
- * The mth occurence of label n: is turned into the symbol "Ln^Bm"
- * where n is the label number and m is the instance number. "L" makes
- * it a label discarded unless debugging and "^B"('\2') ensures no
- * ordinary symbol SHOULD get the same name as a local label
- * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
- *
- * dollar labels get the same treatment, except that ^A is used in place of ^B. */
-
-char *                         /* Return local label name. */
-fb_label_name (n, augend)
-     long n;                   /* we just saw "n:", "nf" or "nb" : n a number */
-     long augend;              /* 0 for nb, 1 for n:, nf */
+/* Caller must copy returned name: we re-use the area for the next name.
+
+   The mth occurence of label n: is turned into the symbol "Ln^Bm"
+   where n is the label number and m is the instance number. "L" makes
+   it a label discarded unless debugging and "^B"('\2') ensures no
+   ordinary symbol SHOULD get the same name as a local label
+   symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
+
+   dollar labels get the same treatment, except that ^A is used in
+   place of ^B.  */
+
+char *                         /* Return local label name.  */
+fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number.  */
+              long augend      /* 0 for nb, 1 for n:, nf.  */)

 {
   long i;
 {
   long i;

-  /* Returned to caller, then copied.  used for created names ("4f") */
+  /* Returned to caller, then copied.  Used for created names ("4f").  */

   static char symbol_name_build[24];
   register char *p;
   register char *q;
   static char symbol_name_build[24];
   register char *p;
   register char *q;

-  char symbol_name_temporary[20];      /* build up a number, BACKWARDS */
+  char symbol_name_temporary[20];      /* Build up a number, BACKWARDS.  */

 
   know (n >= 0);
   know (augend == 0 || augend == 1);
   p = symbol_name_build;
 
   know (n >= 0);
   know (augend == 0 || augend == 1);
   p = symbol_name_build;

+#ifdef LOCAL_LABEL_PREFIX
+  *p++ = LOCAL_LABEL_PREFIX;
+#endif

   *p++ = 'L';
 
   *p++ = 'L';
 

-  /* Next code just does sprintf( {}, "%d", n); */
-  /* label number */
+  /* Next code just does sprintf( {}, "%d", n);  */
+  /* Label number.  */

   q = symbol_name_temporary;
   for (*q++ = 0, i = n; i; ++q)
     {
   q = symbol_name_temporary;
   for (*q++ = 0, i = n; i; ++q)
     {


@@ -1523,9 +1573,9 @@ fb_label_name (n, augend)
   while ((*p = *--q) != '\0')
     ++p;
 
   while ((*p = *--q) != '\0')
     ++p;
 

-  *p++ = 2;                    /* ^B */
+  *p++ = LOCAL_LABEL_CHAR;             /* ^B  */

 
 

-  /* instance number */
+  /* Instance number.  */

   q = symbol_name_temporary;
   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
     {
   q = symbol_name_temporary;
   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
     {


@@ -1534,43 +1584,47 @@ fb_label_name (n, augend)
     }
   while ((*p++ = *--q) != '\0');;
 
     }
   while ((*p++ = *--q) != '\0');;
 

-  /* The label, as a '\0' ended string, starts at symbol_name_build. */
+  /* The label, as a '\0' ended string, starts at symbol_name_build.  */

   return (symbol_name_build);
   return (symbol_name_build);

-}                              /* fb_label_name() */
+}

 
 

-/*
- * decode name that may have been generated by foo_label_name() above.  If
- * the name wasn't generated by foo_label_name(), then return it unaltered.
- * This is used for error messages.
- */
+/* Decode name that may have been generated by foo_label_name() above.
+   If the name wasn't generated by foo_label_name(), then return it
+   unaltered.  This is used for error messages.  */

 
 char *
 
 char *

-decode_local_label_name (s)
-     char *s;
+decode_local_label_name (char *s)

 {
   char *p;
   char *symbol_decode;
   int label_number;
   int instance_number;
   char *type;
 {
   char *p;
   char *symbol_decode;
   int label_number;
   int instance_number;
   char *type;

-  const char *message_format = _("\"%d\" (instance number %d of a %s label)");
+  const char *message_format;
+  int index = 0;
+
+#ifdef LOCAL_LABEL_PREFIX
+  if (s[index] == LOCAL_LABEL_PREFIX)
+    ++index;
+#endif

 
 

-  if (s[0] != 'L')
+  if (s[index] != 'L')

     return s;
 
     return s;
 

-  for (label_number = 0, p = s + 1; isdigit ((unsigned char) *p); ++p)
+  for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)

     label_number = (10 * label_number) + *p - '0';
 
     label_number = (10 * label_number) + *p - '0';
 

-  if (*p == 1)
+  if (*p == DOLLAR_LABEL_CHAR)

     type = "dollar";
     type = "dollar";

-  else if (*p == 2)
+  else if (*p == LOCAL_LABEL_CHAR)

     type = "fb";
   else
     return s;
 
     type = "fb";
   else
     return s;
 

-  for (instance_number = 0, p++; isdigit ((unsigned char) *p); ++p)
+  for (instance_number = 0, p++; ISDIGIT (*p); ++p)

     instance_number = (10 * instance_number) + *p - '0';
 
     instance_number = (10 * instance_number) + *p - '0';
 

+  message_format = _("\"%d\" (instance number %d of a %s label)");

   symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
   sprintf (symbol_decode, message_format, label_number, instance_number, type);
 
   symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
   sprintf (symbol_decode, message_format, label_number, instance_number, type);
 


@@ -1580,30 +1634,33 @@ decode_local_label_name (s)
 /* Get the value of a symbol.  */
 
 valueT
 /* Get the value of a symbol.  */
 
 valueT

-S_GET_VALUE (s)
-     symbolS *s;
+S_GET_VALUE (symbolS *s)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))

-    return ((struct local_symbol *) s)->lsy_offset;
+    return resolve_symbol_value (s);

 #endif
 
 #endif
 

-  if (!s->sy_resolved && s->sy_value.X_op != O_constant)
-    resolve_symbol_value (s, 1);
+  if (!s->sy_resolved)
+    {
+      valueT val = resolve_symbol_value (s);
+      if (!finalize_syms)
+       return val;
+    }

   if (s->sy_value.X_op != O_constant)
     {
       static symbolS *recur;
 
       /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
   if (s->sy_value.X_op != O_constant)
     {
       static symbolS *recur;
 
       /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON

-         may call S_GET_VALUE.  We use a static symbol to avoid the
-         immediate recursion.  */
+        may call S_GET_VALUE.  We use a static symbol to avoid the
+        immediate recursion.  */

       if (recur == s)
        return (valueT) s->sy_value.X_add_number;
       recur = s;
       if (! s->sy_resolved
          || s->sy_value.X_op != O_symbol
          || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
       if (recur == s)
        return (valueT) s->sy_value.X_add_number;
       recur = s;
       if (! s->sy_resolved
          || s->sy_value.X_op != O_symbol
          || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))

-       as_bad (_("Attempt to get value of unresolved symbol %s"),
+       as_bad (_("attempt to get value of unresolved symbol `%s'"),

                S_GET_NAME (s));
       recur = NULL;
     }
                S_GET_NAME (s));
       recur = NULL;
     }


@@ -1613,14 +1670,12 @@ S_GET_VALUE (s)
 /* Set the value of a symbol.  */
 
 void
 /* Set the value of a symbol.  */
 
 void

-S_SET_VALUE (s, val)
-     symbolS *s;
-     valueT val;
+S_SET_VALUE (symbolS *s, valueT val)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
     {
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
     {

-      ((struct local_symbol *) s)->lsy_offset = val;
+      ((struct local_symbol *) s)->lsy_value = val;

       return;
     }
 #endif
       return;
     }
 #endif


@@ -1631,8 +1686,7 @@ S_SET_VALUE (s, val)
 }
 
 void
 }
 
 void

-copy_symbol_attributes (dest, src)
-     symbolS *dest, *src;
+copy_symbol_attributes (symbolS *dest, symbolS *src)

 {
   if (LOCAL_SYMBOL_CHECK (dest))
     dest = local_symbol_convert ((struct local_symbol *) dest);
 {
   if (LOCAL_SYMBOL_CHECK (dest))
     dest = local_symbol_convert ((struct local_symbol *) dest);


@@ -1654,8 +1708,7 @@ copy_symbol_attributes (dest, src)
 #ifdef BFD_ASSEMBLER
 
 int
 #ifdef BFD_ASSEMBLER
 
 int

-S_IS_FUNCTION (s)
-     symbolS *s;
+S_IS_FUNCTION (symbolS *s)

 {
   flagword flags;
 
 {
   flagword flags;
 


@@ -1668,8 +1721,7 @@ S_IS_FUNCTION (s)
 }
 
 int
 }
 
 int

-S_IS_EXTERNAL (s)
-     symbolS *s;
+S_IS_EXTERNAL (symbolS *s)

 {
   flagword flags;
 
 {
   flagword flags;
 


@@ -1678,7 +1730,7 @@ S_IS_EXTERNAL (s)
 
   flags = s->bsym->flags;
 
 
   flags = s->bsym->flags;
 

-  /* sanity check */
+  /* Sanity check.  */

   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 


@@ -1686,8 +1738,7 @@ S_IS_EXTERNAL (s)
 }
 
 int
 }
 
 int

-S_IS_WEAK (s)
-     symbolS *s;
+S_IS_WEAK (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -1695,8 +1746,7 @@ S_IS_WEAK (s)
 }
 
 int
 }
 
 int

-S_IS_COMMON (s)
-     symbolS *s;
+S_IS_COMMON (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -1704,17 +1754,37 @@ S_IS_COMMON (s)
 }
 
 int
 }
 
 int

-S_IS_DEFINED (s)
-     symbolS *s;
+S_IS_DEFINED (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_section != undefined_section;
   return s->bsym->section != undefined_section;
 }
 
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_section != undefined_section;
   return s->bsym->section != undefined_section;
 }
 

+
+#ifndef EXTERN_FORCE_RELOC
+#define EXTERN_FORCE_RELOC IS_ELF
+#endif
+
+/* Return true for symbols that should not be reduced to section
+   symbols or eliminated from expressions, because they may be
+   overridden by the linker.  */
+int
+S_FORCE_RELOC (symbolS *s, int strict)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return ((struct local_symbol *) s)->lsy_section == undefined_section;
+
+  return ((strict
+          && ((s->bsym->flags & BSF_WEAK) != 0
+              || (EXTERN_FORCE_RELOC
+                  && (s->bsym->flags & BSF_GLOBAL) != 0)))
+         || s->bsym->section == undefined_section
+         || bfd_is_com_section (s->bsym->section));
+}
+

 int
 int

-S_IS_DEBUG (s)
-     symbolS *s;
+S_IS_DEBUG (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -1724,8 +1794,7 @@ S_IS_DEBUG (s)
 }
 
 int
 }
 
 int

-S_IS_LOCAL (s)
-     symbolS *s;
+S_IS_LOCAL (symbolS *s)

 {
   flagword flags;
   const char *name;
 {
   flagword flags;
   const char *name;


@@ -1735,7 +1804,7 @@ S_IS_LOCAL (s)
 
   flags = s->bsym->flags;
 
 
   flags = s->bsym->flags;
 

-  /* sanity check */
+  /* Sanity check.  */

   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 


@@ -1743,15 +1812,17 @@ S_IS_LOCAL (s)
     return 1;
 
   if (flag_strip_local_absolute
     return 1;
 
   if (flag_strip_local_absolute

-      && (flags & BSF_GLOBAL) == 0
+      /* Keep BSF_FILE symbols in order to allow debuggers to identify
+        the source file even when the object file is stripped.  */
+      && (flags & (BSF_GLOBAL | BSF_FILE)) == 0

       && bfd_get_section (s->bsym) == absolute_section)
     return 1;
 
   name = S_GET_NAME (s);
   return (name != NULL
          && ! S_IS_DEBUG (s)
       && bfd_get_section (s->bsym) == absolute_section)
     return 1;
 
   name = S_GET_NAME (s);
   return (name != NULL
          && ! S_IS_DEBUG (s)

-         && (strchr (name, '\001')
-             || strchr (name, '\002')
+         && (strchr (name, DOLLAR_LABEL_CHAR)
+             || strchr (name, LOCAL_LABEL_CHAR)

              || (! flag_keep_locals
                  && (bfd_is_local_label (stdoutput, s->bsym)
                      || (flag_mri
              || (! flag_keep_locals
                  && (bfd_is_local_label (stdoutput, s->bsym)
                      || (flag_mri


@@ -1760,22 +1831,19 @@ S_IS_LOCAL (s)
 }
 
 int
 }
 
 int

-S_IS_EXTERN (s)
-     symbolS *s;
+S_IS_EXTERN (symbolS *s)

 {
   return S_IS_EXTERNAL (s);
 }
 
 int
 {
   return S_IS_EXTERNAL (s);
 }
 
 int

-S_IS_STABD (s)
-     symbolS *s;
+S_IS_STABD (symbolS *s)

 {
   return S_GET_NAME (s) == 0;
 }
 
 {
   return S_GET_NAME (s) == 0;
 }
 

-CONST char *
-S_GET_NAME (s)
-     symbolS *s;
+const char *
+S_GET_NAME (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_name;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_name;


@@ -1783,8 +1851,7 @@ S_GET_NAME (s)
 }
 
 segT
 }
 
 segT

-S_GET_SEGMENT (s)
-     symbolS *s;
+S_GET_SEGMENT (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_section;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_section;


@@ -1792,9 +1859,7 @@ S_GET_SEGMENT (s)
 }
 
 void
 }
 
 void

-S_SET_SEGMENT (s, seg)
-     symbolS *s;
-     segT seg;
+S_SET_SEGMENT (symbolS *s, segT seg)

 {
   /* Don't reassign section symbols.  The direct reason is to prevent seg
      faults assigning back to const global symbols such as *ABS*, but it
 {
   /* Don't reassign section symbols.  The direct reason is to prevent seg
      faults assigning back to const global symbols such as *ABS*, but it


@@ -1814,15 +1879,14 @@ S_SET_SEGMENT (s, seg)
   if (s->bsym->flags & BSF_SECTION_SYM)
     {
       if (s->bsym->section != seg)
   if (s->bsym->flags & BSF_SECTION_SYM)
     {
       if (s->bsym->section != seg)

-       abort();
+       abort ();

     }
   else
     s->bsym->section = seg;
 }
 
 void
     }
   else
     s->bsym->section = seg;
 }
 
 void

-S_SET_EXTERNAL (s)
-     symbolS *s;
+S_SET_EXTERNAL (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -1831,13 +1895,23 @@ S_SET_EXTERNAL (s)
       /* Let .weak override .global.  */
       return;
     }
       /* Let .weak override .global.  */
       return;
     }

+  if (s->bsym->flags & BSF_SECTION_SYM)
+    {
+      char * file;
+      unsigned int line;
+
+      /* Do not reassign section symbols.  */
+      as_where (& file, & line);
+      as_warn_where (file, line,
+                    _("section symbols are already global"));
+      return;
+    }

   s->bsym->flags |= BSF_GLOBAL;
   s->bsym->flags |= BSF_GLOBAL;

-  s->bsym->flags &= ~(BSF_LOCAL|BSF_WEAK);
+  s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);

 }
 
 void
 }
 
 void

-S_CLEAR_EXTERNAL (s)
-     symbolS *s;
+S_CLEAR_EXTERNAL (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -1847,23 +1921,38 @@ S_CLEAR_EXTERNAL (s)
       return;
     }
   s->bsym->flags |= BSF_LOCAL;
       return;
     }
   s->bsym->flags |= BSF_LOCAL;

-  s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK);
+  s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);

 }
 
 void
 }
 
 void

-S_SET_WEAK (s)
-     symbolS *s;
+S_SET_WEAK (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
   s->bsym->flags |= BSF_WEAK;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
   s->bsym->flags |= BSF_WEAK;

-  s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL);
+  s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
+}
+
+void
+S_SET_THREAD_LOCAL (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  if (bfd_is_com_section (s->bsym->section)
+      && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
+    return;
+  s->bsym->flags |= BSF_THREAD_LOCAL;
+  if ((s->bsym->flags & BSF_FUNCTION) != 0)
+    as_bad (_("Accessing function `%s' as thread-local object"),
+           S_GET_NAME (s));
+  else if (! bfd_is_und_section (s->bsym->section)
+          && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
+    as_bad (_("Accessing `%s' as thread-local object"),
+           S_GET_NAME (s));

 }
 
 void
 }
 
 void

-S_SET_NAME (s, name)
-     symbolS *s;
-     char *name;
+S_SET_NAME (symbolS *s, char *name)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     {
 {
   if (LOCAL_SYMBOL_CHECK (s))
     {


@@ -1879,8 +1968,7 @@ S_SET_NAME (s, name)
 /* Return the previous symbol in a chain.  */
 
 symbolS *
 /* Return the previous symbol in a chain.  */
 
 symbolS *

-symbol_previous (s)
-     symbolS *s;
+symbol_previous (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();


@@ -1892,8 +1980,7 @@ symbol_previous (s)
 /* Return the next symbol in a chain.  */
 
 symbolS *
 /* Return the next symbol in a chain.  */
 
 symbolS *

-symbol_next (s)
-     symbolS *s;
+symbol_next (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();
 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();


@@ -1903,8 +1990,7 @@ symbol_next (s)
 /* Return a pointer to the value of a symbol as an expression.  */
 
 expressionS *
 /* Return a pointer to the value of a symbol as an expression.  */
 
 expressionS *

-symbol_get_value_expression (s)
-     symbolS *s;
+symbol_get_value_expression (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -1914,21 +2000,27 @@ symbol_get_value_expression (s)
 /* Set the value of a symbol to an expression.  */
 
 void
 /* Set the value of a symbol to an expression.  */
 
 void

-symbol_set_value_expression (s, exp)
-     symbolS *s;
-     const expressionS *exp;
+symbol_set_value_expression (symbolS *s, const expressionS *exp)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
   s->sy_value = *exp;
 }
 
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
   s->sy_value = *exp;
 }
 

+/* Set the value of SYM to the current position in the current segment.  */
+
+void
+symbol_set_value_now (symbolS *sym)
+{
+  S_SET_SEGMENT (sym, now_seg);
+  S_SET_VALUE (sym, frag_now_fix ());
+  symbol_set_frag (sym, frag_now);
+}
+

 /* Set the frag of a symbol.  */
 
 void
 /* Set the frag of a symbol.  */
 
 void

-symbol_set_frag (s, f)
-     symbolS *s;
-     fragS *f;
+symbol_set_frag (symbolS *s, fragS *f)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))


@@ -1943,8 +2035,7 @@ symbol_set_frag (s, f)
 /* Return the frag of a symbol.  */
 
 fragS *
 /* Return the frag of a symbol.  */
 
 fragS *

-symbol_get_frag (s)
-     symbolS *s;
+symbol_get_frag (symbolS *s)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))


@@ -1956,8 +2047,7 @@ symbol_get_frag (s)
 /* Mark a symbol as having been used.  */
 
 void
 /* Mark a symbol as having been used.  */
 
 void

-symbol_mark_used (s)
-     symbolS *s;
+symbol_mark_used (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -1967,8 +2057,7 @@ symbol_mark_used (s)
 /* Clear the mark of whether a symbol has been used.  */
 
 void
 /* Clear the mark of whether a symbol has been used.  */
 
 void

-symbol_clear_used (s)
-     symbolS *s;
+symbol_clear_used (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -1978,8 +2067,7 @@ symbol_clear_used (s)
 /* Return whether a symbol has been used.  */
 
 int
 /* Return whether a symbol has been used.  */
 
 int

-symbol_used_p (s)
-     symbolS *s;
+symbol_used_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;


@@ -1989,8 +2077,7 @@ symbol_used_p (s)
 /* Mark a symbol as having been used in a reloc.  */
 
 void
 /* Mark a symbol as having been used in a reloc.  */
 
 void

-symbol_mark_used_in_reloc (s)
-     symbolS *s;
+symbol_mark_used_in_reloc (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2000,8 +2087,7 @@ symbol_mark_used_in_reloc (s)
 /* Clear the mark of whether a symbol has been used in a reloc.  */
 
 void
 /* Clear the mark of whether a symbol has been used in a reloc.  */
 
 void

-symbol_clear_used_in_reloc (s)
-     symbolS *s;
+symbol_clear_used_in_reloc (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -2011,8 +2097,7 @@ symbol_clear_used_in_reloc (s)
 /* Return whether a symbol has been used in a reloc.  */
 
 int
 /* Return whether a symbol has been used in a reloc.  */
 
 int

-symbol_used_in_reloc_p (s)
-     symbolS *s;
+symbol_used_in_reloc_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -2022,8 +2107,7 @@ symbol_used_in_reloc_p (s)
 /* Mark a symbol as an MRI common symbol.  */
 
 void
 /* Mark a symbol as an MRI common symbol.  */
 
 void

-symbol_mark_mri_common (s)
-     symbolS *s;
+symbol_mark_mri_common (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2033,8 +2117,7 @@ symbol_mark_mri_common (s)
 /* Clear the mark of whether a symbol is an MRI common symbol.  */
 
 void
 /* Clear the mark of whether a symbol is an MRI common symbol.  */
 
 void

-symbol_clear_mri_common (s)
-     symbolS *s;
+symbol_clear_mri_common (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -2044,8 +2127,7 @@ symbol_clear_mri_common (s)
 /* Return whether a symbol is an MRI common symbol.  */
 
 int
 /* Return whether a symbol is an MRI common symbol.  */
 
 int

-symbol_mri_common_p (s)
-     symbolS *s;
+symbol_mri_common_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -2055,8 +2137,7 @@ symbol_mri_common_p (s)
 /* Mark a symbol as having been written.  */
 
 void
 /* Mark a symbol as having been written.  */
 
 void

-symbol_mark_written (s)
-     symbolS *s;
+symbol_mark_written (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -2066,8 +2147,7 @@ symbol_mark_written (s)
 /* Clear the mark of whether a symbol has been written.  */
 
 void
 /* Clear the mark of whether a symbol has been written.  */
 
 void

-symbol_clear_written (s)
-     symbolS *s;
+symbol_clear_written (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;


@@ -2077,8 +2157,7 @@ symbol_clear_written (s)
 /* Return whether a symbol has been written.  */
 
 int
 /* Return whether a symbol has been written.  */
 
 int

-symbol_written_p (s)
-     symbolS *s;
+symbol_written_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;


@@ -2088,8 +2167,7 @@ symbol_written_p (s)
 /* Mark a symbol has having been resolved.  */
 
 void
 /* Mark a symbol has having been resolved.  */
 
 void

-symbol_mark_resolved (s)
-     symbolS *s;
+symbol_mark_resolved (symbolS *s)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))


@@ -2104,8 +2182,7 @@ symbol_mark_resolved (s)
 /* Return whether a symbol has been resolved.  */
 
 int
 /* Return whether a symbol has been resolved.  */
 
 int

-symbol_resolved_p (s)
-     symbolS *s;
+symbol_resolved_p (symbolS *s)

 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))


@@ -2117,15 +2194,14 @@ symbol_resolved_p (s)
 /* Return whether a symbol is a section symbol.  */
 
 int
 /* Return whether a symbol is a section symbol.  */
 
 int

-symbol_section_p (s)
-     symbolS *s ATTRIBUTE_UNUSED;
+symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 #ifdef BFD_ASSEMBLER
   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
 #else
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
 #ifdef BFD_ASSEMBLER
   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
 #else

-  /* FIXME */
+  /* FIXME.  */

   return 0;
 #endif
 }
   return 0;
 #endif
 }


@@ -2133,19 +2209,34 @@ symbol_section_p (s)
 /* Return whether a symbol is equated to another symbol.  */
 
 int
 /* Return whether a symbol is equated to another symbol.  */
 
 int

-symbol_equated_p (s)
-     symbolS *s;
+symbol_equated_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
   return s->sy_value.X_op == O_symbol;
 }
 
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
   return s->sy_value.X_op == O_symbol;
 }
 

+/* Return whether a symbol is equated to another symbol, and should be
+   treated specially when writing out relocs.  */
+
+int
+symbol_equated_reloc_p (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+  /* X_op_symbol, normally not used for O_symbol, is set by
+     resolve_symbol_value to flag expression syms that have been
+     equated.  */
+  return (s->sy_value.X_op == O_symbol
+         && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
+             || ! S_IS_DEFINED (s)
+             || S_IS_COMMON (s)));
+}
+

 /* Return whether a symbol has a constant value.  */
 
 int
 /* Return whether a symbol has a constant value.  */
 
 int

-symbol_constant_p (s)
-     symbolS *s;
+symbol_constant_p (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;


@@ -2157,8 +2248,7 @@ symbol_constant_p (s)
 /* Return the BFD symbol for a symbol.  */
 
 asymbol *
 /* Return the BFD symbol for a symbol.  */
 
 asymbol *

-symbol_get_bfdsym (s)
-     symbolS *s;
+symbol_get_bfdsym (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2168,13 +2258,20 @@ symbol_get_bfdsym (s)
 /* Set the BFD symbol for a symbol.  */
 
 void
 /* Set the BFD symbol for a symbol.  */
 
 void

-symbol_set_bfdsym (s, bsym)
-     symbolS *s;
-     asymbol *bsym;
+symbol_set_bfdsym (symbolS *s, asymbol *bsym)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);

-  s->bsym = bsym;
+  /* Usually, it is harmless to reset a symbol to a BFD section
+     symbol. For example, obj_elf_change_section sets the BFD symbol
+     of an old symbol with the newly created section symbol. But when
+     we have multiple sections with the same name, the newly created
+     section may have the same name as an old section. We check if the
+     old symbol has been already marked as a section symbol before
+     resetting it.  */
+  if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
+    s->bsym = bsym;
+  /* else XXX - What do we do now ?  */

 }
 
 #endif /* BFD_ASSEMBLER */
 }
 
 #endif /* BFD_ASSEMBLER */


@@ -2184,8 +2281,7 @@ symbol_set_bfdsym (s, bsym)
 /* Get a pointer to the object format information for a symbol.  */
 
 OBJ_SYMFIELD_TYPE *
 /* Get a pointer to the object format information for a symbol.  */
 
 OBJ_SYMFIELD_TYPE *

-symbol_get_obj (s)
-     symbolS *s;
+symbol_get_obj (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2195,9 +2291,7 @@ symbol_get_obj (s)
 /* Set the object format information for a symbol.  */
 
 void
 /* Set the object format information for a symbol.  */
 
 void

-symbol_set_obj (s, o)
-     symbolS *s;
-     OBJ_SYMFIELD_TYPE *o;
+symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2211,8 +2305,7 @@ symbol_set_obj (s, o)
 /* Get a pointer to the processor information for a symbol.  */
 
 TC_SYMFIELD_TYPE *
 /* Get a pointer to the processor information for a symbol.  */
 
 TC_SYMFIELD_TYPE *

-symbol_get_tc (s)
-     symbolS *s;
+symbol_get_tc (symbolS *s)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2222,9 +2315,7 @@ symbol_get_tc (s)
 /* Set the processor information for a symbol.  */
 
 void
 /* Set the processor information for a symbol.  */
 
 void

-symbol_set_tc (s, o)
-     symbolS *s;
-     TC_SYMFIELD_TYPE *o;
+symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)

 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);
 {
   if (LOCAL_SYMBOL_CHECK (s))
     s = local_symbol_convert ((struct local_symbol *) s);


@@ -2234,10 +2325,10 @@ symbol_set_tc (s, o)
 #endif /* TC_SYMFIELD_TYPE */
 
 void
 #endif /* TC_SYMFIELD_TYPE */
 
 void

-symbol_begin ()
+symbol_begin (void)

 {
   symbol_lastP = NULL;
 {
   symbol_lastP = NULL;

-  symbol_rootP = NULL;         /* In case we have 0 symbols (!!) */
+  symbol_rootP = NULL;         /* In case we have 0 symbols (!!)  */

   sy_hash = hash_new ();
 #ifdef BFD_ASSEMBLER
   local_hash = hash_new ();
   sy_hash = hash_new ();
 #ifdef BFD_ASSEMBLER
   local_hash = hash_new ();


@@ -2249,7 +2340,7 @@ symbol_begin ()
   abs_symbol.bsym = bfd_abs_section.symbol;
 #endif
 #else
   abs_symbol.bsym = bfd_abs_section.symbol;
 #endif
 #else

-  /* Can't initialise a union. Sigh. */
+  /* Can't initialise a union. Sigh.  */

   S_SET_SEGMENT (&abs_symbol, absolute_section);
 #endif
   abs_symbol.sy_value.X_op = O_constant;
   S_SET_SEGMENT (&abs_symbol, absolute_section);
 #endif
   abs_symbol.sy_value.X_op = O_constant;


@@ -2258,8 +2349,6 @@ symbol_begin ()
   if (LOCAL_LABELS_FB)
     fb_label_init ();
 }
   if (LOCAL_LABELS_FB)
     fb_label_init ();
 }

-
-

 \f
 int indent_level;
 
 \f
 int indent_level;
 


@@ -2270,7 +2359,7 @@ int max_indent_level = 8;
 #if 0
 
 static void
 #if 0
 
 static void

-indent ()
+indent (void)

 {
   printf ("%*s", indent_level * 4, "");
 }
 {
   printf ("%*s", indent_level * 4, "");
 }


@@ -2278,9 +2367,7 @@ indent ()
 #endif
 
 void
 #endif
 
 void

-print_symbol_value_1 (file, sym)
-     FILE *file;
-     symbolS *sym;
+print_symbol_value_1 (FILE *file, symbolS *sym)

 {
   const char *name = S_GET_NAME (sym);
   if (!name || !name[0])
 {
   const char *name = S_GET_NAME (sym);
   if (!name || !name[0])


@@ -2328,7 +2415,7 @@ print_symbol_value_1 (file, sym)
       segT s = S_GET_SEGMENT (sym);
 
       if (s != undefined_section
       segT s = S_GET_SEGMENT (sym);
 
       if (s != undefined_section

-          && s != expr_section)
+         && s != expr_section)

        fprintf (file, " %lx", (long) S_GET_VALUE (sym));
     }
   else if (indent_level < max_indent_level
        fprintf (file, " %lx", (long) S_GET_VALUE (sym));
     }
   else if (indent_level < max_indent_level


@@ -2339,7 +2426,7 @@ print_symbol_value_1 (file, sym)
 #ifdef BFD_ASSEMBLER
       if (LOCAL_SYMBOL_CHECK (sym))
        fprintf (file, "constant %lx",
 #ifdef BFD_ASSEMBLER
       if (LOCAL_SYMBOL_CHECK (sym))
        fprintf (file, "constant %lx",

-                (long) ((struct local_symbol *) sym)->lsy_offset);
+                (long) ((struct local_symbol *) sym)->lsy_value);

       else
 #endif
        print_expr_1 (file, &sym->sy_value);
       else
 #endif
        print_expr_1 (file, &sym->sy_value);


@@ -2350,8 +2437,7 @@ print_symbol_value_1 (file, sym)
 }
 
 void
 }
 
 void

-print_symbol_value (sym)
-     symbolS *sym;
+print_symbol_value (symbolS *sym)

 {
   indent_level = 0;
   print_symbol_value_1 (stderr, sym);
 {
   indent_level = 0;
   print_symbol_value_1 (stderr, sym);


@@ -2359,10 +2445,7 @@ print_symbol_value (sym)
 }
 
 static void
 }
 
 static void

-print_binary (file, name, exp)
-     FILE *file;
-     const char * name;
-     expressionS *exp;
+print_binary (FILE *file, const char *name, expressionS *exp)

 {
   indent_level++;
   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
 {
   indent_level++;
   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");


@@ -2374,9 +2457,7 @@ print_binary (file, name, exp)
 }
 
 void
 }
 
 void

-print_expr_1 (file, exp)
-     FILE *file;
-     expressionS *exp;
+print_expr_1 (FILE *file, expressionS *exp)

 {
   fprintf (file, "expr %lx ", (long) exp);
   switch (exp->X_op)
 {
   fprintf (file, "expr %lx ", (long) exp);
   switch (exp->X_op)


@@ -2488,16 +2569,14 @@ print_expr_1 (file, exp)
 }
 
 void
 }
 
 void

-print_expr (exp)
-     expressionS *exp;
+print_expr (expressionS *exp)

 {
   print_expr_1 (stderr, exp);
   fprintf (stderr, "\n");
 }
 
 void
 {
   print_expr_1 (stderr, exp);
   fprintf (stderr, "\n");
 }
 
 void

-symbol_print_statistics (file)
-     FILE *file;
+symbol_print_statistics (FILE *file)

 {
   hash_print_statistics (file, "symbol table", sy_hash);
 #ifdef BFD_ASSEMBLER
 {
   hash_print_statistics (file, "symbol table", sy_hash);
 #ifdef BFD_ASSEMBLER


@@ -2506,5 +2585,3 @@ symbol_print_statistics (file)
           local_symbol_count, local_symbol_conversion_count);
 #endif
 }
           local_symbol_count, local_symbol_conversion_count);
 #endif
 }

-
-/* end of symbols.c */