/* symbols.c -symbol table-

   Copyright (C) 1987-2023 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   GAS is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with GAS; see the file COPYING.  If not, write to the Free

   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* #define DEBUG_SYMS / * to debug symbol list maintenance.  */

#include "as.h"

#include "safe-ctype.h"

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

#include "subsegs.h"

#include "write.h"

#include <limits.h>

#ifndef CHAR_BIT

#define CHAR_BIT 8

#endif

struct symbol_flags

{

  /* Whether the symbol is a local_symbol.  */

  unsigned int local_symbol : 1;

  /* Weather symbol has been written.  */

  unsigned int written : 1;

  /* Whether symbol value has been completely resolved (used during

     final pass over symbol table).  */

  unsigned int resolved : 1;

  /* Whether the symbol value is currently being resolved (used to

     detect loops in symbol dependencies).  */

  unsigned int resolving : 1;

  /* Whether the symbol value is used in a reloc.  This is used to

     ensure that symbols used in relocs are written out, even if they

     are local and would otherwise not be.  */

  unsigned int used_in_reloc : 1;

  /* Whether the symbol is used as an operand or in an expression.

     NOTE:  Not all the backends keep this information accurate;

     backends which use this bit are responsible for setting it when

     a symbol is used in backend routines.  */

  unsigned int used : 1;

  /* Whether the symbol can be re-defined.  */

  unsigned int volatil : 1;

  /* Whether the symbol is a forward reference, and whether such has

     been determined.  */

  unsigned int forward_ref : 1;

  unsigned int forward_resolved : 1;

  /* This is set if the symbol is defined in an MRI common section.

     We handle such sections as single common symbols, so symbols

     defined within them must be treated specially by the relocation

     routines.  */

  unsigned int mri_common : 1;

  /* This is set if the symbol is set with a .weakref directive.  */

  unsigned int weakrefr : 1;

  /* This is set when the symbol is referenced as part of a .weakref

     directive, but only if the symbol was not in the symbol table

     before.  It is cleared as soon as any direct reference to the

     symbol is present.  */

  unsigned int weakrefd : 1;

  /* Whether the symbol has been marked to be removed by a .symver

     directive.  */

  unsigned int removed : 1;

  /* Set when a warning about the symbol containing multibyte characters

     is generated.  */

  unsigned int multibyte_warned : 1;

};

/* A pointer in the symbol may point to either a complete symbol

   (struct symbol below) or to a local symbol (struct local_symbol

   defined here).  The symbol code can detect the case by examining

   the first field which is present in both structs.

   We do this because we ordinarily only need a small amount of

   information for a local symbol.  The symbol table takes up a lot of

   space, and storing less information for a local symbol can make a

   big difference in assembler memory usage when assembling a large

   file.  */

struct local_symbol

{

  /* Symbol flags.  Only local_symbol and resolved are relevant.  */

  struct symbol_flags flags;

  /* Hash value calculated from name.  */

  hashval_t hash;

  /* The symbol name.  */

  const char *name;

  /* The symbol frag.  */

  fragS *frag;

  /* The symbol section.  */

  asection *section;

  /* The value of the symbol.  */

  valueT value;

};

/* The information we keep for a symbol.  The symbol table holds

   pointers both to this and to local_symbol structures.  The first

   three fields must be identical to struct local_symbol, and the size

   should be the same as or smaller than struct local_symbol.

   Fields that don't fit go to an extension structure.  */

struct symbol

{

  /* Symbol flags.  */

  struct symbol_flags flags;

  /* Hash value calculated from name.  */

  hashval_t hash;

  /* The symbol name.  */

  const char *name;

  /* Pointer to the frag this symbol is attached to, if any.

     Otherwise, NULL.  */

  fragS *frag;

  /* BFD symbol */

  asymbol *bsym;

  /* Extra symbol fields that won't fit.  */

  struct xsymbol *x;

};

/* Extra fields to make up a full symbol.  */

struct xsymbol

{

  /* The value of the symbol.  */

  expressionS value;

  /* Forwards and backwards chain pointers.  */

  struct symbol *next;

  struct symbol *previous;

#ifdef OBJ_SYMFIELD_TYPE

  OBJ_SYMFIELD_TYPE obj;

#endif

#ifdef TC_SYMFIELD_TYPE

  TC_SYMFIELD_TYPE tc;

#endif

};

typedef union symbol_entry

{

  struct local_symbol lsy;

  struct symbol sy;

} symbol_entry_t;

/* Hash function for a symbol_entry.  */

static hashval_t

hash_symbol_entry (const void *e)

{

  symbol_entry_t *entry = (symbol_entry_t *) e;

  if (entry->sy.hash == 0)

    entry->sy.hash = htab_hash_string (entry->sy.name);

  return entry->sy.hash;

}

/* Equality function for a symbol_entry.  */

static int

eq_symbol_entry (const void *a, const void *b)

{

  const symbol_entry_t *ea = (const symbol_entry_t *) a;

  const symbol_entry_t *eb = (const symbol_entry_t *) b;

  return (ea->sy.hash == eb->sy.hash

    && strcmp (ea->sy.name, eb->sy.name) == 0);

}

static void *

symbol_entry_find (htab_t table, const char *name)

{

  hashval_t hash = htab_hash_string (name);

  symbol_entry_t needle = { { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

            hash, name, 0, 0, 0 } };

  return htab_find_with_hash (table, &needle, hash);

}

/* This is non-zero if symbols are case sensitive, which is the

   default.  */

int symbols_case_sensitive = 1;

#ifndef WORKING_DOT_WORD

extern int new_broken_words;

#endif

static htab_t sy_hash;

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

symbolS *symbol_rootP;

symbolS *symbol_lastP;

symbolS abs_symbol;

struct xsymbol abs_symbol_x;

symbolS dot_symbol;

struct xsymbol dot_symbol_x;

#ifdef DEBUG_SYMS

#define debug_verify_symchain verify_symbol_chain

#else

#define debug_verify_symchain(root, last) ((void) 0)

#endif

#define DOLLAR_LABEL_CHAR '\001'

#define LOCAL_LABEL_CHAR  '\002'

#ifndef TC_LABEL_IS_LOCAL

#define TC_LABEL_IS_LOCAL(name) 0

#endif

struct obstack notes;

/* Utility functions to allocate and duplicate memory on the notes

   obstack, each like the corresponding function without "notes_"

   prefix.  All of these exit on an allocation failure.  */

void *

notes_alloc (size_t size)

{

  return obstack_alloc (&notes, size);

}

void *

notes_calloc (size_t n, size_t size)

{

  size_t amt;

  void *ret;

  if (gas_mul_overflow (n, size, &amt))

    {

      obstack_alloc_failed_handler ();

      abort ();

    }

  ret = notes_alloc (amt);

  memset (ret, 0, amt);

  return ret;

}

void *

notes_memdup (const void *src, size_t copy_size, size_t alloc_size)

{

  void *ret = obstack_alloc (&notes, alloc_size);

  memcpy (ret, src, copy_size);

  if (alloc_size > copy_size)

    memset ((char *) ret + copy_size, 0, alloc_size - copy_size);

  return ret;

}

char *

notes_strdup (const char *str)

{

  size_t len = strlen (str) + 1;

  return notes_memdup (str, len, len);

}

char *

notes_concat (const char *first, ...)

{

  va_list args;

  const char *str;

  va_start (args, first);

  for (str = first; str; str = va_arg (args, const char *))

    {

      size_t size = strlen (str);

      obstack_grow (&notes, str, size);

    }

  va_end (args);

  obstack_1grow (&notes, 0);

  return obstack_finish (&notes);

}

/* Use with caution!  Frees PTR and all more recently allocated memory

   on the notes obstack.  */

void

notes_free (void *ptr)

{

  obstack_free (&notes, ptr);

}

#ifdef TE_PE

/* The name of an external symbol which is

   used to make weak PE symbol names unique.  */

const char * an_external_name;

#endif

/* Return a pointer to a new symbol.  Die if we can't make a new

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

   chain.

   This function should be called in the general case of creating a

   symbol.  However, if the output file symbol table has already been

   set, and you are certain that this symbol won't be wanted in the

   output file, you can call symbol_create.  */

symbolS *

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

{

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

  /* Link to end of symbol chain.  */

  symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);

  return symbolP;

}

/* Save a symbol name on a permanent obstack, and convert it according

   to the object file format.  */

static const char *

save_symbol_name (const char *name)

{

  char *ret;

  gas_assert (name != NULL);

  ret = notes_strdup (name);

#ifdef tc_canonicalize_symbol_name

  ret = tc_canonicalize_symbol_name (ret);

#endif

  if (! symbols_case_sensitive)

    {

      char *s;

      for (s = ret; *s != '\0'; s++)

  *s = TOUPPER (*s);

    }

  return ret;

}

static void

symbol_init (symbolS *symbolP, const char *name, asection *sec,

       fragS *frag, valueT valu)

{

  symbolP->frag = frag;

  symbolP->bsym = bfd_make_empty_symbol (stdoutput);

  if (symbolP->bsym == NULL)

    as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));

  symbolP->bsym->name = name;

  symbolP->bsym->section = sec;

  if (multibyte_handling == multibyte_warn_syms

      && ! symbolP->flags.local_symbol

      && sec != undefined_section

      && ! symbolP->flags.multibyte_warned

      && scan_for_multibyte_characters ((const unsigned char *) name,

          (const unsigned char *) name + strlen (name),

          false /* Do not warn.  */))

    {

      as_warn (_("symbol '%s' contains multibyte characters"), name);

      symbolP->flags.multibyte_warned = 1;

    }

  S_SET_VALUE (symbolP, valu);

  if (sec == reg_section)

    symbolP->x->value.X_op = O_register;

  symbol_clear_list_pointers (symbolP);

  obj_symbol_new_hook (symbolP);

#ifdef tc_symbol_new_hook

  tc_symbol_new_hook (symbolP);

#endif

}

/* Create a symbol.  NAME is copied, the caller can destroy/modify.  */

symbolS *

symbol_create (const char *name, segT segment, fragS *frag, valueT valu)

{

  const char *preserved_copy_of_name;

  symbolS *symbolP;

  size_t size;

  preserved_copy_of_name = save_symbol_name (name);

  size = sizeof (symbolS) + sizeof (struct xsymbol);

  symbolP = notes_alloc (size);

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

  memset (symbolP, 0, size);

  symbolP->name = preserved_copy_of_name;

  symbolP->x = (struct xsymbol *) (symbolP + 1);

  symbol_init (symbolP, preserved_copy_of_name, segment, frag, valu);

  return symbolP;

}

/* Local symbol support.  If we can get away with it, we keep only a

   small amount of information for local symbols.  */

/* Used for statistics.  */

static unsigned long local_symbol_count;

static unsigned long local_symbol_conversion_count;

/* Create a local symbol and insert it into the local hash table.  */

struct local_symbol *

local_symbol_make (const char *name, segT section, fragS *frag, valueT val)

{

  const char *name_copy;

  struct local_symbol *ret;

  struct symbol_flags flags = { .local_symbol = 1, .resolved = 0 };

  ++local_symbol_count;

  name_copy = save_symbol_name (name);

  ret = notes_alloc (sizeof *ret);

  ret->flags = flags;

  ret->hash = 0;

  ret->name = name_copy;

  ret->frag = frag;

  ret->section = section;

  ret->value = val;

  htab_insert (sy_hash, ret, 1);

  return ret;

}

/* Convert a local symbol into a real symbol.  */

static symbolS *

local_symbol_convert (void *sym)

{

  symbol_entry_t *ent = (symbol_entry_t *) sym;

  struct xsymbol *xtra;

  valueT val;

  gas_assert (ent->lsy.flags.local_symbol);

  ++local_symbol_conversion_count;

  xtra = notes_alloc (sizeof (*xtra));

  memset (xtra, 0, sizeof (*xtra));

  val = ent->lsy.value;

  ent->sy.x = xtra;

  /* Local symbols are always either defined or used.  */

  ent->sy.flags.used = 1;

  ent->sy.flags.local_symbol = 0;

  symbol_init (&ent->sy, ent->lsy.name, ent->lsy.section, ent->lsy.frag, val);

  symbol_append (&ent->sy, symbol_lastP, &symbol_rootP, &symbol_lastP);

  return &ent->sy;

}

static void

define_sym_at_dot (symbolS *symbolP)

{

  symbolP->frag = frag_now;

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

  S_SET_SEGMENT (symbolP, now_seg);

}

/* We have just seen "<name>:".

   Creates a struct symbol unless it already exists.

   Gripes if we are redefining a symbol incompatibly (and ignores it).  */

symbolS *

colon (/* Just seen "x:" - rattle symbols & frags.  */

       const char *sym_name /* Symbol name, as a canonical string.  */

       /* We copy this string: OK to alter later.  */)

{

  symbolS *symbolP; /* Symbol we are working with.  */

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

     defined.  */

  if (LOCAL_LABELS_DOLLAR

      && !bfd_is_local_label_name (stdoutput, sym_name))

    dollar_label_clear ();

#ifndef WORKING_DOT_WORD

  if (new_broken_words)

    {

      struct broken_word *a;

      int possible_bytes;

      fragS *frag_tmp;

      char *frag_opcode;

      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);

      frag_tmp = frag_now;

      frag_opcode = frag_var (rs_broken_word,

            possible_bytes,

            possible_bytes,

            (relax_substateT) 0,

            (symbolS *) broken_words,

            (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.  */

      while (frag_tmp

       && (frag_tmp->fr_type != rs_broken_word

     || frag_tmp->fr_opcode))

  frag_tmp = frag_tmp->fr_next;

      know (frag_tmp);

      frag_tmp->fr_opcode = frag_opcode;

      new_broken_words = 0;

      for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)

  a->dispfrag = frag_tmp;

    }

#endif /* WORKING_DOT_WORD */

#ifdef obj_frob_colon

  obj_frob_colon (sym_name);

#endif

  if ((symbolP = symbol_find (sym_name)) != 0)

    {

      S_CLEAR_WEAKREFR (symbolP);

#ifdef RESOLVE_SYMBOL_REDEFINITION

      if (RESOLVE_SYMBOL_REDEFINITION (symbolP))

  return symbolP;

#endif

      /* Now check for undefined symbols.  */

      if (symbolP->flags.local_symbol)

  {

    struct local_symbol *locsym = (struct local_symbol *) symbolP;

    if (locsym->section != undefined_section

        && (locsym->frag != frag_now

      || locsym->section != now_seg

      || locsym->value != frag_now_fix ()))

      {

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

        return symbolP;

      }

    locsym->section = now_seg;

    locsym->frag = frag_now;

    locsym->value = frag_now_fix ();

  }

      else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))

         || S_IS_COMMON (symbolP)

         || S_IS_VOLATILE (symbolP))

  {

    if (S_IS_VOLATILE (symbolP))

      {

        symbolP = symbol_clone (symbolP, 1);

        S_SET_VALUE (symbolP, 0);

        S_CLEAR_VOLATILE (symbolP);

      }

    if (S_GET_VALUE (symbolP) == 0)

      {

        define_sym_at_dot (symbolP);

#ifdef N_UNDF

        know (N_UNDF == 0);

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

      }

    else

      {

        /* There are still several cases to check:

     A .comm/.lcomm symbol being redefined as initialized

     data is OK

     A .comm/.lcomm symbol being redefined with a larger

     size is also OK

     This only used to be allowed on VMS gas, but Sun cc

     on the sparc also depends on it.  */

        if (((!S_IS_DEBUG (symbolP)

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

        && S_IS_EXTERNAL (symbolP))

       || S_GET_SEGMENT (symbolP) == bss_section)

      && (now_seg == data_section

          || now_seg == bss_section

          || now_seg == S_GET_SEGMENT (symbolP)))

    {

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

      if (now_seg != data_section)

        {

          /* New .comm for prev .comm symbol.

       If the new size is larger we just change its

       value.  If the new size is smaller, we ignore

       this symbol.  */

          if (S_GET_VALUE (symbolP)

        < ((unsigned) frag_now_fix ()))

      {

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

      }

        }

      else

        {

          /* It is a .comm/.lcomm being converted to initialized

       data.  */

          define_sym_at_dot (symbolP);

        }

    }

        else

    {

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

      static const char *od_buf = "";

#else

      char od_buf[100];

      od_buf[0] = '\0';

      if (OUTPUT_FLAVOR == bfd_target_aout_flavour)

        sprintf (od_buf, "%d.%d.",

           S_GET_OTHER (symbolP),

           S_GET_DESC (symbolP));

#endif

      as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),

          sym_name,

          segment_name (S_GET_SEGMENT (symbolP)),

          od_buf,

          (long) S_GET_VALUE (symbolP));

    }

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

  }

      else

  {

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

    if (!(frag_now == symbolP->frag

    && S_GET_VALUE (symbolP) == frag_now_fix ()

    && S_GET_SEGMENT (symbolP) == now_seg))

      {

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

        symbolP = symbol_clone (symbolP, 0);

        define_sym_at_dot (symbolP);

      }

  }

    }

  else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))

    {

      symbolP = (symbolS *) local_symbol_make (sym_name, now_seg, frag_now,

                 frag_now_fix ());

    }

  else

    {

      symbolP = symbol_new (sym_name, now_seg, frag_now, frag_now_fix ());

      symbol_table_insert (symbolP);

    }

  if (mri_common_symbol != NULL)

    {

      /* This symbol is actually being defined within an MRI common

   section.  This requires special handling.  */

      if (symbolP->flags.local_symbol)

  symbolP = local_symbol_convert (symbolP);

      symbolP->x->value.X_op = O_symbol;

      symbolP->x->value.X_add_symbol = mri_common_symbol;

      symbolP->x->value.X_add_number = S_GET_VALUE (mri_common_symbol);

      symbolP->frag = &zero_address_frag;

      S_SET_SEGMENT (symbolP, expr_section);

      symbolP->flags.mri_common = 1;

    }

#ifdef tc_frob_label

  tc_frob_label (symbolP);

#endif

#ifdef obj_frob_label

  obj_frob_label (symbolP);

#endif

  return symbolP;

}

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

void

symbol_table_insert (symbolS *symbolP)

{

  know (symbolP);

  htab_insert (sy_hash, symbolP, 1);

}

/* If a symbol name does not exist, create it as undefined, and insert

   it into the symbol table.  Return a pointer to it.  */

symbolS *

symbol_find_or_make (const char *name)

{

  symbolS *symbolP;

  symbolP = symbol_find (name);

  if (symbolP == NULL)

    {

      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,

               &zero_address_frag, 0);

    return symbolP;

  }

      symbolP = symbol_make (name);

      symbol_table_insert (symbolP);

    }        /* if symbol wasn't found */

  return (symbolP);

}

symbolS *

symbol_make (const char *name)

{

  symbolS *symbolP;

  /* 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, &zero_address_frag, 0);

  return (symbolP);

}

symbolS *

symbol_clone (symbolS *orgsymP, int replace)

{

  symbolS *newsymP;

  asymbol *bsymorg, *bsymnew;

  /* Make sure we never clone the dot special symbol.  */

  gas_assert (orgsymP != &dot_symbol);

  /* When cloning a local symbol it isn't absolutely necessary to

     convert the original, but converting makes the code much

     simpler to cover this unexpected case.  As of 2020-08-21

     symbol_clone won't be called on a local symbol.  */

  if (orgsymP->flags.local_symbol)

    orgsymP = local_symbol_convert (orgsymP);

  bsymorg = orgsymP->bsym;

  newsymP = notes_alloc (sizeof (symbolS) + sizeof (struct xsymbol));

  *newsymP = *orgsymP;

  newsymP->x = (struct xsymbol *) (newsymP + 1);

  *newsymP->x = *orgsymP->x;

  bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));

  if (bsymnew == NULL)

    as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));

  newsymP->bsym = bsymnew;

  bsymnew->name = bsymorg->name;

  bsymnew->flags = bsymorg->flags & ~BSF_SECTION_SYM;

  bsymnew->section = bsymorg->section;

  bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,

        bfd_asymbol_bfd (bsymnew), bsymnew);

#ifdef obj_symbol_clone_hook

  obj_symbol_clone_hook (newsymP, orgsymP);

#endif

#ifdef tc_symbol_clone_hook

  tc_symbol_clone_hook (newsymP, orgsymP);

#endif

  if (replace)

    {

      if (symbol_rootP == orgsymP)

  symbol_rootP = newsymP;

      else if (orgsymP->x->previous)

  {

    orgsymP->x->previous->x->next = newsymP;

    orgsymP->x->previous = NULL;

  }

      if (symbol_lastP == orgsymP)

  symbol_lastP = newsymP;

      else if (orgsymP->x->next)

  orgsymP->x->next->x->previous = newsymP;

      /* Symbols that won't be output can't be external.  */

      S_CLEAR_EXTERNAL (orgsymP);

      orgsymP->x->previous = orgsymP->x->next = orgsymP;

      debug_verify_symchain (symbol_rootP, symbol_lastP);

      symbol_table_insert (newsymP);

    }

  else

    {

      /* Symbols that won't be output can't be external.  */

      S_CLEAR_EXTERNAL (newsymP);

      newsymP->x->previous = newsymP->x->next = newsymP;

    }

  return newsymP;

}

/* Referenced symbols, if they are forward references, need to be cloned

   (without replacing the original) so that the value of the referenced

   symbols at the point of use is saved by the clone.  */

#undef symbol_clone_if_forward_ref

symbolS *

symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)

{

  if (symbolP

      && !symbolP->flags.local_symbol

      && !symbolP->flags.forward_resolved)

    {

      symbolS *orig_add_symbol = symbolP->x->value.X_add_symbol;

      symbolS *orig_op_symbol = symbolP->x->value.X_op_symbol;

      symbolS *add_symbol = orig_add_symbol;

      symbolS *op_symbol = orig_op_symbol;

      if (symbolP->flags.forward_ref)

  is_forward = 1;

      if (is_forward)

  {

    /* assign_symbol() clones volatile symbols; pre-existing expressions

       hold references to the original instance, but want the current

       value.  Just repeat the lookup.  */

    if (add_symbol && S_IS_VOLATILE (add_symbol))

      add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));

    if (op_symbol && S_IS_VOLATILE (op_symbol))

      op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));

  }

      /* Re-using resolving here, as this routine cannot get called from

   symbol resolution code.  */

      if ((symbolP->bsym->section == expr_section

     || symbolP->flags.forward_ref)

    && !symbolP->flags.resolving)

  {

    symbolP->flags.resolving = 1;

    add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);

    op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);

    symbolP->flags.resolving = 0;

  }

      if (symbolP->flags.forward_ref

    || add_symbol != orig_add_symbol

    || op_symbol != orig_op_symbol)

  {

    if (symbolP != &dot_symbol)

      {

        symbolP = symbol_clone (symbolP, 0);

        symbolP->flags.resolving = 0;

      }

    else

      {

        symbolP = symbol_temp_new_now ();

#ifdef tc_new_dot_label

        tc_new_dot_label (symbolP);

#endif

      }

  }

      symbolP->x->value.X_add_symbol = add_symbol;

      symbolP->x->value.X_op_symbol = op_symbol;

      symbolP->flags.forward_resolved = 1;

    }

  return symbolP;

}

symbolS *

symbol_temp_new (segT seg, fragS *frag, valueT ofs)

{

  return symbol_new (FAKE_LABEL_NAME, seg, frag, ofs);

}

symbolS *

symbol_temp_new_now (void)

{

  return symbol_temp_new (now_seg, frag_now, frag_now_fix ());

}

symbolS *

symbol_temp_new_now_octets (void)

{

  return symbol_temp_new (now_seg, frag_now, frag_now_fix_octets ());

}

symbolS *

symbol_temp_make (void)

{

  return symbol_make (FAKE_LABEL_NAME);

}

/* Implement symbol table lookup.

   In:  A symbol's name as a string: '\0' can't be part of a symbol name.

   Out: NULL if the name was not in the symbol table, else the address

   of a struct symbol associated with that name.  */

symbolS *

symbol_find_exact (const char *name)

{

  return symbol_find_exact_noref (name, 0);

}

symbolS *

symbol_find_exact_noref (const char *name, int noref)

{

  symbolS *sym = symbol_entry_find (sy_hash, name);

  /* Any references to the symbol, except for the reference in

     .weakref, must clear this flag, such that the symbol does not

     turn into a weak symbol.  Note that we don't have to handle the

     local_symbol case, since a weakrefd is always promoted out of the

     local_symbol table when it is turned into a weak symbol.  */

  if (sym && ! noref)

    S_CLEAR_WEAKREFD (sym);

  return sym;

}

symbolS *

symbol_find (const char *name)

{

  return symbol_find_noref (name, 0);

}

symbolS *

symbol_find_noref (const char *name, int noref)

{

  symbolS * result;

  char * copy = NULL;

#ifdef tc_canonicalize_symbol_name

  {

    copy = xstrdup (name);

    name = tc_canonicalize_symbol_name (copy);

  }

#endif

  if (! symbols_case_sensitive)

    {

      const char *orig;

      char *copy2 = NULL;

      unsigned char c;

      orig = name;

      if (copy != NULL)

  copy2 = copy;

      name = copy = XNEWVEC (char, strlen (name) + 1);

      while ((c = *orig++) != '\0')

  *copy++ = TOUPPER (c);

      *copy = '\0';

      free (copy2);

      copy = (char *) name;

    }

  result = symbol_find_exact_noref (name, noref);

  free (copy);

  return result;

}

/* Once upon a time, symbols were kept in a singly linked list.  At

   least coff needs to be able to rearrange them from time to time, for

   which a doubly linked list is much more convenient.  Loic did these

   as macros which seemed dangerous to me so they're now functions.

   xoxorich.  */

/* Link symbol ADDME after symbol TARGET in the chain.  */

void

symbol_append (symbolS *addme, symbolS *target,

         symbolS **rootPP, symbolS **lastPP)

{

  extern int symbol_table_frozen;

  if (symbol_table_frozen)

    abort ();

  if (addme->flags.local_symbol)

    abort ();

  if (target != NULL && target->flags.local_symbol)

    abort ();

  if (target == NULL)

    {

      know (*rootPP == NULL);

      know (*lastPP == NULL);

      addme->x->next = NULL;

      addme->x->previous = NULL;

      *rootPP = addme;

      *lastPP = addme;

      return;

    }        /* if the list is empty  */

  if (target->x->next != NULL)

    {

      target->x->next->x->previous = addme;

    }

  else

    {

      know (*lastPP == target);

      *lastPP = addme;

    }        /* if we have a next  */

  addme->x->next = target->x->next;

  target->x->next = addme;

  addme->x->previous = target;

  debug_verify_symchain (symbol_rootP, symbol_lastP);

}