merge from gcc
[deliverable/binutils-gdb.git] / gas / symbols.c
index 6d8bfcd6d63e15f4fc60f077fd50189a6debfbd8..761a0208515bd6fffc1e9b16f5b420d5a562f938 100644 (file)
@@ -1,5 +1,6 @@
 /* symbols.c -symbol table-
 /* symbols.c -symbol table-
-   Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 1997
+   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.
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
    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"
 
+#include "struc-symbol.h"
+
 /* This is non-zero if symbols are case sensitive, which is the
    default.  */
 int symbols_case_sensitive = 1;
 /* This is non-zero if symbols are case sensitive, which is the
    default.  */
 int symbols_case_sensitive = 1;
@@ -39,7 +41,10 @@ extern int new_broken_words;
 /* symbol-name => struct symbol pointer */
 static struct hash_control *sy_hash;
 
 /* symbol-name => struct symbol pointer */
 static struct hash_control *sy_hash;
 
-/* Below are commented in "symbols.h". */
+/* Table of local symbols.  */
+static struct hash_control *local_hash;
+
+/* Below are commented in "symbols.h".  */
 symbolS *symbol_rootP;
 symbolS *symbol_lastP;
 symbolS abs_symbol;
 symbolS *symbol_rootP;
 symbolS *symbol_lastP;
 symbolS abs_symbol;
@@ -50,35 +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);
 
 
-/* symbol_new()
-  
-   Return a pointer to a new symbol.  Die if we can't make a new
+static void print_binary (FILE *, const char *, expressionS *);
+static void report_op_error (symbolS *, symbolS *, symbolS *);
+
+/* 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;
@@ -91,42 +95,53 @@ symbol_new (name, segment, valu, frag)
   return symbolP;
 }
 
   return symbolP;
 }
 
-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 */
+/* Save a symbol name on a permanent obstack, and convert it according
+   to the object file format.  */
+
+static char *
+save_symbol_name (const char *name)
 {
   unsigned int name_length;
 {
   unsigned int name_length;
-  char *preserved_copy_of_name;
-  symbolS *symbolP;
+  char *ret;
 
 
-  name_length = strlen (name) + 1;     /* +1 for \0 */
+  name_length = strlen (name) + 1;     /* +1 for \0 */
   obstack_grow (&notes, name, name_length);
   obstack_grow (&notes, name, name_length);
-  preserved_copy_of_name = obstack_finish (&notes);
+  ret = obstack_finish (&notes);
+
 #ifdef STRIP_UNDERSCORE
 #ifdef STRIP_UNDERSCORE
-  if (preserved_copy_of_name[0] == '_')
-    preserved_copy_of_name++;
+  if (ret[0] == '_')
+    ++ret;
 #endif
 
 #ifdef tc_canonicalize_symbol_name
 #endif
 
 #ifdef tc_canonicalize_symbol_name
-  preserved_copy_of_name =
-    tc_canonicalize_symbol_name (preserved_copy_of_name);
+  ret = tc_canonicalize_symbol_name (ret);
 #endif
 
   if (! symbols_case_sensitive)
     {
 #endif
 
   if (! symbols_case_sensitive)
     {
-      unsigned char *s;
+      char *s;
 
 
-      for (s = (unsigned char *) preserved_copy_of_name; *s != '\0'; s++)
-       if (islower (*s))
-         *s = toupper (*s);
+      for (s = ret; *s != '\0'; s++)
+       *s = TOUPPER (*s);
     }
 
     }
 
+  return ret;
+}
+
+symbolS *
+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;
+
+  preserved_copy_of_name = save_symbol_name (name);
+
   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
@@ -156,22 +171,109 @@ symbol_create (name, segment, valu, frag)
   return symbolP;
 }
 \f
   return symbolP;
 }
 \f
+#ifdef BFD_ASSEMBLER
+
+/* Local symbol support.  If we can get away with it, we keep only a
+   small amount of information for local symbols.  */
+
+static symbolS *local_symbol_convert (struct local_symbol *);
+
+/* Used for statistics.  */
+
+static unsigned long local_symbol_count;
+static unsigned long local_symbol_conversion_count;
+
+/* This macro is called with a symbol argument passed by reference.
+   It returns whether this is a local symbol.  If necessary, it
+   changes its argument to the real symbol.  */
+
+#define LOCAL_SYMBOL_CHECK(s)                                          \
+  (s->bsym == NULL                                                     \
+   ? (local_symbol_converted_p ((struct local_symbol *) s)             \
+      ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
+        0)                                                             \
+      : 1)                                                             \
+   : 0)
+
+/* Create a local symbol and insert it into the local hash table.  */
+
+struct local_symbol *
+local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
+{
+  char *name_copy;
+  struct local_symbol *ret;
+
+  ++local_symbol_count;
+
+  name_copy = save_symbol_name (name);
+
+  ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
+  ret->lsy_marker = NULL;
+  ret->lsy_name = name_copy;
+  ret->lsy_section = section;
+  local_symbol_set_frag (ret, frag);
+  ret->lsy_value = value;
+
+  hash_jam (local_hash, name_copy, (PTR) ret);
+
+  return ret;
+}
+
+/* Convert a local symbol into a real symbol.  Note that we do not
+   reclaim the space used by the local symbol.  */
+
+static symbolS *
+local_symbol_convert (struct local_symbol *locsym)
+{
+  symbolS *ret;
+
+  assert (locsym->lsy_marker == NULL);
+  if (local_symbol_converted_p (locsym))
+    return local_symbol_get_real_symbol (locsym);
+
+  ++local_symbol_conversion_count;
+
+  ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
+                   local_symbol_get_frag (locsym));
+
+  if (local_symbol_resolved_p (locsym))
+    ret->sy_resolved = 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);
+  local_symbol_set_real_symbol (locsym, ret);
+
+  hash_jam (local_hash, locsym->lsy_name, NULL);
+
+  return ret;
+}
+
+#else /* ! BFD_ASSEMBLER */
+
+#define LOCAL_SYMBOL_CHECK(s) 0
+#define local_symbol_convert(s) ((symbolS *) s)
+
+#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.  */
@@ -199,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);
 
@@ -211,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))
@@ -233,36 +342,53 @@ 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
-       */
-      if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
+      /* Now check for undefined symbols.  */
+      if (LOCAL_SYMBOL_CHECK (symbolP))
+       {
+#ifdef BFD_ASSEMBLER
+         struct local_symbol *locsym = (struct local_symbol *) symbolP;
+
+         if (locsym->lsy_section != undefined_section
+             && (local_symbol_get_frag (locsym) != frag_now
+                 || locsym->lsy_section != now_seg
+                 || locsym->lsy_value != frag_now_fix ()))
+           {
+             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_value = frag_now_fix ();
+#endif
+       }
+      else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
        {
          if (S_GET_VALUE (symbolP) == 0)
            {
              symbolP->sy_frag = frag_now;
 #ifdef OBJ_VMS
        {
          if (S_GET_VALUE (symbolP) == 0)
            {
              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))
@@ -271,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 ()))
                        {
@@ -294,39 +417,53 @@ 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
                {
-#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
 #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)),
                            sym_name,
                            segment_name (S_GET_SEGMENT (symbolP)),
+                           od_buf,
                            (long) S_GET_VALUE (symbolP));
                            (long) S_GET_VALUE (symbolP));
-#endif
                }
                }
-           }                   /* 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
+  else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
+    {
+      symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
+                                              (valueT) frag_now_fix (),
+                                              frag_now);
+    }
+#endif /* BFD_ASSEMBLER */
   else
     {
       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
   else
     {
       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
@@ -336,12 +473,14 @@ 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;
       symbolP->sy_value.X_add_symbol = mri_common_symbol;
       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
       symbolP->sy_value.X_op = O_symbol;
       symbolP->sy_value.X_add_symbol = mri_common_symbol;
       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
@@ -360,39 +499,38 @@ 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;
 
   know (symbolP);
   know (S_GET_NAME (symbolP));
 
 {
   register const char *error_string;
 
   know (symbolP);
   know (S_GET_NAME (symbolP));
 
+  if (LOCAL_SYMBOL_CHECK (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"),
+                 S_GET_NAME (symbolP), error_string);
+      return;
+    }
+
   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
     {
   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;
 
@@ -400,53 +538,93 @@ symbol_find_or_make (name)
 
   if (symbolP == NULL)
     {
 
   if (symbolP == NULL)
     {
+#ifdef BFD_ASSEMBLER
+      if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
+       {
+         symbolP = md_undefined_symbol ((char *) name);
+         if (symbolP != NULL)
+           return symbolP;
+
+         symbolP = (symbolS *) local_symbol_make (name, undefined_section,
+                                                  (valueT) 0,
+                                                  &zero_address_frag);
+         return symbolP;
+       }
+#endif
+
       symbolP = symbol_make (name);
 
       symbol_table_insert (symbolP);
     }                          /* if symbol wasn't found */
 
   return (symbolP);
       symbolP = symbol_make (name);
 
       symbol_table_insert (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() */
+}
+
+symbolS *
+symbol_temp_new (segT seg, valueT ofs, fragS *frag)
+{
+  return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
+}
+
+symbolS *
+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);
+}
 
 
-/*
- *                     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.
- */
+/* 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 *
 
 symbolS *
-symbol_find (name)
-     CONST char *name;
+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++;
@@ -454,43 +632,50 @@ symbol_find_base (name, strip_underscore)
 #ifdef tc_canonicalize_symbol_name
   {
     char *copy;
 #ifdef tc_canonicalize_symbol_name
   {
     char *copy;
+    size_t len = strlen (name) + 1;
 
 
-    copy = (char *) alloca (strlen (name) + 1);
-    strcpy (copy, name);
+    copy = (char *) alloca (len);
+    memcpy (copy, name, len);
     name = tc_canonicalize_symbol_name (copy);
   }
 #endif
 
   if (! symbols_case_sensitive)
     {
     name = tc_canonicalize_symbol_name (copy);
   }
 #endif
 
   if (! symbols_case_sensitive)
     {
-      unsigned char *copy;
+      char *copy;
+      const char *orig;
+      unsigned char c;
+
+      orig = name;
+      name = copy = (char *) alloca (strlen (name) + 1);
 
 
-      copy = (unsigned char *) alloca (strlen (name) + 1);
-      name = (const char *) copy;
-      for (; *copy != '\0'; copy++)
-       if (islower (*copy))
-         *copy = toupper (*copy);
+      while ((c = *orig++) != '\0')
+       {
+         *copy++ = TOUPPER (c);
+       }
+      *copy = '\0';
     }
 
     }
 
-  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 ();
+  if (target != NULL && LOCAL_SYMBOL_CHECK (target))
+    abort ();
+
   if (target == NULL)
     {
       know (*rootPP == NULL);
   if (target == NULL)
     {
       know (*rootPP == NULL);
@@ -502,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)
     {
@@ -514,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;
@@ -526,11 +711,13 @@ 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 ();
   symbolP->sy_next = NULL;
 #ifdef SYMBOLS_NEED_BACKPOINTERS
   symbolP->sy_previous = NULL;
   symbolP->sy_next = NULL;
 #ifdef SYMBOLS_NEED_BACKPOINTERS
   symbolP->sy_previous = NULL;
@@ -538,44 +725,48 @@ 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 (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;
+/* 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 (target))
+    abort ();
+
   if (target->sy_previous != NULL)
     {
       target->sy_previous->sy_next = addme;
   if (target->sy_previous != NULL)
     {
       target->sy_previous->sy_next = addme;
@@ -584,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;
@@ -595,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;
 
@@ -607,6 +796,9 @@ verify_symbol_chain (rootP, lastP)
 
   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
     {
 
   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
     {
+#ifdef BFD_ASSEMBLER
+      assert (symbolP->bsym != NULL);
+#endif
 #ifdef SYMBOLS_NEED_BACKPOINTERS
       assert (symbolP->sy_next->sy_previous == symbolP);
 #else
 #ifdef SYMBOLS_NEED_BACKPOINTERS
       assert (symbolP->sy_next->sy_previous == symbolP);
 #else
@@ -619,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
@@ -632,19 +823,93 @@ 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;
 
   segT final_seg;
 
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (symp))
+    {
+      struct local_symbol *locsym = (struct local_symbol *) symp;
+
+      final_val = locsym->lsy_value;
+      if (local_symbol_resolved_p (locsym))
+       return final_val;
+
+      final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
+
+      if (finalize_syms)
+       {
+         locsym->lsy_value = final_val;
+         local_symbol_mark_resolved (locsym);
+       }
+
+      return final_val;
+    }
+#endif
+
   if (symp->sy_resolved)
     {
       if (symp->sy_value.X_op == O_constant)
   if (symp->sy_resolved)
     {
       if (symp->sy_value.X_op == O_constant)
@@ -658,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;
     }
@@ -689,7 +955,7 @@ resolve_symbol_value (symp, finalize)
          /* Fall through.  */
 
        case O_constant:
          /* 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;
          if (final_seg == expr_section)
            final_seg = absolute_section;
          resolved = 1;
@@ -697,53 +963,95 @@ 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.  */
-             resolved = add_symbol->sy_resolved;
+                relocation routines are going to handle it specially.
+                Don't change the value.  */
+             resolved = symbol_resolved_p (add_symbol);
              break;
            }
 
              break;
            }
 
-         if (finalize && final_val == 0)
-           copy_symbol_attributes (symp, add_symbol);
+         if (finalize_syms && final_val == 0)
+           {
+             if (LOCAL_SYMBOL_CHECK (add_symbol))
+               add_symbol = local_symbol_convert ((struct local_symbol *)
+                                                  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)
                {
                  symp->sy_value.X_op = O_symbol;
                {
                  symp->sy_value.X_op = O_symbol;
-                 S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol));
+                 symp->sy_value.X_add_symbol = add_symbol;
                  symp->sy_value.X_add_number = final_val;
                  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;
                }
              final_val = 0;
-             resolved = add_symbol->sy_resolved;
+             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 = add_symbol->sy_resolved;
+         resolved = symbol_resolved_p (add_symbol);
          break;
 
        case O_uminus:
        case O_bit_not:
        case O_logical_not:
          break;
 
        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;
@@ -753,10 +1061,8 @@ 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 = add_symbol->sy_resolved;
+         resolved = symbol_resolved_p (add_symbol);
          break;
 
        case O_multiply:
          break;
 
        case O_multiply:
@@ -778,96 +1084,76 @@ 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)
-             && 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;
 
                  if (expr_symbol_where (symp, &file, &line))
                {
                  char *file;
                  unsigned int line;
 
                  if (expr_symbol_where (symp, &file, &line))
-                   as_bad_where (file, line, "division by zero");
+                   as_bad_where (file, line, _("division by zero"));
                  else
                  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));
                }
 
@@ -887,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;
@@ -900,9 +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;
-         resolved = (add_symbol->sy_resolved && op_symbol->sy_resolved);
-         break;
+           {
+             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;
 
        case O_register:
        case O_big:
 
        case O_register:
        case O_big:
@@ -918,21 +1220,28 @@ resolve_symbol_value (symp, finalize)
       symp->sy_resolving = 0;
     }
 
       symp->sy_resolving = 0;
     }
 
-  if (finalize)
-    {
-      S_SET_VALUE (symp, final_val);
-      S_SET_SEGMENT (symp, final_seg);
-    }
+  if (finalize_syms)
+    S_SET_VALUE (symp, final_val);
 
 exit_dont_set_value:
 
 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))
+#endif
+    S_SET_SEGMENT (symp, final_seg);
+
   /* 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;
        }
     }
@@ -940,6 +1249,31 @@ exit_dont_set_value:
   return final_val;
 }
 
   return final_val;
 }
 
+#ifdef BFD_ASSEMBLER
+
+static void resolve_local_symbol (const char *, PTR);
+
+/* A static function passed to hash_traverse.  */
+
+static void
+resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)
+{
+  if (value != NULL)
+    resolve_symbol_value (value);
+}
+
+#endif
+
+/* Resolve all local symbols.  */
+
+void
+resolve_local_symbol_values (void)
+{
+#ifdef BFD_ASSEMBLER
+  hash_traverse (local_hash, resolve_local_symbol);
+#endif
+}
+
 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
    They are *really* local.  That is, they go out of scope whenever we see a
    label that isn't local.  Also, like fb labels, there can be multiple
 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
    They are *really* local.  That is, they go out of scope whenever we see a
    label that isn't local.  Also, like fb labels, there can be multiple
@@ -950,12 +1284,11 @@ exit_dont_set_value:
 static long *dollar_labels;
 static long *dollar_label_instances;
 static char *dollar_label_defines;
 static long *dollar_labels;
 static long *dollar_label_instances;
 static char *dollar_label_defines;
-static long dollar_label_count;
+static unsigned long dollar_label_count;
 static unsigned long dollar_label_max;
 
 static unsigned long dollar_label_max;
 
-int 
-dollar_label_defined (label)
-     long label;
+int
+dollar_label_defined (long label)
 {
   long *i;
 
 {
   long *i;
 
@@ -965,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;
 
@@ -981,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;
 
@@ -1008,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)
     {
@@ -1026,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;
@@ -1034,39 +1365,38 @@ 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);
   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)
     {
@@ -1076,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)
     {
@@ -1087,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)
 
@@ -1117,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.  */
 
 
-/* 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;
 
 {
   long *i;
 
@@ -1148,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)
     {
@@ -1169,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;
 
@@ -1195,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
@@ -1204,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)
     {
@@ -1245,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)
     {
@@ -1256,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 (*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 (*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);
 
@@ -1302,25 +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)
 {
 {
-  if (!s->sy_resolved && s->sy_value.X_op != O_constant)
-    resolve_symbol_value (s, 1);
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (s))
+    return resolve_symbol_value (s);
+#endif
+
+  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;
     }
@@ -1330,19 +1670,29 @@ 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))
+    {
+      ((struct local_symbol *) s)->lsy_value = val;
+      return;
+    }
+#endif
+
   s->sy_value.X_op = O_constant;
   s->sy_value.X_add_number = (offsetT) val;
   s->sy_value.X_unsigned = 0;
 }
 
 void
   s->sy_value.X_op = O_constant;
   s->sy_value.X_add_number = (offsetT) val;
   s->sy_value.X_unsigned = 0;
 }
 
 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 (src))
+    src = local_symbol_convert ((struct local_symbol *) src);
+
 #ifdef BFD_ASSEMBLER
   /* In an expression, transfer the settings of these flags.
      The user can override later, of course.  */
 #ifdef BFD_ASSEMBLER
   /* In an expression, transfer the settings of these flags.
      The user can override later, of course.  */
@@ -1358,12 +1708,29 @@ copy_symbol_attributes (dest, src)
 #ifdef BFD_ASSEMBLER
 
 int
 #ifdef BFD_ASSEMBLER
 
 int
-S_IS_EXTERNAL (s)
-     symbolS *s;
+S_IS_FUNCTION (symbolS *s)
+{
+  flagword flags;
+
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+
+  flags = s->bsym->flags;
+
+  return (flags & BSF_FUNCTION) != 0;
+}
+
+int
+S_IS_EXTERNAL (symbolS *s)
 {
 {
-  flagword flags = s->bsym->flags;
+  flagword flags;
 
 
-  /* sanity check */
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+
+  flags = s->bsym->flags;
+
+  /* Sanity check.  */
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
@@ -1371,43 +1738,73 @@ S_IS_EXTERNAL (s)
 }
 
 int
 }
 
 int
-S_IS_WEAK (s)
-     symbolS *s;
+S_IS_WEAK (symbolS *s)
 {
 {
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
   return (s->bsym->flags & BSF_WEAK) != 0;
 }
 
 int
   return (s->bsym->flags & BSF_WEAK) != 0;
 }
 
 int
-S_IS_COMMON (s)
-     symbolS *s;
+S_IS_COMMON (symbolS *s)
 {
 {
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
   return bfd_is_com_section (s->bsym->section);
 }
 
 int
   return bfd_is_com_section (s->bsym->section);
 }
 
 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;
 }
 
   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 (s->bsym->flags & BSF_DEBUGGING)
     return 1;
   return 0;
 }
 
 int
   if (s->bsym->flags & BSF_DEBUGGING)
     return 1;
   return 0;
 }
 
 int
-S_IS_LOCAL (s)
-     symbolS *s;
+S_IS_LOCAL (symbolS *s)
 {
 {
-  flagword flags = s->bsym->flags;
+  flagword flags;
   const char *name;
 
   const char *name;
 
-  /* sanity check */
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 1;
+
+  flags = s->bsym->flags;
+
+  /* Sanity check.  */
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
     abort ();
 
@@ -1422,8 +1819,8 @@ S_IS_LOCAL (s)
   name = S_GET_NAME (s);
   return (name != NULL
          && ! S_IS_DEBUG (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
              || (! flag_keep_locals
                  && (bfd_is_local_label (stdoutput, s->bsym)
                      || (flag_mri
@@ -1432,100 +1829,499 @@ 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;
   return s->bsym->name;
 }
 
 segT
   return s->bsym->name;
 }
 
 segT
-S_GET_SEGMENT (s)
-     symbolS *s;
+S_GET_SEGMENT (symbolS *s)
 {
 {
+  if (LOCAL_SYMBOL_CHECK (s))
+    return ((struct local_symbol *) s)->lsy_section;
   return s->bsym->section;
 }
 
 void
   return s->bsym->section;
 }
 
 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
      shouldn't happen anyway.  */
 
 {
   /* Don't reassign section symbols.  The direct reason is to prevent seg
      faults assigning back to const global symbols such as *ABS*, but it
      shouldn't happen anyway.  */
 
+  if (LOCAL_SYMBOL_CHECK (s))
+    {
+      if (seg == reg_section)
+       s = local_symbol_convert ((struct local_symbol *) s);
+      else
+       {
+         ((struct local_symbol *) s)->lsy_section = seg;
+         return;
+       }
+    }
+
   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 ((s->bsym->flags & BSF_WEAK) != 0)
     {
       /* Let .weak override .global.  */
       return;
     }
   if ((s->bsym->flags & BSF_WEAK) != 0)
     {
       /* 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 ((s->bsym->flags & BSF_WEAK) != 0)
     {
       /* Let .weak override.  */
       return;
     }
   s->bsym->flags |= BSF_LOCAL;
   if ((s->bsym->flags & BSF_WEAK) != 0)
     {
       /* Let .weak override.  */
       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;
   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))
+    {
+      ((struct local_symbol *) s)->lsy_name = name;
+      return;
+    }
   s->bsym->name = name;
 }
 #endif /* BFD_ASSEMBLER */
 
   s->bsym->name = name;
 }
 #endif /* BFD_ASSEMBLER */
 
+#ifdef SYMBOLS_NEED_BACKPOINTERS
+
+/* Return the previous symbol in a chain.  */
+
+symbolS *
+symbol_previous (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    abort ();
+  return s->sy_previous;
+}
+
+#endif /* SYMBOLS_NEED_BACKPOINTERS */
+
+/* Return the next symbol in a chain.  */
+
+symbolS *
+symbol_next (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    abort ();
+  return s->sy_next;
+}
+
+/* Return a pointer to the value of a symbol as an expression.  */
+
+expressionS *
+symbol_get_value_expression (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  return &s->sy_value;
+}
+
+/* Set the value of a symbol to an expression.  */
+
+void
+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 (symbolS *s, fragS *f)
+{
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (s))
+    {
+      local_symbol_set_frag ((struct local_symbol *) s, f);
+      return;
+    }
+#endif
+  s->sy_frag = f;
+}
+
+/* Return the frag of a symbol.  */
+
+fragS *
+symbol_get_frag (symbolS *s)
+{
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (s))
+    return local_symbol_get_frag ((struct local_symbol *) s);
+#endif
+  return s->sy_frag;
+}
+
+/* Mark a symbol as having been used.  */
+
 void
 void
-symbol_begin ()
+symbol_mark_used (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return;
+  s->sy_used = 1;
+}
+
+/* Clear the mark of whether a symbol has been used.  */
+
+void
+symbol_clear_used (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->sy_used = 0;
+}
+
+/* Return whether a symbol has been used.  */
+
+int
+symbol_used_p (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 1;
+  return s->sy_used;
+}
+
+/* Mark a symbol as having been used in a reloc.  */
+
+void
+symbol_mark_used_in_reloc (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->sy_used_in_reloc = 1;
+}
+
+/* Clear the mark of whether a symbol has been used in a reloc.  */
+
+void
+symbol_clear_used_in_reloc (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return;
+  s->sy_used_in_reloc = 0;
+}
+
+/* Return whether a symbol has been used in a reloc.  */
+
+int
+symbol_used_in_reloc_p (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+  return s->sy_used_in_reloc;
+}
+
+/* Mark a symbol as an MRI common symbol.  */
+
+void
+symbol_mark_mri_common (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->sy_mri_common = 1;
+}
+
+/* Clear the mark of whether a symbol is an MRI common symbol.  */
+
+void
+symbol_clear_mri_common (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return;
+  s->sy_mri_common = 0;
+}
+
+/* Return whether a symbol is an MRI common symbol.  */
+
+int
+symbol_mri_common_p (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+  return s->sy_mri_common;
+}
+
+/* Mark a symbol as having been written.  */
+
+void
+symbol_mark_written (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return;
+  s->written = 1;
+}
+
+/* Clear the mark of whether a symbol has been written.  */
+
+void
+symbol_clear_written (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return;
+  s->written = 0;
+}
+
+/* Return whether a symbol has been written.  */
+
+int
+symbol_written_p (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 0;
+  return s->written;
+}
+
+/* Mark a symbol has having been resolved.  */
+
+void
+symbol_mark_resolved (symbolS *s)
+{
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (s))
+    {
+      local_symbol_mark_resolved ((struct local_symbol *) s);
+      return;
+    }
+#endif
+  s->sy_resolved = 1;
+}
+
+/* Return whether a symbol has been resolved.  */
+
+int
+symbol_resolved_p (symbolS *s)
+{
+#ifdef BFD_ASSEMBLER
+  if (LOCAL_SYMBOL_CHECK (s))
+    return local_symbol_resolved_p ((struct local_symbol *) s);
+#endif
+  return s->sy_resolved;
+}
+
+/* Return whether a symbol is a section symbol.  */
+
+int
+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.  */
+  return 0;
+#endif
+}
+
+/* Return whether a symbol is equated to another symbol.  */
+
+int
+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 (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    return 1;
+  return s->sy_value.X_op == O_constant;
+}
+
+#ifdef BFD_ASSEMBLER
+
+/* Return the BFD symbol for a symbol.  */
+
+asymbol *
+symbol_get_bfdsym (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  return s->bsym;
+}
+
+/* Set the BFD symbol for a symbol.  */
+
+void
+symbol_set_bfdsym (symbolS *s, asymbol *bsym)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->bsym = bsym;
+}
+
+#endif /* BFD_ASSEMBLER */
+
+#ifdef OBJ_SYMFIELD_TYPE
+
+/* Get a pointer to the object format information for a symbol.  */
+
+OBJ_SYMFIELD_TYPE *
+symbol_get_obj (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  return &s->sy_obj;
+}
+
+/* Set the object format information for a symbol.  */
+
+void
+symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->sy_obj = *o;
+}
+
+#endif /* OBJ_SYMFIELD_TYPE */
+
+#ifdef TC_SYMFIELD_TYPE
+
+/* Get a pointer to the processor information for a symbol.  */
+
+TC_SYMFIELD_TYPE *
+symbol_get_tc (symbolS *s)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  return &s->sy_tc;
+}
+
+/* Set the processor information for a symbol.  */
+
+void
+symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
+{
+  if (LOCAL_SYMBOL_CHECK (s))
+    s = local_symbol_convert ((struct local_symbol *) s);
+  s->sy_tc = *o;
+}
+
+#endif /* TC_SYMFIELD_TYPE */
+
+void
+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 ();
   sy_hash = hash_new ();
+#ifdef BFD_ASSEMBLER
+  local_hash = hash_new ();
+#endif
 
   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
 #ifdef BFD_ASSEMBLER
 
   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
 #ifdef BFD_ASSEMBLER
@@ -1533,7 +2329,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;
@@ -1542,14 +2338,17 @@ symbol_begin ()
   if (LOCAL_LABELS_FB)
     fb_label_init ();
 }
   if (LOCAL_LABELS_FB)
     fb_label_init ();
 }
-
 \f
 int indent_level;
 
 \f
 int indent_level;
 
+/* Maximum indent level.
+   Available for modification inside a gdb session.  */
+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, "");
 }
@@ -1557,48 +2356,69 @@ 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])
     name = "(unnamed)";
   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
 {
   const char *name = S_GET_NAME (sym);
   if (!name || !name[0])
     name = "(unnamed)";
   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
-  if (sym->sy_frag != &zero_address_frag)
-    fprintf (file, " frag %lx", (long) sym->sy_frag);
-  if (sym->written)
-    fprintf (file, " written");
-  if (sym->sy_resolved)
-    fprintf (file, " resolved");
-  else if (sym->sy_resolving)
-    fprintf (file, " resolving");
-  if (sym->sy_used_in_reloc)
-    fprintf (file, " used-in-reloc");
-  if (sym->sy_used)
-    fprintf (file, " used");
-  if (S_IS_LOCAL (sym))
-    fprintf (file, " local");
-  if (S_IS_EXTERN (sym))
-    fprintf (file, " extern");
-  if (S_IS_DEBUG (sym))
-    fprintf (file, " debug");
-  if (S_IS_DEFINED (sym))
-    fprintf (file, " defined");
+
+  if (LOCAL_SYMBOL_CHECK (sym))
+    {
+#ifdef BFD_ASSEMBLER
+      struct local_symbol *locsym = (struct local_symbol *) sym;
+      if (local_symbol_get_frag (locsym) != &zero_address_frag
+         && local_symbol_get_frag (locsym) != NULL)
+       fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
+      if (local_symbol_resolved_p (locsym))
+       fprintf (file, " resolved");
+      fprintf (file, " local");
+#endif
+    }
+  else
+    {
+      if (sym->sy_frag != &zero_address_frag)
+       fprintf (file, " frag %lx", (long) sym->sy_frag);
+      if (sym->written)
+       fprintf (file, " written");
+      if (sym->sy_resolved)
+       fprintf (file, " resolved");
+      else if (sym->sy_resolving)
+       fprintf (file, " resolving");
+      if (sym->sy_used_in_reloc)
+       fprintf (file, " used-in-reloc");
+      if (sym->sy_used)
+       fprintf (file, " used");
+      if (S_IS_LOCAL (sym))
+       fprintf (file, " local");
+      if (S_IS_EXTERN (sym))
+       fprintf (file, " extern");
+      if (S_IS_DEBUG (sym))
+       fprintf (file, " debug");
+      if (S_IS_DEFINED (sym))
+       fprintf (file, " defined");
+    }
   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
-  if (sym->sy_resolved)
+  if (symbol_resolved_p (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));
     }
        fprintf (file, " %lx", (long) S_GET_VALUE (sym));
     }
-  else if (indent_level < 8 && S_GET_SEGMENT (sym) != undefined_section)
+  else if (indent_level < max_indent_level
+          && S_GET_SEGMENT (sym) != undefined_section)
     {
       indent_level++;
       fprintf (file, "\n%*s<", indent_level * 4, "");
     {
       indent_level++;
       fprintf (file, "\n%*s<", indent_level * 4, "");
-      print_expr_1 (file, &sym->sy_value);
+#ifdef BFD_ASSEMBLER
+      if (LOCAL_SYMBOL_CHECK (sym))
+       fprintf (file, "constant %lx",
+                (long) ((struct local_symbol *) sym)->lsy_value);
+      else
+#endif
+       print_expr_1 (file, &sym->sy_value);
       fprintf (file, ">");
       indent_level--;
     }
       fprintf (file, ">");
       indent_level--;
     }
@@ -1606,18 +2426,27 @@ 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);
   fprintf (stderr, "\n");
 }
 
 {
   indent_level = 0;
   print_symbol_value_1 (stderr, sym);
   fprintf (stderr, "\n");
 }
 
+static void
+print_binary (FILE *file, const char *name, expressionS *exp)
+{
+  indent_level++;
+  fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
+  print_symbol_value_1 (file, exp->X_add_symbol);
+  fprintf (file, ">\n%*s<", indent_level * 4, "");
+  print_symbol_value_1 (file, exp->X_op_symbol);
+  fprintf (file, ">");
+  indent_level--;
+}
+
 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)
@@ -1658,52 +2487,52 @@ print_expr_1 (file, exp)
       fprintf (file, "bit_not");
       break;
     case O_multiply:
       fprintf (file, "bit_not");
       break;
     case O_multiply:
-      fprintf (file, "multiply");
+      print_binary (file, "multiply", exp);
       break;
     case O_divide:
       break;
     case O_divide:
-      fprintf (file, "divide");
+      print_binary (file, "divide", exp);
       break;
     case O_modulus:
       break;
     case O_modulus:
-      fprintf (file, "modulus");
+      print_binary (file, "modulus", exp);
       break;
     case O_left_shift:
       break;
     case O_left_shift:
-      fprintf (file, "lshift");
+      print_binary (file, "lshift", exp);
       break;
     case O_right_shift:
       break;
     case O_right_shift:
-      fprintf (file, "rshift");
+      print_binary (file, "rshift", exp);
       break;
     case O_bit_inclusive_or:
       break;
     case O_bit_inclusive_or:
-      fprintf (file, "bit_ior");
+      print_binary (file, "bit_ior", exp);
       break;
     case O_bit_exclusive_or:
       break;
     case O_bit_exclusive_or:
-      fprintf (file, "bit_xor");
+      print_binary (file, "bit_xor", exp);
       break;
     case O_bit_and:
       break;
     case O_bit_and:
-      fprintf (file, "bit_and");
+      print_binary (file, "bit_and", exp);
       break;
     case O_eq:
       break;
     case O_eq:
-      fprintf (file, "eq");
+      print_binary (file, "eq", exp);
       break;
     case O_ne:
       break;
     case O_ne:
-      fprintf (file, "ne");
+      print_binary (file, "ne", exp);
       break;
     case O_lt:
       break;
     case O_lt:
-      fprintf (file, "lt");
+      print_binary (file, "lt", exp);
       break;
     case O_le:
       break;
     case O_le:
-      fprintf (file, "le");
+      print_binary (file, "le", exp);
       break;
     case O_ge:
       break;
     case O_ge:
-      fprintf (file, "ge");
+      print_binary (file, "ge", exp);
       break;
     case O_gt:
       break;
     case O_gt:
-      fprintf (file, "gt");
+      print_binary (file, "gt", exp);
       break;
     case O_logical_and:
       break;
     case O_logical_and:
-      fprintf (file, "logical_and");
+      print_binary (file, "logical_and", exp);
       break;
     case O_logical_or:
       break;
     case O_logical_or:
-      fprintf (file, "logical_or");
+      print_binary (file, "logical_or", exp);
       break;
     case O_add:
       indent_level++;
       break;
     case O_add:
       indent_level++;
@@ -1729,18 +2558,19 @@ 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);
 {
   hash_print_statistics (file, "symbol table", sy_hash);
+#ifdef BFD_ASSEMBLER
+  hash_print_statistics (file, "mini local symbol table", local_hash);
+  fprintf (file, "%lu mini local symbols created, %lu converted\n",
+          local_symbol_count, local_symbol_conversion_count);
+#endif
 }
 }
-
-/* end of symbols.c */
This page took 0.054754 seconds and 4 git commands to generate.