gas/symbols.c

   1 /* symbols.c -symbol table-
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* #define DEBUG_SYMS / * to debug symbol list maintenance.  */
  24
  25 #include "as.h"
  26
  27 #include "safe-ctype.h"
  28 #include "obstack.h"            /* For "symbols.h" */
  29 #include "subsegs.h"
  30
  31 #include "struc-symbol.h"
  32
  33 /* This is non-zero if symbols are case sensitive, which is the
  34    default.  */
  35 int symbols_case_sensitive = 1;
  36
  37 #ifndef WORKING_DOT_WORD
  38 extern int new_broken_words;
  39 #endif
  40
  41 /* symbol-name => struct symbol pointer */
  42 static struct hash_control *sy_hash;
  43
  44 /* Table of local symbols.  */
  45 static struct hash_control *local_hash;
  46
  47 /* Below are commented in "symbols.h".  */
  48 symbolS *symbol_rootP;
  49 symbolS *symbol_lastP;
  50 symbolS abs_symbol;
  51
  52 #ifdef DEBUG_SYMS
  53 #define debug_verify_symchain verify_symbol_chain
  54 #else
  55 #define debug_verify_symchain(root, last) ((void) 0)
  56 #endif
  57
  58 #define DOLLAR_LABEL_CHAR       '\001'
  59 #define LOCAL_LABEL_CHAR        '\002'
  60
  61 struct obstack notes;
  62 #ifdef USE_UNIQUE
  63 /* The name of an external symbol which is
  64    used to make weak PE symbol names unique.  */
  65 const char * an_external_name;
  66 #endif
  67
  68 static char *save_symbol_name (const char *);
  69 static void fb_label_init (void);
  70 static long dollar_label_instance (long);
  71 static long fb_label_instance (long);
  72
  73 static void print_binary (FILE *, const char *, expressionS *);
  74 static void report_op_error (symbolS *, symbolS *, symbolS *);
  75
  76 /* Return a pointer to a new symbol.  Die if we can't make a new
  77    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
  78    chain.
  79
  80    This function should be called in the general case of creating a
  81    symbol.  However, if the output file symbol table has already been
  82    set, and you are certain that this symbol won't be wanted in the
  83    output file, you can call symbol_create.  */
  84
  85 symbolS *
  86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
  87 {
  88   symbolS *symbolP = symbol_create (name, segment, valu, frag);
  89
  90   /* Link to end of symbol chain.  */
  91   {
  92     extern int symbol_table_frozen;
  93     if (symbol_table_frozen)
  94       abort ();
  95   }
  96   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
  97
  98   return symbolP;
  99 }
 100
 101 /* Save a symbol name on a permanent obstack, and convert it according
 102    to the object file format.  */
 103
 104 static char *
 105 save_symbol_name (const char *name)
 106 {
 107   unsigned int name_length;
 108   char *ret;
 109
 110   name_length = strlen (name) + 1;      /* +1 for \0.  */
 111   obstack_grow (&notes, name, name_length);
 112   ret = obstack_finish (&notes);
 113
 114 #ifdef tc_canonicalize_symbol_name
 115   ret = tc_canonicalize_symbol_name (ret);
 116 #endif
 117
 118   if (! symbols_case_sensitive)
 119     {
 120       char *s;
 121
 122       for (s = ret; *s != '\0'; s++)
 123         *s = TOUPPER (*s);
 124     }
 125
 126   return ret;
 127 }
 128
 129 symbolS *
 130 symbol_create (const char *name, /* It is copied, the caller can destroy/modify.  */
 131                segT segment,    /* Segment identifier (SEG_<something>).  */
 132                valueT valu,     /* Symbol value.  */
 133                fragS *frag      /* Associated fragment.  */)
 134 {
 135   char *preserved_copy_of_name;
 136   symbolS *symbolP;
 137
 138   preserved_copy_of_name = save_symbol_name (name);
 139
 140   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 141
 142   /* symbol must be born in some fixed state.  This seems as good as any.  */
 143   memset (symbolP, 0, sizeof (symbolS));
 144
 145   symbolP->bsym = bfd_make_empty_symbol (stdoutput);
 146   if (symbolP->bsym == NULL)
 147     as_perror ("%s", "bfd_make_empty_symbol");
 148   symbolP->bsym->udata.p = (PTR) symbolP;
 149   S_SET_NAME (symbolP, preserved_copy_of_name);
 150
 151   S_SET_SEGMENT (symbolP, segment);
 152   S_SET_VALUE (symbolP, valu);
 153   symbol_clear_list_pointers (symbolP);
 154
 155   symbolP->sy_frag = frag;
 156
 157   obj_symbol_new_hook (symbolP);
 158
 159 #ifdef tc_symbol_new_hook
 160   tc_symbol_new_hook (symbolP);
 161 #endif
 162
 163   return symbolP;
 164 }
 165 \f
 166
 167 /* Local symbol support.  If we can get away with it, we keep only a
 168    small amount of information for local symbols.  */
 169
 170 static symbolS *local_symbol_convert (struct local_symbol *);
 171
 172 /* Used for statistics.  */
 173
 174 static unsigned long local_symbol_count;
 175 static unsigned long local_symbol_conversion_count;
 176
 177 /* This macro is called with a symbol argument passed by reference.
 178    It returns whether this is a local symbol.  If necessary, it
 179    changes its argument to the real symbol.  */
 180
 181 #define LOCAL_SYMBOL_CHECK(s)                                           \
 182   (s->bsym == NULL                                                      \
 183    ? (local_symbol_converted_p ((struct local_symbol *) s)              \
 184       ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s),  \
 185          0)                                                             \
 186       : 1)                                                              \
 187    : 0)
 188
 189 /* Create a local symbol and insert it into the local hash table.  */
 190
 191 static struct local_symbol *
 192 local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
 193 {
 194   char *name_copy;
 195   struct local_symbol *ret;
 196
 197   ++local_symbol_count;
 198
 199   name_copy = save_symbol_name (name);
 200
 201   ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
 202   ret->lsy_marker = NULL;
 203   ret->lsy_name = name_copy;
 204   ret->lsy_section = section;
 205   local_symbol_set_frag (ret, frag);
 206   ret->lsy_value = value;
 207
 208   hash_jam (local_hash, name_copy, (PTR) ret);
 209
 210   return ret;
 211 }
 212
 213 /* Convert a local symbol into a real symbol.  Note that we do not
 214    reclaim the space used by the local symbol.  */
 215
 216 static symbolS *
 217 local_symbol_convert (struct local_symbol *locsym)
 218 {
 219   symbolS *ret;
 220
 221   assert (locsym->lsy_marker == NULL);
 222   if (local_symbol_converted_p (locsym))
 223     return local_symbol_get_real_symbol (locsym);
 224
 225   ++local_symbol_conversion_count;
 226
 227   ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
 228                     local_symbol_get_frag (locsym));
 229
 230   if (local_symbol_resolved_p (locsym))
 231     ret->sy_resolved = 1;
 232
 233   /* Local symbols are always either defined or used.  */
 234   ret->sy_used = 1;
 235
 236 #ifdef TC_LOCAL_SYMFIELD_CONVERT
 237   TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
 238 #endif
 239
 240   symbol_table_insert (ret);
 241
 242   local_symbol_mark_converted (locsym);
 243   local_symbol_set_real_symbol (locsym, ret);
 244
 245   hash_jam (local_hash, locsym->lsy_name, NULL);
 246
 247   return ret;
 248 }
 249 \f
 250 /* We have just seen "<name>:".
 251    Creates a struct symbol unless it already exists.
 252
 253    Gripes if we are redefining a symbol incompatibly (and ignores it).  */
 254
 255 symbolS *
 256 colon (/* Just seen "x:" - rattle symbols & frags.  */
 257        const char *sym_name     /* Symbol name, as a cannonical string.  */
 258        /* We copy this string: OK to alter later.  */)
 259 {
 260   register symbolS *symbolP;    /* Symbol we are working with.  */
 261
 262   /* Sun local labels go out of scope whenever a non-local symbol is
 263      defined.  */
 264   if (LOCAL_LABELS_DOLLAR
 265       && !bfd_is_local_label_name (stdoutput, sym_name))
 266     dollar_label_clear ();
 267
 268 #ifndef WORKING_DOT_WORD
 269   if (new_broken_words)
 270     {
 271       struct broken_word *a;
 272       int possible_bytes;
 273       fragS *frag_tmp;
 274       char *frag_opcode;
 275
 276       if (now_seg == absolute_section)
 277         {
 278           as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
 279           return NULL;
 280         }
 281
 282       possible_bytes = (md_short_jump_size
 283                         + new_broken_words * md_long_jump_size);
 284
 285       frag_tmp = frag_now;
 286       frag_opcode = frag_var (rs_broken_word,
 287                               possible_bytes,
 288                               possible_bytes,
 289                               (relax_substateT) 0,
 290                               (symbolS *) broken_words,
 291                               (offsetT) 0,
 292                               NULL);
 293
 294       /* We want to store the pointer to where to insert the jump
 295          table in the fr_opcode of the rs_broken_word frag.  This
 296          requires a little hackery.  */
 297       while (frag_tmp
 298              && (frag_tmp->fr_type != rs_broken_word
 299                  || frag_tmp->fr_opcode))
 300         frag_tmp = frag_tmp->fr_next;
 301       know (frag_tmp);
 302       frag_tmp->fr_opcode = frag_opcode;
 303       new_broken_words = 0;
 304
 305       for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
 306         a->dispfrag = frag_tmp;
 307     }
 308 #endif /* WORKING_DOT_WORD */
 309
 310   if ((symbolP = symbol_find (sym_name)) != 0)
 311     {
 312       S_CLEAR_WEAKREFR (symbolP);
 313 #ifdef RESOLVE_SYMBOL_REDEFINITION
 314       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
 315         return symbolP;
 316 #endif
 317       /* Now check for undefined symbols.  */
 318       if (LOCAL_SYMBOL_CHECK (symbolP))
 319         {
 320           struct local_symbol *locsym = (struct local_symbol *) symbolP;
 321
 322           if (locsym->lsy_section != undefined_section
 323               && (local_symbol_get_frag (locsym) != frag_now
 324                   || locsym->lsy_section != now_seg
 325                   || locsym->lsy_value != frag_now_fix ()))
 326             {
 327               as_bad (_("symbol `%s' is already defined"), sym_name);
 328               return symbolP;
 329             }
 330
 331           locsym->lsy_section = now_seg;
 332           local_symbol_set_frag (locsym, frag_now);
 333           locsym->lsy_value = frag_now_fix ();
 334         }
 335       else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
 336                || S_IS_COMMON (symbolP)
 337                || S_IS_VOLATILE (symbolP))
 338         {
 339           if (S_IS_VOLATILE (symbolP)
 340               /* This could be avoided when the symbol wasn't used so far, but
 341                  the comment in struc-symbol.h says this flag isn't reliable.  */
 342               && (1 || !symbol_used_p (symbolP)))
 343             {
 344               symbolP = symbol_clone (symbolP, 1);
 345               S_SET_VALUE (symbolP, 0);
 346               S_CLEAR_VOLATILE (symbolP);
 347             }
 348           if (S_GET_VALUE (symbolP) == 0)
 349             {
 350               symbolP->sy_frag = frag_now;
 351 #ifdef OBJ_VMS
 352               S_SET_OTHER (symbolP, const_flag);
 353 #endif
 354               S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 355               S_SET_SEGMENT (symbolP, now_seg);
 356 #ifdef N_UNDF
 357               know (N_UNDF == 0);
 358 #endif /* if we have one, it better be zero.  */
 359
 360             }
 361           else
 362             {
 363               /* There are still several cases to check:
 364
 365                  A .comm/.lcomm symbol being redefined as initialized
 366                  data is OK
 367
 368                  A .comm/.lcomm symbol being redefined with a larger
 369                  size is also OK
 370
 371                  This only used to be allowed on VMS gas, but Sun cc
 372                  on the sparc also depends on it.  */
 373
 374               if (((!S_IS_DEBUG (symbolP)
 375                     && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
 376                     && S_IS_EXTERNAL (symbolP))
 377                    || S_GET_SEGMENT (symbolP) == bss_section)
 378                   && (now_seg == data_section
 379                       || now_seg == S_GET_SEGMENT (symbolP)))
 380                 {
 381                   /* Select which of the 2 cases this is.  */
 382                   if (now_seg != data_section)
 383                     {
 384                       /* New .comm for prev .comm symbol.
 385
 386                          If the new size is larger we just change its
 387                          value.  If the new size is smaller, we ignore
 388                          this symbol.  */
 389                       if (S_GET_VALUE (symbolP)
 390                           < ((unsigned) frag_now_fix ()))
 391                         {
 392                           S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 393                         }
 394                     }
 395                   else
 396                     {
 397                       /* It is a .comm/.lcomm being converted to initialized
 398                          data.  */
 399                       symbolP->sy_frag = frag_now;
 400 #ifdef OBJ_VMS
 401                       S_SET_OTHER (symbolP, const_flag);
 402 #endif
 403                       S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 404                       S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit.  */
 405                     }
 406                 }
 407               else
 408                 {
 409 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
 410      && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
 411                   static const char *od_buf = "";
 412 #else
 413                   char od_buf[100];
 414                   od_buf[0] = '\0';
 415                   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
 416                     sprintf (od_buf, "%d.%d.",
 417                              S_GET_OTHER (symbolP),
 418                              S_GET_DESC (symbolP));
 419 #endif
 420                   as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
 421                             sym_name,
 422                             segment_name (S_GET_SEGMENT (symbolP)),
 423                             od_buf,
 424                             (long) S_GET_VALUE (symbolP));
 425                 }
 426             }                   /* if the undefined symbol has no value  */
 427         }
 428       else
 429         {
 430           /* Don't blow up if the definition is the same.  */
 431           if (!(frag_now == symbolP->sy_frag
 432                 && S_GET_VALUE (symbolP) == frag_now_fix ()
 433                 && S_GET_SEGMENT (symbolP) == now_seg))
 434             {
 435               as_bad (_("symbol `%s' is already defined"), sym_name);
 436               symbolP = symbol_clone (symbolP, 0);
 437             }
 438         }
 439
 440     }
 441   else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
 442     {
 443       symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
 444                                                (valueT) frag_now_fix (),
 445                                                frag_now);
 446     }
 447   else
 448     {
 449       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
 450                             frag_now);
 451 #ifdef OBJ_VMS
 452       S_SET_OTHER (symbolP, const_flag);
 453 #endif /* OBJ_VMS */
 454
 455       symbol_table_insert (symbolP);
 456     }
 457
 458   if (mri_common_symbol != NULL)
 459     {
 460       /* This symbol is actually being defined within an MRI common
 461          section.  This requires special handling.  */
 462       if (LOCAL_SYMBOL_CHECK (symbolP))
 463         symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
 464       symbolP->sy_value.X_op = O_symbol;
 465       symbolP->sy_value.X_add_symbol = mri_common_symbol;
 466       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
 467       symbolP->sy_frag = &zero_address_frag;
 468       S_SET_SEGMENT (symbolP, expr_section);
 469       symbolP->sy_mri_common = 1;
 470     }
 471
 472 #ifdef tc_frob_label
 473   tc_frob_label (symbolP);
 474 #endif
 475 #ifdef obj_frob_label
 476   obj_frob_label (symbolP);
 477 #endif
 478
 479   return symbolP;
 480 }
 481 \f
 482 /* Die if we can't insert the symbol.  */
 483
 484 void
 485 symbol_table_insert (symbolS *symbolP)
 486 {
 487   register const char *error_string;
 488
 489   know (symbolP);
 490   know (S_GET_NAME (symbolP));
 491
 492   if (LOCAL_SYMBOL_CHECK (symbolP))
 493     {
 494       error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
 495                                (PTR) symbolP);
 496       if (error_string != NULL)
 497         as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
 498                   S_GET_NAME (symbolP), error_string);
 499       return;
 500     }
 501
 502   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
 503     {
 504       as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
 505                 S_GET_NAME (symbolP), error_string);
 506     }                           /* on error  */
 507 }
 508 \f
 509 /* If a symbol name does not exist, create it as undefined, and insert
 510    it into the symbol table.  Return a pointer to it.  */
 511
 512 symbolS *
 513 symbol_find_or_make (const char *name)
 514 {
 515   register symbolS *symbolP;
 516
 517   symbolP = symbol_find (name);
 518
 519   if (symbolP == NULL)
 520     {
 521       if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
 522         {
 523           symbolP = md_undefined_symbol ((char *) name);
 524           if (symbolP != NULL)
 525             return symbolP;
 526
 527           symbolP = (symbolS *) local_symbol_make (name, undefined_section,
 528                                                    (valueT) 0,
 529                                                    &zero_address_frag);
 530           return symbolP;
 531         }
 532
 533       symbolP = symbol_make (name);
 534
 535       symbol_table_insert (symbolP);
 536     }                           /* if symbol wasn't found */
 537
 538   return (symbolP);
 539 }
 540
 541 symbolS *
 542 symbol_make (const char *name)
 543 {
 544   symbolS *symbolP;
 545
 546   /* Let the machine description default it, e.g. for register names.  */
 547   symbolP = md_undefined_symbol ((char *) name);
 548
 549   if (!symbolP)
 550     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
 551
 552   return (symbolP);
 553 }
 554
 555 symbolS *
 556 symbol_clone (symbolS *orgsymP, int replace)
 557 {
 558   symbolS *newsymP;
 559   asymbol *bsymorg, *bsymnew;
 560
 561   /* Running local_symbol_convert on a clone that's not the one currently
 562      in local_hash would incorrectly replace the hash entry.  Thus the
 563      symbol must be converted here.  Note that the rest of the function
 564      depends on not encountering an unconverted symbol.  */
 565   if (LOCAL_SYMBOL_CHECK (orgsymP))
 566     orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
 567   bsymorg = orgsymP->bsym;
 568
 569   know (S_IS_DEFINED (orgsymP));
 570
 571   newsymP = obstack_alloc (&notes, sizeof (*newsymP));
 572   *newsymP = *orgsymP;
 573   bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
 574   if (bsymnew == NULL)
 575     as_perror ("%s", "bfd_make_empty_symbol");
 576   newsymP->bsym = bsymnew;
 577   bsymnew->name = bsymorg->name;
 578   bsymnew->flags =  bsymorg->flags;
 579   bsymnew->section =  bsymorg->section;
 580   bsymnew->udata.p = (PTR) newsymP;
 581   bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
 582                                 bfd_asymbol_bfd (bsymnew), bsymnew);
 583
 584 #ifdef obj_symbol_clone_hook
 585   obj_symbol_clone_hook (newsymP, orgsymP);
 586 #endif
 587
 588 #ifdef tc_symbol_clone_hook
 589   tc_symbol_clone_hook (newsymP, orgsymP);
 590 #endif
 591
 592   if (replace)
 593     {
 594       if (symbol_rootP == orgsymP)
 595         symbol_rootP = newsymP;
 596       else if (orgsymP->sy_previous)
 597         {
 598           orgsymP->sy_previous->sy_next = newsymP;
 599           orgsymP->sy_previous = NULL;
 600         }
 601       if (symbol_lastP == orgsymP)
 602         symbol_lastP = newsymP;
 603       else if (orgsymP->sy_next)
 604         orgsymP->sy_next->sy_previous = newsymP;
 605       orgsymP->sy_next = NULL;
 606       debug_verify_symchain (symbol_rootP, symbol_lastP);
 607
 608       symbol_table_insert (newsymP);
 609     }
 610
 611   return newsymP;
 612 }
 613
 614 /* Referenced symbols, if they are forward references, need to be cloned
 615    (without replacing the original) so that the value of the referenced
 616    symbols at the point of use .  */
 617
 618 #undef symbol_clone_if_forward_ref
 619 symbolS *
 620 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
 621 {
 622   if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
 623     {
 624       symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
 625       symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
 626
 627       if (symbolP->sy_forward_ref)
 628         is_forward = 1;
 629
 630       if (is_forward)
 631         {
 632           /* assign_symbol() clones volatile symbols; pre-existing expressions
 633              hold references to the original instance, but want the current
 634              value.  Just repeat the lookup.  */
 635           if (add_symbol && S_IS_VOLATILE (add_symbol))
 636             add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
 637           if (op_symbol && S_IS_VOLATILE (op_symbol))
 638             op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
 639         }
 640
 641       /* Re-using sy_resolving here, as this routine cannot get called from
 642          symbol resolution code.  */
 643       if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
 644         {
 645           symbolP->sy_resolving = 1;
 646           add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
 647           op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
 648           symbolP->sy_resolving = 0;
 649         }
 650
 651       if (symbolP->sy_forward_ref
 652           || add_symbol != symbolP->sy_value.X_add_symbol
 653           || op_symbol != symbolP->sy_value.X_op_symbol)
 654         symbolP = symbol_clone (symbolP, 0);
 655
 656       symbolP->sy_value.X_add_symbol = add_symbol;
 657       symbolP->sy_value.X_op_symbol = op_symbol;
 658     }
 659
 660   return symbolP;
 661 }
 662
 663 symbolS *
 664 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
 665 {
 666   return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
 667 }
 668
 669 symbolS *
 670 symbol_temp_new_now (void)
 671 {
 672   return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
 673 }
 674
 675 symbolS *
 676 symbol_temp_make (void)
 677 {
 678   return symbol_make (FAKE_LABEL_NAME);
 679 }
 680
 681 /* Implement symbol table lookup.
 682    In:  A symbol's name as a string: '\0' can't be part of a symbol name.
 683    Out: NULL if the name was not in the symbol table, else the address
 684    of a struct symbol associated with that name.  */
 685
 686 symbolS *
 687 symbol_find_exact (const char *name)
 688 {
 689   return symbol_find_exact_noref (name, 0);
 690 }
 691
 692 symbolS *
 693 symbol_find_exact_noref (const char *name, int noref)
 694 {
 695   struct local_symbol *locsym;
 696   symbolS* sym;
 697
 698   locsym = (struct local_symbol *) hash_find (local_hash, name);
 699   if (locsym != NULL)
 700     return (symbolS *) locsym;
 701
 702   sym = ((symbolS *) hash_find (sy_hash, name));
 703
 704   /* Any references to the symbol, except for the reference in
 705      .weakref, must clear this flag, such that the symbol does not
 706      turn into a weak symbol.  Note that we don't have to handle the
 707      local_symbol case, since a weakrefd is always promoted out of the
 708      local_symbol table when it is turned into a weak symbol.  */
 709   if (sym && ! noref)
 710     S_CLEAR_WEAKREFD (sym);
 711
 712   return sym;
 713 }
 714
 715 symbolS *
 716 symbol_find (const char *name)
 717 {
 718   return symbol_find_noref (name, 0);
 719 }
 720
 721 symbolS *
 722 symbol_find_noref (const char *name, int noref)
 723 {
 724 #ifdef tc_canonicalize_symbol_name
 725   {
 726     char *copy;
 727     size_t len = strlen (name) + 1;
 728
 729     copy = (char *) alloca (len);
 730     memcpy (copy, name, len);
 731     name = tc_canonicalize_symbol_name (copy);
 732   }
 733 #endif
 734
 735   if (! symbols_case_sensitive)
 736     {
 737       char *copy;
 738       const char *orig;
 739       unsigned char c;
 740
 741       orig = name;
 742       name = copy = (char *) alloca (strlen (name) + 1);
 743
 744       while ((c = *orig++) != '\0')
 745         {
 746           *copy++ = TOUPPER (c);
 747         }
 748       *copy = '\0';
 749     }
 750
 751   return symbol_find_exact_noref (name, noref);
 752 }
 753
 754 /* Once upon a time, symbols were kept in a singly linked list.  At
 755    least coff needs to be able to rearrange them from time to time, for
 756    which a doubly linked list is much more convenient.  Loic did these
 757    as macros which seemed dangerous to me so they're now functions.
 758    xoxorich.  */
 759
 760 /* Link symbol ADDME after symbol TARGET in the chain.  */
 761
 762 void
 763 symbol_append (symbolS *addme, symbolS *target,
 764                symbolS **rootPP, symbolS **lastPP)
 765 {
 766   if (LOCAL_SYMBOL_CHECK (addme))
 767     abort ();
 768   if (target != NULL && LOCAL_SYMBOL_CHECK (target))
 769     abort ();
 770
 771   if (target == NULL)
 772     {
 773       know (*rootPP == NULL);
 774       know (*lastPP == NULL);
 775       addme->sy_next = NULL;
 776       addme->sy_previous = NULL;
 777       *rootPP = addme;
 778       *lastPP = addme;
 779       return;
 780     }                           /* if the list is empty  */
 781
 782   if (target->sy_next != NULL)
 783     {
 784       target->sy_next->sy_previous = addme;
 785     }
 786   else
 787     {
 788       know (*lastPP == target);
 789       *lastPP = addme;
 790     }                           /* if we have a next  */
 791
 792   addme->sy_next = target->sy_next;
 793   target->sy_next = addme;
 794   addme->sy_previous = target;
 795
 796   debug_verify_symchain (symbol_rootP, symbol_lastP);
 797 }
 798
 799 /* Set the chain pointers of SYMBOL to null.  */
 800
 801 void
 802 symbol_clear_list_pointers (symbolS *symbolP)
 803 {
 804   if (LOCAL_SYMBOL_CHECK (symbolP))
 805     abort ();
 806   symbolP->sy_next = NULL;
 807   symbolP->sy_previous = NULL;
 808 }
 809
 810 /* Remove SYMBOLP from the list.  */
 811
 812 void
 813 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
 814 {
 815   if (LOCAL_SYMBOL_CHECK (symbolP))
 816     abort ();
 817
 818   if (symbolP == *rootPP)
 819     {
 820       *rootPP = symbolP->sy_next;
 821     }                           /* if it was the root  */
 822
 823   if (symbolP == *lastPP)
 824     {
 825       *lastPP = symbolP->sy_previous;
 826     }                           /* if it was the tail  */
 827
 828   if (symbolP->sy_next != NULL)
 829     {
 830       symbolP->sy_next->sy_previous = symbolP->sy_previous;
 831     }                           /* if not last  */
 832
 833   if (symbolP->sy_previous != NULL)
 834     {
 835       symbolP->sy_previous->sy_next = symbolP->sy_next;
 836     }                           /* if not first  */
 837
 838   debug_verify_symchain (*rootPP, *lastPP);
 839 }
 840
 841 /* Link symbol ADDME before symbol TARGET in the chain.  */
 842
 843 void
 844 symbol_insert (symbolS *addme, symbolS *target,
 845                symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
 846 {
 847   if (LOCAL_SYMBOL_CHECK (addme))
 848     abort ();
 849   if (LOCAL_SYMBOL_CHECK (target))
 850     abort ();
 851
 852   if (target->sy_previous != NULL)
 853     {
 854       target->sy_previous->sy_next = addme;
 855     }
 856   else
 857     {
 858       know (*rootPP == target);
 859       *rootPP = addme;
 860     }                           /* if not first  */
 861
 862   addme->sy_previous = target->sy_previous;
 863   target->sy_previous = addme;
 864   addme->sy_next = target;
 865
 866   debug_verify_symchain (*rootPP, *lastPP);
 867 }
 868
 869 void
 870 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
 871 {
 872   symbolS *symbolP = rootP;
 873
 874   if (symbolP == NULL)
 875     return;
 876
 877   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
 878     {
 879       assert (symbolP->bsym != NULL);
 880       assert (symbolP->sy_next->sy_previous == symbolP);
 881     }
 882
 883   assert (lastP == symbolP);
 884 }
 885
 886 static void
 887 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
 888 {
 889   char *file;
 890   unsigned int line;
 891   segT seg_left = S_GET_SEGMENT (left);
 892   segT seg_right = right ? S_GET_SEGMENT (right) : 0;
 893
 894   if (expr_symbol_where (symp, &file, &line))
 895     {
 896       if (seg_left == undefined_section)
 897         as_bad_where (file, line,
 898                       _("undefined symbol `%s' in operation"),
 899                       S_GET_NAME (left));
 900       if (seg_right == undefined_section)
 901         as_bad_where (file, line,
 902                       _("undefined symbol `%s' in operation"),
 903                       S_GET_NAME (right));
 904       if (seg_left != undefined_section
 905           && seg_right != undefined_section)
 906         {
 907           if (right)
 908             as_bad_where (file, line,
 909                           _("invalid sections for operation on `%s' and `%s'"),
 910                           S_GET_NAME (left), S_GET_NAME (right));
 911           else
 912             as_bad_where (file, line,
 913                           _("invalid section for operation on `%s'"),
 914                           S_GET_NAME (left));
 915         }
 916
 917     }
 918   else
 919     {
 920       if (seg_left == undefined_section)
 921         as_bad (_("undefined symbol `%s' in operation setting `%s'"),
 922                 S_GET_NAME (left), S_GET_NAME (symp));
 923       if (seg_right == undefined_section)
 924         as_bad (_("undefined symbol `%s' in operation setting `%s'"),
 925                 S_GET_NAME (right), S_GET_NAME (symp));
 926       if (seg_left != undefined_section
 927           && seg_right != undefined_section)
 928         {
 929           if (right)
 930             as_bad_where (file, line,
 931                           _("invalid sections for operation on `%s' and `%s' setting `%s'"),
 932                           S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
 933           else
 934             as_bad_where (file, line,
 935                           _("invalid section for operation on `%s' setting `%s'"),
 936                           S_GET_NAME (left), S_GET_NAME (symp));
 937         }
 938     }
 939 }
 940
 941 /* Resolve the value of a symbol.  This is called during the final
 942    pass over the symbol table to resolve any symbols with complex
 943    values.  */
 944
 945 valueT
 946 resolve_symbol_value (symbolS *symp)
 947 {
 948   int resolved;
 949   valueT final_val = 0;
 950   segT final_seg;
 951
 952   if (LOCAL_SYMBOL_CHECK (symp))
 953     {
 954       struct local_symbol *locsym = (struct local_symbol *) symp;
 955
 956       final_val = locsym->lsy_value;
 957       if (local_symbol_resolved_p (locsym))
 958         return final_val;
 959
 960       final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
 961
 962       if (finalize_syms)
 963         {
 964           locsym->lsy_value = final_val;
 965           local_symbol_mark_resolved (locsym);
 966         }
 967
 968       return final_val;
 969     }
 970
 971   if (symp->sy_resolved)
 972     {
 973       if (symp->sy_value.X_op == O_constant)
 974         return (valueT) symp->sy_value.X_add_number;
 975       else
 976         return 0;
 977     }
 978
 979   resolved = 0;
 980   final_seg = S_GET_SEGMENT (symp);
 981
 982   if (symp->sy_resolving)
 983     {
 984       if (finalize_syms)
 985         as_bad (_("symbol definition loop encountered at `%s'"),
 986                 S_GET_NAME (symp));
 987       final_val = 0;
 988       resolved = 1;
 989     }
 990   else
 991     {
 992       symbolS *add_symbol, *op_symbol;
 993       offsetT left, right;
 994       segT seg_left, seg_right;
 995       operatorT op;
 996       int move_seg_ok;
 997
 998       symp->sy_resolving = 1;
 999
1000       /* Help out with CSE.  */
1001       add_symbol = symp->sy_value.X_add_symbol;
1002       op_symbol = symp->sy_value.X_op_symbol;
1003       final_val = symp->sy_value.X_add_number;
1004       op = symp->sy_value.X_op;
1005
1006       switch (op)
1007         {
1008         default:
1009           BAD_CASE (op);
1010           break;
1011
1012         case O_absent:
1013           final_val = 0;
1014           /* Fall through.  */
1015
1016         case O_constant:
1017           final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1018           if (final_seg == expr_section)
1019             final_seg = absolute_section;
1020           resolved = 1;
1021           break;
1022
1023         case O_symbol:
1024         case O_symbol_rva:
1025           left = resolve_symbol_value (add_symbol);
1026           seg_left = S_GET_SEGMENT (add_symbol);
1027           if (finalize_syms)
1028             symp->sy_value.X_op_symbol = NULL;
1029
1030         do_symbol:
1031           if (S_IS_WEAKREFR (symp))
1032             {
1033               assert (final_val == 0);
1034               if (S_IS_WEAKREFR (add_symbol))
1035                 {
1036                   assert (add_symbol->sy_value.X_op == O_symbol
1037                           && add_symbol->sy_value.X_add_number == 0);
1038                   add_symbol = add_symbol->sy_value.X_add_symbol;
1039                   assert (! S_IS_WEAKREFR (add_symbol));
1040                   symp->sy_value.X_add_symbol = add_symbol;
1041                 }
1042             }
1043
1044           if (symp->sy_mri_common)
1045             {
1046               /* This is a symbol inside an MRI common section.  The
1047                  relocation routines are going to handle it specially.
1048                  Don't change the value.  */
1049               resolved = symbol_resolved_p (add_symbol);
1050               break;
1051             }
1052
1053           if (finalize_syms && final_val == 0)
1054             {
1055               if (LOCAL_SYMBOL_CHECK (add_symbol))
1056                 add_symbol = local_symbol_convert ((struct local_symbol *)
1057                                                    add_symbol);
1058               copy_symbol_attributes (symp, add_symbol);
1059             }
1060
1061           /* If we have equated this symbol to an undefined or common
1062              symbol, keep X_op set to O_symbol, and don't change
1063              X_add_number.  This permits the routine which writes out
1064              relocation to detect this case, and convert the
1065              relocation to be against the symbol to which this symbol
1066              is equated.  */
1067           if (! S_IS_DEFINED (add_symbol)
1068 #if defined (OBJ_COFF) && defined (TE_PE)
1069               || S_IS_WEAK (add_symbol)
1070 #endif
1071               || S_IS_COMMON (add_symbol))
1072             {
1073               if (finalize_syms)
1074                 {
1075                   symp->sy_value.X_op = O_symbol;
1076                   symp->sy_value.X_add_symbol = add_symbol;
1077                   symp->sy_value.X_add_number = final_val;
1078                   /* Use X_op_symbol as a flag.  */
1079                   symp->sy_value.X_op_symbol = add_symbol;
1080                   final_seg = seg_left;
1081                 }
1082               final_val = 0;
1083               resolved = symbol_resolved_p (add_symbol);
1084               symp->sy_resolving = 0;
1085               goto exit_dont_set_value;
1086             }
1087           else if (finalize_syms && final_seg == expr_section
1088                    && seg_left != expr_section)
1089             {
1090               /* If the symbol is an expression symbol, do similarly
1091                  as for undefined and common syms above.  Handles
1092                  "sym +/- expr" where "expr" cannot be evaluated
1093                  immediately, and we want relocations to be against
1094                  "sym", eg. because it is weak.  */
1095               symp->sy_value.X_op = O_symbol;
1096               symp->sy_value.X_add_symbol = add_symbol;
1097               symp->sy_value.X_add_number = final_val;
1098               symp->sy_value.X_op_symbol = add_symbol;
1099               final_seg = seg_left;
1100               final_val += symp->sy_frag->fr_address + left;
1101               resolved = symbol_resolved_p (add_symbol);
1102               symp->sy_resolving = 0;
1103               goto exit_dont_set_value;
1104             }
1105           else
1106             {
1107               final_val += symp->sy_frag->fr_address + left;
1108               if (final_seg == expr_section || final_seg == undefined_section)
1109                 final_seg = seg_left;
1110             }
1111
1112           resolved = symbol_resolved_p (add_symbol);
1113           if (S_IS_WEAKREFR (symp))
1114             goto exit_dont_set_value;
1115           break;
1116
1117         case O_uminus:
1118         case O_bit_not:
1119         case O_logical_not:
1120           left = resolve_symbol_value (add_symbol);
1121           seg_left = S_GET_SEGMENT (add_symbol);
1122
1123           /* By reducing these to the relevant dyadic operator, we get
1124                 !S -> S == 0    permitted on anything,
1125                 -S -> 0 - S     only permitted on absolute
1126                 ~S -> S ^ ~0    only permitted on absolute  */
1127           if (op != O_logical_not && seg_left != absolute_section
1128               && finalize_syms)
1129             report_op_error (symp, add_symbol, NULL);
1130
1131           if (final_seg == expr_section || final_seg == undefined_section)
1132             final_seg = absolute_section;
1133
1134           if (op == O_uminus)
1135             left = -left;
1136           else if (op == O_logical_not)
1137             left = !left;
1138           else
1139             left = ~left;
1140
1141           final_val += left + symp->sy_frag->fr_address;
1142
1143           resolved = symbol_resolved_p (add_symbol);
1144           break;
1145
1146         case O_multiply:
1147         case O_divide:
1148         case O_modulus:
1149         case O_left_shift:
1150         case O_right_shift:
1151         case O_bit_inclusive_or:
1152         case O_bit_or_not:
1153         case O_bit_exclusive_or:
1154         case O_bit_and:
1155         case O_add:
1156         case O_subtract:
1157         case O_eq:
1158         case O_ne:
1159         case O_lt:
1160         case O_le:
1161         case O_ge:
1162         case O_gt:
1163         case O_logical_and:
1164         case O_logical_or:
1165           left = resolve_symbol_value (add_symbol);
1166           right = resolve_symbol_value (op_symbol);
1167           seg_left = S_GET_SEGMENT (add_symbol);
1168           seg_right = S_GET_SEGMENT (op_symbol);
1169
1170           /* Simplify addition or subtraction of a constant by folding the
1171              constant into X_add_number.  */
1172           if (op == O_add)
1173             {
1174               if (seg_right == absolute_section)
1175                 {
1176                   final_val += right;
1177                   goto do_symbol;
1178                 }
1179               else if (seg_left == absolute_section)
1180                 {
1181                   final_val += left;
1182                   add_symbol = op_symbol;
1183                   left = right;
1184                   seg_left = seg_right;
1185                   goto do_symbol;
1186                 }
1187             }
1188           else if (op == O_subtract)
1189             {
1190               if (seg_right == absolute_section)
1191                 {
1192                   final_val -= right;
1193                   goto do_symbol;
1194                 }
1195             }
1196
1197           move_seg_ok = 1;
1198           /* Equality and non-equality tests are permitted on anything.
1199              Subtraction, and other comparison operators are permitted if
1200              both operands are in the same section.  Otherwise, both
1201              operands must be absolute.  We already handled the case of
1202              addition or subtraction of a constant above.  This will
1203              probably need to be changed for an object file format which
1204              supports arbitrary expressions, such as IEEE-695.  */
1205           if (!(seg_left == absolute_section
1206                    && seg_right == absolute_section)
1207               && !(op == O_eq || op == O_ne)
1208               && !((op == O_subtract
1209                     || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1210                    && seg_left == seg_right
1211                    && (seg_left != undefined_section
1212                        || add_symbol == op_symbol)))
1213             {
1214               /* Don't emit messages unless we're finalizing the symbol value,
1215                  otherwise we may get the same message multiple times.  */
1216               if (finalize_syms)
1217                 report_op_error (symp, add_symbol, op_symbol);
1218               /* However do not move the symbol into the absolute section
1219                  if it cannot currently be resolved - this would confuse
1220                  other parts of the assembler into believing that the
1221                  expression had been evaluated to zero.  */
1222               else
1223                 move_seg_ok = 0;
1224             }
1225
1226           if (move_seg_ok
1227               && (final_seg == expr_section || final_seg == undefined_section))
1228             final_seg = absolute_section;
1229
1230           /* Check for division by zero.  */
1231           if ((op == O_divide || op == O_modulus) && right == 0)
1232             {
1233               /* If seg_right is not absolute_section, then we've
1234                  already issued a warning about using a bad symbol.  */
1235               if (seg_right == absolute_section && finalize_syms)
1236                 {
1237                   char *file;
1238                   unsigned int line;
1239
1240                   if (expr_symbol_where (symp, &file, &line))
1241                     as_bad_where (file, line, _("division by zero"));
1242                   else
1243                     as_bad (_("division by zero when setting `%s'"),
1244                             S_GET_NAME (symp));
1245                 }
1246
1247               right = 1;
1248             }
1249
1250           switch (symp->sy_value.X_op)
1251             {
1252             case O_multiply:            left *= right; break;
1253             case O_divide:              left /= right; break;
1254             case O_modulus:             left %= right; break;
1255             case O_left_shift:          left <<= right; break;
1256             case O_right_shift:         left >>= right; break;
1257             case O_bit_inclusive_or:    left |= right; break;
1258             case O_bit_or_not:          left |= ~right; break;
1259             case O_bit_exclusive_or:    left ^= right; break;
1260             case O_bit_and:             left &= right; break;
1261             case O_add:                 left += right; break;
1262             case O_subtract:            left -= right; break;
1263             case O_eq:
1264             case O_ne:
1265               left = (left == right && seg_left == seg_right
1266                       && (seg_left != undefined_section
1267                           || add_symbol == op_symbol)
1268                       ? ~ (offsetT) 0 : 0);
1269               if (symp->sy_value.X_op == O_ne)
1270                 left = ~left;
1271               break;
1272             case O_lt:  left = left <  right ? ~ (offsetT) 0 : 0; break;
1273             case O_le:  left = left <= right ? ~ (offsetT) 0 : 0; break;
1274             case O_ge:  left = left >= right ? ~ (offsetT) 0 : 0; break;
1275             case O_gt:  left = left >  right ? ~ (offsetT) 0 : 0; break;
1276             case O_logical_and: left = left && right; break;
1277             case O_logical_or:  left = left || right; break;
1278             default:            abort ();
1279             }
1280
1281           final_val += symp->sy_frag->fr_address + left;
1282           if (final_seg == expr_section || final_seg == undefined_section)
1283             {
1284               if (seg_left == undefined_section
1285                   || seg_right == undefined_section)
1286                 final_seg = undefined_section;
1287               else if (seg_left == absolute_section)
1288                 final_seg = seg_right;
1289               else
1290                 final_seg = seg_left;
1291             }
1292           resolved = (symbol_resolved_p (add_symbol)
1293                       && symbol_resolved_p (op_symbol));
1294           break;
1295
1296         case O_register:
1297         case O_big:
1298         case O_illegal:
1299           /* Give an error (below) if not in expr_section.  We don't
1300              want to worry about expr_section symbols, because they
1301              are fictional (they are created as part of expression
1302              resolution), and any problems may not actually mean
1303              anything.  */
1304           break;
1305         }
1306
1307       symp->sy_resolving = 0;
1308     }
1309
1310   if (finalize_syms)
1311     S_SET_VALUE (symp, final_val);
1312
1313 exit_dont_set_value:
1314   /* Always set the segment, even if not finalizing the value.
1315      The segment is used to determine whether a symbol is defined.  */
1316     S_SET_SEGMENT (symp, final_seg);
1317
1318   /* Don't worry if we can't resolve an expr_section symbol.  */
1319   if (finalize_syms)
1320     {
1321       if (resolved)
1322         symp->sy_resolved = 1;
1323       else if (S_GET_SEGMENT (symp) != expr_section)
1324         {
1325           as_bad (_("can't resolve value for symbol `%s'"),
1326                   S_GET_NAME (symp));
1327           symp->sy_resolved = 1;
1328         }
1329     }
1330
1331   return final_val;
1332 }
1333
1334 static void resolve_local_symbol (const char *, PTR);
1335
1336 /* A static function passed to hash_traverse.  */
1337
1338 static void
1339 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)
1340 {
1341   if (value != NULL)
1342     resolve_symbol_value (value);
1343 }
1344
1345 /* Resolve all local symbols.  */
1346
1347 void
1348 resolve_local_symbol_values (void)
1349 {
1350   hash_traverse (local_hash, resolve_local_symbol);
1351 }
1352
1353 /* Obtain the current value of a symbol without changing any
1354    sub-expressions used.  */
1355
1356 int
1357 snapshot_symbol (symbolS *symbolP, valueT *valueP, segT *segP, fragS **fragPP)
1358 {
1359   if (LOCAL_SYMBOL_CHECK (symbolP))
1360     {
1361       struct local_symbol *locsym = (struct local_symbol *) symbolP;
1362
1363       *valueP = locsym->lsy_value;
1364       *segP = locsym->lsy_section;
1365       *fragPP = local_symbol_get_frag (locsym);
1366     }
1367   else
1368     {
1369       expressionS expr = symbolP->sy_value;
1370
1371       if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1372         {
1373           int resolved;
1374
1375           if (symbolP->sy_resolving)
1376             return 0;
1377           symbolP->sy_resolving = 1;
1378           resolved = resolve_expression (&expr);
1379           symbolP->sy_resolving = 0;
1380           if (!resolved)
1381             return 0;
1382
1383           switch (expr.X_op)
1384             {
1385             case O_constant:
1386             case O_register:
1387               /* This check wouldn't be needed if pseudo_set() didn't set
1388                  symbols equated to bare symbols to undefined_section.  */
1389               if (symbolP->bsym->section != undefined_section
1390                   || symbolP->sy_value.X_op != O_symbol)
1391                 break;
1392               /* Fall thru.  */
1393             case O_symbol:
1394             case O_symbol_rva:
1395               symbolP = expr.X_add_symbol;
1396               break;
1397             default:
1398               return 0;
1399             }
1400         }
1401
1402       *valueP = expr.X_add_number;
1403       *segP = symbolP->bsym->section;
1404       *fragPP = symbolP->sy_frag;
1405
1406       if (*segP == expr_section)
1407         switch (expr.X_op)
1408           {
1409           case O_constant: *segP = absolute_section; break;
1410           case O_register: *segP = reg_section; break;
1411           default: break;
1412           }
1413     }
1414
1415   return 1;
1416 }
1417
1418 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
1419    They are *really* local.  That is, they go out of scope whenever we see a
1420    label that isn't local.  Also, like fb labels, there can be multiple
1421    instances of a dollar label.  Therefor, we name encode each instance with
1422    the instance number, keep a list of defined symbols separate from the real
1423    symbol table, and we treat these buggers as a sparse array.  */
1424
1425 static long *dollar_labels;
1426 static long *dollar_label_instances;
1427 static char *dollar_label_defines;
1428 static unsigned long dollar_label_count;
1429 static unsigned long dollar_label_max;
1430
1431 int
1432 dollar_label_defined (long label)
1433 {
1434   long *i;
1435
1436   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1437
1438   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1439     if (*i == label)
1440       return dollar_label_defines[i - dollar_labels];
1441
1442   /* If we get here, label isn't defined.  */
1443   return 0;
1444 }
1445
1446 static long
1447 dollar_label_instance (long label)
1448 {
1449   long *i;
1450
1451   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1452
1453   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1454     if (*i == label)
1455       return (dollar_label_instances[i - dollar_labels]);
1456
1457   /* If we get here, we haven't seen the label before.
1458      Therefore its instance count is zero.  */
1459   return 0;
1460 }
1461
1462 void
1463 dollar_label_clear (void)
1464 {
1465   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1466 }
1467
1468 #define DOLLAR_LABEL_BUMP_BY 10
1469
1470 void
1471 define_dollar_label (long label)
1472 {
1473   long *i;
1474
1475   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1476     if (*i == label)
1477       {
1478         ++dollar_label_instances[i - dollar_labels];
1479         dollar_label_defines[i - dollar_labels] = 1;
1480         return;
1481       }
1482
1483   /* If we get to here, we don't have label listed yet.  */
1484
1485   if (dollar_labels == NULL)
1486     {
1487       dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1488       dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1489       dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1490       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1491       dollar_label_count = 0;
1492     }
1493   else if (dollar_label_count == dollar_label_max)
1494     {
1495       dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1496       dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1497                                          dollar_label_max * sizeof (long));
1498       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1499                                           dollar_label_max * sizeof (long));
1500       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1501     }                           /* if we needed to grow  */
1502
1503   dollar_labels[dollar_label_count] = label;
1504   dollar_label_instances[dollar_label_count] = 1;
1505   dollar_label_defines[dollar_label_count] = 1;
1506   ++dollar_label_count;
1507 }
1508
1509 /* Caller must copy returned name: we re-use the area for the next name.
1510
1511    The mth occurence of label n: is turned into the symbol "Ln^Am"
1512    where n is the label number and m is the instance number. "L" makes
1513    it a label discarded unless debugging and "^A"('\1') ensures no
1514    ordinary symbol SHOULD get the same name as a local label
1515    symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1516
1517    fb labels get the same treatment, except that ^B is used in place
1518    of ^A.  */
1519
1520 char *                          /* Return local label name.  */
1521 dollar_label_name (register long n,     /* we just saw "n$:" : n a number.  */
1522                    register int augend  /* 0 for current instance, 1 for new instance.  */)
1523 {
1524   long i;
1525   /* Returned to caller, then copied.  Used for created names ("4f").  */
1526   static char symbol_name_build[24];
1527   register char *p;
1528   register char *q;
1529   char symbol_name_temporary[20];       /* Build up a number, BACKWARDS.  */
1530
1531   know (n >= 0);
1532   know (augend == 0 || augend == 1);
1533   p = symbol_name_build;
1534 #ifdef LOCAL_LABEL_PREFIX
1535   *p++ = LOCAL_LABEL_PREFIX;
1536 #endif
1537   *p++ = 'L';
1538
1539   /* Next code just does sprintf( {}, "%d", n);  */
1540   /* Label number.  */
1541   q = symbol_name_temporary;
1542   for (*q++ = 0, i = n; i; ++q)
1543     {
1544       *q = i % 10 + '0';
1545       i /= 10;
1546     }
1547   while ((*p = *--q) != '\0')
1548     ++p;
1549
1550   *p++ = DOLLAR_LABEL_CHAR;             /* ^A  */
1551
1552   /* Instance number.  */
1553   q = symbol_name_temporary;
1554   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1555     {
1556       *q = i % 10 + '0';
1557       i /= 10;
1558     }
1559   while ((*p++ = *--q) != '\0');;
1560
1561   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1562   return symbol_name_build;
1563 }
1564
1565 /* Somebody else's idea of local labels. They are made by "n:" where n
1566    is any decimal digit. Refer to them with
1567     "nb" for previous (backward) n:
1568    or "nf" for next (forward) n:.
1569
1570    We do a little better and let n be any number, not just a single digit, but
1571    since the other guy's assembler only does ten, we treat the first ten
1572    specially.
1573
1574    Like someone else's assembler, we have one set of local label counters for
1575    entire assembly, not one set per (sub)segment like in most assemblers. This
1576    implies that one can refer to a label in another segment, and indeed some
1577    crufty compilers have done just that.
1578
1579    Since there could be a LOT of these things, treat them as a sparse
1580    array.  */
1581
1582 #define FB_LABEL_SPECIAL (10)
1583
1584 static long fb_low_counter[FB_LABEL_SPECIAL];
1585 static long *fb_labels;
1586 static long *fb_label_instances;
1587 static long fb_label_count;
1588 static long fb_label_max;
1589
1590 /* This must be more than FB_LABEL_SPECIAL.  */
1591 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1592
1593 static void
1594 fb_label_init (void)
1595 {
1596   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1597 }
1598
1599 /* Add one to the instance number of this fb label.  */
1600
1601 void
1602 fb_label_instance_inc (long label)
1603 {
1604   long *i;
1605
1606   if (label < FB_LABEL_SPECIAL)
1607     {
1608       ++fb_low_counter[label];
1609       return;
1610     }
1611
1612   if (fb_labels != NULL)
1613     {
1614       for (i = fb_labels + FB_LABEL_SPECIAL;
1615            i < fb_labels + fb_label_count; ++i)
1616         {
1617           if (*i == label)
1618             {
1619               ++fb_label_instances[i - fb_labels];
1620               return;
1621             }                   /* if we find it  */
1622         }                       /* for each existing label  */
1623     }
1624
1625   /* If we get to here, we don't have label listed yet.  */
1626
1627   if (fb_labels == NULL)
1628     {
1629       fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1630       fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1631       fb_label_max = FB_LABEL_BUMP_BY;
1632       fb_label_count = FB_LABEL_SPECIAL;
1633
1634     }
1635   else if (fb_label_count == fb_label_max)
1636     {
1637       fb_label_max += FB_LABEL_BUMP_BY;
1638       fb_labels = (long *) xrealloc ((char *) fb_labels,
1639                                      fb_label_max * sizeof (long));
1640       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1641                                               fb_label_max * sizeof (long));
1642     }                           /* if we needed to grow  */
1643
1644   fb_labels[fb_label_count] = label;
1645   fb_label_instances[fb_label_count] = 1;
1646   ++fb_label_count;
1647 }
1648
1649 static long
1650 fb_label_instance (long label)
1651 {
1652   long *i;
1653
1654   if (label < FB_LABEL_SPECIAL)
1655     {
1656       return (fb_low_counter[label]);
1657     }
1658
1659   if (fb_labels != NULL)
1660     {
1661       for (i = fb_labels + FB_LABEL_SPECIAL;
1662            i < fb_labels + fb_label_count; ++i)
1663         {
1664           if (*i == label)
1665             {
1666               return (fb_label_instances[i - fb_labels]);
1667             }                   /* if we find it  */
1668         }                       /* for each existing label  */
1669     }
1670
1671   /* We didn't find the label, so this must be a reference to the
1672      first instance.  */
1673   return 0;
1674 }
1675
1676 /* Caller must copy returned name: we re-use the area for the next name.
1677
1678    The mth occurence of label n: is turned into the symbol "Ln^Bm"
1679    where n is the label number and m is the instance number. "L" makes
1680    it a label discarded unless debugging and "^B"('\2') ensures no
1681    ordinary symbol SHOULD get the same name as a local label
1682    symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1683
1684    dollar labels get the same treatment, except that ^A is used in
1685    place of ^B.  */
1686
1687 char *                          /* Return local label name.  */
1688 fb_label_name (long n,  /* We just saw "n:", "nf" or "nb" : n a number.  */
1689                long augend      /* 0 for nb, 1 for n:, nf.  */)
1690 {
1691   long i;
1692   /* Returned to caller, then copied.  Used for created names ("4f").  */
1693   static char symbol_name_build[24];
1694   register char *p;
1695   register char *q;
1696   char symbol_name_temporary[20];       /* Build up a number, BACKWARDS.  */
1697
1698   know (n >= 0);
1699 #ifdef TC_MMIX
1700   know ((unsigned long) augend <= 2 /* See mmix_fb_label.  */);
1701 #else
1702   know ((unsigned long) augend <= 1);
1703 #endif
1704   p = symbol_name_build;
1705 #ifdef LOCAL_LABEL_PREFIX
1706   *p++ = LOCAL_LABEL_PREFIX;
1707 #endif
1708   *p++ = 'L';
1709
1710   /* Next code just does sprintf( {}, "%d", n);  */
1711   /* Label number.  */
1712   q = symbol_name_temporary;
1713   for (*q++ = 0, i = n; i; ++q)
1714     {
1715       *q = i % 10 + '0';
1716       i /= 10;
1717     }
1718   while ((*p = *--q) != '\0')
1719     ++p;
1720
1721   *p++ = LOCAL_LABEL_CHAR;              /* ^B  */
1722
1723   /* Instance number.  */
1724   q = symbol_name_temporary;
1725   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1726     {
1727       *q = i % 10 + '0';
1728       i /= 10;
1729     }
1730   while ((*p++ = *--q) != '\0');;
1731
1732   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1733   return (symbol_name_build);
1734 }
1735
1736 /* Decode name that may have been generated by foo_label_name() above.
1737    If the name wasn't generated by foo_label_name(), then return it
1738    unaltered.  This is used for error messages.  */
1739
1740 char *
1741 decode_local_label_name (char *s)
1742 {
1743   char *p;
1744   char *symbol_decode;
1745   int label_number;
1746   int instance_number;
1747   char *type;
1748   const char *message_format;
1749   int index = 0;
1750
1751 #ifdef LOCAL_LABEL_PREFIX
1752   if (s[index] == LOCAL_LABEL_PREFIX)
1753     ++index;
1754 #endif
1755
1756   if (s[index] != 'L')
1757     return s;
1758
1759   for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1760     label_number = (10 * label_number) + *p - '0';
1761
1762   if (*p == DOLLAR_LABEL_CHAR)
1763     type = "dollar";
1764   else if (*p == LOCAL_LABEL_CHAR)
1765     type = "fb";
1766   else
1767     return s;
1768
1769   for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1770     instance_number = (10 * instance_number) + *p - '0';
1771
1772   message_format = _("\"%d\" (instance number %d of a %s label)");
1773   symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1774   sprintf (symbol_decode, message_format, label_number, instance_number, type);
1775
1776   return symbol_decode;
1777 }
1778
1779 /* Get the value of a symbol.  */
1780
1781 valueT
1782 S_GET_VALUE (symbolS *s)
1783 {
1784   if (LOCAL_SYMBOL_CHECK (s))
1785     return resolve_symbol_value (s);
1786
1787   if (!s->sy_resolved)
1788     {
1789       valueT val = resolve_symbol_value (s);
1790       if (!finalize_syms)
1791         return val;
1792     }
1793   if (S_IS_WEAKREFR (s))
1794     return S_GET_VALUE (s->sy_value.X_add_symbol);
1795
1796   if (s->sy_value.X_op != O_constant)
1797     {
1798       if (! s->sy_resolved
1799           || s->sy_value.X_op != O_symbol
1800           || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1801         as_bad (_("attempt to get value of unresolved symbol `%s'"),
1802                 S_GET_NAME (s));
1803     }
1804   return (valueT) s->sy_value.X_add_number;
1805 }
1806
1807 /* Set the value of a symbol.  */
1808
1809 void
1810 S_SET_VALUE (symbolS *s, valueT val)
1811 {
1812   if (LOCAL_SYMBOL_CHECK (s))
1813     {
1814       ((struct local_symbol *) s)->lsy_value = val;
1815       return;
1816     }
1817
1818   s->sy_value.X_op = O_constant;
1819   s->sy_value.X_add_number = (offsetT) val;
1820   s->sy_value.X_unsigned = 0;
1821   S_CLEAR_WEAKREFR (s);
1822 }
1823
1824 void
1825 copy_symbol_attributes (symbolS *dest, symbolS *src)
1826 {
1827   if (LOCAL_SYMBOL_CHECK (dest))
1828     dest = local_symbol_convert ((struct local_symbol *) dest);
1829   if (LOCAL_SYMBOL_CHECK (src))
1830     src = local_symbol_convert ((struct local_symbol *) src);
1831
1832   /* In an expression, transfer the settings of these flags.
1833      The user can override later, of course.  */
1834 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1835   dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1836
1837 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1838   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1839 #endif
1840 }
1841
1842 int
1843 S_IS_FUNCTION (symbolS *s)
1844 {
1845   flagword flags;
1846
1847   if (LOCAL_SYMBOL_CHECK (s))
1848     return 0;
1849
1850   flags = s->bsym->flags;
1851
1852   return (flags & BSF_FUNCTION) != 0;
1853 }
1854
1855 int
1856 S_IS_EXTERNAL (symbolS *s)
1857 {
1858   flagword flags;
1859
1860   if (LOCAL_SYMBOL_CHECK (s))
1861     return 0;
1862
1863   flags = s->bsym->flags;
1864
1865   /* Sanity check.  */
1866   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1867     abort ();
1868
1869   return (flags & BSF_GLOBAL) != 0;
1870 }
1871
1872 int
1873 S_IS_WEAK (symbolS *s)
1874 {
1875   if (LOCAL_SYMBOL_CHECK (s))
1876     return 0;
1877   /* Conceptually, a weakrefr is weak if the referenced symbol is.  We
1878      could probably handle a WEAKREFR as always weak though.  E.g., if
1879      the referenced symbol has lost its weak status, there's no reason
1880      to keep handling the weakrefr as if it was weak.  */
1881   if (S_IS_WEAKREFR (s))
1882     return S_IS_WEAK (s->sy_value.X_add_symbol);
1883   return (s->bsym->flags & BSF_WEAK) != 0;
1884 }
1885
1886 int
1887 S_IS_WEAKREFR (symbolS *s)
1888 {
1889   if (LOCAL_SYMBOL_CHECK (s))
1890     return 0;
1891   return s->sy_weakrefr != 0;
1892 }
1893
1894 int
1895 S_IS_WEAKREFD (symbolS *s)
1896 {
1897   if (LOCAL_SYMBOL_CHECK (s))
1898     return 0;
1899   return s->sy_weakrefd != 0;
1900 }
1901
1902 int
1903 S_IS_COMMON (symbolS *s)
1904 {
1905   if (LOCAL_SYMBOL_CHECK (s))
1906     return 0;
1907   return bfd_is_com_section (s->bsym->section);
1908 }
1909
1910 int
1911 S_IS_DEFINED (symbolS *s)
1912 {
1913   if (LOCAL_SYMBOL_CHECK (s))
1914     return ((struct local_symbol *) s)->lsy_section != undefined_section;
1915   return s->bsym->section != undefined_section;
1916 }
1917
1918
1919 #ifndef EXTERN_FORCE_RELOC
1920 #define EXTERN_FORCE_RELOC IS_ELF
1921 #endif
1922
1923 /* Return true for symbols that should not be reduced to section
1924    symbols or eliminated from expressions, because they may be
1925    overridden by the linker.  */
1926 int
1927 S_FORCE_RELOC (symbolS *s, int strict)
1928 {
1929   if (LOCAL_SYMBOL_CHECK (s))
1930     return ((struct local_symbol *) s)->lsy_section == undefined_section;
1931
1932   return ((strict
1933            && ((s->bsym->flags & BSF_WEAK) != 0
1934                || (EXTERN_FORCE_RELOC
1935                    && (s->bsym->flags & BSF_GLOBAL) != 0)))
1936           || s->bsym->section == undefined_section
1937           || bfd_is_com_section (s->bsym->section));
1938 }
1939
1940 int
1941 S_IS_DEBUG (symbolS *s)
1942 {
1943   if (LOCAL_SYMBOL_CHECK (s))
1944     return 0;
1945   if (s->bsym->flags & BSF_DEBUGGING)
1946     return 1;
1947   return 0;
1948 }
1949
1950 int
1951 S_IS_LOCAL (symbolS *s)
1952 {
1953   flagword flags;
1954   const char *name;
1955
1956   if (LOCAL_SYMBOL_CHECK (s))
1957     return 1;
1958
1959   flags = s->bsym->flags;
1960
1961   /* Sanity check.  */
1962   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1963     abort ();
1964
1965   if (bfd_get_section (s->bsym) == reg_section)
1966     return 1;
1967
1968   if (flag_strip_local_absolute
1969       /* Keep BSF_FILE symbols in order to allow debuggers to identify
1970          the source file even when the object file is stripped.  */
1971       && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
1972       && bfd_get_section (s->bsym) == absolute_section)
1973     return 1;
1974
1975   name = S_GET_NAME (s);
1976   return (name != NULL
1977           && ! S_IS_DEBUG (s)
1978           && (strchr (name, DOLLAR_LABEL_CHAR)
1979               || strchr (name, LOCAL_LABEL_CHAR)
1980               || (! flag_keep_locals
1981                   && (bfd_is_local_label (stdoutput, s->bsym)
1982                       || (flag_mri
1983                           && name[0] == '?'
1984                           && name[1] == '?')))));
1985 }
1986
1987 int
1988 S_IS_STABD (symbolS *s)
1989 {
1990   return S_GET_NAME (s) == 0;
1991 }
1992
1993 int
1994 S_IS_VOLATILE (const symbolS *s)
1995 {
1996   if (LOCAL_SYMBOL_CHECK (s))
1997     return 0;
1998   return s->sy_volatile;
1999 }
2000
2001 int
2002 S_IS_FORWARD_REF (const symbolS *s)
2003 {
2004   if (LOCAL_SYMBOL_CHECK (s))
2005     return 0;
2006   return s->sy_forward_ref;
2007 }
2008
2009 const char *
2010 S_GET_NAME (symbolS *s)
2011 {
2012   if (LOCAL_SYMBOL_CHECK (s))
2013     return ((struct local_symbol *) s)->lsy_name;
2014   return s->bsym->name;
2015 }
2016
2017 segT
2018 S_GET_SEGMENT (symbolS *s)
2019 {
2020   if (LOCAL_SYMBOL_CHECK (s))
2021     return ((struct local_symbol *) s)->lsy_section;
2022   return s->bsym->section;
2023 }
2024
2025 void
2026 S_SET_SEGMENT (symbolS *s, segT seg)
2027 {
2028   /* Don't reassign section symbols.  The direct reason is to prevent seg
2029      faults assigning back to const global symbols such as *ABS*, but it
2030      shouldn't happen anyway.  */
2031
2032   if (LOCAL_SYMBOL_CHECK (s))
2033     {
2034       if (seg == reg_section)
2035         s = local_symbol_convert ((struct local_symbol *) s);
2036       else
2037         {
2038           ((struct local_symbol *) s)->lsy_section = seg;
2039           return;
2040         }
2041     }
2042
2043   if (s->bsym->flags & BSF_SECTION_SYM)
2044     {
2045       if (s->bsym->section != seg)
2046         abort ();
2047     }
2048   else
2049     s->bsym->section = seg;
2050 }
2051
2052 void
2053 S_SET_EXTERNAL (symbolS *s)
2054 {
2055   if (LOCAL_SYMBOL_CHECK (s))
2056     s = local_symbol_convert ((struct local_symbol *) s);
2057   if ((s->bsym->flags & BSF_WEAK) != 0)
2058     {
2059       /* Let .weak override .global.  */
2060       return;
2061     }
2062   if (s->bsym->flags & BSF_SECTION_SYM)
2063     {
2064       char * file;
2065       unsigned int line;
2066
2067       /* Do not reassign section symbols.  */
2068       as_where (& file, & line);
2069       as_warn_where (file, line,
2070                      _("section symbols are already global"));
2071       return;
2072     }
2073   s->bsym->flags |= BSF_GLOBAL;
2074   s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2075
2076 #ifdef USE_UNIQUE
2077   if (! an_external_name && S_GET_NAME(s)[0] != '.')
2078     an_external_name = S_GET_NAME (s);
2079 #endif
2080 }
2081
2082 void
2083 S_CLEAR_EXTERNAL (symbolS *s)
2084 {
2085   if (LOCAL_SYMBOL_CHECK (s))
2086     return;
2087   if ((s->bsym->flags & BSF_WEAK) != 0)
2088     {
2089       /* Let .weak override.  */
2090       return;
2091     }
2092   s->bsym->flags |= BSF_LOCAL;
2093   s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2094 }
2095
2096 void
2097 S_SET_WEAK (symbolS *s)
2098 {
2099   if (LOCAL_SYMBOL_CHECK (s))
2100     s = local_symbol_convert ((struct local_symbol *) s);
2101 #ifdef obj_set_weak_hook
2102   obj_set_weak_hook (s);
2103 #endif
2104   s->bsym->flags |= BSF_WEAK;
2105   s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2106 }
2107
2108 void
2109 S_SET_WEAKREFR (symbolS *s)
2110 {
2111   if (LOCAL_SYMBOL_CHECK (s))
2112     s = local_symbol_convert ((struct local_symbol *) s);
2113   s->sy_weakrefr = 1;
2114   /* If the alias was already used, make sure we mark the target as
2115      used as well, otherwise it might be dropped from the symbol
2116      table.  This may have unintended side effects if the alias is
2117      later redirected to another symbol, such as keeping the unused
2118      previous target in the symbol table.  Since it will be weak, it's
2119      not a big deal.  */
2120   if (s->sy_used)
2121     symbol_mark_used (s->sy_value.X_add_symbol);
2122 }
2123
2124 void
2125 S_CLEAR_WEAKREFR (symbolS *s)
2126 {
2127   if (LOCAL_SYMBOL_CHECK (s))
2128     return;
2129   s->sy_weakrefr = 0;
2130 }
2131
2132 void
2133 S_SET_WEAKREFD (symbolS *s)
2134 {
2135   if (LOCAL_SYMBOL_CHECK (s))
2136     s = local_symbol_convert ((struct local_symbol *) s);
2137   s->sy_weakrefd = 1;
2138   S_SET_WEAK (s);
2139 }
2140
2141 void
2142 S_CLEAR_WEAKREFD (symbolS *s)
2143 {
2144   if (LOCAL_SYMBOL_CHECK (s))
2145     return;
2146   if (s->sy_weakrefd)
2147     {
2148       s->sy_weakrefd = 0;
2149       /* If a weakref target symbol is weak, then it was never
2150          referenced directly before, not even in a .global directive,
2151          so decay it to local.  If it remains undefined, it will be
2152          later turned into a global, like any other undefined
2153          symbol.  */
2154       if (s->bsym->flags & BSF_WEAK)
2155         {
2156 #ifdef obj_clear_weak_hook
2157           obj_clear_weak_hook (s);
2158 #endif
2159           s->bsym->flags &= ~BSF_WEAK;
2160           s->bsym->flags |= BSF_LOCAL;
2161         }
2162     }
2163 }
2164
2165 void
2166 S_SET_THREAD_LOCAL (symbolS *s)
2167 {
2168   if (LOCAL_SYMBOL_CHECK (s))
2169     s = local_symbol_convert ((struct local_symbol *) s);
2170   if (bfd_is_com_section (s->bsym->section)
2171       && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2172     return;
2173   s->bsym->flags |= BSF_THREAD_LOCAL;
2174   if ((s->bsym->flags & BSF_FUNCTION) != 0)
2175     as_bad (_("Accessing function `%s' as thread-local object"),
2176             S_GET_NAME (s));
2177   else if (! bfd_is_und_section (s->bsym->section)
2178            && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2179     as_bad (_("Accessing `%s' as thread-local object"),
2180             S_GET_NAME (s));
2181 }
2182
2183 void
2184 S_SET_NAME (symbolS *s, const char *name)
2185 {
2186   if (LOCAL_SYMBOL_CHECK (s))
2187     {
2188       ((struct local_symbol *) s)->lsy_name = name;
2189       return;
2190     }
2191   s->bsym->name = name;
2192 }
2193
2194 void
2195 S_SET_VOLATILE (symbolS *s)
2196 {
2197   if (LOCAL_SYMBOL_CHECK (s))
2198     s = local_symbol_convert ((struct local_symbol *) s);
2199   s->sy_volatile = 1;
2200 }
2201
2202 void
2203 S_CLEAR_VOLATILE (symbolS *s)
2204 {
2205   if (!LOCAL_SYMBOL_CHECK (s))
2206     s->sy_volatile = 0;
2207 }
2208
2209 void
2210 S_SET_FORWARD_REF (symbolS *s)
2211 {
2212   if (LOCAL_SYMBOL_CHECK (s))
2213     s = local_symbol_convert ((struct local_symbol *) s);
2214   s->sy_forward_ref = 1;
2215 }
2216
2217 /* Return the previous symbol in a chain.  */
2218
2219 symbolS *
2220 symbol_previous (symbolS *s)
2221 {
2222   if (LOCAL_SYMBOL_CHECK (s))
2223     abort ();
2224   return s->sy_previous;
2225 }
2226
2227 /* Return the next symbol in a chain.  */
2228
2229 symbolS *
2230 symbol_next (symbolS *s)
2231 {
2232   if (LOCAL_SYMBOL_CHECK (s))
2233     abort ();
2234   return s->sy_next;
2235 }
2236
2237 /* Return a pointer to the value of a symbol as an expression.  */
2238
2239 expressionS *
2240 symbol_get_value_expression (symbolS *s)
2241 {
2242   if (LOCAL_SYMBOL_CHECK (s))
2243     s = local_symbol_convert ((struct local_symbol *) s);
2244   return &s->sy_value;
2245 }
2246
2247 /* Set the value of a symbol to an expression.  */
2248
2249 void
2250 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2251 {
2252   if (LOCAL_SYMBOL_CHECK (s))
2253     s = local_symbol_convert ((struct local_symbol *) s);
2254   s->sy_value = *exp;
2255   S_CLEAR_WEAKREFR (s);
2256 }
2257
2258 /* Return a pointer to the X_add_number component of a symbol.  */
2259
2260 offsetT *
2261 symbol_X_add_number (symbolS *s)
2262 {
2263   if (LOCAL_SYMBOL_CHECK (s))
2264     return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2265
2266   return &s->sy_value.X_add_number;
2267 }
2268
2269 /* Set the value of SYM to the current position in the current segment.  */
2270
2271 void
2272 symbol_set_value_now (symbolS *sym)
2273 {
2274   S_SET_SEGMENT (sym, now_seg);
2275   S_SET_VALUE (sym, frag_now_fix ());
2276   symbol_set_frag (sym, frag_now);
2277 }
2278
2279 /* Set the frag of a symbol.  */
2280
2281 void
2282 symbol_set_frag (symbolS *s, fragS *f)
2283 {
2284   if (LOCAL_SYMBOL_CHECK (s))
2285     {
2286       local_symbol_set_frag ((struct local_symbol *) s, f);
2287       return;
2288     }
2289   s->sy_frag = f;
2290   S_CLEAR_WEAKREFR (s);
2291 }
2292
2293 /* Return the frag of a symbol.  */
2294
2295 fragS *
2296 symbol_get_frag (symbolS *s)
2297 {
2298   if (LOCAL_SYMBOL_CHECK (s))
2299     return local_symbol_get_frag ((struct local_symbol *) s);
2300   return s->sy_frag;
2301 }
2302
2303 /* Mark a symbol as having been used.  */
2304
2305 void
2306 symbol_mark_used (symbolS *s)
2307 {
2308   if (LOCAL_SYMBOL_CHECK (s))
2309     return;
2310   s->sy_used = 1;
2311   if (S_IS_WEAKREFR (s))
2312     symbol_mark_used (s->sy_value.X_add_symbol);
2313 }
2314
2315 /* Clear the mark of whether a symbol has been used.  */
2316
2317 void
2318 symbol_clear_used (symbolS *s)
2319 {
2320   if (LOCAL_SYMBOL_CHECK (s))
2321     s = local_symbol_convert ((struct local_symbol *) s);
2322   s->sy_used = 0;
2323 }
2324
2325 /* Return whether a symbol has been used.  */
2326
2327 int
2328 symbol_used_p (symbolS *s)
2329 {
2330   if (LOCAL_SYMBOL_CHECK (s))
2331     return 1;
2332   return s->sy_used;
2333 }
2334
2335 /* Mark a symbol as having been used in a reloc.  */
2336
2337 void
2338 symbol_mark_used_in_reloc (symbolS *s)
2339 {
2340   if (LOCAL_SYMBOL_CHECK (s))
2341     s = local_symbol_convert ((struct local_symbol *) s);
2342   s->sy_used_in_reloc = 1;
2343 }
2344
2345 /* Clear the mark of whether a symbol has been used in a reloc.  */
2346
2347 void
2348 symbol_clear_used_in_reloc (symbolS *s)
2349 {
2350   if (LOCAL_SYMBOL_CHECK (s))
2351     return;
2352   s->sy_used_in_reloc = 0;
2353 }
2354
2355 /* Return whether a symbol has been used in a reloc.  */
2356
2357 int
2358 symbol_used_in_reloc_p (symbolS *s)
2359 {
2360   if (LOCAL_SYMBOL_CHECK (s))
2361     return 0;
2362   return s->sy_used_in_reloc;
2363 }
2364
2365 /* Mark a symbol as an MRI common symbol.  */
2366
2367 void
2368 symbol_mark_mri_common (symbolS *s)
2369 {
2370   if (LOCAL_SYMBOL_CHECK (s))
2371     s = local_symbol_convert ((struct local_symbol *) s);
2372   s->sy_mri_common = 1;
2373 }
2374
2375 /* Clear the mark of whether a symbol is an MRI common symbol.  */
2376
2377 void
2378 symbol_clear_mri_common (symbolS *s)
2379 {
2380   if (LOCAL_SYMBOL_CHECK (s))
2381     return;
2382   s->sy_mri_common = 0;
2383 }
2384
2385 /* Return whether a symbol is an MRI common symbol.  */
2386
2387 int
2388 symbol_mri_common_p (symbolS *s)
2389 {
2390   if (LOCAL_SYMBOL_CHECK (s))
2391     return 0;
2392   return s->sy_mri_common;
2393 }
2394
2395 /* Mark a symbol as having been written.  */
2396
2397 void
2398 symbol_mark_written (symbolS *s)
2399 {
2400   if (LOCAL_SYMBOL_CHECK (s))
2401     return;
2402   s->written = 1;
2403 }
2404
2405 /* Clear the mark of whether a symbol has been written.  */
2406
2407 void
2408 symbol_clear_written (symbolS *s)
2409 {
2410   if (LOCAL_SYMBOL_CHECK (s))
2411     return;
2412   s->written = 0;
2413 }
2414
2415 /* Return whether a symbol has been written.  */
2416
2417 int
2418 symbol_written_p (symbolS *s)
2419 {
2420   if (LOCAL_SYMBOL_CHECK (s))
2421     return 0;
2422   return s->written;
2423 }
2424
2425 /* Mark a symbol has having been resolved.  */
2426
2427 void
2428 symbol_mark_resolved (symbolS *s)
2429 {
2430   if (LOCAL_SYMBOL_CHECK (s))
2431     {
2432       local_symbol_mark_resolved ((struct local_symbol *) s);
2433       return;
2434     }
2435   s->sy_resolved = 1;
2436 }
2437
2438 /* Return whether a symbol has been resolved.  */
2439
2440 int
2441 symbol_resolved_p (symbolS *s)
2442 {
2443   if (LOCAL_SYMBOL_CHECK (s))
2444     return local_symbol_resolved_p ((struct local_symbol *) s);
2445   return s->sy_resolved;
2446 }
2447
2448 /* Return whether a symbol is a section symbol.  */
2449
2450 int
2451 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2452 {
2453   if (LOCAL_SYMBOL_CHECK (s))
2454     return 0;
2455   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2456 }
2457
2458 /* Return whether a symbol is equated to another symbol.  */
2459
2460 int
2461 symbol_equated_p (symbolS *s)
2462 {
2463   if (LOCAL_SYMBOL_CHECK (s))
2464     return 0;
2465   return s->sy_value.X_op == O_symbol;
2466 }
2467
2468 /* Return whether a symbol is equated to another symbol, and should be
2469    treated specially when writing out relocs.  */
2470
2471 int
2472 symbol_equated_reloc_p (symbolS *s)
2473 {
2474   if (LOCAL_SYMBOL_CHECK (s))
2475     return 0;
2476   /* X_op_symbol, normally not used for O_symbol, is set by
2477      resolve_symbol_value to flag expression syms that have been
2478      equated.  */
2479   return (s->sy_value.X_op == O_symbol
2480 #if defined (OBJ_COFF) && defined (TE_PE)
2481           && ! S_IS_WEAK (s)
2482 #endif
2483           && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2484               || ! S_IS_DEFINED (s)
2485               || S_IS_COMMON (s)));
2486 }
2487
2488 /* Return whether a symbol has a constant value.  */
2489
2490 int
2491 symbol_constant_p (symbolS *s)
2492 {
2493   if (LOCAL_SYMBOL_CHECK (s))
2494     return 1;
2495   return s->sy_value.X_op == O_constant;
2496 }
2497
2498 /* Return the BFD symbol for a symbol.  */
2499
2500 asymbol *
2501 symbol_get_bfdsym (symbolS *s)
2502 {
2503   if (LOCAL_SYMBOL_CHECK (s))
2504     s = local_symbol_convert ((struct local_symbol *) s);
2505   return s->bsym;
2506 }
2507
2508 /* Set the BFD symbol for a symbol.  */
2509
2510 void
2511 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2512 {
2513   if (LOCAL_SYMBOL_CHECK (s))
2514     s = local_symbol_convert ((struct local_symbol *) s);
2515   /* Usually, it is harmless to reset a symbol to a BFD section
2516      symbol. For example, obj_elf_change_section sets the BFD symbol
2517      of an old symbol with the newly created section symbol. But when
2518      we have multiple sections with the same name, the newly created
2519      section may have the same name as an old section. We check if the
2520      old symbol has been already marked as a section symbol before
2521      resetting it.  */
2522   if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2523     s->bsym = bsym;
2524   /* else XXX - What do we do now ?  */
2525 }
2526
2527 #ifdef OBJ_SYMFIELD_TYPE
2528
2529 /* Get a pointer to the object format information for a symbol.  */
2530
2531 OBJ_SYMFIELD_TYPE *
2532 symbol_get_obj (symbolS *s)
2533 {
2534   if (LOCAL_SYMBOL_CHECK (s))
2535     s = local_symbol_convert ((struct local_symbol *) s);
2536   return &s->sy_obj;
2537 }
2538
2539 /* Set the object format information for a symbol.  */
2540
2541 void
2542 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2543 {
2544   if (LOCAL_SYMBOL_CHECK (s))
2545     s = local_symbol_convert ((struct local_symbol *) s);
2546   s->sy_obj = *o;
2547 }
2548
2549 #endif /* OBJ_SYMFIELD_TYPE */
2550
2551 #ifdef TC_SYMFIELD_TYPE
2552
2553 /* Get a pointer to the processor information for a symbol.  */
2554
2555 TC_SYMFIELD_TYPE *
2556 symbol_get_tc (symbolS *s)
2557 {
2558   if (LOCAL_SYMBOL_CHECK (s))
2559     s = local_symbol_convert ((struct local_symbol *) s);
2560   return &s->sy_tc;
2561 }
2562
2563 /* Set the processor information for a symbol.  */
2564
2565 void
2566 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2567 {
2568   if (LOCAL_SYMBOL_CHECK (s))
2569     s = local_symbol_convert ((struct local_symbol *) s);
2570   s->sy_tc = *o;
2571 }
2572
2573 #endif /* TC_SYMFIELD_TYPE */
2574
2575 void
2576 symbol_begin (void)
2577 {
2578   symbol_lastP = NULL;
2579   symbol_rootP = NULL;          /* In case we have 0 symbols (!!)  */
2580   sy_hash = hash_new ();
2581   local_hash = hash_new ();
2582
2583   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2584 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2585   abs_symbol.bsym = bfd_abs_section.symbol;
2586 #endif
2587   abs_symbol.sy_value.X_op = O_constant;
2588   abs_symbol.sy_frag = &zero_address_frag;
2589
2590   if (LOCAL_LABELS_FB)
2591     fb_label_init ();
2592 }
2593 \f
2594 int indent_level;
2595
2596 /* Maximum indent level.
2597    Available for modification inside a gdb session.  */
2598 static int max_indent_level = 8;
2599
2600 void
2601 print_symbol_value_1 (FILE *file, symbolS *sym)
2602 {
2603   const char *name = S_GET_NAME (sym);
2604   if (!name || !name[0])
2605     name = "(unnamed)";
2606   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2607
2608   if (LOCAL_SYMBOL_CHECK (sym))
2609     {
2610       struct local_symbol *locsym = (struct local_symbol *) sym;
2611       if (local_symbol_get_frag (locsym) != &zero_address_frag
2612           && local_symbol_get_frag (locsym) != NULL)
2613         fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2614       if (local_symbol_resolved_p (locsym))
2615         fprintf (file, " resolved");
2616       fprintf (file, " local");
2617     }
2618   else
2619     {
2620       if (sym->sy_frag != &zero_address_frag)
2621         fprintf (file, " frag %lx", (long) sym->sy_frag);
2622       if (sym->written)
2623         fprintf (file, " written");
2624       if (sym->sy_resolved)
2625         fprintf (file, " resolved");
2626       else if (sym->sy_resolving)
2627         fprintf (file, " resolving");
2628       if (sym->sy_used_in_reloc)
2629         fprintf (file, " used-in-reloc");
2630       if (sym->sy_used)
2631         fprintf (file, " used");
2632       if (S_IS_LOCAL (sym))
2633         fprintf (file, " local");
2634       if (S_IS_EXTERNAL (sym))
2635         fprintf (file, " extern");
2636       if (S_IS_WEAK (sym))
2637         fprintf (file, " weak");
2638       if (S_IS_DEBUG (sym))
2639         fprintf (file, " debug");
2640       if (S_IS_DEFINED (sym))
2641         fprintf (file, " defined");
2642     }
2643   if (S_IS_WEAKREFR (sym))
2644     fprintf (file, " weakrefr");
2645   if (S_IS_WEAKREFD (sym))
2646     fprintf (file, " weakrefd");
2647   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2648   if (symbol_resolved_p (sym))
2649     {
2650       segT s = S_GET_SEGMENT (sym);
2651
2652       if (s != undefined_section
2653           && s != expr_section)
2654         fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2655     }
2656   else if (indent_level < max_indent_level
2657            && S_GET_SEGMENT (sym) != undefined_section)
2658     {
2659       indent_level++;
2660       fprintf (file, "\n%*s<", indent_level * 4, "");
2661       if (LOCAL_SYMBOL_CHECK (sym))
2662         fprintf (file, "constant %lx",
2663                  (long) ((struct local_symbol *) sym)->lsy_value);
2664       else
2665         print_expr_1 (file, &sym->sy_value);
2666       fprintf (file, ">");
2667       indent_level--;
2668     }
2669   fflush (file);
2670 }
2671
2672 void
2673 print_symbol_value (symbolS *sym)
2674 {
2675   indent_level = 0;
2676   print_symbol_value_1 (stderr, sym);
2677   fprintf (stderr, "\n");
2678 }
2679
2680 static void
2681 print_binary (FILE *file, const char *name, expressionS *exp)
2682 {
2683   indent_level++;
2684   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2685   print_symbol_value_1 (file, exp->X_add_symbol);
2686   fprintf (file, ">\n%*s<", indent_level * 4, "");
2687   print_symbol_value_1 (file, exp->X_op_symbol);
2688   fprintf (file, ">");
2689   indent_level--;
2690 }
2691
2692 void
2693 print_expr_1 (FILE *file, expressionS *exp)
2694 {
2695   fprintf (file, "expr %lx ", (long) exp);
2696   switch (exp->X_op)
2697     {
2698     case O_illegal:
2699       fprintf (file, "illegal");
2700       break;
2701     case O_absent:
2702       fprintf (file, "absent");
2703       break;
2704     case O_constant:
2705       fprintf (file, "constant %lx", (long) exp->X_add_number);
2706       break;
2707     case O_symbol:
2708       indent_level++;
2709       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2710       print_symbol_value_1 (file, exp->X_add_symbol);
2711       fprintf (file, ">");
2712     maybe_print_addnum:
2713       if (exp->X_add_number)
2714         fprintf (file, "\n%*s%lx", indent_level * 4, "",
2715                  (long) exp->X_add_number);
2716       indent_level--;
2717       break;
2718     case O_register:
2719       fprintf (file, "register #%d", (int) exp->X_add_number);
2720       break;
2721     case O_big:
2722       fprintf (file, "big");
2723       break;
2724     case O_uminus:
2725       fprintf (file, "uminus -<");
2726       indent_level++;
2727       print_symbol_value_1 (file, exp->X_add_symbol);
2728       fprintf (file, ">");
2729       goto maybe_print_addnum;
2730     case O_bit_not:
2731       fprintf (file, "bit_not");
2732       break;
2733     case O_multiply:
2734       print_binary (file, "multiply", exp);
2735       break;
2736     case O_divide:
2737       print_binary (file, "divide", exp);
2738       break;
2739     case O_modulus:
2740       print_binary (file, "modulus", exp);
2741       break;
2742     case O_left_shift:
2743       print_binary (file, "lshift", exp);
2744       break;
2745     case O_right_shift:
2746       print_binary (file, "rshift", exp);
2747       break;
2748     case O_bit_inclusive_or:
2749       print_binary (file, "bit_ior", exp);
2750       break;
2751     case O_bit_exclusive_or:
2752       print_binary (file, "bit_xor", exp);
2753       break;
2754     case O_bit_and:
2755       print_binary (file, "bit_and", exp);
2756       break;
2757     case O_eq:
2758       print_binary (file, "eq", exp);
2759       break;
2760     case O_ne:
2761       print_binary (file, "ne", exp);
2762       break;
2763     case O_lt:
2764       print_binary (file, "lt", exp);
2765       break;
2766     case O_le:
2767       print_binary (file, "le", exp);
2768       break;
2769     case O_ge:
2770       print_binary (file, "ge", exp);
2771       break;
2772     case O_gt:
2773       print_binary (file, "gt", exp);
2774       break;
2775     case O_logical_and:
2776       print_binary (file, "logical_and", exp);
2777       break;
2778     case O_logical_or:
2779       print_binary (file, "logical_or", exp);
2780       break;
2781     case O_add:
2782       indent_level++;
2783       fprintf (file, "add\n%*s<", indent_level * 4, "");
2784       print_symbol_value_1 (file, exp->X_add_symbol);
2785       fprintf (file, ">\n%*s<", indent_level * 4, "");
2786       print_symbol_value_1 (file, exp->X_op_symbol);
2787       fprintf (file, ">");
2788       goto maybe_print_addnum;
2789     case O_subtract:
2790       indent_level++;
2791       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2792       print_symbol_value_1 (file, exp->X_add_symbol);
2793       fprintf (file, ">\n%*s<", indent_level * 4, "");
2794       print_symbol_value_1 (file, exp->X_op_symbol);
2795       fprintf (file, ">");
2796       goto maybe_print_addnum;
2797     default:
2798       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2799       break;
2800     }
2801   fflush (stdout);
2802 }
2803
2804 void
2805 print_expr (expressionS *exp)
2806 {
2807   print_expr_1 (stderr, exp);
2808   fprintf (stderr, "\n");
2809 }
2810
2811 void
2812 symbol_print_statistics (FILE *file)
2813 {
2814   hash_print_statistics (file, "symbol table", sy_hash);
2815   hash_print_statistics (file, "mini local symbol table", local_hash);
2816   fprintf (file, "%lu mini local symbols created, %lu converted\n",
2817            local_symbol_count, local_symbol_conversion_count);
2818 }