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