gas/symbols.c

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