Subversion Repositories Kolibri OS

/* symbols.c -symbol table-

   Copyright (C) 1987-2015 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 "struc-symbol.h"

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

/* symbol-name => struct symbol pointer */

static struct hash_control *sy_hash;

/* 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 dot_symbol;

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

#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

static char *save_symbol_name (const char *);

static void fb_label_init (void);

static long dollar_label_instance (long);

static long fb_label_instance (long);

static void print_binary (FILE *, const char *, expressionS *);

/* 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, valueT valu, fragS *frag)

{

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

  /* Link to end of symbol chain.  */

  {

    extern int symbol_table_frozen;

    if (symbol_table_frozen)

      abort ();

  }

  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 char *

save_symbol_name (const char *name)

{

  size_t name_length;

  char *ret;

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

  obstack_grow (¬es, name, name_length);

  ret = (char *) obstack_finish (¬es);

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

}

symbolS *

symbol_create (const char *name, /* It is copied, the caller can destroy/modify.  */

	       segT segment,	/* Segment identifier (SEG_).  */

	       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 (¬es, sizeof (symbolS));

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

  memset (symbolP, 0, sizeof (symbolS));

  symbolP->bsym = bfd_make_empty_symbol (stdoutput);

  if (symbolP->bsym == NULL)

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

  S_SET_NAME (symbolP, preserved_copy_of_name);

  S_SET_SEGMENT (symbolP, segment);

  S_SET_VALUE (symbolP, valu);

  symbol_clear_list_pointers (symbolP);

  symbolP->sy_frag = frag;

  obj_symbol_new_hook (symbolP);

#ifdef tc_symbol_new_hook

  tc_symbol_new_hook (symbolP);

#endif

  return symbolP;

}

/* 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->sy_flags.sy_local_symbol 						\

   ? (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 val, fragS *frag)

{

  char *name_copy;

  struct local_symbol *ret;

  ++local_symbol_count;

  name_copy = save_symbol_name (name);

  ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);

  ret->lsy_flags.sy_local_symbol = 1;

  ret->lsy_flags.sy_resolved = 0;

  ret->lsy_name = name_copy;

  ret->lsy_section = section;

  local_symbol_set_frag (ret, frag);

  ret->lsy_value = val;

  hash_jam (local_hash, name_copy, (void *) 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;

  gas_assert (locsym->lsy_flags.sy_local_symbol);

  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_flags.sy_resolved = 1;

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

  ret->sy_flags.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;

}

static void

define_sym_at_dot (symbolS *symbolP)

{

  symbolP->sy_frag = frag_now;

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

  S_SET_SEGMENT (symbolP, now_seg);

}

/* We have just seen ":".

   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 cannonical 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 (LOCAL_SYMBOL_CHECK (symbolP))

	{

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

	}

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

     && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))

		  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->sy_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,

					       (valueT) frag_now_fix (),

					       frag_now);

    }

  else

    {

      symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),

			    frag_now);

      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 (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_frag = &zero_address_frag;

      S_SET_SEGMENT (symbolP, expr_section);

      symbolP->sy_flags.sy_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)

{

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

			       (void *) 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), (void *) symbolP)))

    {

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

		S_GET_NAME (symbolP), error_string);

    }				/* on error  */

}

/* 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,

						   (valueT) 0,

						   &zero_address_frag);

	  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, (valueT) 0, &zero_address_frag);

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

  /* Running local_symbol_convert on a clone that's not the one currently

     in local_hash would incorrectly replace the hash entry.  Thus the

     symbol must be converted here.  Note that the rest of the function

     depends on not encountering an unconverted symbol.  */

  if (LOCAL_SYMBOL_CHECK (orgsymP))

    orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);

  bsymorg = orgsymP->bsym;

  newsymP = (symbolS *) obstack_alloc (¬es, sizeof (*newsymP));

  *newsymP = *orgsymP;

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

	{

	  orgsymP->sy_previous->sy_next = newsymP;

	  orgsymP->sy_previous = NULL;

	}

      if (symbol_lastP == orgsymP)

	symbol_lastP = newsymP;

      else if (orgsymP->sy_next)

	orgsymP->sy_next->sy_previous = newsymP;

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

      S_CLEAR_EXTERNAL (orgsymP);

      orgsymP->sy_previous = orgsymP->sy_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->sy_previous = newsymP->sy_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 .  */

#undef symbol_clone_if_forward_ref

symbolS *

symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)

{

  if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))

    {

      symbolS *add_symbol = symbolP->sy_value.X_add_symbol;

      symbolS *op_symbol = symbolP->sy_value.X_op_symbol;

      if (symbolP->sy_flags.sy_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 sy_resolving here, as this routine cannot get called from

	 symbol resolution code.  */

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

           || symbolP->sy_flags.sy_forward_ref)

	  && !symbolP->sy_flags.sy_resolving)

	{

	  symbolP->sy_flags.sy_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->sy_flags.sy_resolving = 0;

	}

      if (symbolP->sy_flags.sy_forward_ref

	  || add_symbol != symbolP->sy_value.X_add_symbol

	  || op_symbol != symbolP->sy_value.X_op_symbol)

	{

	  if (symbolP != &dot_symbol)

	    {

	      symbolP = symbol_clone (symbolP, 0);

	      symbolP->sy_flags.sy_resolving = 0;

	    }

	  else

	    {

	      symbolP = symbol_temp_new_now ();

#ifdef tc_new_dot_label

	      tc_new_dot_label (symbolP);

#endif

	    }

	}

      symbolP->sy_value.X_add_symbol = add_symbol;

      symbolP->sy_value.X_op_symbol = op_symbol;

    }

  return symbolP;

}

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

}

/* 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)

{

  struct local_symbol *locsym;

  symbolS* sym;

  locsym = (struct local_symbol *) hash_find (local_hash, name);

  if (locsym != NULL)

    return (symbolS *) locsym;

  sym = ((symbolS *) hash_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)

{

#ifdef tc_canonicalize_symbol_name

  {

    char *copy;

    size_t len = strlen (name) + 1;

    copy = (char *) alloca (len);

    memcpy (copy, name, len);

    name = tc_canonicalize_symbol_name (copy);

  }

#endif

  if (! symbols_case_sensitive)

    {

      char *copy;

      const char *orig;

      unsigned char c;

      orig = name;

      name = copy = (char *) alloca (strlen (name) + 1);

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

	{

	  *copy++ = TOUPPER (c);

	}

      *copy = '\0';

    }

  return symbol_find_exact_noref (name, noref);

}

/* 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)

{

  if (LOCAL_SYMBOL_CHECK (addme))

    abort ();

  if (target != NULL && LOCAL_SYMBOL_CHECK (target))

    abort ();

  if (target == NULL)

    {

      know (*rootPP == NULL);

      know (*lastPP == NULL);

      addme->sy_next = NULL;

      addme->sy_previous = NULL;

      *rootPP = addme;

      *lastPP = addme;

      return;

    }				/* if the list is empty  */

  if (target->sy_next != NULL)

    {

      target->sy_next->sy_previous = addme;

    }

  else

    {

      know (*lastPP == target);

      *lastPP = addme;

    }				/* if we have a next  */

  addme->sy_next = target->sy_next;

  target->sy_next = addme;

  addme->sy_previous = target;

  debug_verify_symchain (symbol_rootP, symbol_lastP);

}

/* 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;

  symbolP->sy_previous = NULL;

}

/* 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 it was the root  */

  if (symbolP == *lastPP)

    {

      *lastPP = symbolP->sy_previous;

    }				/* if it was the tail  */

  if (symbolP->sy_next != NULL)

    {

      symbolP->sy_next->sy_previous = symbolP->sy_previous;

    }				/* if not last  */

  if (symbolP->sy_previous != NULL)

    {

      symbolP->sy_previous->sy_next = symbolP->sy_next;

    }				/* if not first  */

  debug_verify_symchain (*rootPP, *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;

    }

  else

    {

      know (*rootPP == target);

      *rootPP = addme;

    }				/* if not first  */

  addme->sy_previous = target->sy_previous;

  target->sy_previous = addme;

  addme->sy_next = target;

  debug_verify_symchain (*rootPP, *lastPP);

}

void

verify_symbol_chain (symbolS *rootP, symbolS *lastP)

{

  symbolS *symbolP = rootP;

  if (symbolP == NULL)

    return;

  for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))

    {

      gas_assert (symbolP->bsym != NULL);

      gas_assert (symbolP->sy_flags.sy_local_symbol == 0);

      gas_assert (symbolP->sy_next->sy_previous == symbolP);

    }

  gas_assert (lastP == symbolP);

}

#ifdef OBJ_COMPLEX_RELC

static int

use_complex_relocs_for (symbolS * symp)

{

  switch (symp->sy_value.X_op)

    {

    case O_constant:

      return 0;

    case O_symbol:

    case O_symbol_rva:

    case O_uminus:

    case O_bit_not:

    case O_logical_not:

      if (  (S_IS_COMMON (symp->sy_value.X_add_symbol)

	   || S_IS_LOCAL (symp->sy_value.X_add_symbol))

	  &&

	      (S_IS_DEFINED (symp->sy_value.X_add_symbol)

	   && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))

	return 0;

      break;

    case O_multiply:

    case O_divide:

    case O_modulus:

    case O_left_shift:

    case O_right_shift:

    case O_bit_inclusive_or:

    case O_bit_or_not:

    case O_bit_exclusive_or:

    case O_bit_and:

    case O_add:

    case O_subtract:

    case O_eq:

    case O_ne:

    case O_lt:

    case O_le:

    case O_ge:

    case O_gt:

    case O_logical_and:

    case O_logical_or:

      if (  (S_IS_COMMON (symp->sy_value.X_add_symbol)

	   || S_IS_LOCAL (symp->sy_value.X_add_symbol))

	  &&

	    (S_IS_COMMON (symp->sy_value.X_op_symbol)

	   || S_IS_LOCAL (symp->sy_value.X_op_symbol))

	  && S_IS_DEFINED (symp->sy_value.X_add_symbol)

	  && S_IS_DEFINED (symp->sy_value.X_op_symbol)

	  && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section

	  && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)

	return 0;

      break;

    default:

      break;

    }

  return 1;

}

#endif

static void

report_op_error (symbolS *symp, symbolS *left, operatorT op, symbolS *right)

{

  char *file;

  unsigned int line;

  segT seg_left = left ? S_GET_SEGMENT (left) : 0;

  segT seg_right = S_GET_SEGMENT (right);

  const char *opname;

  switch (op)

    {

    default:

      abort ();

      return;

    case O_uminus:		opname = "-"; break;

    case O_bit_not:		opname = "~"; break;

    case O_logical_not:		opname = "!"; break;

    case O_multiply:		opname = "*"; break;

    case O_divide:		opname = "/"; break;

    case O_modulus:		opname = "%"; break;

    case O_left_shift:		opname = "<<"; break;

    case O_right_shift:		opname = ">>"; break;

    case O_bit_inclusive_or:	opname = "|"; break;

    case O_bit_or_not:		opname = "|~"; break;

    case O_bit_exclusive_or:	opname = "^"; break;

    case O_bit_and:		opname = "&"; break;

    case O_add:			opname = "+"; break;

    case O_subtract:		opname = "-"; break;

    case O_eq:			opname = "=="; break;

    case O_ne:			opname = "!="; break;

    case O_lt:			opname = "<"; break;

    case O_le:			opname = "<="; break;

    case O_ge:			opname = ">="; break;

    case O_gt:			opname = ">"; break;

    case O_logical_and:		opname = "&&"; break;

    case O_logical_or:		opname = "||"; break;

    }

  if (expr_symbol_where (symp, &file, &line))

    {

      if (left)

	as_bad_where (file, line,

		      _("invalid operands (%s and %s sections) for `%s'"),

		      seg_left->name, seg_right->name, opname);

      else

	as_bad_where (file, line,

		      _("invalid operand (%s section) for `%s'"),

		      seg_right->name, opname);

    }

  else

    {

      const char *sname = S_GET_NAME (symp);

      if (left)

	as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),

		seg_left->name, seg_right->name, opname, sname);

      else

	as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),

		seg_right->name, opname, sname);

    }

}

/* 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 (symbolS *symp)

{

  int resolved;

  valueT final_val = 0;

  segT final_seg;

  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;

    }

  if (symp->sy_flags.sy_resolved)

    {

      if (symp->sy_value.X_op == O_constant)

	return (valueT) symp->sy_value.X_add_number;

      else

	return 0;

    }

  resolved = 0;

  final_seg = S_GET_SEGMENT (symp);

  if (symp->sy_flags.sy_resolving)

    {

      if (finalize_syms)

	as_bad (_("symbol definition loop encountered at `%s'"),

		S_GET_NAME (symp));

      final_val = 0;

      resolved = 1;

    }

#ifdef OBJ_COMPLEX_RELC

  else if (final_seg == expr_section

	   && use_complex_relocs_for (symp))

    {

      symbolS * relc_symbol = NULL;

      char * relc_symbol_name = NULL;

      relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);

      /* For debugging, print out conversion input & output.  */

#ifdef DEBUG_SYMS

      print_expr (& symp->sy_value);

      if (relc_symbol_name)

	fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);

#endif

      if (relc_symbol_name != NULL)

	relc_symbol = symbol_new (relc_symbol_name, undefined_section,

				  0, & zero_address_frag);

      if (relc_symbol == NULL)

	{

	  as_bad (_("cannot convert expression symbol %s to complex relocation"),

		  S_GET_NAME (symp));

	  resolved = 0;

	}

      else

	{

	  symbol_table_insert (relc_symbol);

 	  /* S_CLEAR_EXTERNAL (relc_symbol); */

	  if (symp->bsym->flags & BSF_SRELC)

	    relc_symbol->bsym->flags |= BSF_SRELC;

	  else

	    relc_symbol->bsym->flags |= BSF_RELC;

	  /* symp->bsym->flags |= BSF_RELC; */

	  copy_symbol_attributes (symp, relc_symbol);

	  symp->sy_value.X_op = O_symbol;

	  symp->sy_value.X_add_symbol = relc_symbol;

	  symp->sy_value.X_add_number = 0;

	  resolved = 1;

	}

      final_seg = undefined_section;

      goto exit_dont_set_value;