X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fsymbols.c;h=761a0208515bd6fffc1e9b16f5b420d5a562f938;hb=cbf0ee7967dfcaf5876437ef1a5bad2ccf85f0dc;hp=07b80ea559b6d620facaa993b82a357675c8be26;hpb=30727aa6d12fb866494020c0b62ab265a2bdcdfe;p=deliverable%2Fbinutils-gdb.git

diff --git a/gas/symbols.c b/gas/symbols.c
index 07b80ea559..761a020851 100644
--- a/gas/symbols.c
+++ b/gas/symbols.c
@@ -1,5 +1,6 @@
 /* symbols.c -symbol table-
-   Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+   1999, 2000, 2001, 2002, 2003
    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.  */
 
-/* #define DEBUG_SYMS / * to debug symbol list maintenance */
-
-#include <ctype.h>
+/* #define DEBUG_SYMS / * to debug symbol list maintenance.  */
 
 #include "as.h"
 
+#include "safe-ctype.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;
 
-/* Below are commented in "symbols.h". */
+/* Below are commented in "symbols.h".  */
 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 DOLLAR_LABEL_CHAR	'\001'
+#define LOCAL_LABEL_CHAR	'\002'
+
 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.
- 
+
    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);
 
-  /*
-   * Link to end of symbol chain.
-   */
+  /* Link to end of symbol chain.  */
 #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 *
-save_symbol_name (name)
-     const char *name;
+save_symbol_name (const char *name)
 {
   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);
 
@@ -123,22 +119,20 @@ save_symbol_name (name)
 
   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 *
-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;
@@ -147,7 +141,7 @@ symbol_create (name, segment, valu, frag)
 
   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
@@ -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.  */
 
-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.  */
 
@@ -205,12 +197,8 @@ static unsigned long local_symbol_conversion_count;
 
 /* 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;
@@ -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_offset = offset;
+  ret->lsy_value = value;
 
   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 *
-local_symbol_convert (locsym)
-     struct local_symbol *locsym;
+local_symbol_convert (struct local_symbol *locsym)
 {
   symbolS *ret;
 
@@ -246,7 +233,7 @@ local_symbol_convert (locsym)
 
   ++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))
@@ -255,6 +242,10 @@ local_symbol_convert (locsym)
   /* 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);
@@ -272,22 +263,17 @@ local_symbol_convert (locsym)
 
 #endif /* ! BFD_ASSEMBLER */
 
+/* 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 *
-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.  */
@@ -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;
+
+      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);
 
@@ -327,9 +320,9 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
 			      (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))
@@ -349,9 +342,7 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
       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
@@ -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
-		  || 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);
-	  locsym->lsy_offset = frag_now_fix ();
+	  locsym->lsy_value = frag_now_fix ();
 #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
-	      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 /* if we have one, it better be zero. */
+#endif /* if we have one, it better be zero.  */
 
 	    }
 	  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))
@@ -406,17 +397,14 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
 		  && (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)
 		    {
-		      /*
-		       *   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 ()))
 			{
@@ -429,37 +417,43 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
 			 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 ());
-		      S_SET_SEGMENT (symbolP, now_seg);	/* keep N_EXT bit */
+		      S_SET_SEGMENT (symbolP, now_seg);	/* Keep N_EXT bit.  */
 		    }
 		}
 	      else
 		{
-#if defined (S_GET_OTHER) && defined (S_GET_DESC)
-		  as_fatal (_("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%ld."),
-			    sym_name,
-			    segment_name (S_GET_SEGMENT (symbolP)),
-			    S_GET_OTHER (symbolP), S_GET_DESC (symbolP),
-			    (long) S_GET_VALUE (symbolP));
+#if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
+     && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
+		  static const char *od_buf = "";
 #else
-		  as_fatal (_("Symbol \"%s\" is already defined as \"%s\"/%ld."),
+		  char od_buf[100];
+		  od_buf[0] = '\0';
+#ifdef BFD_ASSEMBLER
+		  if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
+#endif
+		    sprintf (od_buf, "%d.%d.",
+			     S_GET_OTHER (symbolP),
+			     S_GET_DESC (symbolP));
+#endif
+		  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));
-#endif
 		}
-	    }			/* if the undefined symbol has no value */
+	    }			/* if the undefined symbol has no value  */
 	}
       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))
-	    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
@@ -479,12 +473,12 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
 #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
-         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;
@@ -505,17 +499,10 @@ colon (sym_name)		/* just seen "x:" - rattle symbols & frags */
   return symbolP;
 }
 
+/* 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;
 
@@ -527,27 +514,23 @@ symbol_table_insert (symbolP)
       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)))
     {
-      as_fatal (_("Inserting \"%s\" into symbol table failed: %s"),
+      as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
 		S_GET_NAME (symbolP), error_string);
-    }				/* on error */
-}				/* symbol_table_insert() */
+    }				/* on error  */
+}
 
-/*
- *			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 *
-symbol_find_or_make (name)
-     const char *name;
+symbol_find_or_make (const char *name)
 {
   register symbolS *symbolP;
 
@@ -575,47 +558,73 @@ symbol_find_or_make (name)
     }				/* if symbol wasn't found */
 
   return (symbolP);
-}				/* symbol_find_or_make() */
+}
 
 symbolS *
-symbol_make (name)
-     CONST char *name;
+symbol_make (const char *name)
 {
   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);
-}				/* 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 *
-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 */
-}				/* symbol_find() */
+}
+
+symbolS *
+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 (name, strip_underscore)
-     CONST char *name;
-     int strip_underscore;
+symbol_find_base (const char *name, int strip_underscore)
 {
   if (strip_underscore && *name == '_')
     name++;
@@ -642,41 +651,25 @@ symbol_find_base (name, strip_underscore)
 
       while ((c = *orig++) != '\0')
 	{
-	  if (islower (c))
-	    c = toupper (c);
-	  *copy++ = c;
+	  *copy++ = TOUPPER (c);
 	}
       *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.  */
 
-/* Link symbol ADDME after symbol TARGET in the chain. */
-void 
-symbol_append (addme, target, rootPP, lastPP)
-     symbolS *addme;
-     symbolS *target;
-     symbolS **rootPP;
-     symbolS **lastPP;
+void
+symbol_append (symbolS *addme, symbolS *target,
+	       symbolS **rootPP, symbolS **lastPP)
 {
   if (LOCAL_SYMBOL_CHECK (addme))
     abort ();
@@ -694,7 +687,7 @@ symbol_append (addme, target, rootPP, lastPP)
       *rootPP = addme;
       *lastPP = addme;
       return;
-    }				/* if the list is empty */
+    }				/* if the list is empty  */
 
   if (target->sy_next != NULL)
     {
@@ -706,7 +699,7 @@ symbol_append (addme, target, rootPP, lastPP)
     {
       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;
@@ -718,10 +711,10 @@ symbol_append (addme, target, rootPP, lastPP)
   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 ();
@@ -732,12 +725,10 @@ symbol_clear_list_pointers (symbolP)
 }
 
 #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 ();
@@ -745,33 +736,31 @@ symbol_remove (symbolP, rootPP, lastPP)
   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 it was the tail */
+    }				/* if it was the tail  */
 
   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 not first */
+    }				/* if not first  */
 
   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 ();
@@ -786,7 +775,7 @@ symbol_insert (addme, target, rootPP, lastPP)
     {
       know (*rootPP == target);
       *rootPP = addme;
-    }				/* if not first */
+    }				/* if not first  */
 
   addme->sy_previous = target->sy_previous;
   target->sy_previous = addme;
@@ -797,10 +786,8 @@ symbol_insert (addme, target, rootPP, lastPP)
 
 #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;
 
@@ -824,8 +811,7 @@ verify_symbol_chain (rootP, lastP)
 }
 
 void
-verify_symbol_chain_2 (sym)
-     symbolS *sym;
+verify_symbol_chain_2 (symbolS *sym)
 {
   symbolS *p = sym, *n = sym;
 #ifdef SYMBOLS_NEED_BACKPOINTERS
@@ -837,17 +823,70 @@ verify_symbol_chain_2 (sym)
   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_symbol_value (symp, finalize)
-     symbolS *symp;
-     int finalize;
+resolve_symbol_value (symbolS *symp)
 {
   int resolved;
-  valueT final_val;
+  valueT final_val = 0;
   segT final_seg;
 
 #ifdef BFD_ASSEMBLER
@@ -855,15 +894,15 @@ resolve_symbol_value (symp, finalize)
     {
       struct local_symbol *locsym = (struct local_symbol *) symp;
 
+      final_val = locsym->lsy_value;
       if (local_symbol_resolved_p (locsym))
-	return locsym->lsy_offset;
+	return final_val;
 
-      final_val = (local_symbol_get_frag (locsym)->fr_address
-		   + locsym->lsy_offset);
+      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);
 	}
 
@@ -884,8 +923,9 @@ resolve_symbol_value (symp, finalize)
 
   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;
     }
@@ -915,7 +955,7 @@ resolve_symbol_value (symp, finalize)
 	  /* Fall through.  */
 
 	case O_constant:
-	  final_val += symp->sy_frag->fr_address;
+	  final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
 	  if (final_seg == expr_section)
 	    final_seg = absolute_section;
 	  resolved = 1;
@@ -923,19 +963,22 @@ resolve_symbol_value (symp, finalize)
 
 	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
-                 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;
 	    }
 
-	  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 *)
@@ -943,30 +986,51 @@ resolve_symbol_value (symp, finalize)
 	      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 (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;
+		  /* 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);
+	      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)
-		final_seg = S_GET_SEGMENT (add_symbol);
+		final_seg = seg_left;
 	    }
 
 	  resolved = symbol_resolved_p (add_symbol);
@@ -975,7 +1039,19 @@ resolve_symbol_value (symp, finalize)
 	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;
@@ -985,8 +1061,6 @@ resolve_symbol_value (symp, finalize)
 	    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;
@@ -1010,91 +1084,68 @@ resolve_symbol_value (symp, finalize)
 	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.  */
-	  if (op == O_add || op == O_subtract)
+	  if (op == O_add)
 	    {
 	      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;
 		}
-	      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;
-		  op_symbol = NULL;
+		  seg_left = seg_right;
 		  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
-                 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;
@@ -1102,7 +1153,7 @@ resolve_symbol_value (symp, finalize)
 		  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));
 		}
 
@@ -1122,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_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;
@@ -1135,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_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));
-   	  break;
+	  break;
 
 	case O_register:
 	case O_big:
@@ -1154,27 +1220,28 @@ resolve_symbol_value (symp, finalize)
       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)
-      /* 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
-	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.  */
-  if (finalize)
+  if (finalize_syms)
     {
       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;
 	}
     }
@@ -1184,17 +1251,15 @@ exit_dont_set_value:
 
 #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
-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)
-    resolve_symbol_value (value, 1);
+    resolve_symbol_value (value);
 }
 
 #endif
@@ -1202,7 +1267,7 @@ resolve_local_symbol (key, value)
 /* Resolve all local symbols.  */
 
 void
-resolve_local_symbol_values ()
+resolve_local_symbol_values (void)
 {
 #ifdef BFD_ASSEMBLER
   hash_traverse (local_hash, resolve_local_symbol);
@@ -1222,9 +1287,8 @@ static char *dollar_label_defines;
 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;
 
@@ -1234,13 +1298,12 @@ dollar_label_defined (label)
     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;
-}				/* dollar_label_defined() */
+}
 
 static long
-dollar_label_instance (label)
-     long label;
+dollar_label_instance (long label)
 {
   long *i;
 
@@ -1250,22 +1313,21 @@ dollar_label_instance (label)
     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;
 }
 
-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
 
-void 
-define_dollar_label (label)
-     long label;
+void
+define_dollar_label (long label)
 {
   long *i;
 
@@ -1277,7 +1339,7 @@ define_dollar_label (label)
 	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)
     {
@@ -1295,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);
-    }				/* if we needed to grow */
+    }				/* if we needed to grow  */
 
   dollar_labels[dollar_label_count] = label;
   dollar_label_instances[dollar_label_count] = 1;
@@ -1303,31 +1365,27 @@ define_dollar_label (label)
   ++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;
-  /* 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;
-  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);
@@ -1337,8 +1395,8 @@ dollar_label_name (n, augend)
 #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)
     {
@@ -1348,9 +1406,9 @@ dollar_label_name (n, augend)
   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)
     {
@@ -1359,27 +1417,26 @@ dollar_label_name (n, augend)
     }
   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;
 }
 
-/*
- * 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)
 
@@ -1389,19 +1446,19 @@ static long *fb_label_instances;
 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)
 
-static void 
-fb_label_init ()
+static void
+fb_label_init (void)
 {
   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
-}				/* fb_label_init() */
+}
+
+/* Add one to the instance number of this fb label.  */
 
-/* add one to the instance number of this fb label */
-void 
-fb_label_instance_inc (label)
-     long label;
+void
+fb_label_instance_inc (long label)
 {
   long *i;
 
@@ -1420,11 +1477,11 @@ fb_label_instance_inc (label)
 	    {
 	      ++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)
     {
@@ -1441,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));
-    }				/* 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;
 }
 
-static long 
-fb_label_instance (label)
-     long label;
+static long
+fb_label_instance (long label)
 {
   long *i;
 
@@ -1467,8 +1523,8 @@ fb_label_instance (label)
 	  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
@@ -1476,38 +1532,38 @@ fb_label_instance (label)
   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;
-  /* 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;
-  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;
+#ifdef LOCAL_LABEL_PREFIX
+  *p++ = LOCAL_LABEL_PREFIX;
+#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)
     {
@@ -1517,9 +1573,9 @@ fb_label_name (n, augend)
   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)
     {
@@ -1528,43 +1584,47 @@ fb_label_name (n, augend)
     }
   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);
-}				/* 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 *
-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;
-  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;
 
-  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';
 
-  if (*p == 1)
+  if (*p == DOLLAR_LABEL_CHAR)
     type = "dollar";
-  else if (*p == 2)
+  else if (*p == LOCAL_LABEL_CHAR)
     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';
 
+  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);
 
@@ -1574,30 +1634,33 @@ decode_local_label_name (s)
 /* 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))
-    return ((struct local_symbol *) s)->lsy_offset;
+    return resolve_symbol_value (s);
 #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
-         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)))
-	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;
     }
@@ -1607,14 +1670,12 @@ S_GET_VALUE (s)
 /* 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))
     {
-      ((struct local_symbol *) s)->lsy_offset = val;
+      ((struct local_symbol *) s)->lsy_value = val;
       return;
     }
 #endif
@@ -1625,8 +1686,7 @@ S_SET_VALUE (s, val)
 }
 
 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);
@@ -1648,8 +1708,7 @@ copy_symbol_attributes (dest, src)
 #ifdef BFD_ASSEMBLER
 
 int
-S_IS_FUNCTION (s)
-     symbolS *s;
+S_IS_FUNCTION (symbolS *s)
 {
   flagword flags;
 
@@ -1662,8 +1721,7 @@ S_IS_FUNCTION (s)
 }
 
 int
-S_IS_EXTERNAL (s)
-     symbolS *s;
+S_IS_EXTERNAL (symbolS *s)
 {
   flagword flags;
 
@@ -1672,7 +1730,7 @@ S_IS_EXTERNAL (s)
 
   flags = s->bsym->flags;
 
-  /* sanity check */
+  /* Sanity check.  */
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
@@ -1680,8 +1738,7 @@ S_IS_EXTERNAL (s)
 }
 
 int
-S_IS_WEAK (s)
-     symbolS *s;
+S_IS_WEAK (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
@@ -1689,8 +1746,7 @@ S_IS_WEAK (s)
 }
 
 int
-S_IS_COMMON (s)
-     symbolS *s;
+S_IS_COMMON (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
@@ -1698,17 +1754,37 @@ S_IS_COMMON (s)
 }
 
 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;
 }
 
+
+#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
-S_IS_DEBUG (s)
-     symbolS *s;
+S_IS_DEBUG (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 0;
@@ -1718,8 +1794,7 @@ S_IS_DEBUG (s)
 }
 
 int
-S_IS_LOCAL (s)
-     symbolS *s;
+S_IS_LOCAL (symbolS *s)
 {
   flagword flags;
   const char *name;
@@ -1729,7 +1804,7 @@ S_IS_LOCAL (s)
 
   flags = s->bsym->flags;
 
-  /* sanity check */
+  /* Sanity check.  */
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
@@ -1744,8 +1819,8 @@ S_IS_LOCAL (s)
   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
@@ -1754,22 +1829,19 @@ S_IS_LOCAL (s)
 }
 
 int
-S_IS_EXTERN (s)
-     symbolS *s;
+S_IS_EXTERN (symbolS *s)
 {
   return S_IS_EXTERNAL (s);
 }
 
 int
-S_IS_STABD (s)
-     symbolS *s;
+S_IS_STABD (symbolS *s)
 {
   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;
@@ -1777,8 +1849,7 @@ S_GET_NAME (s)
 }
 
 segT
-S_GET_SEGMENT (s)
-     symbolS *s;
+S_GET_SEGMENT (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return ((struct local_symbol *) s)->lsy_section;
@@ -1786,9 +1857,7 @@ S_GET_SEGMENT (s)
 }
 
 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
@@ -1808,15 +1877,14 @@ S_SET_SEGMENT (s, seg)
   if (s->bsym->flags & BSF_SECTION_SYM)
     {
       if (s->bsym->section != seg)
-	abort();
+	abort ();
     }
   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);
@@ -1825,13 +1893,23 @@ S_SET_EXTERNAL (s)
       /* 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_LOCAL|BSF_WEAK);
+  s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
 }
 
 void
-S_CLEAR_EXTERNAL (s)
-     symbolS *s;
+S_CLEAR_EXTERNAL (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return;
@@ -1841,23 +1919,38 @@ S_CLEAR_EXTERNAL (s)
       return;
     }
   s->bsym->flags |= BSF_LOCAL;
-  s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK);
+  s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
 }
 
 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;
-  s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL);
+  s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
 }
 
 void
-S_SET_NAME (s, name)
-     symbolS *s;
-     char *name;
+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
+S_SET_NAME (symbolS *s, char *name)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     {
@@ -1873,8 +1966,7 @@ S_SET_NAME (s, name)
 /* Return the previous symbol in a chain.  */
 
 symbolS *
-symbol_previous (s)
-     symbolS *s;
+symbol_previous (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();
@@ -1886,8 +1978,7 @@ symbol_previous (s)
 /* Return the next symbol in a chain.  */
 
 symbolS *
-symbol_next (s)
-     symbolS *s;
+symbol_next (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     abort ();
@@ -1897,8 +1988,7 @@ symbol_next (s)
 /* 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);
@@ -1908,21 +1998,27 @@ symbol_get_value_expression (s)
 /* 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;
 }
 
+/* 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
-symbol_set_frag (s, f)
-     symbolS *s;
-     fragS *f;
+symbol_set_frag (symbolS *s, fragS *f)
 {
 #ifdef BFD_ASSEMBLER
   if (LOCAL_SYMBOL_CHECK (s))
@@ -1937,8 +2033,7 @@ symbol_set_frag (s, f)
 /* 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))
@@ -1950,8 +2045,7 @@ symbol_get_frag (s)
 /* 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;
@@ -1961,8 +2055,7 @@ symbol_mark_used (s)
 /* 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);
@@ -1972,8 +2065,7 @@ symbol_clear_used (s)
 /* 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;
@@ -1983,8 +2075,7 @@ symbol_used_p (s)
 /* 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);
@@ -1994,8 +2085,7 @@ symbol_mark_used_in_reloc (s)
 /* 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;
@@ -2005,8 +2095,7 @@ symbol_clear_used_in_reloc (s)
 /* 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;
@@ -2016,8 +2105,7 @@ symbol_used_in_reloc_p (s)
 /* 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);
@@ -2027,8 +2115,7 @@ symbol_mark_mri_common (s)
 /* 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;
@@ -2038,8 +2125,7 @@ symbol_clear_mri_common (s)
 /* 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;
@@ -2049,8 +2135,7 @@ symbol_mri_common_p (s)
 /* 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;
@@ -2060,8 +2145,7 @@ symbol_mark_written (s)
 /* 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;
@@ -2071,8 +2155,7 @@ symbol_clear_written (s)
 /* 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;
@@ -2082,8 +2165,7 @@ symbol_written_p (s)
 /* 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))
@@ -2098,8 +2180,7 @@ symbol_mark_resolved (s)
 /* 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))
@@ -2111,15 +2192,14 @@ symbol_resolved_p (s)
 /* Return whether a symbol is a section symbol.  */
 
 int
-symbol_section_p (s)
-     symbolS *s;
+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
-  /* FIXME */
+  /* FIXME.  */
   return 0;
 #endif
 }
@@ -2127,19 +2207,34 @@ symbol_section_p (s)
 /* 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;
 }
 
+/* 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
-symbol_constant_p (s)
-     symbolS *s;
+symbol_constant_p (symbolS *s)
 {
   if (LOCAL_SYMBOL_CHECK (s))
     return 1;
@@ -2151,8 +2246,7 @@ symbol_constant_p (s)
 /* 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);
@@ -2162,9 +2256,7 @@ symbol_get_bfdsym (s)
 /* 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);
@@ -2178,8 +2270,7 @@ symbol_set_bfdsym (s, bsym)
 /* 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);
@@ -2189,9 +2280,7 @@ symbol_get_obj (s)
 /* 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);
@@ -2205,8 +2294,7 @@ symbol_set_obj (s, o)
 /* 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);
@@ -2216,9 +2304,7 @@ symbol_get_tc (s)
 /* 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);
@@ -2228,10 +2314,10 @@ symbol_set_tc (s, o)
 #endif /* TC_SYMFIELD_TYPE */
 
 void
-symbol_begin ()
+symbol_begin (void)
 {
   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 ();
@@ -2243,7 +2329,7 @@ symbol_begin ()
   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;
@@ -2252,8 +2338,6 @@ symbol_begin ()
   if (LOCAL_LABELS_FB)
     fb_label_init ();
 }
-
-
 
 int indent_level;
 
@@ -2264,7 +2348,7 @@ int max_indent_level = 8;
 #if 0
 
 static void
-indent ()
+indent (void)
 {
   printf ("%*s", indent_level * 4, "");
 }
@@ -2272,9 +2356,7 @@ indent ()
 #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])
@@ -2322,7 +2404,7 @@ print_symbol_value_1 (file, sym)
       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
@@ -2333,7 +2415,7 @@ print_symbol_value_1 (file, sym)
 #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);
@@ -2344,8 +2426,7 @@ print_symbol_value_1 (file, sym)
 }
 
 void
-print_symbol_value (sym)
-     symbolS *sym;
+print_symbol_value (symbolS *sym)
 {
   indent_level = 0;
   print_symbol_value_1 (stderr, sym);
@@ -2353,10 +2434,7 @@ print_symbol_value (sym)
 }
 
 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, "");
@@ -2368,9 +2446,7 @@ print_binary (file, name, exp)
 }
 
 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)
@@ -2482,16 +2558,14 @@ print_expr_1 (file, exp)
 }
 
 void
-print_expr (exp)
-     expressionS *exp;
+print_expr (expressionS *exp)
 {
   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
@@ -2500,5 +2574,3 @@ symbol_print_statistics (file)
 	   local_symbol_count, local_symbol_conversion_count);
 #endif
 }
-
-/* end of symbols.c */