gas/symbols.c

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