/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/gas/symbols.c
Warning:	line 302, column 27 Access to field 'fr_opcode' results in a dereference of a null pointer (loaded from variable 'frag_tmp')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name symbols.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/gas -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/gas -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/gas -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/gas/config -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../include -I /usr/src/gnu/usr.bin/binutils-2.17/gas/.. -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/gas/../intl -I ../intl -D LOCALEDIR="/usr/share/locale" -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-null-pointer-arithmetic -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/gas -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c
1/* symbols.c -symbol table-
 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
 1999, 2000, 2001, 2002, 2003, 2004, 2005
 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 2, 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.  */

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

25#include "as.h"

27#include "safe-ctype.h"
28#include "obstack.h"		/* For "symbols.h" */
29#include "subsegs.h"

31#include "struc-symbol.h"

33/* This is non-zero if symbols are case sensitive, which is the
 default.  */
35int symbols_case_sensitive = 1;

37#ifndef WORKING_DOT_WORD
38extern int new_broken_words;
39#endif

41/* symbol-name => struct symbol pointer */
42static struct hash_control *sy_hash;

44/* Table of local symbols.  */
45static struct hash_control *local_hash;

47/* Below are commented in "symbols.h".  */
48symbolS *symbol_rootP;
49symbolS *symbol_lastP;
50symbolS abs_symbol;

52#ifdef DEBUG_SYMS
53#define debug_verify_symchain verify_symbol_chain
54#else
55#define debug_verify_symchain(root, last)((void) 0) ((void) 0)
56#endif

58#define DOLLAR_LABEL_CHAR'\001'	'\001'
59#define LOCAL_LABEL_CHAR'\002'	'\002'

61struct obstack notes;
62#ifdef USE_UNIQUE
63/* The name of an external symbol which is
 used to make weak PE symbol names unique.  */
65const char * an_external_name;
66#endif

68static char *save_symbol_name (const char *);
69static void fb_label_init (void);
70static long dollar_label_instance (long);
71static long fb_label_instance (long);

73static void print_binary (FILE *, const char *, expressionS *);
74static void report_op_error (symbolS *, symbolS *, symbolS *);

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

85symbolS *
86symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
87{
symbolS *symbolP = symbol_create (name, segment, valu, frag);

/* Link to end of symbol chain.  */
{
  extern int symbol_table_frozen;
  if (symbol_table_frozen)
    abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 94, __PRETTY_FUNCTION__);
}
symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);

return symbolP;
99}

101/* Save a symbol name on a permanent obstack, and convert it according
 to the object file format.  */

104static char *
105save_symbol_name (const char *name)
106{
unsigned int name_length;
char *ret;

name_length = strlen (name) + 1;	/* +1 for \0.  */
obstack_grow (&notes, name, name_length)__extension__ ({ struct obstack *__o = (&notes); int __len
 = (name_length); if (__o->next_free + __len > __o->
chunk_limit) _obstack_newchunk (__o, __len); memcpy ((__o->
next_free), ((name)), (__len)); __o->next_free += __len; (
void) 0; });
ret = obstack_finish (&notes)__extension__ ({ struct obstack *__o1 = (&notes); void *value
; value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; });

114#ifdef tc_canonicalize_symbol_name
ret = tc_canonicalize_symbol_name (ret);
116#endif

if (! symbols_case_sensitive)
  {
    char *s;

    for (s = ret; *s != '\0'; s++)
*s = TOUPPER (*s)_sch_toupper[(*s) & 0xff];
  }

return ret;
127}

129symbolS *
130symbol_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.  */)
134{
char *preserved_copy_of_name;
symbolS *symbolP;

preserved_copy_of_name = save_symbol_name (name);

symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS))__extension__ ({ struct obstack *__h = (&notes); __extension__
 ({ struct obstack *__o = (__h); int __len = ((sizeof (symbolS
))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); });

/* 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)((*((stdoutput)->xvec->_bfd_make_empty_symbol)) (stdoutput
));
if (symbolP->bsym == NULL((void*)0))
  as_perror ("%s", "bfd_make_empty_symbol");
symbolP->bsym->udata.p = (PTRvoid *) symbolP;
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_hookelf_obj_symbol_new_hook (symbolP);

159#ifdef tc_symbol_new_hook
tc_symbol_new_hook (symbolP);
161#endif

return symbolP;
164}
165

167/* Local symbol support.  If we can get away with it, we keep only a
 small amount of information for local symbols.  */

170static symbolS *local_symbol_convert (struct local_symbol *);

172/* Used for statistics.  */

174static unsigned long local_symbol_count;
175static unsigned long local_symbol_conversion_count;

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

181#define LOCAL_SYMBOL_CHECK(s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0)						\
(s->bsym == NULL((void*)0)							\
 ? (local_symbol_converted_p ((struct local_symbol *) s)(((struct local_symbol *) s)->lsy_section == reg_section)		\
    ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_sym),	\
0)								\
    : 1)								\
 : 0)

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

191static struct local_symbol *
192local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
193{
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)__extension__ ({ struct obstack *__h = (&notes); __extension__
 ({ struct obstack *__o = (__h); int __len = ((sizeof *ret));
 if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); });
ret->lsy_marker = NULL((void*)0);
ret->lsy_name = name_copy;
ret->lsy_section = section;
local_symbol_set_frag (ret, frag)((ret)->u.lsy_frag = (frag));
ret->lsy_value = value;

hash_jam (local_hash, name_copy, (PTRvoid *) ret);

return ret;
211}

213/* Convert a local symbol into a real symbol.  Note that we do not
 reclaim the space used by the local symbol.  */

216static symbolS *
217local_symbol_convert (struct local_symbol *locsym)
218{
symbolS *ret;

assert (locsym->lsy_marker == NULL)((void) ((locsym->lsy_marker == ((void*)0)) ? 0 : (as_assert
 ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 221, __PRETTY_FUNCTION__
), 0)));
if (local_symbol_converted_p (locsym)((locsym)->lsy_section == reg_section))
  return local_symbol_get_real_symbol (locsym)((locsym)->u.lsy_sym);

++local_symbol_conversion_count;

ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
    local_symbol_get_frag (locsym)((locsym)->u.lsy_frag));

if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0)))
  ret->sy_resolved = 1;

/* Local symbols are always either defined or used.  */
ret->sy_used = 1;

236#ifdef TC_LOCAL_SYMFIELD_CONVERT
TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
238#endif

symbol_table_insert (ret);

local_symbol_mark_converted (locsym)((locsym)->lsy_section = reg_section);
local_symbol_set_real_symbol (locsym, ret)((locsym)->u.lsy_sym = (ret));

hash_jam (local_hash, locsym->lsy_name, NULL((void*)0));

return ret;
248}
249
250/* We have just seen "<name>:".
 Creates a struct symbol unless it already exists.

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

255symbolS *
256colon (/* Just seen "x:" - rattle symbols & frags.  */
     const char *sym_name	/* Symbol name, as a cannonical string.  */
     /* We copy this string: OK to alter later.  */)
259{
register symbolS *symbolP;	/* Symbol we are working with.  */

/* Sun local labels go out of scope whenever a non-local symbol is
   defined.  */
if (LOCAL_LABELS_DOLLAR0
    && !bfd_is_local_label_name (stdoutput, sym_name)((*((stdoutput)->xvec->_bfd_is_local_label_name)) (stdoutput
, sym_name)))
  dollar_label_clear ();

268#ifndef WORKING_DOT_WORD
if (new_broken_words)
1
Assuming 'new_broken_words' is not equal to 0→
2
←
Taking true branch→
  {
    struct broken_word *a;
    int possible_bytes;
    fragS *frag_tmp;
    char *frag_opcode;

    if (now_seg == absolute_section((asection *) &bfd_abs_section))
3
←
Assuming the condition is false→
4
←
Taking false branch→
{
 as_bad (_("cannot define symbol `%s' in absolute section")("cannot define symbol `%s' in absolute section"), sym_name);
 return NULL((void*)0);
}

    possible_bytes = (md_short_jump_size
	+ new_broken_words * md_long_jump_size);

    frag_tmp = frag_now;
5
←
Value assigned to 'frag_tmp'→
    frag_opcode = frag_var (rs_broken_word,
	      possible_bytes,
	      possible_bytes,
	      (relax_substateT) 0,
	      (symbolS *) broken_words,
	      (offsetT) 0,
	      NULL((void*)0));

    /* 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
6
←
Assuming 'frag_tmp' is null→
    && (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;
7
←
Access to field 'fr_opcode' results in a dereference of a null pointer (loaded from variable 'frag_tmp')
    new_broken_words = 0;

    for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
a->dispfrag = frag_tmp;
  }
308#endif /* WORKING_DOT_WORD */

if ((symbolP = symbol_find (sym_name)) != 0)
  {
    S_CLEAR_WEAKREFR (symbolP);
313#ifdef RESOLVE_SYMBOL_REDEFINITION
    if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
return symbolP;
316#endif
    /* Now check for undefined symbols.  */
    if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
{
 struct local_symbol *locsym = (struct local_symbol *) symbolP;

 if (locsym->lsy_section != undefined_section((asection *) &bfd_und_section)
     && (local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != frag_now
  || locsym->lsy_section != now_seg
  || locsym->lsy_value != frag_now_fix ()))
   {
     as_bad (_("symbol `%s' is already defined")("symbol `%s' is already defined"), sym_name);
     return symbolP;
   }

 locsym->lsy_section = now_seg;
 local_symbol_set_frag (locsym, frag_now)((locsym)->u.lsy_frag = (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)
     /* This could be avoided when the symbol wasn't used so far, but
 the comment in struc-symbol.h says this flag isn't reliable.  */
     && (1 || !symbol_used_p (symbolP)))
   {
     symbolP = symbol_clone (symbolP, 1);
     S_SET_VALUE (symbolP, 0);
     S_CLEAR_VOLATILE (symbolP);
   }
 if (S_GET_VALUE (symbolP) == 0)
   {
     symbolP->sy_frag = frag_now;
351#ifdef OBJ_VMS
     S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))->
the_bfd))->internal_elf_sym.st_other = (const_flag));
353#endif
     S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
     S_SET_SEGMENT (symbolP, now_seg);
356#ifdef N_UNDF
     know (N_UNDF == 0);
358#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.  */
      symbolP->sy_frag = frag_now;
401#ifdef OBJ_VMS
      S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))->
the_bfd))->internal_elf_sym.st_other = (const_flag));
403#endif
      S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
      S_SET_SEGMENT (symbolP, now_seg);	/* Keep N_EXT bit.  */
    }
}
     else
{
410#if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
   && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
  static const char *od_buf = "";
413#else
  char od_buf[100];
  od_buf[0] = '\0';
  if (OUTPUT_FLAVORbfd_target_elf_flavour == bfd_target_aout_flavour)
    sprintf (od_buf, "%d.%d.",
	     S_GET_OTHER (symbolP)(elf_s_get_other (symbolP)),
	     S_GET_DESC (symbolP));
420#endif
  as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld")("symbol `%s' is already defined as \"%s\"/%s%ld"),
	    sym_name,
	    segment_name (S_GET_SEGMENT (symbolP))((S_GET_SEGMENT (symbolP))->name + 0),
	    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")("symbol `%s' is already defined"), sym_name);
     symbolP = symbol_clone (symbolP, 0);
   }
}

  }
else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name)((*((stdoutput)->xvec->_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);
452#ifdef OBJ_VMS
    S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))->
the_bfd))->internal_elf_sym.st_other = (const_flag));
454#endif /* OBJ_VMS */

    symbol_table_insert (symbolP);
  }

if (mri_common_symbol != NULL((void*)0))
  {
    /* This symbol is actually being defined within an MRI common
section.  This requires special handling.  */
    if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
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_mri_common = 1;
  }

473#ifdef tc_frob_label
tc_frob_label (symbolP);
475#endif
476#ifdef obj_frob_labeldwarf2_emit_label
obj_frob_labeldwarf2_emit_label (symbolP);
478#endif

return symbolP;
481}
482
483/* Die if we can't insert the symbol.  */

485void
486symbol_table_insert (symbolS *symbolP)
487{
register const char *error_string;

know (symbolP);
know (S_GET_NAME (symbolP));

if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
  {
    error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
	       (PTRvoid *) symbolP);
    if (error_string != NULL((void*)0))
as_fatal (_("inserting \"%s\" into symbol table failed: %s")("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), (PTRvoid *) symbolP)))
  {
    as_fatal (_("inserting \"%s\" into symbol table failed: %s")("inserting \"%s\" into symbol table failed: %s"),
S_GET_NAME (symbolP), error_string);
  }				/* on error  */
508}
509
510/* If a symbol name does not exist, create it as undefined, and insert
 it into the symbol table.  Return a pointer to it.  */

513symbolS *
514symbol_find_or_make (const char *name)
515{
register symbolS *symbolP;

symbolP = symbol_find (name);

if (symbolP == NULL((void*)0))
  {
    if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name)((*((stdoutput)->xvec->_bfd_is_local_label_name)) (stdoutput
, name)))
{
 symbolP = md_undefined_symbol ((char *) name);
 if (symbolP != NULL((void*)0))
   return symbolP;

 symbolP = (symbolS *) local_symbol_make (name, undefined_section((asection *) &bfd_und_section),
				   (valueT) 0,
				   &zero_address_frag);
 return symbolP;
}

    symbolP = symbol_make (name);

    symbol_table_insert (symbolP);
  }				/* if symbol wasn't found */

return (symbolP);
540}

542symbolS *
543symbol_make (const char *name)
544{
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((asection *) &bfd_und_section), (valueT) 0, &zero_address_frag);

return (symbolP);
554}

556symbolS *
557symbol_clone (symbolS *orgsymP, int replace)
558{
symbolS *newsymP;
asymbol *bsymorg, *bsymnew;

/* 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->bsym == ((void*)0) ? ((((struct local_symbol *) orgsymP
)->lsy_section == reg_section) ? (orgsymP = (((struct local_symbol
 *) orgsymP)->u.lsy_sym), 0) : 1) : 0))
  orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
bsymorg = orgsymP->bsym;

know (S_IS_DEFINED (orgsymP));

newsymP = obstack_alloc (&notes, sizeof (*newsymP))__extension__ ({ struct obstack *__h = (&notes); __extension__
 ({ struct obstack *__o = (__h); int __len = ((sizeof (*newsymP
))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); });
*newsymP = *orgsymP;
bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg))((*((((bsymorg)->the_bfd))->xvec->_bfd_make_empty_symbol
)) (((bsymorg)->the_bfd)));
if (bsymnew == NULL((void*)0))
  as_perror ("%s", "bfd_make_empty_symbol");
newsymP->bsym = bsymnew;
bsymnew->name = bsymorg->name;
bsymnew->flags =  bsymorg->flags;
bsymnew->section =  bsymorg->section;
bsymnew->udata.p = (PTRvoid *) newsymP;
bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,((*((((bsymnew)->the_bfd))->xvec->_bfd_copy_private_symbol_data
)) (((bsymorg)->the_bfd), bsymorg, ((bsymnew)->the_bfd)
, bsymnew))
		bfd_asymbol_bfd (bsymnew), bsymnew)((*((((bsymnew)->the_bfd))->xvec->_bfd_copy_private_symbol_data
)) (((bsymorg)->the_bfd), bsymorg, ((bsymnew)->the_bfd)
, bsymnew));

585#ifdef obj_symbol_clone_hook
obj_symbol_clone_hook (newsymP, orgsymP);
587#endif

589#ifdef tc_symbol_clone_hook
tc_symbol_clone_hook (newsymP, orgsymP);
591#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((void*)0);
}
    if (symbol_lastP == orgsymP)
symbol_lastP = newsymP;
    else if (orgsymP->sy_next)
orgsymP->sy_next->sy_previous = newsymP;
    orgsymP->sy_next = NULL((void*)0);
    debug_verify_symchain (symbol_rootP, symbol_lastP)((void) 0);

    symbol_table_insert (newsymP);
  }

return newsymP;
613}

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

619#undef symbol_clone_if_forward_ref
620symbolS *
621symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
622{
if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
  {
    symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
    symbolS *op_symbol = symbolP->sy_value.X_op_symbol;

    if (symbolP->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_resolving)
{
 symbolP->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_resolving = 0;
}

    if (symbolP->sy_forward_ref
 || add_symbol != symbolP->sy_value.X_add_symbol
 || op_symbol != symbolP->sy_value.X_op_symbol)
symbolP = symbol_clone (symbolP, 0);

    symbolP->sy_value.X_add_symbol = add_symbol;
    symbolP->sy_value.X_op_symbol = op_symbol;
  }

return symbolP;
662}

664symbolS *
665symbol_temp_new (segT seg, valueT ofs, fragS *frag)
666{
return symbol_new (FAKE_LABEL_NAME"L0\001", seg, ofs, frag);
668}

670symbolS *
671symbol_temp_new_now (void)
672{
return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
674}

676symbolS *
677symbol_temp_make (void)
678{
return symbol_make (FAKE_LABEL_NAME"L0\001");
680}

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

687symbolS *
688symbol_find_exact (const char *name)
689{
return symbol_find_exact_noref (name, 0);
691}

693symbolS *
694symbol_find_exact_noref (const char *name, int noref)
695{
struct local_symbol *locsym;
symbolS* sym;

locsym = (struct local_symbol *) hash_find (local_hash, name);
if (locsym != NULL((void*)0))
  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;
714}

716symbolS *
717symbol_find (const char *name)
718{
return symbol_find_noref (name, 0);
720}

722symbolS *
723symbol_find_noref (const char *name, int noref)
724{
725#ifdef tc_canonicalize_symbol_name
{
  char *copy;
  size_t len = strlen (name) + 1;

  copy = (char *) alloca (len)__builtin_alloca(len);
  memcpy (copy, name, len);
  name = tc_canonicalize_symbol_name (copy);
}
734#endif

if (! symbols_case_sensitive)
  {
    char *copy;
    const char *orig;
    unsigned char c;

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

    while ((c = *orig++) != '\0')
{
 *copy++ = TOUPPER (c)_sch_toupper[(c) & 0xff];
}
    *copy = '\0';
  }

return symbol_find_exact_noref (name, noref);
753}

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

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

763void
764symbol_append (symbolS *addme, symbolS *target,
      symbolS **rootPP, symbolS **lastPP)
766{
if (LOCAL_SYMBOL_CHECK (addme)(addme->bsym == ((void*)0) ? ((((struct local_symbol *) addme
)->lsy_section == reg_section) ? (addme = (((struct local_symbol
 *) addme)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 768, __PRETTY_FUNCTION__);
if (target != NULL((void*)0) && LOCAL_SYMBOL_CHECK (target)(target->bsym == ((void*)0) ? ((((struct local_symbol *) target
)->lsy_section == reg_section) ? (target = (((struct local_symbol
 *) target)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 770, __PRETTY_FUNCTION__);

if (target == NULL((void*)0))
  {
    know (*rootPP == NULL);
    know (*lastPP == NULL);
    addme->sy_next = NULL((void*)0);
    addme->sy_previous = NULL((void*)0);
    *rootPP = addme;
    *lastPP = addme;
    return;
  }				/* if the list is empty  */

if (target->sy_next != NULL((void*)0))
  {
    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)((void) 0);
798}

800/* Set the chain pointers of SYMBOL to null.  */

802void
803symbol_clear_list_pointers (symbolS *symbolP)
804{
if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 806, __PRETTY_FUNCTION__);
symbolP->sy_next = NULL((void*)0);
symbolP->sy_previous = NULL((void*)0);
809}

811/* Remove SYMBOLP from the list.  */

813void
814symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
815{
if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 817, __PRETTY_FUNCTION__);

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((void*)0))
  {
    symbolP->sy_next->sy_previous = symbolP->sy_previous;
  }				/* if not last  */

if (symbolP->sy_previous != NULL((void*)0))
  {
    symbolP->sy_previous->sy_next = symbolP->sy_next;
  }				/* if not first  */

debug_verify_symchain (*rootPP, *lastPP)((void) 0);
840}

842/* Link symbol ADDME before symbol TARGET in the chain.  */

844void
845symbol_insert (symbolS *addme, symbolS *target,
      symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
847{
if (LOCAL_SYMBOL_CHECK (addme)(addme->bsym == ((void*)0) ? ((((struct local_symbol *) addme
)->lsy_section == reg_section) ? (addme = (((struct local_symbol
 *) addme)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 849, __PRETTY_FUNCTION__);
if (LOCAL_SYMBOL_CHECK (target)(target->bsym == ((void*)0) ? ((((struct local_symbol *) target
)->lsy_section == reg_section) ? (target = (((struct local_symbol
 *) target)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 851, __PRETTY_FUNCTION__);

if (target->sy_previous != NULL((void*)0))
  {
    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) 0);
868}

870void
871verify_symbol_chain (symbolS *rootP, symbolS *lastP)
872{
symbolS *symbolP = rootP;

if (symbolP == NULL((void*)0))
  return;

for (; symbol_next (symbolP) != NULL((void*)0); symbolP = symbol_next (symbolP))
  {
    assert (symbolP->bsym != NULL)((void) ((symbolP->bsym != ((void*)0)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
, 880, __PRETTY_FUNCTION__), 0)));
    assert (symbolP->sy_next->sy_previous == symbolP)((void) ((symbolP->sy_next->sy_previous == symbolP) ? 0
 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
, 881, __PRETTY_FUNCTION__), 0)));
  }

assert (lastP == symbolP)((void) ((lastP == symbolP) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
, 884, __PRETTY_FUNCTION__), 0)));
885}

887static void
888report_op_error (symbolS *symp, symbolS *left, symbolS *right)
889{
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((asection *) &bfd_und_section))
as_bad_where (file, line,
      _("undefined symbol `%s' in operation")("undefined symbol `%s' in operation"),
      S_GET_NAME (left));
    if (seg_right == undefined_section((asection *) &bfd_und_section))
as_bad_where (file, line,
      _("undefined symbol `%s' in operation")("undefined symbol `%s' in operation"),
      S_GET_NAME (right));
    if (seg_left != undefined_section((asection *) &bfd_und_section)
 && seg_right != undefined_section((asection *) &bfd_und_section))
{
 if (right)
   as_bad_where (file, line,
	  _("invalid sections for operation on `%s' and `%s'")("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'")("invalid section for operation on `%s'"),
	  S_GET_NAME (left));
}

  }
else
  {
    if (seg_left == undefined_section((asection *) &bfd_und_section))
as_bad (_("undefined symbol `%s' in operation setting `%s'")("undefined symbol `%s' in operation setting `%s'"),
S_GET_NAME (left), S_GET_NAME (symp));
    if (seg_right == undefined_section((asection *) &bfd_und_section))
as_bad (_("undefined symbol `%s' in operation setting `%s'")("undefined symbol `%s' in operation setting `%s'"),
S_GET_NAME (right), S_GET_NAME (symp));
    if (seg_left != undefined_section((asection *) &bfd_und_section)
 && seg_right != undefined_section((asection *) &bfd_und_section))
{
 if (right)
   as_bad_where (file, line,
	  _("invalid sections for operation on `%s' and `%s' setting `%s'")("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'")("invalid section for operation on `%s' setting `%s'"),
	  S_GET_NAME (left), S_GET_NAME (symp));
}
  }
940}

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

946valueT
947resolve_symbol_value (symbolS *symp)
948{
int resolved;
valueT final_val = 0;
segT final_seg;

if (LOCAL_SYMBOL_CHECK (symp)(symp->bsym == ((void*)0) ? ((((struct local_symbol *) symp
)->lsy_section == reg_section) ? (symp = (((struct local_symbol
 *) symp)->u.lsy_sym), 0) : 1) : 0))
  {
    struct local_symbol *locsym = (struct local_symbol *) symp;

    final_val = locsym->lsy_value;
    if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0)))
return final_val;

    final_val += local_symbol_get_frag (locsym)((locsym)->u.lsy_frag)->fr_address / OCTETS_PER_BYTE(1<<0);

    if (finalize_syms)
{
 locsym->lsy_value = final_val;
 local_symbol_mark_resolved (locsym)((locsym)->u.lsy_frag = ((void*)0));
}

    return final_val;
  }

if (symp->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_resolving)
  {
    if (finalize_syms)
as_bad (_("symbol definition loop encountered at `%s'")("symbol definition loop encountered at `%s'"),
S_GET_NAME (symp));
    final_val = 0;
    resolved = 1;
  }
else
  {
    symbolS *add_symbol, *op_symbol;
    offsetT left, right;
    segT seg_left, seg_right;
    operatorT op;
    int move_seg_ok;

    symp->sy_resolving = 1;

    /* Help out with CSE.  */
    add_symbol = symp->sy_value.X_add_symbol;
    op_symbol = symp->sy_value.X_op_symbol;
    final_val = symp->sy_value.X_add_number;
    op = symp->sy_value.X_op;

    switch (op)
{
default:
 BAD_CASE (op){ as_fatal (("Case value %ld unexpected at line %d of file \"%s\"\n"
), (long) op, 1010, "/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
); };
 break;

case O_absent:
 final_val = 0;
 /* Fall through.  */

case O_constant:
 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE(1<<0);
 if (final_seg == expr_section)
   final_seg = absolute_section((asection *) &bfd_abs_section);
 resolved = 1;
 break;

case O_symbol:
case O_symbol_rva:
 left = resolve_symbol_value (add_symbol);
 seg_left = S_GET_SEGMENT (add_symbol);
 if (finalize_syms)
   symp->sy_value.X_op_symbol = NULL((void*)0);

do_symbol:
 if (S_IS_WEAKREFR (symp))
   {
     assert (final_val == 0)((void) ((final_val == 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
, 1034, __PRETTY_FUNCTION__), 0)));
     if (S_IS_WEAKREFR (add_symbol))
{
  assert (add_symbol->sy_value.X_op == O_symbol((void) ((add_symbol->sy_value.X_op == O_symbol &&
 add_symbol->sy_value.X_add_number == 0) ? 0 : (as_assert (
"/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1038, __PRETTY_FUNCTION__
), 0)))
	  && add_symbol->sy_value.X_add_number == 0)((void) ((add_symbol->sy_value.X_op == O_symbol &&
 add_symbol->sy_value.X_add_number == 0) ? 0 : (as_assert (
"/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1038, __PRETTY_FUNCTION__
), 0)));
  add_symbol = add_symbol->sy_value.X_add_symbol;
  assert (! S_IS_WEAKREFR (add_symbol))((void) ((! S_IS_WEAKREFR (add_symbol)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c"
, 1040, __PRETTY_FUNCTION__), 0)));
  symp->sy_value.X_add_symbol = add_symbol;
}
   }

 if (symp->sy_mri_common)
   {
     /* This is a symbol inside an MRI common section.  The
 relocation routines are going to handle it specially.
 Don't change the value.  */
     resolved = symbol_resolved_p (add_symbol);
     break;
   }

 if (finalize_syms && final_val == 0)
   {
     if (LOCAL_SYMBOL_CHECK (add_symbol)(add_symbol->bsym == ((void*)0) ? ((((struct local_symbol *
) add_symbol)->lsy_section == reg_section) ? (add_symbol =
 (((struct local_symbol *) add_symbol)->u.lsy_sym), 0) : 1
) : 0))
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 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)
1069#if defined (OBJ_COFF) && defined (TE_PE)
     || S_IS_WEAK (add_symbol)
1071#endif
     || S_IS_COMMON (add_symbol))
   {
     if (finalize_syms)
{
  symp->sy_value.X_op = O_symbol;
  symp->sy_value.X_add_symbol = add_symbol;
  symp->sy_value.X_add_number = final_val;
  /* Use X_op_symbol as a flag.  */
  symp->sy_value.X_op_symbol = add_symbol;
  final_seg = seg_left;
}
     final_val = 0;
     resolved = symbol_resolved_p (add_symbol);
     symp->sy_resolving = 0;
     goto exit_dont_set_value;
   }
 else if (finalize_syms && final_seg == expr_section
   && seg_left != expr_section)
   {
     /* If the symbol is an expression symbol, do similarly
 as for undefined and common syms above.  Handles
 "sym +/- expr" where "expr" cannot be evaluated
 immediately, and we want relocations to be against
 "sym", eg. because it is weak.  */
     symp->sy_value.X_op = O_symbol;
     symp->sy_value.X_add_symbol = add_symbol;
     symp->sy_value.X_add_number = final_val;
     symp->sy_value.X_op_symbol = add_symbol;
     final_seg = seg_left;
     final_val += symp->sy_frag->fr_address + left;
     resolved = symbol_resolved_p (add_symbol);
     symp->sy_resolving = 0;
     goto exit_dont_set_value;
   }
 else
   {
     final_val += symp->sy_frag->fr_address + left;
     if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section))
final_seg = seg_left;
   }

 resolved = symbol_resolved_p (add_symbol);
 if (S_IS_WEAKREFR (symp))
   goto exit_dont_set_value;
 break;

case O_uminus:
case O_bit_not:
case O_logical_not:
 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((asection *) &bfd_abs_section)
     && finalize_syms)
   report_op_error (symp, add_symbol, NULL((void*)0));

 if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section))
   final_seg = absolute_section((asection *) &bfd_abs_section);

 if (op == O_uminus)
   left = -left;
 else if (op == O_logical_not)
   left = !left;
 else
   left = ~left;

 final_val += left + symp->sy_frag->fr_address;

 resolved = symbol_resolved_p (add_symbol);
 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:
 left = resolve_symbol_value (add_symbol);
 right = resolve_symbol_value (op_symbol);
 seg_left = S_GET_SEGMENT (add_symbol);
 seg_right = S_GET_SEGMENT (op_symbol);

 /* Simplify addition or subtraction of a constant by folding the
    constant into X_add_number.  */
 if (op == O_add)
   {
     if (seg_right == absolute_section((asection *) &bfd_abs_section))
{
  final_val += right;
  goto do_symbol;
}
     else if (seg_left == absolute_section((asection *) &bfd_abs_section))
{
  final_val += left;
  add_symbol = op_symbol;
  left = right;
  seg_left = seg_right;
  goto do_symbol;
}
   }
 else if (op == O_subtract)
   {
     if (seg_right == absolute_section((asection *) &bfd_abs_section))
{
  final_val -= right;
  goto do_symbol;
}
   }

 move_seg_ok = 1;
 /* 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.  */
 if (!(seg_left == absolute_section((asection *) &bfd_abs_section)
   && seg_right == absolute_section((asection *) &bfd_abs_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((asection *) &bfd_und_section)
       || add_symbol == op_symbol)))
   {
     /* Don't emit messages unless we're finalizing the symbol value,
 otherwise we may get the same message multiple times.  */
     if (finalize_syms)
report_op_error (symp, add_symbol, op_symbol);
     /* However do not move the symbol into the absolute section
 if it cannot currently be resolved - this would confuse
 other parts of the assembler into believing that the
 expression had been evaluated to zero.  */
     else
move_seg_ok = 0;
   }

 if (move_seg_ok
     && (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section)))
   final_seg = absolute_section((asection *) &bfd_abs_section);

 /* Check for division by zero.  */
 if ((op == O_divide || op == O_modulus) && right == 0)
   {
     /* If seg_right is not absolute_section, then we've
 already issued a warning about using a bad symbol.  */
     if (seg_right == absolute_section((asection *) &bfd_abs_section) && finalize_syms)
{
  char *file;
  unsigned int line;

  if (expr_symbol_where (symp, &file, &line))
    as_bad_where (file, line, _("division by zero")("division by zero"));
  else
    as_bad (_("division by zero when setting `%s'")("division by zero when setting `%s'"),
	    S_GET_NAME (symp));
}

     right = 1;
   }

 switch (symp->sy_value.X_op)
   {
   case O_multiply:		left *= right; break;
   case O_divide:		left /= right; break;
   case O_modulus:		left %= right; break;
   case O_left_shift:		left <<= right; break;
   case O_right_shift:		left >>= right; break;
   case O_bit_inclusive_or:	left |= right; break;
   case O_bit_or_not:		left |= ~right; break;
   case O_bit_exclusive_or:	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:
   case O_ne:
     left = (left == right && seg_left == seg_right
      && (seg_left != undefined_section((asection *) &bfd_und_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_gt:	left = left >  right ? ~ (offsetT) 0 : 0; break;
   case O_logical_and:	left = left && right; break;
   case O_logical_or:	left = left || right; break;
   default:		abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 1279, __PRETTY_FUNCTION__);
   }

 final_val += symp->sy_frag->fr_address + left;
 if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section))
   {
     if (seg_left == undefined_section((asection *) &bfd_und_section)
  || seg_right == undefined_section((asection *) &bfd_und_section))
final_seg = undefined_section((asection *) &bfd_und_section);
     else if (seg_left == absolute_section((asection *) &bfd_abs_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_illegal:
 /* Give an error (below) if not in expr_section.  We don't
    want to worry about expr_section symbols, because they
    are fictional (they are created as part of expression
    resolution), and any problems may not actually mean
    anything.  */
 break;
}

    symp->sy_resolving = 0;
  }

if (finalize_syms)
  S_SET_VALUE (symp, final_val);

1314exit_dont_set_value:
/* Always set the segment, even if not finalizing the value.
   The segment is used to determine whether a symbol is defined.  */
  S_SET_SEGMENT (symp, final_seg);

/* Don't worry if we can't resolve an expr_section symbol.  */
if (finalize_syms)
  {
    if (resolved)
symp->sy_resolved = 1;
    else if (S_GET_SEGMENT (symp) != expr_section)
{
 as_bad (_("can't resolve value for symbol `%s'")("can't resolve value for symbol `%s'"),
  S_GET_NAME (symp));
 symp->sy_resolved = 1;
}
  }

return final_val;
1333}

1335static void resolve_local_symbol (const char *, PTRvoid *);

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

1339static void
1340resolve_local_symbol (const char *key ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PTRvoid * value)
1341{
if (value != NULL((void*)0))
  resolve_symbol_value (value);
1344}

1346/* Resolve all local symbols.  */

1348void
1349resolve_local_symbol_values (void)
1350{
hash_traverse (local_hash, resolve_local_symbol);
1352}

1354/* Obtain the current value of a symbol without changing any
 sub-expressions used.  */

1357int
1358snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1359{
symbolS *symbolP = *symbolPP;

if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP
)->lsy_section == reg_section) ? (symbolP = (((struct local_symbol
 *) symbolP)->u.lsy_sym), 0) : 1) : 0))
  {
    struct local_symbol *locsym = (struct local_symbol *) symbolP;

    *valueP = locsym->lsy_value;
    *segP = locsym->lsy_section;
    *fragPP = local_symbol_get_frag (locsym)((locsym)->u.lsy_frag);
  }
else
  {
    expressionS expr = symbolP->sy_value;

    if (!symbolP->sy_resolved && expr.X_op != O_illegal)
{
 int resolved;

 if (symbolP->sy_resolving)
   return 0;
 symbolP->sy_resolving = 1;
 resolved = resolve_expression (&expr);
 symbolP->sy_resolving = 0;
 if (!resolved)
   return 0;

 switch (expr.X_op)
   {
   case O_constant:
   case O_register:
     if (!symbol_equated_p (symbolP))
break;
     /* Fall thru.  */
   case O_symbol:
   case O_symbol_rva:
     symbolP = expr.X_add_symbol;
     break;
   default:
     return 0;
   }
}

    /* Never change a defined symbol.  */
    if (symbolP->bsym->section == undefined_section((asection *) &bfd_und_section)
 || symbolP->bsym->section == expr_section)
*symbolPP = symbolP;
    *valueP = expr.X_add_number;
    *segP = symbolP->bsym->section;
    *fragPP = symbolP->sy_frag;

    if (*segP == expr_section)
switch (expr.X_op)
 {
 case O_constant: *segP = absolute_section((asection *) &bfd_abs_section); break;
 case O_register: *segP = reg_section; break;
 default: break;
 }
  }

return 1;
1420}

1422/* 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
 instances of a dollar label.  Therefor, we name encode each instance with
 the instance number, keep a list of defined symbols separate from the real
 symbol table, and we treat these buggers as a sparse array.  */

1429static long *dollar_labels;
1430static long *dollar_label_instances;
1431static char *dollar_label_defines;
1432static unsigned long dollar_label_count;
1433static unsigned long dollar_label_max;

1435int
1436dollar_label_defined (long label)
1437{
long *i;

know ((dollar_labels != NULL) || (dollar_label_count == 0));

for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  if (*i == label)
    return dollar_label_defines[i - dollar_labels];

/* If we get here, label isn't defined.  */
return 0;
1448}

1450static long
1451dollar_label_instance (long label)
1452{
long *i;

know ((dollar_labels != NULL) || (dollar_label_count == 0));

for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  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.  */
return 0;
1464}

1466void
1467dollar_label_clear (void)
1468{
memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1470}

1472#define DOLLAR_LABEL_BUMP_BY10 10

1474void
1475define_dollar_label (long label)
1476{
long *i;

for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
  if (*i == label)
    {
++dollar_label_instances[i - dollar_labels];
dollar_label_defines[i - dollar_labels] = 1;
return;
    }

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

if (dollar_labels == NULL((void*)0))
  {
    dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY10 * sizeof (long));
    dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY10 * sizeof (long));
    dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY10);
    dollar_label_max = DOLLAR_LABEL_BUMP_BY10;
    dollar_label_count = 0;
  }
else if (dollar_label_count == dollar_label_max)
  {
    dollar_label_max += DOLLAR_LABEL_BUMP_BY10;
    dollar_labels = (long *) xrealloc ((char *) dollar_labels,
			 dollar_label_max * sizeof (long));
    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  */

dollar_labels[dollar_label_count] = label;
dollar_label_instances[dollar_label_count] = 1;
dollar_label_defines[dollar_label_count] = 1;
++dollar_label_count;
1511}

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

1524char *				/* Return local label name.  */
1525dollar_label_name (register long n,	/* we just saw "n$:" : n a number.  */
   register int augend	/* 0 for current instance, 1 for new instance.  */)
1527{
long i;
/* Returned to caller, then copied.  Used for created names ("4f").  */
static char symbol_name_build[24];
register char *p;
register char *q;
char symbol_name_temporary[20];	/* Build up a number, BACKWARDS.  */

know (n >= 0);
know (augend == 0 || augend == 1);
p = symbol_name_build;
1538#ifdef LOCAL_LABEL_PREFIX
*p++ = LOCAL_LABEL_PREFIX;
1540#endif
*p++ = 'L';

/* Next code just does sprintf( {}, "%d", n);  */
/* Label number.  */
q = symbol_name_temporary;
for (*q++ = 0, i = n; i; ++q)
  {
    *q = i % 10 + '0';
    i /= 10;
  }
while ((*p = *--q) != '\0')
  ++p;

*p++ = DOLLAR_LABEL_CHAR'\001';		/* ^A  */

/* Instance number.  */
q = symbol_name_temporary;
for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
  {
    *q = i % 10 + '0';
    i /= 10;
  }
while ((*p++ = *--q) != '\0')
;

/* The label, as a '\0' ended string, starts at symbol_name_build.  */
return symbol_name_build;
1568}

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

1587#define FB_LABEL_SPECIAL(10) (10)

1589static long fb_low_counter[FB_LABEL_SPECIAL(10)];
1590static long *fb_labels;
1591static long *fb_label_instances;
1592static long fb_label_count;
1593static long fb_label_max;

1595/* This must be more than FB_LABEL_SPECIAL.  */
1596#define FB_LABEL_BUMP_BY((10) + 6) (FB_LABEL_SPECIAL(10) + 6)

1598static void
1599fb_label_init (void)
1600{
memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1602}

1604/* Add one to the instance number of this fb label.  */

1606void
1607fb_label_instance_inc (long label)
1608{
long *i;

if (label < FB_LABEL_SPECIAL(10))
  {
    ++fb_low_counter[label];
    return;
  }

if (fb_labels != NULL((void*)0))
  {
    for (i = fb_labels + FB_LABEL_SPECIAL(10);
  i < fb_labels + fb_label_count; ++i)
{
 if (*i == label)
   {
     ++fb_label_instances[i - fb_labels];
     return;
   }			/* if we find it  */
}			/* for each existing label  */
  }

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

if (fb_labels == NULL((void*)0))
  {
    fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY((10) + 6) * sizeof (long));
    fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY((10) + 6) * sizeof (long));
    fb_label_max = FB_LABEL_BUMP_BY((10) + 6);
    fb_label_count = FB_LABEL_SPECIAL(10);

  }
else if (fb_label_count == fb_label_max)
  {
    fb_label_max += FB_LABEL_BUMP_BY((10) + 6);
    fb_labels = (long *) xrealloc ((char *) fb_labels,
		     fb_label_max * sizeof (long));
    fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
			      fb_label_max * sizeof (long));
  }				/* if we needed to grow  */

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

1654static long
1655fb_label_instance (long label)
1656{
long *i;

if (label < FB_LABEL_SPECIAL(10))
  {
    return (fb_low_counter[label]);
  }

if (fb_labels != NULL((void*)0))
  {
    for (i = fb_labels + FB_LABEL_SPECIAL(10);
  i < fb_labels + fb_label_count; ++i)
{
 if (*i == label)
   {
     return (fb_label_instances[i - fb_labels]);
   }			/* if we find it  */
}			/* for each existing label  */
  }

/* We didn't find the label, so this must be a reference to the
   first instance.  */
return 0;
1679}

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

1692char *				/* Return local label name.  */
1693fb_label_name (long n,	/* We just saw "n:", "nf" or "nb" : n a number.  */
      long augend	/* 0 for nb, 1 for n:, nf.  */)
1695{
long i;
/* Returned to caller, then copied.  Used for created names ("4f").  */
static char symbol_name_build[24];
register char *p;
register char *q;
char symbol_name_temporary[20];	/* Build up a number, BACKWARDS.  */

know (n >= 0);
1704#ifdef TC_MMIX
know ((unsigned long) augend <= 2 /* See mmix_fb_label.  */);
1706#else
know ((unsigned long) augend <= 1);
1708#endif
p = symbol_name_build;
1710#ifdef LOCAL_LABEL_PREFIX
*p++ = LOCAL_LABEL_PREFIX;
1712#endif
*p++ = 'L';

/* Next code just does sprintf( {}, "%d", n);  */
/* Label number.  */
q = symbol_name_temporary;
for (*q++ = 0, i = n; i; ++q)
  {
    *q = i % 10 + '0';
    i /= 10;
  }
while ((*p = *--q) != '\0')
  ++p;

*p++ = LOCAL_LABEL_CHAR'\002';		/* ^B  */

/* Instance number.  */
q = symbol_name_temporary;
for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
  {
    *q = i % 10 + '0';
    i /= 10;
  }
while ((*p++ = *--q) != '\0')
;

/* The label, as a '\0' ended string, starts at symbol_name_build.  */
return (symbol_name_build);
1740}

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

1746char *
1747decode_local_label_name (char *s)
1748{
char *p;
char *symbol_decode;
int label_number;
int instance_number;
char *type;
const char *message_format;
int index = 0;

1757#ifdef LOCAL_LABEL_PREFIX
if (s[index] == LOCAL_LABEL_PREFIX)
  ++index;
1760#endif

if (s[index] != 'L')
  return s;

for (label_number = 0, p = s + index + 1; ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit
)); ++p)
  label_number = (10 * label_number) + *p - '0';

if (*p == DOLLAR_LABEL_CHAR'\001')
  type = "dollar";
else if (*p == LOCAL_LABEL_CHAR'\002')
  type = "fb";
else
  return s;

for (instance_number = 0, p++; ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit
)); ++p)
  instance_number = (10 * instance_number) + *p - '0';

message_format = _("\"%d\" (instance number %d of a %s label)")("\"%d\" (instance number %d of a %s label)");
symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30)__extension__ ({ struct obstack *__h = (&notes); __extension__
 ({ struct obstack *__o = (__h); int __len = ((strlen (message_format
) + 30)); if (__o->chunk_limit - __o->next_free < __len
) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len
)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h
); void *value; value = (void *) __o1->object_base; if (__o1
->next_free == value) __o1->maybe_empty_object = 1; __o1
->next_free = (((((__o1->next_free) - (char *) 0)+__o1->
alignment_mask) & ~ (__o1->alignment_mask)) + (char *)
 0); if (__o1->next_free - (char *)__o1->chunk > __o1
->chunk_limit - (char *)__o1->chunk) __o1->next_free
 = __o1->chunk_limit; __o1->object_base = __o1->next_free
; value; }); });
sprintf (symbol_decode, message_format, label_number, instance_number, type);

return symbol_decode;
1783}

1785/* Get the value of a symbol.  */

1787valueT
1788S_GET_VALUE (symbolS *s)
1789{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return resolve_symbol_value (s);

if (!s->sy_resolved)
  {
    valueT val = resolve_symbol_value (s);
    if (!finalize_syms)
return val;
  }
if (S_IS_WEAKREFR (s))
  return S_GET_VALUE (s->sy_value.X_add_symbol);

if (s->sy_value.X_op != O_constant)
  {
    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'")("attempt to get value of unresolved symbol `%s'"),
S_GET_NAME (s));
  }
return (valueT) s->sy_value.X_add_number;
1811}

1813/* Set the value of a symbol.  */

1815void
1816S_SET_VALUE (symbolS *s, valueT val)
1817{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  {
    ((struct local_symbol *) s)->lsy_value = val;
    return;
  }

s->sy_value.X_op = O_constant;
s->sy_value.X_add_number = (offsetT) val;
s->sy_value.X_unsigned = 0;
S_CLEAR_WEAKREFR (s);
1828}

1830void
1831copy_symbol_attributes (symbolS *dest, symbolS *src)
1832{
if (LOCAL_SYMBOL_CHECK (dest)(dest->bsym == ((void*)0) ? ((((struct local_symbol *) dest
)->lsy_section == reg_section) ? (dest = (((struct local_symbol
 *) dest)->u.lsy_sym), 0) : 1) : 0))
  dest = local_symbol_convert ((struct local_symbol *) dest);
if (LOCAL_SYMBOL_CHECK (src)(src->bsym == ((void*)0) ? ((((struct local_symbol *) src)
->lsy_section == reg_section) ? (src = (((struct local_symbol
 *) src)->u.lsy_sym), 0) : 1) : 0))
  src = local_symbol_convert ((struct local_symbol *) src);

/* In an expression, transfer the settings of these flags.
   The user can override later, of course.  */
1840#define COPIED_SYMFLAGS(0x10 | 0x10000)	(BSF_FUNCTION0x10 | BSF_OBJECT0x10000)
dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS(0x10 | 0x10000);

1843#ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src)(elf_copy_symbol_attributes (dest, src));
1845#endif
1846}

1848int
1849S_IS_FUNCTION (symbolS *s)
1850{
flagword flags;

if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;

flags = s->bsym->flags;

return (flags & BSF_FUNCTION0x10) != 0;
1859}

1861int
1862S_IS_EXTERNAL (symbolS *s)
1863{
flagword flags;

if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;

flags = s->bsym->flags;

/* Sanity check.  */
if ((flags & BSF_LOCAL0x01) && (flags & BSF_GLOBAL0x02))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 1873, __PRETTY_FUNCTION__);

return (flags & BSF_GLOBAL0x02) != 0;
1876}

1878int
1879S_IS_WEAK (symbolS *s)
1880{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
/* Conceptually, a weakrefr is weak if the referenced symbol is.  We
   could probably handle a WEAKREFR as always weak though.  E.g., if
   the referenced symbol has lost its weak status, there's no reason
   to keep handling the weakrefr as if it was weak.  */
if (S_IS_WEAKREFR (s))
  return S_IS_WEAK (s->sy_value.X_add_symbol);
return (s->bsym->flags & BSF_WEAK0x80) != 0;
1890}

1892int
1893S_IS_WEAKREFR (symbolS *s)
1894{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_weakrefr != 0;
1898}

1900int
1901S_IS_WEAKREFD (symbolS *s)
1902{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_weakrefd != 0;
1906}

1908int
1909S_IS_COMMON (symbolS *s)
1910{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0);
1914}

1916int
1917S_IS_DEFINED (symbolS *s)
1918{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return ((struct local_symbol *) s)->lsy_section != undefined_section((asection *) &bfd_und_section);
return s->bsym->section != undefined_section((asection *) &bfd_und_section);
1922}


1925#ifndef EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour)
1926#define EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour) IS_ELF1
1927#endif

1929/* Return true for symbols that should not be reduced to section
 symbols or eliminated from expressions, because they may be
 overridden by the linker.  */
1932int
1933S_FORCE_RELOC (symbolS *s, int strict)
1934{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return ((struct local_symbol *) s)->lsy_section == undefined_section((asection *) &bfd_und_section);

return ((strict
  && ((s->bsym->flags & BSF_WEAK0x80) != 0
      || (EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour)
   && (s->bsym->flags & BSF_GLOBAL0x02) != 0)))
 || s->bsym->section == undefined_section((asection *) &bfd_und_section)
 || bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0));
1944}

1946int
1947S_IS_DEBUG (symbolS *s)
1948{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
if (s->bsym->flags & BSF_DEBUGGING0x08)
  return 1;
return 0;
1954}

1956int
1957S_IS_LOCAL (symbolS *s)
1958{
flagword flags;
const char *name;

if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 1;

flags = s->bsym->flags;

/* Sanity check.  */
if ((flags & BSF_LOCAL0x01) && (flags & BSF_GLOBAL0x02))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 1969, __PRETTY_FUNCTION__);

if (bfd_get_section (s->bsym)((s->bsym)->section) == reg_section)
  return 1;

if (flag_strip_local_absolute
    /* Keep BSF_FILE symbols in order to allow debuggers to identify
the source file even when the object file is stripped.  */
    && (flags & (BSF_GLOBAL0x02 | BSF_FILE0x4000)) == 0
    && bfd_get_section (s->bsym)((s->bsym)->section) == absolute_section((asection *) &bfd_abs_section))
  return 1;

name = S_GET_NAME (s);
return (name != NULL((void*)0)
 && ! S_IS_DEBUG (s)
 && (strchr (name, DOLLAR_LABEL_CHAR'\001')
     || strchr (name, LOCAL_LABEL_CHAR'\002')
     || (! flag_keep_locals
  && (bfd_is_local_label (stdoutput, s->bsym)
      || (flag_mri
	  && name[0] == '?'
	  && name[1] == '?')))));
1991}

1993int
1994S_IS_STABD (symbolS *s)
1995{
return S_GET_NAME (s) == 0;
1997}

1999int
2000S_IS_VOLATILE (const symbolS *s)
2001{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_volatile;
2005}

2007int
2008S_IS_FORWARD_REF (const symbolS *s)
2009{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_forward_ref;
2013}

2015const char *
2016S_GET_NAME (symbolS *s)
2017{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return ((struct local_symbol *) s)->lsy_name;
return s->bsym->name;
2021}

2023segT
2024S_GET_SEGMENT (symbolS *s)
2025{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return ((struct local_symbol *) s)->lsy_section;
return s->bsym->section;
2029}

2031void
2032S_SET_SEGMENT (symbolS *s, segT seg)
2033{
/* 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)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  {
    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_SYM0x100)
  {
    if (s->bsym->section != seg)
abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 2052, __PRETTY_FUNCTION__);
  }
else
  s->bsym->section = seg;
2056}

2058void
2059S_SET_EXTERNAL (symbolS *s)
2060{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
if ((s->bsym->flags & BSF_WEAK0x80) != 0)
  {
    /* Let .weak override .global.  */
    return;
  }
if (s->bsym->flags & BSF_SECTION_SYM0x100)
  {
    char * file;
    unsigned int line;

    /* Do not reassign section symbols.  */
    as_where (& file, & line);
    as_warn_where (file, line,
     _("section symbols are already global")("section symbols are already global"));
    return;
  }
s->bsym->flags |= BSF_GLOBAL0x02;
s->bsym->flags &= ~(BSF_LOCAL0x01 | BSF_WEAK0x80);

2082#ifdef USE_UNIQUE
if (! an_external_name && S_GET_NAME(s)[0] != '.')
  an_external_name = S_GET_NAME (s);
2085#endif
2086}

2088void
2089S_CLEAR_EXTERNAL (symbolS *s)
2090{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
if ((s->bsym->flags & BSF_WEAK0x80) != 0)
  {
    /* Let .weak override.  */
    return;
  }
s->bsym->flags |= BSF_LOCAL0x01;
s->bsym->flags &= ~(BSF_GLOBAL0x02 | BSF_WEAK0x80);
2100}

2102void
2103S_SET_WEAK (symbolS *s)
2104{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
2107#ifdef obj_set_weak_hook
obj_set_weak_hook (s);
2109#endif
s->bsym->flags |= BSF_WEAK0x80;
s->bsym->flags &= ~(BSF_GLOBAL0x02 | BSF_LOCAL0x01);
2112}

2114void
2115S_SET_WEAKREFR (symbolS *s)
2116{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_weakrefr = 1;
/* If the alias was already used, make sure we mark the target as
   used as well, otherwise it might be dropped from the symbol
   table.  This may have unintended side effects if the alias is
   later redirected to another symbol, such as keeping the unused
   previous target in the symbol table.  Since it will be weak, it's
   not a big deal.  */
if (s->sy_used)
  symbol_mark_used (s->sy_value.X_add_symbol);
2128}

2130void
2131S_CLEAR_WEAKREFR (symbolS *s)
2132{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->sy_weakrefr = 0;
2136}

2138void
2139S_SET_WEAKREFD (symbolS *s)
2140{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_weakrefd = 1;
S_SET_WEAK (s);
2145}

2147void
2148S_CLEAR_WEAKREFD (symbolS *s)
2149{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
if (s->sy_weakrefd)
  {
    s->sy_weakrefd = 0;
    /* If a weakref target symbol is weak, then it was never
referenced directly before, not even in a .global directive,
so decay it to local.  If it remains undefined, it will be
later turned into a global, like any other undefined
symbol.  */
    if (s->bsym->flags & BSF_WEAK0x80)
{
2162#ifdef obj_clear_weak_hook
 obj_clear_weak_hook (s);
2164#endif
 s->bsym->flags &= ~BSF_WEAK0x80;
 s->bsym->flags |= BSF_LOCAL0x01;
}
  }
2169}

2171void
2172S_SET_THREAD_LOCAL (symbolS *s)
2173{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
if (bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0)
    && (s->bsym->flags & BSF_THREAD_LOCAL0x40000) != 0)
  return;
s->bsym->flags |= BSF_THREAD_LOCAL0x40000;
if ((s->bsym->flags & BSF_FUNCTION0x10) != 0)
  as_bad (_("Accessing function `%s' as thread-local object")("Accessing function `%s' as thread-local object"),
   S_GET_NAME (s));
else if (! bfd_is_und_section (s->bsym->section)((s->bsym->section) == ((asection *) &bfd_und_section
))
  && (s->bsym->section->flags & SEC_THREAD_LOCAL0x400) == 0)
  as_bad (_("Accessing `%s' as thread-local object")("Accessing `%s' as thread-local object"),
   S_GET_NAME (s));
2187}

2189void
2190S_SET_NAME (symbolS *s, const char *name)
2191{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  {
    ((struct local_symbol *) s)->lsy_name = name;
    return;
  }
s->bsym->name = name;
2198}

2200void
2201S_SET_VOLATILE (symbolS *s)
2202{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_volatile = 1;
2206}

2208void
2209S_CLEAR_VOLATILE (symbolS *s)
2210{
if (!LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s->sy_volatile = 0;
2213}

2215void
2216S_SET_FORWARD_REF (symbolS *s)
2217{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_forward_ref = 1;
2221}

2223/* Return the previous symbol in a chain.  */

2225symbolS *
2226symbol_previous (symbolS *s)
2227{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 2229, __PRETTY_FUNCTION__);
return s->sy_previous;
2231}

2233/* Return the next symbol in a chain.  */

2235symbolS *
2236symbol_next (symbolS *s)
2237{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c",
 2239, __PRETTY_FUNCTION__);
return s->sy_next;
2241}

2243/* Return a pointer to the value of a symbol as an expression.  */

2245expressionS *
2246symbol_get_value_expression (symbolS *s)
2247{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
return &s->sy_value;
2251}

2253/* Set the value of a symbol to an expression.  */

2255void
2256symbol_set_value_expression (symbolS *s, const expressionS *exp)
2257{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_value = *exp;
S_CLEAR_WEAKREFR (s);
2262}

2264/* Return a pointer to the X_add_number component of a symbol.  */

2266offsetT *
2267symbol_X_add_number (symbolS *s)
2268{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return (offsetT *) &((struct local_symbol *) s)->lsy_value;

return &s->sy_value.X_add_number;
2273}

2275/* Set the value of SYM to the current position in the current segment.  */

2277void
2278symbol_set_value_now (symbolS *sym)
2279{
S_SET_SEGMENT (sym, now_seg);
S_SET_VALUE (sym, frag_now_fix ());
symbol_set_frag (sym, frag_now);
2283}

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

2287void
2288symbol_set_frag (symbolS *s, fragS *f)
2289{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  {
    local_symbol_set_frag ((struct local_symbol *) s, f)(((struct local_symbol *) s)->u.lsy_frag = (f));
    return;
  }
s->sy_frag = f;
S_CLEAR_WEAKREFR (s);
2297}

2299/* Return the frag of a symbol.  */

2301fragS *
2302symbol_get_frag (symbolS *s)
2303{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return local_symbol_get_frag ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag);
return s->sy_frag;
2307}

2309/* Mark a symbol as having been used.  */

2311void
2312symbol_mark_used (symbolS *s)
2313{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->sy_used = 1;
if (S_IS_WEAKREFR (s))
  symbol_mark_used (s->sy_value.X_add_symbol);
2319}

2321/* Clear the mark of whether a symbol has been used.  */

2323void
2324symbol_clear_used (symbolS *s)
2325{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_used = 0;
2329}

2331/* Return whether a symbol has been used.  */

2333int
2334symbol_used_p (symbolS *s)
2335{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 1;
return s->sy_used;
2339}

2341/* Mark a symbol as having been used in a reloc.  */

2343void
2344symbol_mark_used_in_reloc (symbolS *s)
2345{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_used_in_reloc = 1;
2349}

2351/* Clear the mark of whether a symbol has been used in a reloc.  */

2353void
2354symbol_clear_used_in_reloc (symbolS *s)
2355{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->sy_used_in_reloc = 0;
2359}

2361/* Return whether a symbol has been used in a reloc.  */

2363int
2364symbol_used_in_reloc_p (symbolS *s)
2365{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_used_in_reloc;
2369}

2371/* Mark a symbol as an MRI common symbol.  */

2373void
2374symbol_mark_mri_common (symbolS *s)
2375{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_mri_common = 1;
2379}

2381/* Clear the mark of whether a symbol is an MRI common symbol.  */

2383void
2384symbol_clear_mri_common (symbolS *s)
2385{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->sy_mri_common = 0;
2389}

2391/* Return whether a symbol is an MRI common symbol.  */

2393int
2394symbol_mri_common_p (symbolS *s)
2395{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_mri_common;
2399}

2401/* Mark a symbol as having been written.  */

2403void
2404symbol_mark_written (symbolS *s)
2405{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->written = 1;
2409}

2411/* Clear the mark of whether a symbol has been written.  */

2413void
2414symbol_clear_written (symbolS *s)
2415{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return;
s->written = 0;
2419}

2421/* Return whether a symbol has been written.  */

2423int
2424symbol_written_p (symbolS *s)
2425{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->written;
2429}

2431/* Mark a symbol has having been resolved.  */

2433void
2434symbol_mark_resolved (symbolS *s)
2435{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  {
    local_symbol_mark_resolved ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag = ((void*)0));
    return;
  }
s->sy_resolved = 1;
2442}

2444/* Return whether a symbol has been resolved.  */

2446int
2447symbol_resolved_p (symbolS *s)
2448{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return local_symbol_resolved_p ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag == ((void*)0));
return s->sy_resolved;
2452}

2454/* Return whether a symbol is a section symbol.  */

2456int
2457symbol_section_p (symbolS *s ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2458{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return (s->bsym->flags & BSF_SECTION_SYM0x100) != 0;
2462}

2464/* Return whether a symbol is equated to another symbol.  */

2466int
2467symbol_equated_p (symbolS *s)
2468{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 0;
return s->sy_value.X_op == O_symbol;
2472}

2474/* Return whether a symbol is equated to another symbol, and should be
 treated specially when writing out relocs.  */

2477int
2478symbol_equated_reloc_p (symbolS *s)
2479{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  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
2486#if defined (OBJ_COFF) && defined (TE_PE)
 && ! S_IS_WEAK (s)
2488#endif
 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL((void*)0))
     || ! S_IS_DEFINED (s)
     || S_IS_COMMON (s)));
2492}

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

2496int
2497symbol_constant_p (symbolS *s)
2498{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  return 1;
return s->sy_value.X_op == O_constant;
2502}

2504/* Return the BFD symbol for a symbol.  */

2506asymbol *
2507symbol_get_bfdsym (symbolS *s)
2508{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
return s->bsym;
2512}

2514/* Set the BFD symbol for a symbol.  */

2516void
2517symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2518{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
/* Usually, it is harmless to reset a symbol to a BFD section
   symbol. For example, obj_elf_change_section sets the BFD symbol
   of an old symbol with the newly created section symbol. But when
   we have multiple sections with the same name, the newly created
   section may have the same name as an old section. We check if the
   old symbol has been already marked as a section symbol before
   resetting it.  */
if ((s->bsym->flags & BSF_SECTION_SYM0x100) == 0)
  s->bsym = bsym;
/* else XXX - What do we do now ?  */
2531}

2533#ifdef OBJ_SYMFIELD_TYPEstruct elf_obj_sy

2535/* Get a pointer to the object format information for a symbol.  */

2537OBJ_SYMFIELD_TYPEstruct elf_obj_sy *
2538symbol_get_obj (symbolS *s)
2539{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
return &s->sy_obj;
2543}

2545/* Set the object format information for a symbol.  */

2547void
2548symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPEstruct elf_obj_sy *o)
2549{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_obj = *o;
2553}

2555#endif /* OBJ_SYMFIELD_TYPE */

2557#ifdef TC_SYMFIELD_TYPE

2559/* Get a pointer to the processor information for a symbol.  */

2561TC_SYMFIELD_TYPE *
2562symbol_get_tc (symbolS *s)
2563{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
return &s->sy_tc;
2567}

2569/* Set the processor information for a symbol.  */

2571void
2572symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2573{
if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)->
lsy_section == reg_section) ? (s = (((struct local_symbol *) s
)->u.lsy_sym), 0) : 1) : 0))
  s = local_symbol_convert ((struct local_symbol *) s);
s->sy_tc = *o;
2577}

2579#endif /* TC_SYMFIELD_TYPE */

2581void
2582symbol_begin (void)
2583{
symbol_lastP = NULL((void*)0);
symbol_rootP = NULL((void*)0);		/* In case we have 0 symbols (!!)  */
sy_hash = hash_new ();
local_hash = hash_new ();

memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2590#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
abs_symbol.bsym = bfd_abs_section.symbol;
2592#endif
abs_symbol.sy_value.X_op = O_constant;
abs_symbol.sy_frag = &zero_address_frag;

if (LOCAL_LABELS_FB1)
  fb_label_init ();
2598}
2599
2600int indent_level;

2602/* Maximum indent level.
 Available for modification inside a gdb session.  */
2604static int max_indent_level = 8;

2606void
2607print_symbol_value_1 (FILE *file, symbolS *sym)
2608{
const char *name = S_GET_NAME (sym);
if (!name || !name[0])
  name = "(unnamed)";
fprintf (file, "sym %lx %s", (unsigned long) sym, name);

if (LOCAL_SYMBOL_CHECK (sym)(sym->bsym == ((void*)0) ? ((((struct local_symbol *) sym)
->lsy_section == reg_section) ? (sym = (((struct local_symbol
 *) sym)->u.lsy_sym), 0) : 1) : 0))
  {
    struct local_symbol *locsym = (struct local_symbol *) sym;
    if (local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != &zero_address_frag
 && local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != NULL((void*)0))
fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym)((locsym)->u.lsy_frag));
    if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0)))
fprintf (file, " resolved");
    fprintf (file, " local");
  }
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_EXTERNAL (sym))
fprintf (file, " extern");
    if (S_IS_WEAK (sym))
fprintf (file, " weak");
    if (S_IS_DEBUG (sym))
fprintf (file, " debug");
    if (S_IS_DEFINED (sym))
fprintf (file, " defined");
  }
if (S_IS_WEAKREFR (sym))
  fprintf (file, " weakrefr");
if (S_IS_WEAKREFD (sym))
  fprintf (file, " weakrefd");
fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym))((S_GET_SEGMENT (sym))->name + 0));
if (symbol_resolved_p (sym))
  {
    segT s = S_GET_SEGMENT (sym);

    if (s != undefined_section((asection *) &bfd_und_section)
 && s != expr_section)
fprintf (file, " %lx", (long) S_GET_VALUE (sym));
  }
else if (indent_level < max_indent_level
  && S_GET_SEGMENT (sym) != undefined_section((asection *) &bfd_und_section))
  {
    indent_level++;
    fprintf (file, "\n%*s<", indent_level * 4, "");
    if (LOCAL_SYMBOL_CHECK (sym)(sym->bsym == ((void*)0) ? ((((struct local_symbol *) sym)
->lsy_section == reg_section) ? (sym = (((struct local_symbol
 *) sym)->u.lsy_sym), 0) : 1) : 0))
fprintf (file, "constant %lx",
 (long) ((struct local_symbol *) sym)->lsy_value);
    else
print_expr_1 (file, &sym->sy_value);
    fprintf (file, ">");
    indent_level--;
  }
fflush (file);
2676}

2678void
2679print_symbol_value (symbolS *sym)
2680{
indent_level = 0;
print_symbol_value_1 (stderr(&__sF[2]), sym);
fprintf (stderr(&__sF[2]), "\n");
2684}

2686static void
2687print_binary (FILE *file, const char *name, expressionS *exp)
2688{
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--;
2696}

2698void
2699print_expr_1 (FILE *file, expressionS *exp)
2700{
fprintf (file, "expr %lx ", (long) exp);
switch (exp->X_op)
  {
  case O_illegal:
    fprintf (file, "illegal");
    break;
  case O_absent:
    fprintf (file, "absent");
    break;
  case O_constant:
    fprintf (file, "constant %lx", (long) exp->X_add_number);
    break;
  case O_symbol:
    indent_level++;
    fprintf (file, "symbol\n%*s<", indent_level * 4, "");
    print_symbol_value_1 (file, exp->X_add_symbol);
    fprintf (file, ">");
  maybe_print_addnum:
    if (exp->X_add_number)
fprintf (file, "\n%*s%lx", indent_level * 4, "",
 (long) exp->X_add_number);
    indent_level--;
    break;
  case O_register:
    fprintf (file, "register #%d", (int) exp->X_add_number);
    break;
  case O_big:
    fprintf (file, "big");
    break;
  case O_uminus:
    fprintf (file, "uminus -<");
    indent_level++;
    print_symbol_value_1 (file, exp->X_add_symbol);
    fprintf (file, ">");
    goto maybe_print_addnum;
  case O_bit_not:
    fprintf (file, "bit_not");
    break;
  case O_multiply:
    print_binary (file, "multiply", exp);
    break;
  case O_divide:
    print_binary (file, "divide", exp);
    break;
  case O_modulus:
    print_binary (file, "modulus", exp);
    break;
  case O_left_shift:
    print_binary (file, "lshift", exp);
    break;
  case O_right_shift:
    print_binary (file, "rshift", exp);
    break;
  case O_bit_inclusive_or:
    print_binary (file, "bit_ior", exp);
    break;
  case O_bit_exclusive_or:
    print_binary (file, "bit_xor", exp);
    break;
  case O_bit_and:
    print_binary (file, "bit_and", exp);
    break;
  case O_eq:
    print_binary (file, "eq", exp);
    break;
  case O_ne:
    print_binary (file, "ne", exp);
    break;
  case O_lt:
    print_binary (file, "lt", exp);
    break;
  case O_le:
    print_binary (file, "le", exp);
    break;
  case O_ge:
    print_binary (file, "ge", exp);
    break;
  case O_gt:
    print_binary (file, "gt", exp);
    break;
  case O_logical_and:
    print_binary (file, "logical_and", exp);
    break;
  case O_logical_or:
    print_binary (file, "logical_or", exp);
    break;
  case O_add:
    indent_level++;
    fprintf (file, "add\n%*s<", 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, ">");
    goto maybe_print_addnum;
  case O_subtract:
    indent_level++;
    fprintf (file, "subtract\n%*s<", 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, ">");
    goto maybe_print_addnum;
  default:
    fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
    break;
  }
fflush (stdout(&__sF[1]));
2808}

2810void
2811print_expr (expressionS *exp)
2812{
print_expr_1 (stderr(&__sF[2]), exp);
fprintf (stderr(&__sF[2]), "\n");
2815}

2817void
2818symbol_print_statistics (FILE *file)
2819{
hash_print_statistics (file, "symbol table", sy_hash);
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);
2824}