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   if (s->bsym->flags & BSF_SECTION_SYM)
1828     {
1829       char * file;
1830       unsigned int line;
1831
1832       /* Do not reassign section symbols.  */
1833       as_where (& file, & line);
1834       as_warn_where (file, line,
1835                      _("Section symbols are already global"));
1836       return;
1837     }
1838   s->bsym->flags |= BSF_GLOBAL;
1839   s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
1840 }
1841
1842 void
1843 S_CLEAR_EXTERNAL (s)
1844      symbolS *s;
1845 {
1846   if (LOCAL_SYMBOL_CHECK (s))
1847     return;
1848   if ((s->bsym->flags & BSF_WEAK) != 0)
1849     {
1850       /* Let .weak override.  */
1851       return;
1852     }
1853   s->bsym->flags |= BSF_LOCAL;
1854   s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
1855 }
1856
1857 void
1858 S_SET_WEAK (s)
1859      symbolS *s;
1860 {
1861   if (LOCAL_SYMBOL_CHECK (s))
1862     s = local_symbol_convert ((struct local_symbol *) s);
1863   s->bsym->flags |= BSF_WEAK;
1864   s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
1865 }
1866
1867 void
1868 S_SET_NAME (s, name)
1869      symbolS *s;
1870      char *name;
1871 {
1872   if (LOCAL_SYMBOL_CHECK (s))
1873     {
1874       ((struct local_symbol *) s)->lsy_name = name;
1875       return;
1876     }
1877   s->bsym->name = name;
1878 }
1879 #endif /* BFD_ASSEMBLER */
1880
1881 #ifdef SYMBOLS_NEED_BACKPOINTERS
1882
1883 /* Return the previous symbol in a chain.  */
1884
1885 symbolS *
1886 symbol_previous (s)
1887      symbolS *s;
1888 {
1889   if (LOCAL_SYMBOL_CHECK (s))
1890     abort ();
1891   return s->sy_previous;
1892 }
1893
1894 #endif /* SYMBOLS_NEED_BACKPOINTERS */
1895
1896 /* Return the next symbol in a chain.  */
1897
1898 symbolS *
1899 symbol_next (s)
1900      symbolS *s;
1901 {
1902   if (LOCAL_SYMBOL_CHECK (s))
1903     abort ();
1904   return s->sy_next;
1905 }
1906
1907 /* Return a pointer to the value of a symbol as an expression.  */
1908
1909 expressionS *
1910 symbol_get_value_expression (s)
1911      symbolS *s;
1912 {
1913   if (LOCAL_SYMBOL_CHECK (s))
1914     s = local_symbol_convert ((struct local_symbol *) s);
1915   return &s->sy_value;
1916 }
1917
1918 /* Set the value of a symbol to an expression.  */
1919
1920 void
1921 symbol_set_value_expression (s, exp)
1922      symbolS *s;
1923      const expressionS *exp;
1924 {
1925   if (LOCAL_SYMBOL_CHECK (s))
1926     s = local_symbol_convert ((struct local_symbol *) s);
1927   s->sy_value = *exp;
1928 }
1929
1930 /* Set the frag of a symbol.  */
1931
1932 void
1933 symbol_set_frag (s, f)
1934      symbolS *s;
1935      fragS *f;
1936 {
1937 #ifdef BFD_ASSEMBLER
1938   if (LOCAL_SYMBOL_CHECK (s))
1939     {
1940       local_symbol_set_frag ((struct local_symbol *) s, f);
1941       return;
1942     }
1943 #endif
1944   s->sy_frag = f;
1945 }
1946
1947 /* Return the frag of a symbol.  */
1948
1949 fragS *
1950 symbol_get_frag (s)
1951      symbolS *s;
1952 {
1953 #ifdef BFD_ASSEMBLER
1954   if (LOCAL_SYMBOL_CHECK (s))
1955     return local_symbol_get_frag ((struct local_symbol *) s);
1956 #endif
1957   return s->sy_frag;
1958 }
1959
1960 /* Mark a symbol as having been used.  */
1961
1962 void
1963 symbol_mark_used (s)
1964      symbolS *s;
1965 {
1966   if (LOCAL_SYMBOL_CHECK (s))
1967     return;
1968   s->sy_used = 1;
1969 }
1970
1971 /* Clear the mark of whether a symbol has been used.  */
1972
1973 void
1974 symbol_clear_used (s)
1975      symbolS *s;
1976 {
1977   if (LOCAL_SYMBOL_CHECK (s))
1978     s = local_symbol_convert ((struct local_symbol *) s);
1979   s->sy_used = 0;
1980 }
1981
1982 /* Return whether a symbol has been used.  */
1983
1984 int
1985 symbol_used_p (s)
1986      symbolS *s;
1987 {
1988   if (LOCAL_SYMBOL_CHECK (s))
1989     return 1;
1990   return s->sy_used;
1991 }
1992
1993 /* Mark a symbol as having been used in a reloc.  */
1994
1995 void
1996 symbol_mark_used_in_reloc (s)
1997      symbolS *s;
1998 {
1999   if (LOCAL_SYMBOL_CHECK (s))
2000     s = local_symbol_convert ((struct local_symbol *) s);
2001   s->sy_used_in_reloc = 1;
2002 }
2003
2004 /* Clear the mark of whether a symbol has been used in a reloc.  */
2005
2006 void
2007 symbol_clear_used_in_reloc (s)
2008      symbolS *s;
2009 {
2010   if (LOCAL_SYMBOL_CHECK (s))
2011     return;
2012   s->sy_used_in_reloc = 0;
2013 }
2014
2015 /* Return whether a symbol has been used in a reloc.  */
2016
2017 int
2018 symbol_used_in_reloc_p (s)
2019      symbolS *s;
2020 {
2021   if (LOCAL_SYMBOL_CHECK (s))
2022     return 0;
2023   return s->sy_used_in_reloc;
2024 }
2025
2026 /* Mark a symbol as an MRI common symbol.  */
2027
2028 void
2029 symbol_mark_mri_common (s)
2030      symbolS *s;
2031 {
2032   if (LOCAL_SYMBOL_CHECK (s))
2033     s = local_symbol_convert ((struct local_symbol *) s);
2034   s->sy_mri_common = 1;
2035 }
2036
2037 /* Clear the mark of whether a symbol is an MRI common symbol.  */
2038
2039 void
2040 symbol_clear_mri_common (s)
2041      symbolS *s;
2042 {
2043   if (LOCAL_SYMBOL_CHECK (s))
2044     return;
2045   s->sy_mri_common = 0;
2046 }
2047
2048 /* Return whether a symbol is an MRI common symbol.  */
2049
2050 int
2051 symbol_mri_common_p (s)
2052      symbolS *s;
2053 {
2054   if (LOCAL_SYMBOL_CHECK (s))
2055     return 0;
2056   return s->sy_mri_common;
2057 }
2058
2059 /* Mark a symbol as having been written.  */
2060
2061 void
2062 symbol_mark_written (s)
2063      symbolS *s;
2064 {
2065   if (LOCAL_SYMBOL_CHECK (s))
2066     return;
2067   s->written = 1;
2068 }
2069
2070 /* Clear the mark of whether a symbol has been written.  */
2071
2072 void
2073 symbol_clear_written (s)
2074      symbolS *s;
2075 {
2076   if (LOCAL_SYMBOL_CHECK (s))
2077     return;
2078   s->written = 0;
2079 }
2080
2081 /* Return whether a symbol has been written.  */
2082
2083 int
2084 symbol_written_p (s)
2085      symbolS *s;
2086 {
2087   if (LOCAL_SYMBOL_CHECK (s))
2088     return 0;
2089   return s->written;
2090 }
2091
2092 /* Mark a symbol has having been resolved.  */
2093
2094 void
2095 symbol_mark_resolved (s)
2096      symbolS *s;
2097 {
2098 #ifdef BFD_ASSEMBLER
2099   if (LOCAL_SYMBOL_CHECK (s))
2100     {
2101       local_symbol_mark_resolved ((struct local_symbol *) s);
2102       return;
2103     }
2104 #endif
2105   s->sy_resolved = 1;
2106 }
2107
2108 /* Return whether a symbol has been resolved.  */
2109
2110 int
2111 symbol_resolved_p (s)
2112      symbolS *s;
2113 {
2114 #ifdef BFD_ASSEMBLER
2115   if (LOCAL_SYMBOL_CHECK (s))
2116     return local_symbol_resolved_p ((struct local_symbol *) s);
2117 #endif
2118   return s->sy_resolved;
2119 }
2120
2121 /* Return whether a symbol is a section symbol.  */
2122
2123 int
2124 symbol_section_p (s)
2125      symbolS *s ATTRIBUTE_UNUSED;
2126 {
2127   if (LOCAL_SYMBOL_CHECK (s))
2128     return 0;
2129 #ifdef BFD_ASSEMBLER
2130   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2131 #else
2132   /* FIXME.  */
2133   return 0;
2134 #endif
2135 }
2136
2137 /* Return whether a symbol is equated to another symbol.  */
2138
2139 int
2140 symbol_equated_p (s)
2141      symbolS *s;
2142 {
2143   if (LOCAL_SYMBOL_CHECK (s))
2144     return 0;
2145   return s->sy_value.X_op == O_symbol;
2146 }
2147
2148 /* Return whether a symbol has a constant value.  */
2149
2150 int
2151 symbol_constant_p (s)
2152      symbolS *s;
2153 {
2154   if (LOCAL_SYMBOL_CHECK (s))
2155     return 1;
2156   return s->sy_value.X_op == O_constant;
2157 }
2158
2159 #ifdef BFD_ASSEMBLER
2160
2161 /* Return the BFD symbol for a symbol.  */
2162
2163 asymbol *
2164 symbol_get_bfdsym (s)
2165      symbolS *s;
2166 {
2167   if (LOCAL_SYMBOL_CHECK (s))
2168     s = local_symbol_convert ((struct local_symbol *) s);
2169   return s->bsym;
2170 }
2171
2172 /* Set the BFD symbol for a symbol.  */
2173
2174 void
2175 symbol_set_bfdsym (s, bsym)
2176      symbolS *s;
2177      asymbol *bsym;
2178 {
2179   if (LOCAL_SYMBOL_CHECK (s))
2180     s = local_symbol_convert ((struct local_symbol *) s);
2181   s->bsym = bsym;
2182 }
2183
2184 #endif /* BFD_ASSEMBLER */
2185
2186 #ifdef OBJ_SYMFIELD_TYPE
2187
2188 /* Get a pointer to the object format information for a symbol.  */
2189
2190 OBJ_SYMFIELD_TYPE *
2191 symbol_get_obj (s)
2192      symbolS *s;
2193 {
2194   if (LOCAL_SYMBOL_CHECK (s))
2195     s = local_symbol_convert ((struct local_symbol *) s);
2196   return &s->sy_obj;
2197 }
2198
2199 /* Set the object format information for a symbol.  */
2200
2201 void
2202 symbol_set_obj (s, o)
2203      symbolS *s;
2204      OBJ_SYMFIELD_TYPE *o;
2205 {
2206   if (LOCAL_SYMBOL_CHECK (s))
2207     s = local_symbol_convert ((struct local_symbol *) s);
2208   s->sy_obj = *o;
2209 }
2210
2211 #endif /* OBJ_SYMFIELD_TYPE */
2212
2213 #ifdef TC_SYMFIELD_TYPE
2214
2215 /* Get a pointer to the processor information for a symbol.  */
2216
2217 TC_SYMFIELD_TYPE *
2218 symbol_get_tc (s)
2219      symbolS *s;
2220 {
2221   if (LOCAL_SYMBOL_CHECK (s))
2222     s = local_symbol_convert ((struct local_symbol *) s);
2223   return &s->sy_tc;
2224 }
2225
2226 /* Set the processor information for a symbol.  */
2227
2228 void
2229 symbol_set_tc (s, o)
2230      symbolS *s;
2231      TC_SYMFIELD_TYPE *o;
2232 {
2233   if (LOCAL_SYMBOL_CHECK (s))
2234     s = local_symbol_convert ((struct local_symbol *) s);
2235   s->sy_tc = *o;
2236 }
2237
2238 #endif /* TC_SYMFIELD_TYPE */
2239
2240 void
2241 symbol_begin ()
2242 {
2243   symbol_lastP = NULL;
2244   symbol_rootP = NULL;          /* In case we have 0 symbols (!!)  */
2245   sy_hash = hash_new ();
2246 #ifdef BFD_ASSEMBLER
2247   local_hash = hash_new ();
2248 #endif
2249
2250   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2251 #ifdef BFD_ASSEMBLER
2252 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2253   abs_symbol.bsym = bfd_abs_section.symbol;
2254 #endif
2255 #else
2256   /* Can't initialise a union. Sigh.  */
2257   S_SET_SEGMENT (&abs_symbol, absolute_section);
2258 #endif
2259   abs_symbol.sy_value.X_op = O_constant;
2260   abs_symbol.sy_frag = &zero_address_frag;
2261
2262   if (LOCAL_LABELS_FB)
2263     fb_label_init ();
2264 }
2265 \f
2266 int indent_level;
2267
2268 /* Maximum indent level.
2269    Available for modification inside a gdb session.  */
2270 int max_indent_level = 8;
2271
2272 #if 0
2273
2274 static void
2275 indent ()
2276 {
2277   printf ("%*s", indent_level * 4, "");
2278 }
2279
2280 #endif
2281
2282 void
2283 print_symbol_value_1 (file, sym)
2284      FILE *file;
2285      symbolS *sym;
2286 {
2287   const char *name = S_GET_NAME (sym);
2288   if (!name || !name[0])
2289     name = "(unnamed)";
2290   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2291
2292   if (LOCAL_SYMBOL_CHECK (sym))
2293     {
2294 #ifdef BFD_ASSEMBLER
2295       struct local_symbol *locsym = (struct local_symbol *) sym;
2296       if (local_symbol_get_frag (locsym) != &zero_address_frag
2297           && local_symbol_get_frag (locsym) != NULL)
2298         fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2299       if (local_symbol_resolved_p (locsym))
2300         fprintf (file, " resolved");
2301       fprintf (file, " local");
2302 #endif
2303     }
2304   else
2305     {
2306       if (sym->sy_frag != &zero_address_frag)
2307         fprintf (file, " frag %lx", (long) sym->sy_frag);
2308       if (sym->written)
2309         fprintf (file, " written");
2310       if (sym->sy_resolved)
2311         fprintf (file, " resolved");
2312       else if (sym->sy_resolving)
2313         fprintf (file, " resolving");
2314       if (sym->sy_used_in_reloc)
2315         fprintf (file, " used-in-reloc");
2316       if (sym->sy_used)
2317         fprintf (file, " used");
2318       if (S_IS_LOCAL (sym))
2319         fprintf (file, " local");
2320       if (S_IS_EXTERN (sym))
2321         fprintf (file, " extern");
2322       if (S_IS_DEBUG (sym))
2323         fprintf (file, " debug");
2324       if (S_IS_DEFINED (sym))
2325         fprintf (file, " defined");
2326     }
2327   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2328   if (symbol_resolved_p (sym))
2329     {
2330       segT s = S_GET_SEGMENT (sym);
2331
2332       if (s != undefined_section
2333           && s != expr_section)
2334         fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2335     }
2336   else if (indent_level < max_indent_level
2337            && S_GET_SEGMENT (sym) != undefined_section)
2338     {
2339       indent_level++;
2340       fprintf (file, "\n%*s<", indent_level * 4, "");
2341 #ifdef BFD_ASSEMBLER
2342       if (LOCAL_SYMBOL_CHECK (sym))
2343         fprintf (file, "constant %lx",
2344                  (long) ((struct local_symbol *) sym)->lsy_offset);
2345       else
2346 #endif
2347         print_expr_1 (file, &sym->sy_value);
2348       fprintf (file, ">");
2349       indent_level--;
2350     }
2351   fflush (file);
2352 }
2353
2354 void
2355 print_symbol_value (sym)
2356      symbolS *sym;
2357 {
2358   indent_level = 0;
2359   print_symbol_value_1 (stderr, sym);
2360   fprintf (stderr, "\n");
2361 }
2362
2363 static void
2364 print_binary (file, name, exp)
2365      FILE *file;
2366      const char *name;
2367      expressionS *exp;
2368 {
2369   indent_level++;
2370   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2371   print_symbol_value_1 (file, exp->X_add_symbol);
2372   fprintf (file, ">\n%*s<", indent_level * 4, "");
2373   print_symbol_value_1 (file, exp->X_op_symbol);
2374   fprintf (file, ">");
2375   indent_level--;
2376 }
2377
2378 void
2379 print_expr_1 (file, exp)
2380      FILE *file;
2381      expressionS *exp;
2382 {
2383   fprintf (file, "expr %lx ", (long) exp);
2384   switch (exp->X_op)
2385     {
2386     case O_illegal:
2387       fprintf (file, "illegal");
2388       break;
2389     case O_absent:
2390       fprintf (file, "absent");
2391       break;
2392     case O_constant:
2393       fprintf (file, "constant %lx", (long) exp->X_add_number);
2394       break;
2395     case O_symbol:
2396       indent_level++;
2397       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2398       print_symbol_value_1 (file, exp->X_add_symbol);
2399       fprintf (file, ">");
2400     maybe_print_addnum:
2401       if (exp->X_add_number)
2402         fprintf (file, "\n%*s%lx", indent_level * 4, "",
2403                  (long) exp->X_add_number);
2404       indent_level--;
2405       break;
2406     case O_register:
2407       fprintf (file, "register #%d", (int) exp->X_add_number);
2408       break;
2409     case O_big:
2410       fprintf (file, "big");
2411       break;
2412     case O_uminus:
2413       fprintf (file, "uminus -<");
2414       indent_level++;
2415       print_symbol_value_1 (file, exp->X_add_symbol);
2416       fprintf (file, ">");
2417       goto maybe_print_addnum;
2418     case O_bit_not:
2419       fprintf (file, "bit_not");
2420       break;
2421     case O_multiply:
2422       print_binary (file, "multiply", exp);
2423       break;
2424     case O_divide:
2425       print_binary (file, "divide", exp);
2426       break;
2427     case O_modulus:
2428       print_binary (file, "modulus", exp);
2429       break;
2430     case O_left_shift:
2431       print_binary (file, "lshift", exp);
2432       break;
2433     case O_right_shift:
2434       print_binary (file, "rshift", exp);
2435       break;
2436     case O_bit_inclusive_or:
2437       print_binary (file, "bit_ior", exp);
2438       break;
2439     case O_bit_exclusive_or:
2440       print_binary (file, "bit_xor", exp);
2441       break;
2442     case O_bit_and:
2443       print_binary (file, "bit_and", exp);
2444       break;
2445     case O_eq:
2446       print_binary (file, "eq", exp);
2447       break;
2448     case O_ne:
2449       print_binary (file, "ne", exp);
2450       break;
2451     case O_lt:
2452       print_binary (file, "lt", exp);
2453       break;
2454     case O_le:
2455       print_binary (file, "le", exp);
2456       break;
2457     case O_ge:
2458       print_binary (file, "ge", exp);
2459       break;
2460     case O_gt:
2461       print_binary (file, "gt", exp);
2462       break;
2463     case O_logical_and:
2464       print_binary (file, "logical_and", exp);
2465       break;
2466     case O_logical_or:
2467       print_binary (file, "logical_or", exp);
2468       break;
2469     case O_add:
2470       indent_level++;
2471       fprintf (file, "add\n%*s<", indent_level * 4, "");
2472       print_symbol_value_1 (file, exp->X_add_symbol);
2473       fprintf (file, ">\n%*s<", indent_level * 4, "");
2474       print_symbol_value_1 (file, exp->X_op_symbol);
2475       fprintf (file, ">");
2476       goto maybe_print_addnum;
2477     case O_subtract:
2478       indent_level++;
2479       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2480       print_symbol_value_1 (file, exp->X_add_symbol);
2481       fprintf (file, ">\n%*s<", indent_level * 4, "");
2482       print_symbol_value_1 (file, exp->X_op_symbol);
2483       fprintf (file, ">");
2484       goto maybe_print_addnum;
2485     default:
2486       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2487       break;
2488     }
2489   fflush (stdout);
2490 }
2491
2492 void
2493 print_expr (exp)
2494      expressionS *exp;
2495 {
2496   print_expr_1 (stderr, exp);
2497   fprintf (stderr, "\n");
2498 }
2499
2500 void
2501 symbol_print_statistics (file)
2502      FILE *file;
2503 {
2504   hash_print_statistics (file, "symbol table", sy_hash);
2505 #ifdef BFD_ASSEMBLER
2506   hash_print_statistics (file, "mini local symbol table", local_hash);
2507   fprintf (file, "%lu mini local symbols created, %lu converted\n",
2508            local_symbol_count, local_symbol_conversion_count);
2509 #endif
2510 }