gas/symbols.c

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