gas/symbols.c

   1 /* symbols.c -symbol table-
   2    Copyright (C) 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996
   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
  19    the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* #define DEBUG_SYMS / * to debug symbol list maintenance */
  22
  23 #include <ctype.h>
  24
  25 #include "as.h"
  26
  27 #include "obstack.h"            /* For "symbols.h" */
  28 #include "subsegs.h"
  29
  30 /* This is non-zero if symbols are case sensitive, which is the
  31    default.  */
  32 int symbols_case_sensitive = 1;
  33
  34 #ifndef WORKING_DOT_WORD
  35 extern int new_broken_words;
  36 #endif
  37
  38 /* symbol-name => struct symbol pointer */
  39 static struct hash_control *sy_hash;
  40
  41 /* Below are commented in "symbols.h". */
  42 symbolS *symbol_rootP;
  43 symbolS *symbol_lastP;
  44 symbolS abs_symbol;
  45
  46 #ifdef DEBUG_SYMS
  47 #define debug_verify_symchain verify_symbol_chain
  48 #else
  49 #define debug_verify_symchain(root, last) ((void) 0)
  50 #endif
  51
  52 struct obstack notes;
  53
  54 static void fb_label_init PARAMS ((void));
  55
  56 /* symbol_new()
  57
  58    Return a pointer to a new symbol.  Die if we can't make a new
  59    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
  60    chain.
  61
  62    This function should be called in the general case of creating a
  63    symbol.  However, if the output file symbol table has already been
  64    set, and you are certain that this symbol won't be wanted in the
  65    output file, you can call symbol_create.  */
  66
  67 symbolS *
  68 symbol_new (name, segment, valu, frag)
  69      const char *name;
  70      segT segment;
  71      valueT valu;
  72      fragS *frag;
  73 {
  74   symbolS *symbolP = symbol_create (name, segment, valu, frag);
  75
  76   /*
  77    * Link to end of symbol chain.
  78    */
  79 #ifdef BFD_ASSEMBLER
  80   {
  81     extern int symbol_table_frozen;
  82     if (symbol_table_frozen)
  83       abort ();
  84   }
  85 #endif
  86   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
  87   debug_verify_symchain (symbol_rootP, symbol_lastP);
  88
  89   return symbolP;
  90 }
  91
  92 symbolS *
  93 symbol_create (name, segment, valu, frag)
  94      const char *name;          /* It is copied, the caller can destroy/modify */
  95      segT segment;              /* Segment identifier (SEG_<something>) */
  96      valueT valu;               /* Symbol value */
  97      fragS *frag;               /* Associated fragment */
  98 {
  99   unsigned int name_length;
 100   char *preserved_copy_of_name;
 101   symbolS *symbolP;
 102
 103   name_length = strlen (name) + 1;      /* +1 for \0 */
 104   obstack_grow (&notes, name, name_length);
 105   preserved_copy_of_name = obstack_finish (&notes);
 106 #ifdef STRIP_UNDERSCORE
 107   if (preserved_copy_of_name[0] == '_')
 108     preserved_copy_of_name++;
 109 #endif
 110
 111 #ifdef tc_canonicalize_symbol_name
 112   preserved_copy_of_name =
 113     tc_canonicalize_symbol_name (preserved_copy_of_name);
 114 #endif
 115
 116   if (! symbols_case_sensitive)
 117     {
 118       unsigned char *s;
 119
 120       for (s = (unsigned char *) preserved_copy_of_name; *s != '\0'; s++)
 121         if (islower (*s))
 122           *s = toupper (*s);
 123     }
 124
 125   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 126
 127   /* symbol must be born in some fixed state.  This seems as good as any. */
 128   memset (symbolP, 0, sizeof (symbolS));
 129
 130 #ifdef BFD_ASSEMBLER
 131   symbolP->bsym = bfd_make_empty_symbol (stdoutput);
 132   if (symbolP->bsym == NULL)
 133     as_perror ("%s", "bfd_make_empty_symbol");
 134   symbolP->bsym->udata.p = (PTR) symbolP;
 135 #endif
 136   S_SET_NAME (symbolP, preserved_copy_of_name);
 137
 138   S_SET_SEGMENT (symbolP, segment);
 139   S_SET_VALUE (symbolP, valu);
 140   symbol_clear_list_pointers (symbolP);
 141
 142   symbolP->sy_frag = frag;
 143 #ifndef BFD_ASSEMBLER
 144   symbolP->sy_number = ~0;
 145   symbolP->sy_name_offset = (unsigned int) ~0;
 146 #endif
 147
 148   obj_symbol_new_hook (symbolP);
 149
 150 #ifdef tc_symbol_new_hook
 151   tc_symbol_new_hook (symbolP);
 152 #endif
 153
 154   return symbolP;
 155 }
 156 \f
 157
 158 /*
 159  *                      colon()
 160  *
 161  * We have just seen "<name>:".
 162  * Creates a struct symbol unless it already exists.
 163  *
 164  * Gripes if we are redefining a symbol incompatibly (and ignores it).
 165  *
 166  */
 167 symbolS *
 168 colon (sym_name)                /* just seen "x:" - rattle symbols & frags */
 169      const char *sym_name;      /* symbol name, as a cannonical string */
 170      /* We copy this string: OK to alter later. */
 171 {
 172   register symbolS *symbolP;    /* symbol we are working with */
 173
 174   /* Sun local labels go out of scope whenever a non-local symbol is
 175      defined.  */
 176   if (LOCAL_LABELS_DOLLAR && ! LOCAL_LABEL (sym_name))
 177     dollar_label_clear ();
 178
 179 #ifndef WORKING_DOT_WORD
 180   if (new_broken_words)
 181     {
 182       struct broken_word *a;
 183       int possible_bytes;
 184       fragS *frag_tmp;
 185       char *frag_opcode;
 186
 187       extern const int md_short_jump_size;
 188       extern const int md_long_jump_size;
 189       possible_bytes = (md_short_jump_size
 190                         + new_broken_words * md_long_jump_size);
 191
 192       frag_tmp = frag_now;
 193       frag_opcode = frag_var (rs_broken_word,
 194                               possible_bytes,
 195                               possible_bytes,
 196                               (relax_substateT) 0,
 197                               (symbolS *) broken_words,
 198                               0L,
 199                               NULL);
 200
 201       /* We want to store the pointer to where to insert the jump table in the
 202          fr_opcode of the rs_broken_word frag.  This requires a little
 203          hackery.  */
 204       while (frag_tmp
 205              && (frag_tmp->fr_type != rs_broken_word
 206                  || frag_tmp->fr_opcode))
 207         frag_tmp = frag_tmp->fr_next;
 208       know (frag_tmp);
 209       frag_tmp->fr_opcode = frag_opcode;
 210       new_broken_words = 0;
 211
 212       for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
 213         a->dispfrag = frag_tmp;
 214     }
 215 #endif /* WORKING_DOT_WORD */
 216
 217   if ((symbolP = symbol_find (sym_name)) != 0)
 218     {
 219 #ifdef RESOLVE_SYMBOL_REDEFINITION
 220       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
 221         return symbolP;
 222 #endif
 223       /*
 224        *        Now check for undefined symbols
 225        */
 226       if (!S_IS_DEFINED (symbolP))
 227         {
 228           if (S_GET_VALUE (symbolP) == 0)
 229             {
 230               symbolP->sy_frag = frag_now;
 231 #ifdef OBJ_VMS
 232               S_SET_OTHER(symbolP, const_flag);
 233 #endif
 234               S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 235               S_SET_SEGMENT (symbolP, now_seg);
 236 #ifdef N_UNDF
 237               know (N_UNDF == 0);
 238 #endif /* if we have one, it better be zero. */
 239
 240             }
 241           else
 242             {
 243               /*
 244                *        There are still several cases to check:
 245                *                A .comm/.lcomm symbol being redefined as
 246                *                        initialized data is OK
 247                *                A .comm/.lcomm symbol being redefined with
 248                *                        a larger size is also OK
 249                *
 250                * This only used to be allowed on VMS gas, but Sun cc
 251                * on the sparc also depends on it.
 252                */
 253
 254               if (((!S_IS_DEBUG (symbolP)
 255                     && !S_IS_DEFINED (symbolP)
 256                     && S_IS_EXTERNAL (symbolP))
 257                    || S_GET_SEGMENT (symbolP) == bss_section)
 258                   && (now_seg == data_section
 259                       || now_seg == S_GET_SEGMENT (symbolP)))
 260                 {
 261                   /*
 262                    *    Select which of the 2 cases this is
 263                    */
 264                   if (now_seg != data_section)
 265                     {
 266                       /*
 267                        *   New .comm for prev .comm symbol.
 268                        *        If the new size is larger we just
 269                        *        change its value.  If the new size
 270                        *        is smaller, we ignore this symbol
 271                        */
 272                       if (S_GET_VALUE (symbolP)
 273                           < ((unsigned) frag_now_fix ()))
 274                         {
 275                           S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 276                         }
 277                     }
 278                   else
 279                     {
 280                       /* It is a .comm/.lcomm being converted to initialized
 281                          data.  */
 282                       symbolP->sy_frag = frag_now;
 283 #ifdef OBJ_VMS
 284                       S_SET_OTHER(symbolP, const_flag);
 285 #endif
 286                       S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 287                       S_SET_SEGMENT (symbolP, now_seg); /* keep N_EXT bit */
 288                     }
 289                 }
 290               else
 291                 {
 292 #if defined (S_GET_OTHER) && defined (S_GET_DESC)
 293                   as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%ld.",
 294                             sym_name,
 295                             segment_name (S_GET_SEGMENT (symbolP)),
 296                             S_GET_OTHER (symbolP), S_GET_DESC (symbolP),
 297                             (long) S_GET_VALUE (symbolP));
 298 #else
 299                   as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%ld.",
 300                             sym_name,
 301                             segment_name (S_GET_SEGMENT (symbolP)),
 302                             (long) S_GET_VALUE (symbolP));
 303 #endif
 304                 }
 305             }                   /* if the undefined symbol has no value */
 306         }
 307       else
 308         {
 309           /* Don't blow up if the definition is the same */
 310           if (!(frag_now == symbolP->sy_frag
 311                 && S_GET_VALUE (symbolP) == frag_now_fix ()
 312                 && S_GET_SEGMENT (symbolP) == now_seg))
 313             as_fatal ("Symbol %s already defined.", sym_name);
 314         }                       /* if this symbol is not yet defined */
 315
 316     }
 317   else
 318     {
 319       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
 320                             frag_now);
 321 #ifdef OBJ_VMS
 322       S_SET_OTHER (symbolP, const_flag);
 323 #endif /* OBJ_VMS */
 324
 325       symbol_table_insert (symbolP);
 326     }                           /* if we have seen this symbol before */
 327
 328   if (mri_common_symbol != NULL)
 329     {
 330       /* This symbol is actually being defined within an MRI common
 331          section.  This requires special handling.  */
 332       symbolP->sy_value.X_op = O_symbol;
 333       symbolP->sy_value.X_add_symbol = mri_common_symbol;
 334       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
 335       symbolP->sy_frag = &zero_address_frag;
 336       S_SET_SEGMENT (symbolP, expr_section);
 337       symbolP->sy_mri_common = 1;
 338     }
 339
 340 #ifdef tc_frob_label
 341   tc_frob_label (symbolP);
 342 #endif
 343
 344   return symbolP;
 345 }
 346 \f
 347
 348 /*
 349  *                      symbol_table_insert()
 350  *
 351  * Die if we can't insert the symbol.
 352  *
 353  */
 354
 355 void
 356 symbol_table_insert (symbolP)
 357      symbolS *symbolP;
 358 {
 359   register const char *error_string;
 360
 361   know (symbolP);
 362   know (S_GET_NAME (symbolP));
 363
 364   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
 365     {
 366       as_fatal ("Inserting \"%s\" into symbol table failed: %s",
 367                 S_GET_NAME (symbolP), error_string);
 368     }                           /* on error */
 369 }                               /* symbol_table_insert() */
 370 \f
 371 /*
 372  *                      symbol_find_or_make()
 373  *
 374  * If a symbol name does not exist, create it as undefined, and insert
 375  * it into the symbol table. Return a pointer to it.
 376  */
 377 symbolS *
 378 symbol_find_or_make (name)
 379      const char *name;
 380 {
 381   register symbolS *symbolP;
 382
 383   symbolP = symbol_find (name);
 384
 385   if (symbolP == NULL)
 386     {
 387       symbolP = symbol_make (name);
 388
 389       symbol_table_insert (symbolP);
 390     }                           /* if symbol wasn't found */
 391
 392   return (symbolP);
 393 }                               /* symbol_find_or_make() */
 394
 395 symbolS *
 396 symbol_make (name)
 397      CONST char *name;
 398 {
 399   symbolS *symbolP;
 400
 401   /* Let the machine description default it, e.g. for register names. */
 402   symbolP = md_undefined_symbol ((char *) name);
 403
 404   if (!symbolP)
 405     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
 406
 407   return (symbolP);
 408 }                               /* symbol_make() */
 409
 410 /*
 411  *                      symbol_find()
 412  *
 413  * Implement symbol table lookup.
 414  * In:  A symbol's name as a string: '\0' can't be part of a symbol name.
 415  * Out: NULL if the name was not in the symbol table, else the address
 416  *      of a struct symbol associated with that name.
 417  */
 418
 419 symbolS *
 420 symbol_find (name)
 421      CONST char *name;
 422 {
 423 #ifdef STRIP_UNDERSCORE
 424   return (symbol_find_base (name, 1));
 425 #else /* STRIP_UNDERSCORE */
 426   return (symbol_find_base (name, 0));
 427 #endif /* STRIP_UNDERSCORE */
 428 }                               /* symbol_find() */
 429
 430 symbolS *
 431 symbol_find_base (name, strip_underscore)
 432      CONST char *name;
 433      int strip_underscore;
 434 {
 435   if (strip_underscore && *name == '_')
 436     name++;
 437
 438 #ifdef tc_canonicalize_symbol_name
 439   {
 440     char *copy;
 441
 442     copy = (char *) alloca (strlen (name) + 1);
 443     strcpy (copy, name);
 444     name = tc_canonicalize_symbol_name (copy);
 445   }
 446 #endif
 447
 448   if (! symbols_case_sensitive)
 449     {
 450       unsigned char *copy;
 451
 452       copy = (unsigned char *) alloca (strlen (name) + 1);
 453       name = (const char *) copy;
 454       for (; *copy != '\0'; copy++)
 455         if (islower (*copy))
 456           *copy = toupper (*copy);
 457     }
 458
 459   return ((symbolS *) hash_find (sy_hash, name));
 460 }
 461
 462 /*
 463  * Once upon a time, symbols were kept in a singly linked list.  At
 464  * least coff needs to be able to rearrange them from time to time, for
 465  * which a doubly linked list is much more convenient.  Loic did these
 466  * as macros which seemed dangerous to me so they're now functions.
 467  * xoxorich.
 468  */
 469
 470 /* Link symbol ADDME after symbol TARGET in the chain. */
 471 void
 472 symbol_append (addme, target, rootPP, lastPP)
 473      symbolS *addme;
 474      symbolS *target;
 475      symbolS **rootPP;
 476      symbolS **lastPP;
 477 {
 478   if (target == NULL)
 479     {
 480       know (*rootPP == NULL);
 481       know (*lastPP == NULL);
 482       *rootPP = addme;
 483       *lastPP = addme;
 484       return;
 485     }                           /* if the list is empty */
 486
 487   if (target->sy_next != NULL)
 488     {
 489 #ifdef SYMBOLS_NEED_BACKPOINTERS
 490       target->sy_next->sy_previous = addme;
 491 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 492     }
 493   else
 494     {
 495       know (*lastPP == target);
 496       *lastPP = addme;
 497     }                           /* if we have a next */
 498
 499   addme->sy_next = target->sy_next;
 500   target->sy_next = addme;
 501
 502 #ifdef SYMBOLS_NEED_BACKPOINTERS
 503   addme->sy_previous = target;
 504 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 505 }
 506
 507 /* Set the chain pointers of SYMBOL to null. */
 508 void
 509 symbol_clear_list_pointers (symbolP)
 510      symbolS *symbolP;
 511 {
 512   symbolP->sy_next = NULL;
 513 #ifdef SYMBOLS_NEED_BACKPOINTERS
 514   symbolP->sy_previous = NULL;
 515 #endif
 516 }
 517
 518 #ifdef SYMBOLS_NEED_BACKPOINTERS
 519 /* Remove SYMBOLP from the list. */
 520 void
 521 symbol_remove (symbolP, rootPP, lastPP)
 522      symbolS *symbolP;
 523      symbolS **rootPP;
 524      symbolS **lastPP;
 525 {
 526   if (symbolP == *rootPP)
 527     {
 528       *rootPP = symbolP->sy_next;
 529     }                           /* if it was the root */
 530
 531   if (symbolP == *lastPP)
 532     {
 533       *lastPP = symbolP->sy_previous;
 534     }                           /* if it was the tail */
 535
 536   if (symbolP->sy_next != NULL)
 537     {
 538       symbolP->sy_next->sy_previous = symbolP->sy_previous;
 539     }                           /* if not last */
 540
 541   if (symbolP->sy_previous != NULL)
 542     {
 543       symbolP->sy_previous->sy_next = symbolP->sy_next;
 544     }                           /* if not first */
 545
 546   debug_verify_symchain (*rootPP, *lastPP);
 547 }
 548
 549 /* Link symbol ADDME before symbol TARGET in the chain. */
 550 void
 551 symbol_insert (addme, target, rootPP, lastPP)
 552      symbolS *addme;
 553      symbolS *target;
 554      symbolS **rootPP;
 555      symbolS **lastPP;
 556 {
 557   if (target->sy_previous != NULL)
 558     {
 559       target->sy_previous->sy_next = addme;
 560     }
 561   else
 562     {
 563       know (*rootPP == target);
 564       *rootPP = addme;
 565     }                           /* if not first */
 566
 567   addme->sy_previous = target->sy_previous;
 568   target->sy_previous = addme;
 569   addme->sy_next = target;
 570
 571   debug_verify_symchain (*rootPP, *lastPP);
 572 }
 573
 574 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 575
 576 void
 577 verify_symbol_chain (rootP, lastP)
 578      symbolS *rootP;
 579      symbolS *lastP;
 580 {
 581   symbolS *symbolP = rootP;
 582
 583   if (symbolP == NULL)
 584     return;
 585
 586   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
 587     {
 588 #ifdef SYMBOLS_NEED_BACKPOINTERS
 589       know (symbolP->sy_next->sy_previous == symbolP);
 590 #else
 591       /* Walk the list anyways, to make sure pointers are still good.  */
 592       ;
 593 #endif /* SYMBOLS_NEED_BACKPOINTERS */
 594     }
 595
 596   assert (lastP == symbolP);
 597 }
 598
 599 void
 600 verify_symbol_chain_2 (sym)
 601      symbolS *sym;
 602 {
 603   symbolS *p = sym, *n = sym;
 604 #ifdef SYMBOLS_NEED_BACKPOINTERS
 605   while (symbol_previous (p))
 606     p = symbol_previous (p);
 607 #endif
 608   while (symbol_next (n))
 609     n = symbol_next (n);
 610   verify_symbol_chain (p, n);
 611 }
 612
 613 /* Resolve the value of a symbol.  This is called during the final
 614    pass over the symbol table to resolve any symbols with complex
 615    values.  */
 616
 617 void
 618 resolve_symbol_value (symp)
 619      symbolS *symp;
 620 {
 621   int resolved;
 622
 623   if (symp->sy_resolved)
 624     return;
 625
 626   resolved = 0;
 627
 628   if (symp->sy_resolving)
 629     {
 630       as_bad ("Symbol definition loop encountered at %s",
 631               S_GET_NAME (symp));
 632       S_SET_VALUE (symp, (valueT) 0);
 633       resolved = 1;
 634     }
 635   else
 636     {
 637       offsetT left, right, val;
 638       segT seg_left, seg_right;
 639
 640       symp->sy_resolving = 1;
 641
 642     reduce:
 643       switch (symp->sy_value.X_op)
 644         {
 645         case O_absent:
 646           S_SET_VALUE (symp, 0);
 647           /* Fall through.  */
 648         case O_constant:
 649           S_SET_VALUE (symp, S_GET_VALUE (symp) + symp->sy_frag->fr_address);
 650           if (S_GET_SEGMENT (symp) == expr_section)
 651             S_SET_SEGMENT (symp, absolute_section);
 652           resolved = 1;
 653           break;
 654
 655         case O_symbol:
 656           resolve_symbol_value (symp->sy_value.X_add_symbol);
 657
 658           if (symp->sy_mri_common)
 659             {
 660               /* This is a symbol inside an MRI common section.  The
 661                  relocation routines are going to handle it specially.
 662                  Don't change the value.  */
 663               S_SET_VALUE (symp, symp->sy_value.X_add_number);
 664               resolved = symp->sy_value.X_add_symbol->sy_resolved;
 665               break;
 666             }
 667
 668           if (symp->sy_value.X_add_number == 0)
 669             copy_symbol_attributes (symp, symp->sy_value.X_add_symbol);
 670
 671           S_SET_VALUE (symp,
 672                        (symp->sy_value.X_add_number
 673                         + symp->sy_frag->fr_address
 674                         + S_GET_VALUE (symp->sy_value.X_add_symbol)));
 675           if (S_GET_SEGMENT (symp) == expr_section
 676               || S_GET_SEGMENT (symp) == undefined_section)
 677             S_SET_SEGMENT (symp,
 678                            S_GET_SEGMENT (symp->sy_value.X_add_symbol));
 679
 680           /* If we have equated this symbol to an undefined symbol, we
 681              keep X_op set to O_symbol.  This permits the routine
 682              which writes out relocation to detect this case, and
 683              convert the relocation to be against the symbol to which
 684              this symbol is equated.  */
 685           if (! S_IS_DEFINED (symp) || S_IS_COMMON (symp))
 686             symp->sy_value.X_op = O_symbol;
 687
 688           resolved = symp->sy_value.X_add_symbol->sy_resolved;
 689           break;
 690
 691         case O_uminus:
 692         case O_bit_not:
 693         case O_logical_not:
 694           resolve_symbol_value (symp->sy_value.X_add_symbol);
 695           if (symp->sy_value.X_op == O_uminus)
 696             val = - S_GET_VALUE (symp->sy_value.X_add_symbol);
 697           else if (symp->sy_value.X_op == O_logical_not)
 698             val = ! S_GET_VALUE (symp->sy_value.X_add_symbol);
 699           else
 700             val = ~ S_GET_VALUE (symp->sy_value.X_add_symbol);
 701           S_SET_VALUE (symp,
 702                        (val
 703                         + symp->sy_value.X_add_number
 704                         + symp->sy_frag->fr_address));
 705           if (S_GET_SEGMENT (symp) == expr_section
 706               || S_GET_SEGMENT (symp) == undefined_section)
 707             S_SET_SEGMENT (symp, absolute_section);
 708           resolved = symp->sy_value.X_add_symbol->sy_resolved;
 709           break;
 710
 711         case O_add:
 712           resolve_symbol_value (symp->sy_value.X_add_symbol);
 713           resolve_symbol_value (symp->sy_value.X_op_symbol);
 714           seg_left = S_GET_SEGMENT (symp->sy_value.X_add_symbol);
 715           seg_right = S_GET_SEGMENT (symp->sy_value.X_op_symbol);
 716           /* This case comes up with PIC support.  */
 717           {
 718             symbolS *s_left = symp->sy_value.X_add_symbol;
 719             symbolS *s_right = symp->sy_value.X_op_symbol;
 720
 721             if (seg_left == absolute_section)
 722               {
 723                 symbolS *t;
 724                 segT ts;
 725                 t = s_left;
 726                 s_left = s_right;
 727                 s_right = t;
 728                 ts = seg_left;
 729                 seg_left = seg_right;
 730                 seg_right = ts;
 731               }
 732             if (seg_right == absolute_section
 733                 && s_right->sy_resolved)
 734               {
 735                 symp->sy_value.X_add_number += S_GET_VALUE (s_right);
 736                 symp->sy_value.X_op_symbol = 0;
 737                 symp->sy_value.X_add_symbol = s_left;
 738                 symp->sy_value.X_op = O_symbol;
 739                 goto reduce;
 740               }
 741           }
 742           /* fall through */
 743
 744         case O_multiply:
 745         case O_divide:
 746         case O_modulus:
 747         case O_left_shift:
 748         case O_right_shift:
 749         case O_bit_inclusive_or:
 750         case O_bit_or_not:
 751         case O_bit_exclusive_or:
 752         case O_bit_and:
 753         case O_subtract:
 754         case O_eq:
 755         case O_ne:
 756         case O_lt:
 757         case O_le:
 758         case O_ge:
 759         case O_gt:
 760         case O_logical_and:
 761         case O_logical_or:
 762           resolve_symbol_value (symp->sy_value.X_add_symbol);
 763           resolve_symbol_value (symp->sy_value.X_op_symbol);
 764           seg_left = S_GET_SEGMENT (symp->sy_value.X_add_symbol);
 765           seg_right = S_GET_SEGMENT (symp->sy_value.X_op_symbol);
 766           if (seg_left != seg_right
 767               && seg_left != undefined_section
 768               && seg_right != undefined_section)
 769             {
 770               char *file;
 771               unsigned int line;
 772
 773               if (expr_symbol_where (symp, &file, &line))
 774                 as_bad_where
 775                   (file, line,
 776                    "illegal operation on symbols in different sections");
 777               else
 778                 as_bad
 779                   ("%s set to illegal operation on symbols in different sections",
 780                    S_GET_NAME (symp));
 781             }
 782           if ((S_GET_SEGMENT (symp->sy_value.X_add_symbol)
 783                != absolute_section)
 784               && symp->sy_value.X_op != O_subtract)
 785             {
 786               char *file;
 787               unsigned int line;
 788
 789               if (expr_symbol_where (symp, &file, &line))
 790                 as_bad_where (file, line,
 791                               "illegal operation on non-absolute symbols");
 792               else
 793                 as_bad ("%s set to illegal operation on non-absolute symbols",
 794                         S_GET_NAME (symp));
 795             }
 796           left = S_GET_VALUE (symp->sy_value.X_add_symbol);
 797           right = S_GET_VALUE (symp->sy_value.X_op_symbol);
 798           switch (symp->sy_value.X_op)
 799             {
 800             case O_multiply:            val = left * right; break;
 801             case O_divide:              val = left / right; break;
 802             case O_modulus:             val = left % right; break;
 803             case O_left_shift:          val = left << right; break;
 804             case O_right_shift:         val = left >> right; break;
 805             case O_bit_inclusive_or:    val = left | right; break;
 806             case O_bit_or_not:          val = left |~ right; break;
 807             case O_bit_exclusive_or:    val = left ^ right; break;
 808             case O_bit_and:             val = left & right; break;
 809             case O_add:                 val = left + right; break;
 810             case O_subtract:            val = left - right; break;
 811             case O_eq:          val = left == right ? ~ (offsetT) 0 : 0;
 812             case O_ne:          val = left != right ? ~ (offsetT) 0 : 0;
 813             case O_lt:          val = left <  right ? ~ (offsetT) 0 : 0;
 814             case O_le:          val = left <= right ? ~ (offsetT) 0 : 0;
 815             case O_ge:          val = left >= right ? ~ (offsetT) 0 : 0;
 816             case O_gt:          val = left >  right ? ~ (offsetT) 0 : 0;
 817             case O_logical_and: val = left && right; break;
 818             case O_logical_or:  val = left || right; break;
 819             default:                    abort ();
 820             }
 821           S_SET_VALUE (symp,
 822                        (symp->sy_value.X_add_number
 823                         + symp->sy_frag->fr_address
 824                         + val));
 825           if (S_GET_SEGMENT (symp) == expr_section
 826               || S_GET_SEGMENT (symp) == undefined_section)
 827             S_SET_SEGMENT (symp, absolute_section);
 828           resolved = (symp->sy_value.X_add_symbol->sy_resolved
 829                       && symp->sy_value.X_op_symbol->sy_resolved);
 830           break;
 831
 832         case O_register:
 833         case O_big:
 834         case O_illegal:
 835           /* Give an error (below) if not in expr_section.  We don't
 836              want to worry about expr_section symbols, because they
 837              are fictional (they are created as part of expression
 838              resolution), and any problems may not actually mean
 839              anything.  */
 840           break;
 841         }
 842     }
 843
 844   /* Don't worry if we can't resolve an expr_section symbol.  */
 845   if (resolved)
 846     symp->sy_resolved = 1;
 847   else if (S_GET_SEGMENT (symp) != expr_section)
 848     {
 849       as_bad ("can't resolve value for symbol \"%s\"", S_GET_NAME (symp));
 850       symp->sy_resolved = 1;
 851     }
 852 }
 853
 854 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
 855    They are *really* local.  That is, they go out of scope whenever we see a
 856    label that isn't local.  Also, like fb labels, there can be multiple
 857    instances of a dollar label.  Therefor, we name encode each instance with
 858    the instance number, keep a list of defined symbols separate from the real
 859    symbol table, and we treat these buggers as a sparse array.  */
 860
 861 static long *dollar_labels;
 862 static long *dollar_label_instances;
 863 static char *dollar_label_defines;
 864 static long dollar_label_count;
 865 static unsigned long dollar_label_max;
 866
 867 int
 868 dollar_label_defined (label)
 869      long label;
 870 {
 871   long *i;
 872
 873   know ((dollar_labels != NULL) || (dollar_label_count == 0));
 874
 875   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
 876     if (*i == label)
 877       return dollar_label_defines[i - dollar_labels];
 878
 879   /* if we get here, label isn't defined */
 880   return 0;
 881 }                               /* dollar_label_defined() */
 882
 883 static int
 884 dollar_label_instance (label)
 885      long label;
 886 {
 887   long *i;
 888
 889   know ((dollar_labels != NULL) || (dollar_label_count == 0));
 890
 891   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
 892     if (*i == label)
 893       return (dollar_label_instances[i - dollar_labels]);
 894
 895   /* If we get here, we haven't seen the label before, therefore its instance
 896      count is zero.  */
 897   return 0;
 898 }
 899
 900 void
 901 dollar_label_clear ()
 902 {
 903   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
 904 }
 905
 906 #define DOLLAR_LABEL_BUMP_BY 10
 907
 908 void
 909 define_dollar_label (label)
 910      long label;
 911 {
 912   long *i;
 913
 914   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
 915     if (*i == label)
 916       {
 917         ++dollar_label_instances[i - dollar_labels];
 918         dollar_label_defines[i - dollar_labels] = 1;
 919         return;
 920       }
 921
 922   /* if we get to here, we don't have label listed yet. */
 923
 924   if (dollar_labels == NULL)
 925     {
 926       dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
 927       dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
 928       dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
 929       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
 930       dollar_label_count = 0;
 931     }
 932   else if (dollar_label_count == dollar_label_max)
 933     {
 934       dollar_label_max += DOLLAR_LABEL_BUMP_BY;
 935       dollar_labels = (long *) xrealloc ((char *) dollar_labels,
 936                                          dollar_label_max * sizeof (long));
 937       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
 938                                           dollar_label_max * sizeof (long));
 939       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
 940     }                           /* if we needed to grow */
 941
 942   dollar_labels[dollar_label_count] = label;
 943   dollar_label_instances[dollar_label_count] = 1;
 944   dollar_label_defines[dollar_label_count] = 1;
 945   ++dollar_label_count;
 946 }
 947
 948 /*
 949  *                      dollar_label_name()
 950  *
 951  * Caller must copy returned name: we re-use the area for the next name.
 952  *
 953  * The mth occurence of label n: is turned into the symbol "Ln^Am"
 954  * where n is the label number and m is the instance number. "L" makes
 955  * it a label discarded unless debugging and "^A"('\1') ensures no
 956  * ordinary symbol SHOULD get the same name as a local label
 957  * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
 958  *
 959  * fb labels get the same treatment, except that ^B is used in place of ^A.
 960  */
 961
 962 char *                          /* Return local label name. */
 963 dollar_label_name (n, augend)
 964      register long n;           /* we just saw "n$:" : n a number */
 965      register int augend;       /* 0 for current instance, 1 for new instance */
 966 {
 967   long i;
 968   /* Returned to caller, then copied.  used for created names ("4f") */
 969   static char symbol_name_build[24];
 970   register char *p;
 971   register char *q;
 972   char symbol_name_temporary[20];       /* build up a number, BACKWARDS */
 973
 974   know (n >= 0);
 975   know (augend == 0 || augend == 1);
 976   p = symbol_name_build;
 977   *p++ = 'L';
 978
 979   /* Next code just does sprintf( {}, "%d", n); */
 980   /* label number */
 981   q = symbol_name_temporary;
 982   for (*q++ = 0, i = n; i; ++q)
 983     {
 984       *q = i % 10 + '0';
 985       i /= 10;
 986     }
 987   while ((*p = *--q) != '\0')
 988     ++p;
 989
 990   *p++ = 1;                     /* ^A */
 991
 992   /* instance number */
 993   q = symbol_name_temporary;
 994   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
 995     {
 996       *q = i % 10 + '0';
 997       i /= 10;
 998     }
 999   while ((*p++ = *--q) != '\0');;
1000
1001   /* The label, as a '\0' ended string, starts at symbol_name_build. */
1002   return symbol_name_build;
1003 }
1004
1005 /*
1006  * Sombody else's idea of local labels. They are made by "n:" where n
1007  * is any decimal digit. Refer to them with
1008  *  "nb" for previous (backward) n:
1009  *  or "nf" for next (forward) n:.
1010  *
1011  * We do a little better and let n be any number, not just a single digit, but
1012  * since the other guy's assembler only does ten, we treat the first ten
1013  * specially.
1014  *
1015  * Like someone else's assembler, we have one set of local label counters for
1016  * entire assembly, not one set per (sub)segment like in most assemblers. This
1017  * implies that one can refer to a label in another segment, and indeed some
1018  * crufty compilers have done just that.
1019  *
1020  * Since there could be a LOT of these things, treat them as a sparse array.
1021  */
1022
1023 #define FB_LABEL_SPECIAL (10)
1024
1025 static long fb_low_counter[FB_LABEL_SPECIAL];
1026 static long *fb_labels;
1027 static long *fb_label_instances;
1028 static long fb_label_count;
1029 static long fb_label_max;
1030
1031 /* this must be more than FB_LABEL_SPECIAL */
1032 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1033
1034 static void
1035 fb_label_init ()
1036 {
1037   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1038 }                               /* fb_label_init() */
1039
1040 /* add one to the instance number of this fb label */
1041 void
1042 fb_label_instance_inc (label)
1043      long label;
1044 {
1045   long *i;
1046
1047   if (label < FB_LABEL_SPECIAL)
1048     {
1049       ++fb_low_counter[label];
1050       return;
1051     }
1052
1053   if (fb_labels != NULL)
1054     {
1055       for (i = fb_labels + FB_LABEL_SPECIAL;
1056            i < fb_labels + fb_label_count; ++i)
1057         {
1058           if (*i == label)
1059             {
1060               ++fb_label_instances[i - fb_labels];
1061               return;
1062             }                   /* if we find it */
1063         }                       /* for each existing label */
1064     }
1065
1066   /* if we get to here, we don't have label listed yet. */
1067
1068   if (fb_labels == NULL)
1069     {
1070       fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1071       fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1072       fb_label_max = FB_LABEL_BUMP_BY;
1073       fb_label_count = FB_LABEL_SPECIAL;
1074
1075     }
1076   else if (fb_label_count == fb_label_max)
1077     {
1078       fb_label_max += FB_LABEL_BUMP_BY;
1079       fb_labels = (long *) xrealloc ((char *) fb_labels,
1080                                      fb_label_max * sizeof (long));
1081       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1082                                               fb_label_max * sizeof (long));
1083     }                           /* if we needed to grow */
1084
1085   fb_labels[fb_label_count] = label;
1086   fb_label_instances[fb_label_count] = 1;
1087   ++fb_label_count;
1088 }
1089
1090 static long
1091 fb_label_instance (label)
1092      long label;
1093 {
1094   long *i;
1095
1096   if (label < FB_LABEL_SPECIAL)
1097     {
1098       return (fb_low_counter[label]);
1099     }
1100
1101   if (fb_labels != NULL)
1102     {
1103       for (i = fb_labels + FB_LABEL_SPECIAL;
1104            i < fb_labels + fb_label_count; ++i)
1105         {
1106           if (*i == label)
1107             {
1108               return (fb_label_instances[i - fb_labels]);
1109             }                   /* if we find it */
1110         }                       /* for each existing label */
1111     }
1112
1113   /* We didn't find the label, so this must be a reference to the
1114      first instance.  */
1115   return 0;
1116 }
1117
1118 /*
1119  *                      fb_label_name()
1120  *
1121  * Caller must copy returned name: we re-use the area for the next name.
1122  *
1123  * The mth occurence of label n: is turned into the symbol "Ln^Bm"
1124  * where n is the label number and m is the instance number. "L" makes
1125  * it a label discarded unless debugging and "^B"('\2') ensures no
1126  * ordinary symbol SHOULD get the same name as a local label
1127  * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1128  *
1129  * dollar labels get the same treatment, except that ^A is used in place of ^B. */
1130
1131 char *                          /* Return local label name. */
1132 fb_label_name (n, augend)
1133      long n;                    /* we just saw "n:", "nf" or "nb" : n a number */
1134      long augend;               /* 0 for nb, 1 for n:, nf */
1135 {
1136   long i;
1137   /* Returned to caller, then copied.  used for created names ("4f") */
1138   static char symbol_name_build[24];
1139   register char *p;
1140   register char *q;
1141   char symbol_name_temporary[20];       /* build up a number, BACKWARDS */
1142
1143   know (n >= 0);
1144   know (augend == 0 || augend == 1);
1145   p = symbol_name_build;
1146   *p++ = 'L';
1147
1148   /* Next code just does sprintf( {}, "%d", n); */
1149   /* label number */
1150   q = symbol_name_temporary;
1151   for (*q++ = 0, i = n; i; ++q)
1152     {
1153       *q = i % 10 + '0';
1154       i /= 10;
1155     }
1156   while ((*p = *--q) != '\0')
1157     ++p;
1158
1159   *p++ = 2;                     /* ^B */
1160
1161   /* instance number */
1162   q = symbol_name_temporary;
1163   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1164     {
1165       *q = i % 10 + '0';
1166       i /= 10;
1167     }
1168   while ((*p++ = *--q) != '\0');;
1169
1170   /* The label, as a '\0' ended string, starts at symbol_name_build. */
1171   return (symbol_name_build);
1172 }                               /* fb_label_name() */
1173
1174 /*
1175  * decode name that may have been generated by foo_label_name() above.  If
1176  * the name wasn't generated by foo_label_name(), then return it unaltered.
1177  * This is used for error messages.
1178  */
1179
1180 char *
1181 decode_local_label_name (s)
1182      char *s;
1183 {
1184   char *p;
1185   char *symbol_decode;
1186   int label_number;
1187   int instance_number;
1188   char *type;
1189   const char *message_format = "\"%d\" (instance number %d of a %s label)";
1190
1191   if (s[0] != 'L')
1192     return s;
1193
1194   for (label_number = 0, p = s + 1; isdigit (*p); ++p)
1195     label_number = (10 * label_number) + *p - '0';
1196
1197   if (*p == 1)
1198     type = "dollar";
1199   else if (*p == 2)
1200     type = "fb";
1201   else
1202     return s;
1203
1204   for (instance_number = 0, p++; isdigit (*p); ++p)
1205     instance_number = (10 * instance_number) + *p - '0';
1206
1207   symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1208   sprintf (symbol_decode, message_format, label_number, instance_number, type);
1209
1210   return symbol_decode;
1211 }
1212
1213 /* Get the value of a symbol.  */
1214
1215 valueT
1216 S_GET_VALUE (s)
1217      symbolS *s;
1218 {
1219   if (!s->sy_resolved && !s->sy_resolving && s->sy_value.X_op != O_constant)
1220     resolve_symbol_value (s);
1221   if (s->sy_value.X_op != O_constant)
1222     {
1223       static symbolS *recur;
1224
1225       /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
1226          may call S_GET_VALUE.  We use a static symbol to avoid the
1227          immediate recursion.  */
1228       if (recur == s)
1229         return (valueT) s->sy_value.X_add_number;
1230       recur = s;
1231       if (! s->sy_resolved
1232           || s->sy_value.X_op != O_symbol
1233           || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1234         as_bad ("Attempt to get value of unresolved symbol %s",
1235                 S_GET_NAME (s));
1236       recur = NULL;
1237     }
1238   return (valueT) s->sy_value.X_add_number;
1239 }
1240
1241 /* Set the value of a symbol.  */
1242
1243 void
1244 S_SET_VALUE (s, val)
1245      symbolS *s;
1246      valueT val;
1247 {
1248   s->sy_value.X_op = O_constant;
1249   s->sy_value.X_add_number = (offsetT) val;
1250   s->sy_value.X_unsigned = 0;
1251 }
1252
1253 void
1254 copy_symbol_attributes (dest, src)
1255      symbolS *dest, *src;
1256 {
1257 #ifdef BFD_ASSEMBLER
1258   /* In an expression, transfer the settings of these flags.
1259      The user can override later, of course.  */
1260 #define COPIED_SYMFLAGS (BSF_FUNCTION)
1261   dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1262 #endif
1263
1264 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1265   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1266 #endif
1267 }
1268
1269 #ifdef BFD_ASSEMBLER
1270
1271 int
1272 S_IS_EXTERNAL (s)
1273      symbolS *s;
1274 {
1275   flagword flags = s->bsym->flags;
1276
1277   /* sanity check */
1278   if (flags & BSF_LOCAL && flags & BSF_GLOBAL)
1279     abort ();
1280
1281   return (flags & BSF_GLOBAL) != 0;
1282 }
1283
1284 int
1285 S_IS_WEAK (s)
1286      symbolS *s;
1287 {
1288   return (s->bsym->flags & BSF_WEAK) != 0;
1289 }
1290
1291 int
1292 S_IS_COMMON (s)
1293      symbolS *s;
1294 {
1295   return bfd_is_com_section (s->bsym->section);
1296 }
1297
1298 int
1299 S_IS_DEFINED (s)
1300      symbolS *s;
1301 {
1302   return s->bsym->section != undefined_section;
1303 }
1304
1305 int
1306 S_IS_DEBUG (s)
1307      symbolS *s;
1308 {
1309   if (s->bsym->flags & BSF_DEBUGGING)
1310     return 1;
1311   return 0;
1312 }
1313
1314 int
1315 S_IS_LOCAL (s)
1316      symbolS *s;
1317 {
1318   flagword flags = s->bsym->flags;
1319   const char *name;
1320
1321   /* sanity check */
1322   if (flags & BSF_LOCAL && flags & BSF_GLOBAL)
1323     abort ();
1324
1325   if (bfd_get_section (s->bsym) == reg_section)
1326     return 1;
1327
1328   name = S_GET_NAME (s);
1329   return (name != NULL
1330           && ! S_IS_DEBUG (s)
1331           && (strchr (name, '\001')
1332               || strchr (name, '\002')
1333               || (! flag_keep_locals
1334                   && (LOCAL_LABEL (name)
1335                       || (flag_mri
1336                           && name[0] == '?'
1337                           && name[1] == '?')))));
1338 }
1339
1340 int
1341 S_IS_EXTERN (s)
1342      symbolS *s;
1343 {
1344   return S_IS_EXTERNAL (s);
1345 }
1346
1347 int
1348 S_IS_STABD (s)
1349      symbolS *s;
1350 {
1351   return S_GET_NAME (s) == 0;
1352 }
1353
1354 CONST char *
1355 S_GET_NAME (s)
1356      symbolS *s;
1357 {
1358   return s->bsym->name;
1359 }
1360
1361 segT
1362 S_GET_SEGMENT (s)
1363      symbolS *s;
1364 {
1365   return s->bsym->section;
1366 }
1367
1368 void
1369 S_SET_SEGMENT (s, seg)
1370      symbolS *s;
1371      segT seg;
1372 {
1373   s->bsym->section = seg;
1374 }
1375
1376 void
1377 S_SET_EXTERNAL (s)
1378      symbolS *s;
1379 {
1380   if ((s->bsym->flags & BSF_WEAK) != 0)
1381     {
1382       /* Let .weak override .global.  */
1383       return;
1384     }
1385   s->bsym->flags |= BSF_GLOBAL;
1386   s->bsym->flags &= ~(BSF_LOCAL|BSF_WEAK);
1387 }
1388
1389 void
1390 S_CLEAR_EXTERNAL (s)
1391      symbolS *s;
1392 {
1393   if ((s->bsym->flags & BSF_WEAK) != 0)
1394     {
1395       /* Let .weak override.  */
1396       return;
1397     }
1398   s->bsym->flags |= BSF_LOCAL;
1399   s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK);
1400 }
1401
1402 void
1403 S_SET_WEAK (s)
1404      symbolS *s;
1405 {
1406   s->bsym->flags |= BSF_WEAK;
1407   s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL);
1408 }
1409
1410 void
1411 S_SET_NAME (s, name)
1412      symbolS *s;
1413      char *name;
1414 {
1415   s->bsym->name = name;
1416 }
1417 #endif /* BFD_ASSEMBLER */
1418
1419 void
1420 symbol_begin ()
1421 {
1422   symbol_lastP = NULL;
1423   symbol_rootP = NULL;          /* In case we have 0 symbols (!!) */
1424   sy_hash = hash_new ();
1425
1426   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
1427 #ifdef BFD_ASSEMBLER
1428 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
1429   abs_symbol.bsym = bfd_abs_section.symbol;
1430 #endif
1431 #else
1432   /* Can't initialise a union. Sigh. */
1433   S_SET_SEGMENT (&abs_symbol, absolute_section);
1434 #endif
1435   abs_symbol.sy_value.X_op = O_constant;
1436   abs_symbol.sy_frag = &zero_address_frag;
1437
1438   if (LOCAL_LABELS_FB)
1439     fb_label_init ();
1440 }
1441
1442 \f
1443 int indent_level;
1444
1445 #if 0
1446
1447 static void
1448 indent ()
1449 {
1450   printf ("%*s", indent_level * 4, "");
1451 }
1452
1453 #endif
1454
1455 void print_expr_1 PARAMS ((FILE *, expressionS *));
1456 void print_symbol_value_1 PARAMS ((FILE *, symbolS *));
1457
1458 void
1459 print_symbol_value_1 (file, sym)
1460      FILE *file;
1461      symbolS *sym;
1462 {
1463   const char *name = S_GET_NAME (sym);
1464   if (!name || !name[0])
1465     name = "(unnamed)";
1466   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
1467   if (sym->sy_frag != &zero_address_frag)
1468     fprintf (file, " frag %lx", (long) sym->sy_frag);
1469   if (sym->written)
1470     fprintf (file, " written");
1471   if (sym->sy_resolved)
1472     fprintf (file, " resolved");
1473   else if (sym->sy_resolving)
1474     fprintf (file, " resolving");
1475   if (sym->sy_used_in_reloc)
1476     fprintf (file, " used-in-reloc");
1477   if (sym->sy_used)
1478     fprintf (file, " used");
1479   if (S_IS_LOCAL (sym))
1480     fprintf (file, " local");
1481   if (S_IS_EXTERN (sym))
1482     fprintf (file, " extern");
1483   if (S_IS_DEBUG (sym))
1484     fprintf (file, " debug");
1485   if (S_IS_DEFINED (sym))
1486     fprintf (file, " defined");
1487   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
1488   if (sym->sy_resolved)
1489     {
1490       segT s = S_GET_SEGMENT (sym);
1491
1492       if (s != undefined_section
1493           && s != expr_section)
1494         fprintf (file, " %lx", (long) S_GET_VALUE (sym));
1495     }
1496   else if (indent_level < 8 && S_GET_SEGMENT (sym) != undefined_section)
1497     {
1498       indent_level++;
1499       fprintf (file, "\n%*s<", indent_level * 4, "");
1500       print_expr_1 (file, &sym->sy_value);
1501       fprintf (file, ">");
1502       indent_level--;
1503     }
1504   fflush (file);
1505 }
1506
1507 void
1508 print_symbol_value (sym)
1509      symbolS *sym;
1510 {
1511   indent_level = 0;
1512   print_symbol_value_1 (stderr, sym);
1513   fprintf (stderr, "\n");
1514 }
1515
1516 void
1517 print_expr_1 (file, exp)
1518      FILE *file;
1519      expressionS *exp;
1520 {
1521   fprintf (file, "expr %lx ", (long) exp);
1522   switch (exp->X_op)
1523     {
1524     case O_illegal:
1525       fprintf (file, "illegal");
1526       break;
1527     case O_absent:
1528       fprintf (file, "absent");
1529       break;
1530     case O_constant:
1531       fprintf (file, "constant %lx", (long) exp->X_add_number);
1532       break;
1533     case O_symbol:
1534       indent_level++;
1535       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
1536       print_symbol_value_1 (file, exp->X_add_symbol);
1537       fprintf (file, ">");
1538     maybe_print_addnum:
1539       if (exp->X_add_number)
1540         fprintf (file, "\n%*s%lx", indent_level * 4, "",
1541                  (long) exp->X_add_number);
1542       indent_level--;
1543       break;
1544     case O_register:
1545       fprintf (file, "register #%d", (int) exp->X_add_number);
1546       break;
1547     case O_big:
1548       fprintf (file, "big");
1549       break;
1550     case O_uminus:
1551       fprintf (file, "uminus -<");
1552       indent_level++;
1553       print_symbol_value_1 (file, exp->X_add_symbol);
1554       fprintf (file, ">");
1555       goto maybe_print_addnum;
1556     case O_bit_not:
1557       fprintf (file, "bit_not");
1558       break;
1559     case O_multiply:
1560       fprintf (file, "multiply");
1561       break;
1562     case O_divide:
1563       fprintf (file, "divide");
1564       break;
1565     case O_modulus:
1566       fprintf (file, "modulus");
1567       break;
1568     case O_left_shift:
1569       fprintf (file, "lshift");
1570       break;
1571     case O_right_shift:
1572       fprintf (file, "rshift");
1573       break;
1574     case O_bit_inclusive_or:
1575       fprintf (file, "bit_ior");
1576       break;
1577     case O_bit_exclusive_or:
1578       fprintf (file, "bit_xor");
1579       break;
1580     case O_bit_and:
1581       fprintf (file, "bit_and");
1582       break;
1583     case O_eq:
1584       fprintf (file, "eq");
1585       break;
1586     case O_ne:
1587       fprintf (file, "ne");
1588       break;
1589     case O_lt:
1590       fprintf (file, "lt");
1591       break;
1592     case O_le:
1593       fprintf (file, "le");
1594       break;
1595     case O_ge:
1596       fprintf (file, "ge");
1597       break;
1598     case O_gt:
1599       fprintf (file, "gt");
1600       break;
1601     case O_logical_and:
1602       fprintf (file, "logical_and");
1603       break;
1604     case O_logical_or:
1605       fprintf (file, "logical_or");
1606       break;
1607     case O_add:
1608       indent_level++;
1609       fprintf (file, "add\n%*s<", indent_level * 4, "");
1610       print_symbol_value_1 (file, exp->X_add_symbol);
1611       fprintf (file, ">\n%*s<", indent_level * 4, "");
1612       print_symbol_value_1 (file, exp->X_op_symbol);
1613       fprintf (file, ">");
1614       goto maybe_print_addnum;
1615     case O_subtract:
1616       indent_level++;
1617       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
1618       print_symbol_value_1 (file, exp->X_add_symbol);
1619       fprintf (file, ">\n%*s<", indent_level * 4, "");
1620       print_symbol_value_1 (file, exp->X_op_symbol);
1621       fprintf (file, ">");
1622       goto maybe_print_addnum;
1623     default:
1624       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
1625       break;
1626     }
1627   fflush (stdout);
1628 }
1629
1630 void
1631 print_expr (exp)
1632      expressionS *exp;
1633 {
1634   print_expr_1 (stderr, exp);
1635   fprintf (stderr, "\n");
1636 }
1637
1638 void
1639 symbol_print_statistics (file)
1640      FILE *file;
1641 {
1642   hash_print_statistics (file, "symbol table", sy_hash);
1643 }
1644
1645 /* end of symbols.c */