gas/symbols.c

   1 /* symbols.c -symbol table-
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* #define DEBUG_SYMS / * to debug symbol list maintenance.  */
  24
  25 #include "as.h"
  26
  27 #include "safe-ctype.h"
  28 #include "obstack.h"            /* For "symbols.h" */
  29 #include "subsegs.h"
  30
  31 #include "struc-symbol.h"
  32
  33 /* This is non-zero if symbols are case sensitive, which is the
  34    default.  */
  35 int symbols_case_sensitive = 1;
  36
  37 #ifndef WORKING_DOT_WORD
  38 extern int new_broken_words;
  39 #endif
  40
  41 /* symbol-name => struct symbol pointer */
  42 static struct hash_control *sy_hash;
  43
  44 /* Table of local symbols.  */
  45 static struct hash_control *local_hash;
  46
  47 /* Below are commented in "symbols.h".  */
  48 symbolS *symbol_rootP;
  49 symbolS *symbol_lastP;
  50 symbolS abs_symbol;
  51
  52 #ifdef DEBUG_SYMS
  53 #define debug_verify_symchain verify_symbol_chain
  54 #else
  55 #define debug_verify_symchain(root, last) ((void) 0)
  56 #endif
  57
  58 #define DOLLAR_LABEL_CHAR       '\001'
  59 #define LOCAL_LABEL_CHAR        '\002'
  60
  61 struct obstack notes;
  62 #ifdef USE_UNIQUE
  63 /* The name of an external symbol which is
  64    used to make weak PE symbol names unique.  */
  65 const char * an_external_name;
  66 #endif
  67
  68 static char *save_symbol_name (const char *);
  69 static void fb_label_init (void);
  70 static long dollar_label_instance (long);
  71 static long fb_label_instance (long);
  72
  73 static void print_binary (FILE *, const char *, expressionS *);
  74 static void report_op_error (symbolS *, symbolS *, symbolS *);
  75
  76 /* Return a pointer to a new symbol.  Die if we can't make a new
  77    symbol.  Fill in the symbol's values.  Add symbol to end of symbol
  78    chain.
  79
  80    This function should be called in the general case of creating a
  81    symbol.  However, if the output file symbol table has already been
  82    set, and you are certain that this symbol won't be wanted in the
  83    output file, you can call symbol_create.  */
  84
  85 symbolS *
  86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
  87 {
  88   symbolS *symbolP = symbol_create (name, segment, valu, frag);
  89
  90   /* Link to end of symbol chain.  */
  91   {
  92     extern int symbol_table_frozen;
  93     if (symbol_table_frozen)
  94       abort ();
  95   }
  96   symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
  97
  98   return symbolP;
  99 }
 100
 101 /* Save a symbol name on a permanent obstack, and convert it according
 102    to the object file format.  */
 103
 104 static char *
 105 save_symbol_name (const char *name)
 106 {
 107   unsigned int name_length;
 108   char *ret;
 109
 110   name_length = strlen (name) + 1;      /* +1 for \0.  */
 111   obstack_grow (&notes, name, name_length);
 112   ret = obstack_finish (&notes);
 113
 114 #ifdef tc_canonicalize_symbol_name
 115   ret = tc_canonicalize_symbol_name (ret);
 116 #endif
 117
 118   if (! symbols_case_sensitive)
 119     {
 120       char *s;
 121
 122       for (s = ret; *s != '\0'; s++)
 123         *s = TOUPPER (*s);
 124     }
 125
 126   return ret;
 127 }
 128
 129 symbolS *
 130 symbol_create (const char *name, /* It is copied, the caller can destroy/modify.  */
 131                segT segment,    /* Segment identifier (SEG_<something>).  */
 132                valueT valu,     /* Symbol value.  */
 133                fragS *frag      /* Associated fragment.  */)
 134 {
 135   char *preserved_copy_of_name;
 136   symbolS *symbolP;
 137
 138   preserved_copy_of_name = save_symbol_name (name);
 139
 140   symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 141
 142   /* symbol must be born in some fixed state.  This seems as good as any.  */
 143   memset (symbolP, 0, sizeof (symbolS));
 144
 145   symbolP->bsym = bfd_make_empty_symbol (stdoutput);
 146   if (symbolP->bsym == NULL)
 147     as_perror ("%s", "bfd_make_empty_symbol");
 148   symbolP->bsym->udata.p = (PTR) symbolP;
 149   S_SET_NAME (symbolP, preserved_copy_of_name);
 150
 151   S_SET_SEGMENT (symbolP, segment);
 152   S_SET_VALUE (symbolP, valu);
 153   symbol_clear_list_pointers (symbolP);
 154
 155   symbolP->sy_frag = frag;
 156
 157   obj_symbol_new_hook (symbolP);
 158
 159 #ifdef tc_symbol_new_hook
 160   tc_symbol_new_hook (symbolP);
 161 #endif
 162
 163   return symbolP;
 164 }
 165 \f
 166
 167 /* Local symbol support.  If we can get away with it, we keep only a
 168    small amount of information for local symbols.  */
 169
 170 static symbolS *local_symbol_convert (struct local_symbol *);
 171
 172 /* Used for statistics.  */
 173
 174 static unsigned long local_symbol_count;
 175 static unsigned long local_symbol_conversion_count;
 176
 177 /* This macro is called with a symbol argument passed by reference.
 178    It returns whether this is a local symbol.  If necessary, it
 179    changes its argument to the real symbol.  */
 180
 181 #define LOCAL_SYMBOL_CHECK(s)                                           \
 182   (s->bsym == NULL                                                      \
 183    ? (local_symbol_converted_p ((struct local_symbol *) s)              \
 184       ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s),  \
 185          0)                                                             \
 186       : 1)                                                              \
 187    : 0)
 188
 189 /* Create a local symbol and insert it into the local hash table.  */
 190
 191 static struct local_symbol *
 192 local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
 193 {
 194   char *name_copy;
 195   struct local_symbol *ret;
 196
 197   ++local_symbol_count;
 198
 199   name_copy = save_symbol_name (name);
 200
 201   ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
 202   ret->lsy_marker = NULL;
 203   ret->lsy_name = name_copy;
 204   ret->lsy_section = section;
 205   local_symbol_set_frag (ret, frag);
 206   ret->lsy_value = value;
 207
 208   hash_jam (local_hash, name_copy, (PTR) ret);
 209
 210   return ret;
 211 }
 212
 213 /* Convert a local symbol into a real symbol.  Note that we do not
 214    reclaim the space used by the local symbol.  */
 215
 216 static symbolS *
 217 local_symbol_convert (struct local_symbol *locsym)
 218 {
 219   symbolS *ret;
 220
 221   assert (locsym->lsy_marker == NULL);
 222   if (local_symbol_converted_p (locsym))
 223     return local_symbol_get_real_symbol (locsym);
 224
 225   ++local_symbol_conversion_count;
 226
 227   ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
 228                     local_symbol_get_frag (locsym));
 229
 230   if (local_symbol_resolved_p (locsym))
 231     ret->sy_resolved = 1;
 232
 233   /* Local symbols are always either defined or used.  */
 234   ret->sy_used = 1;
 235
 236 #ifdef TC_LOCAL_SYMFIELD_CONVERT
 237   TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
 238 #endif
 239
 240   symbol_table_insert (ret);
 241
 242   local_symbol_mark_converted (locsym);
 243   local_symbol_set_real_symbol (locsym, ret);
 244
 245   hash_jam (local_hash, locsym->lsy_name, NULL);
 246
 247   return ret;
 248 }
 249 \f
 250 /* We have just seen "<name>:".
 251    Creates a struct symbol unless it already exists.
 252
 253    Gripes if we are redefining a symbol incompatibly (and ignores it).  */
 254
 255 symbolS *
 256 colon (/* Just seen "x:" - rattle symbols & frags.  */
 257        const char *sym_name     /* Symbol name, as a cannonical string.  */
 258        /* We copy this string: OK to alter later.  */)
 259 {
 260   register symbolS *symbolP;    /* Symbol we are working with.  */
 261
 262   /* Sun local labels go out of scope whenever a non-local symbol is
 263      defined.  */
 264   if (LOCAL_LABELS_DOLLAR
 265       && !bfd_is_local_label_name (stdoutput, sym_name))
 266     dollar_label_clear ();
 267
 268 #ifndef WORKING_DOT_WORD
 269   if (new_broken_words)
 270     {
 271       struct broken_word *a;
 272       int possible_bytes;
 273       fragS *frag_tmp;
 274       char *frag_opcode;
 275
 276       if (now_seg == absolute_section)
 277         {
 278           as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
 279           return NULL;
 280         }
 281
 282       possible_bytes = (md_short_jump_size
 283                         + new_broken_words * md_long_jump_size);
 284
 285       frag_tmp = frag_now;
 286       frag_opcode = frag_var (rs_broken_word,
 287                               possible_bytes,
 288                               possible_bytes,
 289                               (relax_substateT) 0,
 290                               (symbolS *) broken_words,
 291                               (offsetT) 0,
 292                               NULL);
 293
 294       /* We want to store the pointer to where to insert the jump
 295          table in the fr_opcode of the rs_broken_word frag.  This
 296          requires a little hackery.  */
 297       while (frag_tmp
 298              && (frag_tmp->fr_type != rs_broken_word
 299                  || frag_tmp->fr_opcode))
 300         frag_tmp = frag_tmp->fr_next;
 301       know (frag_tmp);
 302       frag_tmp->fr_opcode = frag_opcode;
 303       new_broken_words = 0;
 304
 305       for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
 306         a->dispfrag = frag_tmp;
 307     }
 308 #endif /* WORKING_DOT_WORD */
 309
 310   if ((symbolP = symbol_find (sym_name)) != 0)
 311     {
 312       S_CLEAR_WEAKREFR (symbolP);
 313 #ifdef RESOLVE_SYMBOL_REDEFINITION
 314       if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
 315         return symbolP;
 316 #endif
 317       /* Now check for undefined symbols.  */
 318       if (LOCAL_SYMBOL_CHECK (symbolP))
 319         {
 320           struct local_symbol *locsym = (struct local_symbol *) symbolP;
 321
 322           if (locsym->lsy_section != undefined_section
 323               && (local_symbol_get_frag (locsym) != frag_now
 324                   || locsym->lsy_section != now_seg
 325                   || locsym->lsy_value != frag_now_fix ()))
 326             {
 327               as_bad (_("symbol `%s' is already defined"), sym_name);
 328               return symbolP;
 329             }
 330
 331           locsym->lsy_section = now_seg;
 332           local_symbol_set_frag (locsym, frag_now);
 333           locsym->lsy_value = frag_now_fix ();
 334         }
 335       else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
 336                || S_IS_COMMON (symbolP))
 337         {
 338           if (S_GET_VALUE (symbolP) == 0)
 339             {
 340               symbolP->sy_frag = frag_now;
 341 #ifdef OBJ_VMS
 342               S_SET_OTHER (symbolP, const_flag);
 343 #endif
 344               S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 345               S_SET_SEGMENT (symbolP, now_seg);
 346 #ifdef N_UNDF
 347               know (N_UNDF == 0);
 348 #endif /* if we have one, it better be zero.  */
 349
 350             }
 351           else
 352             {
 353               /* There are still several cases to check:
 354
 355                  A .comm/.lcomm symbol being redefined as initialized
 356                  data is OK
 357
 358                  A .comm/.lcomm symbol being redefined with a larger
 359                  size is also OK
 360
 361                  This only used to be allowed on VMS gas, but Sun cc
 362                  on the sparc also depends on it.  */
 363
 364               if (((!S_IS_DEBUG (symbolP)
 365                     && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
 366                     && S_IS_EXTERNAL (symbolP))
 367                    || S_GET_SEGMENT (symbolP) == bss_section)
 368                   && (now_seg == data_section
 369                       || now_seg == S_GET_SEGMENT (symbolP)))
 370                 {
 371                   /* Select which of the 2 cases this is.  */
 372                   if (now_seg != data_section)
 373                     {
 374                       /* New .comm for prev .comm symbol.
 375
 376                          If the new size is larger we just change its
 377                          value.  If the new size is smaller, we ignore
 378                          this symbol.  */
 379                       if (S_GET_VALUE (symbolP)
 380                           < ((unsigned) frag_now_fix ()))
 381                         {
 382                           S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 383                         }
 384                     }
 385                   else
 386                     {
 387                       /* It is a .comm/.lcomm being converted to initialized
 388                          data.  */
 389                       symbolP->sy_frag = frag_now;
 390 #ifdef OBJ_VMS
 391                       S_SET_OTHER (symbolP, const_flag);
 392 #endif
 393                       S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
 394                       S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit.  */
 395                     }
 396                 }
 397               else
 398                 {
 399 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
 400      && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
 401                   static const char *od_buf = "";
 402 #else
 403                   char od_buf[100];
 404                   od_buf[0] = '\0';
 405                   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
 406                     sprintf (od_buf, "%d.%d.",
 407                              S_GET_OTHER (symbolP),
 408                              S_GET_DESC (symbolP));
 409 #endif
 410                   as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
 411                             sym_name,
 412                             segment_name (S_GET_SEGMENT (symbolP)),
 413                             od_buf,
 414                             (long) S_GET_VALUE (symbolP));
 415                 }
 416             }                   /* if the undefined symbol has no value  */
 417         }
 418       else
 419         {
 420           /* Don't blow up if the definition is the same.  */
 421           if (!(frag_now == symbolP->sy_frag
 422                 && S_GET_VALUE (symbolP) == frag_now_fix ()
 423                 && S_GET_SEGMENT (symbolP) == now_seg))
 424             as_bad (_("symbol `%s' is already defined"), sym_name);
 425         }
 426
 427     }
 428   else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
 429     {
 430       symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
 431                                                (valueT) frag_now_fix (),
 432                                                frag_now);
 433     }
 434   else
 435     {
 436       symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
 437                             frag_now);
 438 #ifdef OBJ_VMS
 439       S_SET_OTHER (symbolP, const_flag);
 440 #endif /* OBJ_VMS */
 441
 442       symbol_table_insert (symbolP);
 443     }
 444
 445   if (mri_common_symbol != NULL)
 446     {
 447       /* This symbol is actually being defined within an MRI common
 448          section.  This requires special handling.  */
 449       if (LOCAL_SYMBOL_CHECK (symbolP))
 450         symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
 451       symbolP->sy_value.X_op = O_symbol;
 452       symbolP->sy_value.X_add_symbol = mri_common_symbol;
 453       symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
 454       symbolP->sy_frag = &zero_address_frag;
 455       S_SET_SEGMENT (symbolP, expr_section);
 456       symbolP->sy_mri_common = 1;
 457     }
 458
 459 #ifdef tc_frob_label
 460   tc_frob_label (symbolP);
 461 #endif
 462 #ifdef obj_frob_label
 463   obj_frob_label (symbolP);
 464 #endif
 465
 466   return symbolP;
 467 }
 468 \f
 469 /* Die if we can't insert the symbol.  */
 470
 471 void
 472 symbol_table_insert (symbolS *symbolP)
 473 {
 474   register const char *error_string;
 475
 476   know (symbolP);
 477   know (S_GET_NAME (symbolP));
 478
 479   if (LOCAL_SYMBOL_CHECK (symbolP))
 480     {
 481       error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
 482                                (PTR) symbolP);
 483       if (error_string != NULL)
 484         as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
 485                   S_GET_NAME (symbolP), error_string);
 486       return;
 487     }
 488
 489   if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
 490     {
 491       as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
 492                 S_GET_NAME (symbolP), error_string);
 493     }                           /* on error  */
 494 }
 495 \f
 496 /* If a symbol name does not exist, create it as undefined, and insert
 497    it into the symbol table.  Return a pointer to it.  */
 498
 499 symbolS *
 500 symbol_find_or_make (const char *name)
 501 {
 502   register symbolS *symbolP;
 503
 504   symbolP = symbol_find (name);
 505
 506   if (symbolP == NULL)
 507     {
 508       if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
 509         {
 510           symbolP = md_undefined_symbol ((char *) name);
 511           if (symbolP != NULL)
 512             return symbolP;
 513
 514           symbolP = (symbolS *) local_symbol_make (name, undefined_section,
 515                                                    (valueT) 0,
 516                                                    &zero_address_frag);
 517           return symbolP;
 518         }
 519
 520       symbolP = symbol_make (name);
 521
 522       symbol_table_insert (symbolP);
 523     }                           /* if symbol wasn't found */
 524
 525   return (symbolP);
 526 }
 527
 528 symbolS *
 529 symbol_make (const char *name)
 530 {
 531   symbolS *symbolP;
 532
 533   /* Let the machine description default it, e.g. for register names.  */
 534   symbolP = md_undefined_symbol ((char *) name);
 535
 536   if (!symbolP)
 537     symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
 538
 539   return (symbolP);
 540 }
 541
 542 symbolS *
 543 symbol_clone (symbolS *orgsymP, int replace)
 544 {
 545   symbolS *newsymP;
 546   asymbol *bsymorg, *bsymnew;
 547
 548   /* Running local_symbol_convert on a clone that's not the one currently
 549      in local_hash would incorrectly replace the hash entry.  Thus the
 550      symbol must be converted here.  Note that the rest of the function
 551      depends on not encountering an unconverted symbol.  */
 552   if (LOCAL_SYMBOL_CHECK (orgsymP))
 553     orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
 554   bsymorg = orgsymP->bsym;
 555
 556   know (S_IS_DEFINED (orgsymP));
 557
 558   newsymP = obstack_alloc (&notes, sizeof (*newsymP));
 559   *newsymP = *orgsymP;
 560   bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
 561   if (bsymnew == NULL)
 562     as_perror ("%s", "bfd_make_empty_symbol");
 563   newsymP->bsym = bsymnew;
 564   bsymnew->name = bsymorg->name;
 565   bsymnew->flags =  bsymorg->flags;
 566   bsymnew->section =  bsymorg->section;
 567   bsymnew->udata.p = (PTR) newsymP;
 568   bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
 569                                 bfd_asymbol_bfd (bsymnew), bsymnew);
 570
 571 #ifdef obj_symbol_clone_hook
 572   obj_symbol_clone_hook (newsymP, orgsymP);
 573 #endif
 574
 575 #ifdef tc_symbol_clone_hook
 576   tc_symbol_clone_hook (newsymP, orgsymP);
 577 #endif
 578
 579   if (replace)
 580     {
 581       if (symbol_rootP == orgsymP)
 582         symbol_rootP = newsymP;
 583       else if (orgsymP->sy_previous)
 584         {
 585           orgsymP->sy_previous->sy_next = newsymP;
 586           orgsymP->sy_previous = NULL;
 587         }
 588       if (symbol_lastP == orgsymP)
 589         symbol_lastP = newsymP;
 590       else if (orgsymP->sy_next)
 591         orgsymP->sy_next->sy_previous = newsymP;
 592       orgsymP->sy_next = NULL;
 593       debug_verify_symchain (symbol_rootP, symbol_lastP);
 594
 595       symbol_table_insert (newsymP);
 596     }
 597
 598   return newsymP;
 599 }
 600
 601 /* Referenced symbols, if they are forward references, need to be cloned
 602    (without replacing the original) so that the value of the referenced
 603    symbols at the point of use .  */
 604
 605 #undef symbol_clone_if_forward_ref
 606 symbolS *
 607 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
 608 {
 609   if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
 610     {
 611       symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
 612       symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
 613
 614       if (symbolP->sy_forward_ref)
 615         is_forward = 1;
 616
 617       if (is_forward)
 618         {
 619           /* assign_symbol() clones volatile symbols; pre-existing expressions
 620              hold references to the original instance, but want the current
 621              value.  Just repeat the lookup.  */
 622           if (add_symbol && S_IS_VOLATILE (add_symbol))
 623             add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
 624           if (op_symbol && S_IS_VOLATILE (op_symbol))
 625             op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
 626         }
 627
 628       /* Re-using sy_resolving here, as this routine cannot get called from
 629          symbol resolution code.  */
 630       if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
 631         {
 632           symbolP->sy_resolving = 1;
 633           add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
 634           op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
 635           symbolP->sy_resolving = 0;
 636         }
 637
 638       if (symbolP->sy_forward_ref
 639           || add_symbol != symbolP->sy_value.X_add_symbol
 640           || op_symbol != symbolP->sy_value.X_op_symbol)
 641         symbolP = symbol_clone (symbolP, 0);
 642
 643       symbolP->sy_value.X_add_symbol = add_symbol;
 644       symbolP->sy_value.X_op_symbol = op_symbol;
 645     }
 646
 647   return symbolP;
 648 }
 649
 650 symbolS *
 651 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
 652 {
 653   return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
 654 }
 655
 656 symbolS *
 657 symbol_temp_new_now (void)
 658 {
 659   return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
 660 }
 661
 662 symbolS *
 663 symbol_temp_make (void)
 664 {
 665   return symbol_make (FAKE_LABEL_NAME);
 666 }
 667
 668 /* Implement symbol table lookup.
 669    In:  A symbol's name as a string: '\0' can't be part of a symbol name.
 670    Out: NULL if the name was not in the symbol table, else the address
 671    of a struct symbol associated with that name.  */
 672
 673 symbolS *
 674 symbol_find_exact (const char *name)
 675 {
 676   return symbol_find_exact_noref (name, 0);
 677 }
 678
 679 symbolS *
 680 symbol_find_exact_noref (const char *name, int noref)
 681 {
 682   struct local_symbol *locsym;
 683   symbolS* sym;
 684
 685   locsym = (struct local_symbol *) hash_find (local_hash, name);
 686   if (locsym != NULL)
 687     return (symbolS *) locsym;
 688
 689   sym = ((symbolS *) hash_find (sy_hash, name));
 690
 691   /* Any references to the symbol, except for the reference in
 692      .weakref, must clear this flag, such that the symbol does not
 693      turn into a weak symbol.  Note that we don't have to handle the
 694      local_symbol case, since a weakrefd is always promoted out of the
 695      local_symbol table when it is turned into a weak symbol.  */
 696   if (sym && ! noref)
 697     S_CLEAR_WEAKREFD (sym);
 698
 699   return sym;
 700 }
 701
 702 symbolS *
 703 symbol_find (const char *name)
 704 {
 705   return symbol_find_noref (name, 0);
 706 }
 707
 708 symbolS *
 709 symbol_find_noref (const char *name, int noref)
 710 {
 711 #ifdef tc_canonicalize_symbol_name
 712   {
 713     char *copy;
 714     size_t len = strlen (name) + 1;
 715
 716     copy = (char *) alloca (len);
 717     memcpy (copy, name, len);
 718     name = tc_canonicalize_symbol_name (copy);
 719   }
 720 #endif
 721
 722   if (! symbols_case_sensitive)
 723     {
 724       char *copy;
 725       const char *orig;
 726       unsigned char c;
 727
 728       orig = name;
 729       name = copy = (char *) alloca (strlen (name) + 1);
 730
 731       while ((c = *orig++) != '\0')
 732         {
 733           *copy++ = TOUPPER (c);
 734         }
 735       *copy = '\0';
 736     }
 737
 738   return symbol_find_exact_noref (name, noref);
 739 }
 740
 741 /* Once upon a time, symbols were kept in a singly linked list.  At
 742    least coff needs to be able to rearrange them from time to time, for
 743    which a doubly linked list is much more convenient.  Loic did these
 744    as macros which seemed dangerous to me so they're now functions.
 745    xoxorich.  */
 746
 747 /* Link symbol ADDME after symbol TARGET in the chain.  */
 748
 749 void
 750 symbol_append (symbolS *addme, symbolS *target,
 751                symbolS **rootPP, symbolS **lastPP)
 752 {
 753   if (LOCAL_SYMBOL_CHECK (addme))
 754     abort ();
 755   if (target != NULL && LOCAL_SYMBOL_CHECK (target))
 756     abort ();
 757
 758   if (target == NULL)
 759     {
 760       know (*rootPP == NULL);
 761       know (*lastPP == NULL);
 762       addme->sy_next = NULL;
 763       addme->sy_previous = NULL;
 764       *rootPP = addme;
 765       *lastPP = addme;
 766       return;
 767     }                           /* if the list is empty  */
 768
 769   if (target->sy_next != NULL)
 770     {
 771       target->sy_next->sy_previous = addme;
 772     }
 773   else
 774     {
 775       know (*lastPP == target);
 776       *lastPP = addme;
 777     }                           /* if we have a next  */
 778
 779   addme->sy_next = target->sy_next;
 780   target->sy_next = addme;
 781   addme->sy_previous = target;
 782
 783   debug_verify_symchain (symbol_rootP, symbol_lastP);
 784 }
 785
 786 /* Set the chain pointers of SYMBOL to null.  */
 787
 788 void
 789 symbol_clear_list_pointers (symbolS *symbolP)
 790 {
 791   if (LOCAL_SYMBOL_CHECK (symbolP))
 792     abort ();
 793   symbolP->sy_next = NULL;
 794   symbolP->sy_previous = NULL;
 795 }
 796
 797 /* Remove SYMBOLP from the list.  */
 798
 799 void
 800 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
 801 {
 802   if (LOCAL_SYMBOL_CHECK (symbolP))
 803     abort ();
 804
 805   if (symbolP == *rootPP)
 806     {
 807       *rootPP = symbolP->sy_next;
 808     }                           /* if it was the root  */
 809
 810   if (symbolP == *lastPP)
 811     {
 812       *lastPP = symbolP->sy_previous;
 813     }                           /* if it was the tail  */
 814
 815   if (symbolP->sy_next != NULL)
 816     {
 817       symbolP->sy_next->sy_previous = symbolP->sy_previous;
 818     }                           /* if not last  */
 819
 820   if (symbolP->sy_previous != NULL)
 821     {
 822       symbolP->sy_previous->sy_next = symbolP->sy_next;
 823     }                           /* if not first  */
 824
 825   debug_verify_symchain (*rootPP, *lastPP);
 826 }
 827
 828 /* Link symbol ADDME before symbol TARGET in the chain.  */
 829
 830 void
 831 symbol_insert (symbolS *addme, symbolS *target,
 832                symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
 833 {
 834   if (LOCAL_SYMBOL_CHECK (addme))
 835     abort ();
 836   if (LOCAL_SYMBOL_CHECK (target))
 837     abort ();
 838
 839   if (target->sy_previous != NULL)
 840     {
 841       target->sy_previous->sy_next = addme;
 842     }
 843   else
 844     {
 845       know (*rootPP == target);
 846       *rootPP = addme;
 847     }                           /* if not first  */
 848
 849   addme->sy_previous = target->sy_previous;
 850   target->sy_previous = addme;
 851   addme->sy_next = target;
 852
 853   debug_verify_symchain (*rootPP, *lastPP);
 854 }
 855
 856 void
 857 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
 858 {
 859   symbolS *symbolP = rootP;
 860
 861   if (symbolP == NULL)
 862     return;
 863
 864   for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
 865     {
 866       assert (symbolP->bsym != NULL);
 867       assert (symbolP->sy_next->sy_previous == symbolP);
 868     }
 869
 870   assert (lastP == symbolP);
 871 }
 872
 873 static void
 874 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
 875 {
 876   char *file;
 877   unsigned int line;
 878   segT seg_left = S_GET_SEGMENT (left);
 879   segT seg_right = right ? S_GET_SEGMENT (right) : 0;
 880
 881   if (expr_symbol_where (symp, &file, &line))
 882     {
 883       if (seg_left == undefined_section)
 884         as_bad_where (file, line,
 885                       _("undefined symbol `%s' in operation"),
 886                       S_GET_NAME (left));
 887       if (seg_right == undefined_section)
 888         as_bad_where (file, line,
 889                       _("undefined symbol `%s' in operation"),
 890                       S_GET_NAME (right));
 891       if (seg_left != undefined_section
 892           && seg_right != undefined_section)
 893         {
 894           if (right)
 895             as_bad_where (file, line,
 896                           _("invalid sections for operation on `%s' and `%s'"),
 897                           S_GET_NAME (left), S_GET_NAME (right));
 898           else
 899             as_bad_where (file, line,
 900                           _("invalid section for operation on `%s'"),
 901                           S_GET_NAME (left));
 902         }
 903
 904     }
 905   else
 906     {
 907       if (seg_left == undefined_section)
 908         as_bad (_("undefined symbol `%s' in operation setting `%s'"),
 909                 S_GET_NAME (left), S_GET_NAME (symp));
 910       if (seg_right == undefined_section)
 911         as_bad (_("undefined symbol `%s' in operation setting `%s'"),
 912                 S_GET_NAME (right), S_GET_NAME (symp));
 913       if (seg_left != undefined_section
 914           && seg_right != undefined_section)
 915         {
 916           if (right)
 917             as_bad_where (file, line,
 918                           _("invalid sections for operation on `%s' and `%s' setting `%s'"),
 919                           S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
 920           else
 921             as_bad_where (file, line,
 922                           _("invalid section for operation on `%s' setting `%s'"),
 923                           S_GET_NAME (left), S_GET_NAME (symp));
 924         }
 925     }
 926 }
 927
 928 /* Resolve the value of a symbol.  This is called during the final
 929    pass over the symbol table to resolve any symbols with complex
 930    values.  */
 931
 932 valueT
 933 resolve_symbol_value (symbolS *symp)
 934 {
 935   int resolved;
 936   valueT final_val = 0;
 937   segT final_seg;
 938
 939   if (LOCAL_SYMBOL_CHECK (symp))
 940     {
 941       struct local_symbol *locsym = (struct local_symbol *) symp;
 942
 943       final_val = locsym->lsy_value;
 944       if (local_symbol_resolved_p (locsym))
 945         return final_val;
 946
 947       final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
 948
 949       if (finalize_syms)
 950         {
 951           locsym->lsy_value = final_val;
 952           local_symbol_mark_resolved (locsym);
 953         }
 954
 955       return final_val;
 956     }
 957
 958   if (symp->sy_resolved)
 959     {
 960       if (symp->sy_value.X_op == O_constant)
 961         return (valueT) symp->sy_value.X_add_number;
 962       else
 963         return 0;
 964     }
 965
 966   resolved = 0;
 967   final_seg = S_GET_SEGMENT (symp);
 968
 969   if (symp->sy_resolving)
 970     {
 971       if (finalize_syms)
 972         as_bad (_("symbol definition loop encountered at `%s'"),
 973                 S_GET_NAME (symp));
 974       final_val = 0;
 975       resolved = 1;
 976     }
 977   else
 978     {
 979       symbolS *add_symbol, *op_symbol;
 980       offsetT left, right;
 981       segT seg_left, seg_right;
 982       operatorT op;
 983       int move_seg_ok;
 984
 985       symp->sy_resolving = 1;
 986
 987       /* Help out with CSE.  */
 988       add_symbol = symp->sy_value.X_add_symbol;
 989       op_symbol = symp->sy_value.X_op_symbol;
 990       final_val = symp->sy_value.X_add_number;
 991       op = symp->sy_value.X_op;
 992
 993       switch (op)
 994         {
 995         default:
 996           BAD_CASE (op);
 997           break;
 998
 999         case O_absent:
1000           final_val = 0;
1001           /* Fall through.  */
1002
1003         case O_constant:
1004           final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1005           if (final_seg == expr_section)
1006             final_seg = absolute_section;
1007           resolved = 1;
1008           break;
1009
1010         case O_symbol:
1011         case O_symbol_rva:
1012           left = resolve_symbol_value (add_symbol);
1013           seg_left = S_GET_SEGMENT (add_symbol);
1014           if (finalize_syms)
1015             symp->sy_value.X_op_symbol = NULL;
1016
1017         do_symbol:
1018           if (S_IS_WEAKREFR (symp))
1019             {
1020               assert (final_val == 0);
1021               if (S_IS_WEAKREFR (add_symbol))
1022                 {
1023                   assert (add_symbol->sy_value.X_op == O_symbol
1024                           && add_symbol->sy_value.X_add_number == 0);
1025                   add_symbol = add_symbol->sy_value.X_add_symbol;
1026                   assert (! S_IS_WEAKREFR (add_symbol));
1027                   symp->sy_value.X_add_symbol = add_symbol;
1028                 }
1029             }
1030
1031           if (symp->sy_mri_common)
1032             {
1033               /* This is a symbol inside an MRI common section.  The
1034                  relocation routines are going to handle it specially.
1035                  Don't change the value.  */
1036               resolved = symbol_resolved_p (add_symbol);
1037               break;
1038             }
1039
1040           if (finalize_syms && final_val == 0)
1041             {
1042               if (LOCAL_SYMBOL_CHECK (add_symbol))
1043                 add_symbol = local_symbol_convert ((struct local_symbol *)
1044                                                    add_symbol);
1045               copy_symbol_attributes (symp, add_symbol);
1046             }
1047
1048           /* If we have equated this symbol to an undefined or common
1049              symbol, keep X_op set to O_symbol, and don't change
1050              X_add_number.  This permits the routine which writes out
1051              relocation to detect this case, and convert the
1052              relocation to be against the symbol to which this symbol
1053              is equated.  */
1054           if (! S_IS_DEFINED (add_symbol)
1055 #if defined (OBJ_COFF) && defined (TE_PE)
1056               || S_IS_WEAK (add_symbol)
1057 #endif
1058               || S_IS_COMMON (add_symbol))
1059             {
1060               if (finalize_syms)
1061                 {
1062                   symp->sy_value.X_op = O_symbol;
1063                   symp->sy_value.X_add_symbol = add_symbol;
1064                   symp->sy_value.X_add_number = final_val;
1065                   /* Use X_op_symbol as a flag.  */
1066                   symp->sy_value.X_op_symbol = add_symbol;
1067                   final_seg = seg_left;
1068                 }
1069               final_val = 0;
1070               resolved = symbol_resolved_p (add_symbol);
1071               symp->sy_resolving = 0;
1072               goto exit_dont_set_value;
1073             }
1074           else if (finalize_syms && final_seg == expr_section
1075                    && seg_left != expr_section)
1076             {
1077               /* If the symbol is an expression symbol, do similarly
1078                  as for undefined and common syms above.  Handles
1079                  "sym +/- expr" where "expr" cannot be evaluated
1080                  immediately, and we want relocations to be against
1081                  "sym", eg. because it is weak.  */
1082               symp->sy_value.X_op = O_symbol;
1083               symp->sy_value.X_add_symbol = add_symbol;
1084               symp->sy_value.X_add_number = final_val;
1085               symp->sy_value.X_op_symbol = add_symbol;
1086               final_seg = seg_left;
1087               final_val += symp->sy_frag->fr_address + left;
1088               resolved = symbol_resolved_p (add_symbol);
1089               symp->sy_resolving = 0;
1090               goto exit_dont_set_value;
1091             }
1092           else
1093             {
1094               final_val += symp->sy_frag->fr_address + left;
1095               if (final_seg == expr_section || final_seg == undefined_section)
1096                 final_seg = seg_left;
1097             }
1098
1099           resolved = symbol_resolved_p (add_symbol);
1100           if (S_IS_WEAKREFR (symp))
1101             goto exit_dont_set_value;
1102           break;
1103
1104         case O_uminus:
1105         case O_bit_not:
1106         case O_logical_not:
1107           left = resolve_symbol_value (add_symbol);
1108           seg_left = S_GET_SEGMENT (add_symbol);
1109
1110           /* By reducing these to the relevant dyadic operator, we get
1111                 !S -> S == 0    permitted on anything,
1112                 -S -> 0 - S     only permitted on absolute
1113                 ~S -> S ^ ~0    only permitted on absolute  */
1114           if (op != O_logical_not && seg_left != absolute_section
1115               && finalize_syms)
1116             report_op_error (symp, add_symbol, NULL);
1117
1118           if (final_seg == expr_section || final_seg == undefined_section)
1119             final_seg = absolute_section;
1120
1121           if (op == O_uminus)
1122             left = -left;
1123           else if (op == O_logical_not)
1124             left = !left;
1125           else
1126             left = ~left;
1127
1128           final_val += left + symp->sy_frag->fr_address;
1129
1130           resolved = symbol_resolved_p (add_symbol);
1131           break;
1132
1133         case O_multiply:
1134         case O_divide:
1135         case O_modulus:
1136         case O_left_shift:
1137         case O_right_shift:
1138         case O_bit_inclusive_or:
1139         case O_bit_or_not:
1140         case O_bit_exclusive_or:
1141         case O_bit_and:
1142         case O_add:
1143         case O_subtract:
1144         case O_eq:
1145         case O_ne:
1146         case O_lt:
1147         case O_le:
1148         case O_ge:
1149         case O_gt:
1150         case O_logical_and:
1151         case O_logical_or:
1152           left = resolve_symbol_value (add_symbol);
1153           right = resolve_symbol_value (op_symbol);
1154           seg_left = S_GET_SEGMENT (add_symbol);
1155           seg_right = S_GET_SEGMENT (op_symbol);
1156
1157           /* Simplify addition or subtraction of a constant by folding the
1158              constant into X_add_number.  */
1159           if (op == O_add)
1160             {
1161               if (seg_right == absolute_section)
1162                 {
1163                   final_val += right;
1164                   goto do_symbol;
1165                 }
1166               else if (seg_left == absolute_section)
1167                 {
1168                   final_val += left;
1169                   add_symbol = op_symbol;
1170                   left = right;
1171                   seg_left = seg_right;
1172                   goto do_symbol;
1173                 }
1174             }
1175           else if (op == O_subtract)
1176             {
1177               if (seg_right == absolute_section)
1178                 {
1179                   final_val -= right;
1180                   goto do_symbol;
1181                 }
1182             }
1183
1184           move_seg_ok = 1;
1185           /* Equality and non-equality tests are permitted on anything.
1186              Subtraction, and other comparison operators are permitted if
1187              both operands are in the same section.  Otherwise, both
1188              operands must be absolute.  We already handled the case of
1189              addition or subtraction of a constant above.  This will
1190              probably need to be changed for an object file format which
1191              supports arbitrary expressions, such as IEEE-695.  */
1192           if (!(seg_left == absolute_section
1193                    && seg_right == absolute_section)
1194               && !(op == O_eq || op == O_ne)
1195               && !((op == O_subtract
1196                     || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1197                    && seg_left == seg_right
1198                    && (seg_left != undefined_section
1199                        || add_symbol == op_symbol)))
1200             {
1201               /* Don't emit messages unless we're finalizing the symbol value,
1202                  otherwise we may get the same message multiple times.  */
1203               if (finalize_syms)
1204                 report_op_error (symp, add_symbol, op_symbol);
1205               /* However do not move the symbol into the absolute section
1206                  if it cannot currently be resolved - this would confuse
1207                  other parts of the assembler into believing that the
1208                  expression had been evaluated to zero.  */
1209               else
1210                 move_seg_ok = 0;
1211             }
1212
1213           if (move_seg_ok
1214               && (final_seg == expr_section || final_seg == undefined_section))
1215             final_seg = absolute_section;
1216
1217           /* Check for division by zero.  */
1218           if ((op == O_divide || op == O_modulus) && right == 0)
1219             {
1220               /* If seg_right is not absolute_section, then we've
1221                  already issued a warning about using a bad symbol.  */
1222               if (seg_right == absolute_section && finalize_syms)
1223                 {
1224                   char *file;
1225                   unsigned int line;
1226
1227                   if (expr_symbol_where (symp, &file, &line))
1228                     as_bad_where (file, line, _("division by zero"));
1229                   else
1230                     as_bad (_("division by zero when setting `%s'"),
1231                             S_GET_NAME (symp));
1232                 }
1233
1234               right = 1;
1235             }
1236
1237           switch (symp->sy_value.X_op)
1238             {
1239             case O_multiply:            left *= right; break;
1240             case O_divide:              left /= right; break;
1241             case O_modulus:             left %= right; break;
1242             case O_left_shift:          left <<= right; break;
1243             case O_right_shift:         left >>= right; break;
1244             case O_bit_inclusive_or:    left |= right; break;
1245             case O_bit_or_not:          left |= ~right; break;
1246             case O_bit_exclusive_or:    left ^= right; break;
1247             case O_bit_and:             left &= right; break;
1248             case O_add:                 left += right; break;
1249             case O_subtract:            left -= right; break;
1250             case O_eq:
1251             case O_ne:
1252               left = (left == right && seg_left == seg_right
1253                       && (seg_left != undefined_section
1254                           || add_symbol == op_symbol)
1255                       ? ~ (offsetT) 0 : 0);
1256               if (symp->sy_value.X_op == O_ne)
1257                 left = ~left;
1258               break;
1259             case O_lt:  left = left <  right ? ~ (offsetT) 0 : 0; break;
1260             case O_le:  left = left <= right ? ~ (offsetT) 0 : 0; break;
1261             case O_ge:  left = left >= right ? ~ (offsetT) 0 : 0; break;
1262             case O_gt:  left = left >  right ? ~ (offsetT) 0 : 0; break;
1263             case O_logical_and: left = left && right; break;
1264             case O_logical_or:  left = left || right; break;
1265             default:            abort ();
1266             }
1267
1268           final_val += symp->sy_frag->fr_address + left;
1269           if (final_seg == expr_section || final_seg == undefined_section)
1270             {
1271               if (seg_left == undefined_section
1272                   || seg_right == undefined_section)
1273                 final_seg = undefined_section;
1274               else if (seg_left == absolute_section)
1275                 final_seg = seg_right;
1276               else
1277                 final_seg = seg_left;
1278             }
1279           resolved = (symbol_resolved_p (add_symbol)
1280                       && symbol_resolved_p (op_symbol));
1281           break;
1282
1283         case O_register:
1284         case O_big:
1285         case O_illegal:
1286           /* Give an error (below) if not in expr_section.  We don't
1287              want to worry about expr_section symbols, because they
1288              are fictional (they are created as part of expression
1289              resolution), and any problems may not actually mean
1290              anything.  */
1291           break;
1292         }
1293
1294       symp->sy_resolving = 0;
1295     }
1296
1297   if (finalize_syms)
1298     S_SET_VALUE (symp, final_val);
1299
1300 exit_dont_set_value:
1301   /* Always set the segment, even if not finalizing the value.
1302      The segment is used to determine whether a symbol is defined.  */
1303     S_SET_SEGMENT (symp, final_seg);
1304
1305   /* Don't worry if we can't resolve an expr_section symbol.  */
1306   if (finalize_syms)
1307     {
1308       if (resolved)
1309         symp->sy_resolved = 1;
1310       else if (S_GET_SEGMENT (symp) != expr_section)
1311         {
1312           as_bad (_("can't resolve value for symbol `%s'"),
1313                   S_GET_NAME (symp));
1314           symp->sy_resolved = 1;
1315         }
1316     }
1317
1318   return final_val;
1319 }
1320
1321 static void resolve_local_symbol (const char *, PTR);
1322
1323 /* A static function passed to hash_traverse.  */
1324
1325 static void
1326 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)
1327 {
1328   if (value != NULL)
1329     resolve_symbol_value (value);
1330 }
1331
1332 /* Resolve all local symbols.  */
1333
1334 void
1335 resolve_local_symbol_values (void)
1336 {
1337   hash_traverse (local_hash, resolve_local_symbol);
1338 }
1339
1340 /* Obtain the current value of a symbol without changing any
1341    sub-expressions used.  */
1342
1343 int
1344 snapshot_symbol (symbolS *symbolP, valueT *valueP, segT *segP, fragS **fragPP)
1345 {
1346   if (LOCAL_SYMBOL_CHECK (symbolP))
1347     {
1348       struct local_symbol *locsym = (struct local_symbol *) symbolP;
1349
1350       *valueP = locsym->lsy_value;
1351       *segP = locsym->lsy_section;
1352       *fragPP = local_symbol_get_frag (locsym);
1353     }
1354   else
1355     {
1356       expressionS expr = symbolP->sy_value;
1357
1358       if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1359         {
1360           int resolved;
1361
1362           if (symbolP->sy_resolving)
1363             return 0;
1364           symbolP->sy_resolving = 1;
1365           resolved = resolve_expression (&expr);
1366           symbolP->sy_resolving = 0;
1367           if (!resolved)
1368             return 0;
1369
1370           switch (expr.X_op)
1371             {
1372             case O_constant:
1373             case O_register:
1374               /* This check wouldn't be needed if pseudo_set() didn't set
1375                  symbols equated to bare symbols to undefined_section.  */
1376               if (symbolP->bsym->section != undefined_section
1377                   || symbolP->sy_value.X_op != O_symbol)
1378                 break;
1379               /* Fall thru.  */
1380             case O_symbol:
1381             case O_symbol_rva:
1382               symbolP = expr.X_add_symbol;
1383               break;
1384             default:
1385               return 0;
1386             }
1387         }
1388
1389       *valueP = expr.X_add_number;
1390       *segP = symbolP->bsym->section;
1391       *fragPP = symbolP->sy_frag;
1392
1393       if (*segP == expr_section)
1394         switch (expr.X_op)
1395           {
1396           case O_constant: *segP = absolute_section; break;
1397           case O_register: *segP = reg_section; break;
1398           default: break;
1399           }
1400     }
1401
1402   return 1;
1403 }
1404
1405 /* Dollar labels look like a number followed by a dollar sign.  Eg, "42$".
1406    They are *really* local.  That is, they go out of scope whenever we see a
1407    label that isn't local.  Also, like fb labels, there can be multiple
1408    instances of a dollar label.  Therefor, we name encode each instance with
1409    the instance number, keep a list of defined symbols separate from the real
1410    symbol table, and we treat these buggers as a sparse array.  */
1411
1412 static long *dollar_labels;
1413 static long *dollar_label_instances;
1414 static char *dollar_label_defines;
1415 static unsigned long dollar_label_count;
1416 static unsigned long dollar_label_max;
1417
1418 int
1419 dollar_label_defined (long label)
1420 {
1421   long *i;
1422
1423   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1424
1425   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1426     if (*i == label)
1427       return dollar_label_defines[i - dollar_labels];
1428
1429   /* If we get here, label isn't defined.  */
1430   return 0;
1431 }
1432
1433 static long
1434 dollar_label_instance (long label)
1435 {
1436   long *i;
1437
1438   know ((dollar_labels != NULL) || (dollar_label_count == 0));
1439
1440   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1441     if (*i == label)
1442       return (dollar_label_instances[i - dollar_labels]);
1443
1444   /* If we get here, we haven't seen the label before.
1445      Therefore its instance count is zero.  */
1446   return 0;
1447 }
1448
1449 void
1450 dollar_label_clear (void)
1451 {
1452   memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1453 }
1454
1455 #define DOLLAR_LABEL_BUMP_BY 10
1456
1457 void
1458 define_dollar_label (long label)
1459 {
1460   long *i;
1461
1462   for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1463     if (*i == label)
1464       {
1465         ++dollar_label_instances[i - dollar_labels];
1466         dollar_label_defines[i - dollar_labels] = 1;
1467         return;
1468       }
1469
1470   /* If we get to here, we don't have label listed yet.  */
1471
1472   if (dollar_labels == NULL)
1473     {
1474       dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1475       dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1476       dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1477       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1478       dollar_label_count = 0;
1479     }
1480   else if (dollar_label_count == dollar_label_max)
1481     {
1482       dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1483       dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1484                                          dollar_label_max * sizeof (long));
1485       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1486                                           dollar_label_max * sizeof (long));
1487       dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1488     }                           /* if we needed to grow  */
1489
1490   dollar_labels[dollar_label_count] = label;
1491   dollar_label_instances[dollar_label_count] = 1;
1492   dollar_label_defines[dollar_label_count] = 1;
1493   ++dollar_label_count;
1494 }
1495
1496 /* Caller must copy returned name: we re-use the area for the next name.
1497
1498    The mth occurence of label n: is turned into the symbol "Ln^Am"
1499    where n is the label number and m is the instance number. "L" makes
1500    it a label discarded unless debugging and "^A"('\1') ensures no
1501    ordinary symbol SHOULD get the same name as a local label
1502    symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1503
1504    fb labels get the same treatment, except that ^B is used in place
1505    of ^A.  */
1506
1507 char *                          /* Return local label name.  */
1508 dollar_label_name (register long n,     /* we just saw "n$:" : n a number.  */
1509                    register int augend  /* 0 for current instance, 1 for new instance.  */)
1510 {
1511   long i;
1512   /* Returned to caller, then copied.  Used for created names ("4f").  */
1513   static char symbol_name_build[24];
1514   register char *p;
1515   register char *q;
1516   char symbol_name_temporary[20];       /* Build up a number, BACKWARDS.  */
1517
1518   know (n >= 0);
1519   know (augend == 0 || augend == 1);
1520   p = symbol_name_build;
1521 #ifdef LOCAL_LABEL_PREFIX
1522   *p++ = LOCAL_LABEL_PREFIX;
1523 #endif
1524   *p++ = 'L';
1525
1526   /* Next code just does sprintf( {}, "%d", n);  */
1527   /* Label number.  */
1528   q = symbol_name_temporary;
1529   for (*q++ = 0, i = n; i; ++q)
1530     {
1531       *q = i % 10 + '0';
1532       i /= 10;
1533     }
1534   while ((*p = *--q) != '\0')
1535     ++p;
1536
1537   *p++ = DOLLAR_LABEL_CHAR;             /* ^A  */
1538
1539   /* Instance number.  */
1540   q = symbol_name_temporary;
1541   for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1542     {
1543       *q = i % 10 + '0';
1544       i /= 10;
1545     }
1546   while ((*p++ = *--q) != '\0');;
1547
1548   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1549   return symbol_name_build;
1550 }
1551
1552 /* Somebody else's idea of local labels. They are made by "n:" where n
1553    is any decimal digit. Refer to them with
1554     "nb" for previous (backward) n:
1555    or "nf" for next (forward) n:.
1556
1557    We do a little better and let n be any number, not just a single digit, but
1558    since the other guy's assembler only does ten, we treat the first ten
1559    specially.
1560
1561    Like someone else's assembler, we have one set of local label counters for
1562    entire assembly, not one set per (sub)segment like in most assemblers. This
1563    implies that one can refer to a label in another segment, and indeed some
1564    crufty compilers have done just that.
1565
1566    Since there could be a LOT of these things, treat them as a sparse
1567    array.  */
1568
1569 #define FB_LABEL_SPECIAL (10)
1570
1571 static long fb_low_counter[FB_LABEL_SPECIAL];
1572 static long *fb_labels;
1573 static long *fb_label_instances;
1574 static long fb_label_count;
1575 static long fb_label_max;
1576
1577 /* This must be more than FB_LABEL_SPECIAL.  */
1578 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1579
1580 static void
1581 fb_label_init (void)
1582 {
1583   memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1584 }
1585
1586 /* Add one to the instance number of this fb label.  */
1587
1588 void
1589 fb_label_instance_inc (long label)
1590 {
1591   long *i;
1592
1593   if (label < FB_LABEL_SPECIAL)
1594     {
1595       ++fb_low_counter[label];
1596       return;
1597     }
1598
1599   if (fb_labels != NULL)
1600     {
1601       for (i = fb_labels + FB_LABEL_SPECIAL;
1602            i < fb_labels + fb_label_count; ++i)
1603         {
1604           if (*i == label)
1605             {
1606               ++fb_label_instances[i - fb_labels];
1607               return;
1608             }                   /* if we find it  */
1609         }                       /* for each existing label  */
1610     }
1611
1612   /* If we get to here, we don't have label listed yet.  */
1613
1614   if (fb_labels == NULL)
1615     {
1616       fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1617       fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1618       fb_label_max = FB_LABEL_BUMP_BY;
1619       fb_label_count = FB_LABEL_SPECIAL;
1620
1621     }
1622   else if (fb_label_count == fb_label_max)
1623     {
1624       fb_label_max += FB_LABEL_BUMP_BY;
1625       fb_labels = (long *) xrealloc ((char *) fb_labels,
1626                                      fb_label_max * sizeof (long));
1627       fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1628                                               fb_label_max * sizeof (long));
1629     }                           /* if we needed to grow  */
1630
1631   fb_labels[fb_label_count] = label;
1632   fb_label_instances[fb_label_count] = 1;
1633   ++fb_label_count;
1634 }
1635
1636 static long
1637 fb_label_instance (long label)
1638 {
1639   long *i;
1640
1641   if (label < FB_LABEL_SPECIAL)
1642     {
1643       return (fb_low_counter[label]);
1644     }
1645
1646   if (fb_labels != NULL)
1647     {
1648       for (i = fb_labels + FB_LABEL_SPECIAL;
1649            i < fb_labels + fb_label_count; ++i)
1650         {
1651           if (*i == label)
1652             {
1653               return (fb_label_instances[i - fb_labels]);
1654             }                   /* if we find it  */
1655         }                       /* for each existing label  */
1656     }
1657
1658   /* We didn't find the label, so this must be a reference to the
1659      first instance.  */
1660   return 0;
1661 }
1662
1663 /* Caller must copy returned name: we re-use the area for the next name.
1664
1665    The mth occurence of label n: is turned into the symbol "Ln^Bm"
1666    where n is the label number and m is the instance number. "L" makes
1667    it a label discarded unless debugging and "^B"('\2') ensures no
1668    ordinary symbol SHOULD get the same name as a local label
1669    symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1670
1671    dollar labels get the same treatment, except that ^A is used in
1672    place of ^B.  */
1673
1674 char *                          /* Return local label name.  */
1675 fb_label_name (long n,  /* We just saw "n:", "nf" or "nb" : n a number.  */
1676                long augend      /* 0 for nb, 1 for n:, nf.  */)
1677 {
1678   long i;
1679   /* Returned to caller, then copied.  Used for created names ("4f").  */
1680   static char symbol_name_build[24];
1681   register char *p;
1682   register char *q;
1683   char symbol_name_temporary[20];       /* Build up a number, BACKWARDS.  */
1684
1685   know (n >= 0);
1686 #ifdef TC_MMIX
1687   know ((unsigned long) augend <= 2 /* See mmix_fb_label.  */);
1688 #else
1689   know ((unsigned long) augend <= 1);
1690 #endif
1691   p = symbol_name_build;
1692 #ifdef LOCAL_LABEL_PREFIX
1693   *p++ = LOCAL_LABEL_PREFIX;
1694 #endif
1695   *p++ = 'L';
1696
1697   /* Next code just does sprintf( {}, "%d", n);  */
1698   /* Label number.  */
1699   q = symbol_name_temporary;
1700   for (*q++ = 0, i = n; i; ++q)
1701     {
1702       *q = i % 10 + '0';
1703       i /= 10;
1704     }
1705   while ((*p = *--q) != '\0')
1706     ++p;
1707
1708   *p++ = LOCAL_LABEL_CHAR;              /* ^B  */
1709
1710   /* Instance number.  */
1711   q = symbol_name_temporary;
1712   for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1713     {
1714       *q = i % 10 + '0';
1715       i /= 10;
1716     }
1717   while ((*p++ = *--q) != '\0');;
1718
1719   /* The label, as a '\0' ended string, starts at symbol_name_build.  */
1720   return (symbol_name_build);
1721 }
1722
1723 /* Decode name that may have been generated by foo_label_name() above.
1724    If the name wasn't generated by foo_label_name(), then return it
1725    unaltered.  This is used for error messages.  */
1726
1727 char *
1728 decode_local_label_name (char *s)
1729 {
1730   char *p;
1731   char *symbol_decode;
1732   int label_number;
1733   int instance_number;
1734   char *type;
1735   const char *message_format;
1736   int index = 0;
1737
1738 #ifdef LOCAL_LABEL_PREFIX
1739   if (s[index] == LOCAL_LABEL_PREFIX)
1740     ++index;
1741 #endif
1742
1743   if (s[index] != 'L')
1744     return s;
1745
1746   for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1747     label_number = (10 * label_number) + *p - '0';
1748
1749   if (*p == DOLLAR_LABEL_CHAR)
1750     type = "dollar";
1751   else if (*p == LOCAL_LABEL_CHAR)
1752     type = "fb";
1753   else
1754     return s;
1755
1756   for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1757     instance_number = (10 * instance_number) + *p - '0';
1758
1759   message_format = _("\"%d\" (instance number %d of a %s label)");
1760   symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1761   sprintf (symbol_decode, message_format, label_number, instance_number, type);
1762
1763   return symbol_decode;
1764 }
1765
1766 /* Get the value of a symbol.  */
1767
1768 valueT
1769 S_GET_VALUE (symbolS *s)
1770 {
1771   if (LOCAL_SYMBOL_CHECK (s))
1772     return resolve_symbol_value (s);
1773
1774   if (!s->sy_resolved)
1775     {
1776       valueT val = resolve_symbol_value (s);
1777       if (!finalize_syms)
1778         return val;
1779     }
1780   if (S_IS_WEAKREFR (s))
1781     return S_GET_VALUE (s->sy_value.X_add_symbol);
1782
1783   if (s->sy_value.X_op != O_constant)
1784     {
1785       if (! s->sy_resolved
1786           || s->sy_value.X_op != O_symbol
1787           || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1788         as_bad (_("attempt to get value of unresolved symbol `%s'"),
1789                 S_GET_NAME (s));
1790     }
1791   return (valueT) s->sy_value.X_add_number;
1792 }
1793
1794 /* Set the value of a symbol.  */
1795
1796 void
1797 S_SET_VALUE (symbolS *s, valueT val)
1798 {
1799   if (LOCAL_SYMBOL_CHECK (s))
1800     {
1801       ((struct local_symbol *) s)->lsy_value = val;
1802       return;
1803     }
1804
1805   s->sy_value.X_op = O_constant;
1806   s->sy_value.X_add_number = (offsetT) val;
1807   s->sy_value.X_unsigned = 0;
1808   S_CLEAR_WEAKREFR (s);
1809 }
1810
1811 void
1812 copy_symbol_attributes (symbolS *dest, symbolS *src)
1813 {
1814   if (LOCAL_SYMBOL_CHECK (dest))
1815     dest = local_symbol_convert ((struct local_symbol *) dest);
1816   if (LOCAL_SYMBOL_CHECK (src))
1817     src = local_symbol_convert ((struct local_symbol *) src);
1818
1819   /* In an expression, transfer the settings of these flags.
1820      The user can override later, of course.  */
1821 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1822   dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1823
1824 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1825   OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1826 #endif
1827 }
1828
1829 int
1830 S_IS_FUNCTION (symbolS *s)
1831 {
1832   flagword flags;
1833
1834   if (LOCAL_SYMBOL_CHECK (s))
1835     return 0;
1836
1837   flags = s->bsym->flags;
1838
1839   return (flags & BSF_FUNCTION) != 0;
1840 }
1841
1842 int
1843 S_IS_EXTERNAL (symbolS *s)
1844 {
1845   flagword flags;
1846
1847   if (LOCAL_SYMBOL_CHECK (s))
1848     return 0;
1849
1850   flags = s->bsym->flags;
1851
1852   /* Sanity check.  */
1853   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1854     abort ();
1855
1856   return (flags & BSF_GLOBAL) != 0;
1857 }
1858
1859 int
1860 S_IS_WEAK (symbolS *s)
1861 {
1862   if (LOCAL_SYMBOL_CHECK (s))
1863     return 0;
1864   /* Conceptually, a weakrefr is weak if the referenced symbol is.  We
1865      could probably handle a WEAKREFR as always weak though.  E.g., if
1866      the referenced symbol has lost its weak status, there's no reason
1867      to keep handling the weakrefr as if it was weak.  */
1868   if (S_IS_WEAKREFR (s))
1869     return S_IS_WEAK (s->sy_value.X_add_symbol);
1870   return (s->bsym->flags & BSF_WEAK) != 0;
1871 }
1872
1873 int
1874 S_IS_WEAKREFR (symbolS *s)
1875 {
1876   if (LOCAL_SYMBOL_CHECK (s))
1877     return 0;
1878   return s->sy_weakrefr != 0;
1879 }
1880
1881 int
1882 S_IS_WEAKREFD (symbolS *s)
1883 {
1884   if (LOCAL_SYMBOL_CHECK (s))
1885     return 0;
1886   return s->sy_weakrefd != 0;
1887 }
1888
1889 int
1890 S_IS_COMMON (symbolS *s)
1891 {
1892   if (LOCAL_SYMBOL_CHECK (s))
1893     return 0;
1894   return bfd_is_com_section (s->bsym->section);
1895 }
1896
1897 int
1898 S_IS_DEFINED (symbolS *s)
1899 {
1900   if (LOCAL_SYMBOL_CHECK (s))
1901     return ((struct local_symbol *) s)->lsy_section != undefined_section;
1902   return s->bsym->section != undefined_section;
1903 }
1904
1905
1906 #ifndef EXTERN_FORCE_RELOC
1907 #define EXTERN_FORCE_RELOC IS_ELF
1908 #endif
1909
1910 /* Return true for symbols that should not be reduced to section
1911    symbols or eliminated from expressions, because they may be
1912    overridden by the linker.  */
1913 int
1914 S_FORCE_RELOC (symbolS *s, int strict)
1915 {
1916   if (LOCAL_SYMBOL_CHECK (s))
1917     return ((struct local_symbol *) s)->lsy_section == undefined_section;
1918
1919   return ((strict
1920            && ((s->bsym->flags & BSF_WEAK) != 0
1921                || (EXTERN_FORCE_RELOC
1922                    && (s->bsym->flags & BSF_GLOBAL) != 0)))
1923           || s->bsym->section == undefined_section
1924           || bfd_is_com_section (s->bsym->section));
1925 }
1926
1927 int
1928 S_IS_DEBUG (symbolS *s)
1929 {
1930   if (LOCAL_SYMBOL_CHECK (s))
1931     return 0;
1932   if (s->bsym->flags & BSF_DEBUGGING)
1933     return 1;
1934   return 0;
1935 }
1936
1937 int
1938 S_IS_LOCAL (symbolS *s)
1939 {
1940   flagword flags;
1941   const char *name;
1942
1943   if (LOCAL_SYMBOL_CHECK (s))
1944     return 1;
1945
1946   flags = s->bsym->flags;
1947
1948   /* Sanity check.  */
1949   if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1950     abort ();
1951
1952   if (bfd_get_section (s->bsym) == reg_section)
1953     return 1;
1954
1955   if (flag_strip_local_absolute
1956       /* Keep BSF_FILE symbols in order to allow debuggers to identify
1957          the source file even when the object file is stripped.  */
1958       && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
1959       && bfd_get_section (s->bsym) == absolute_section)
1960     return 1;
1961
1962   name = S_GET_NAME (s);
1963   return (name != NULL
1964           && ! S_IS_DEBUG (s)
1965           && (strchr (name, DOLLAR_LABEL_CHAR)
1966               || strchr (name, LOCAL_LABEL_CHAR)
1967               || (! flag_keep_locals
1968                   && (bfd_is_local_label (stdoutput, s->bsym)
1969                       || (flag_mri
1970                           && name[0] == '?'
1971                           && name[1] == '?')))));
1972 }
1973
1974 int
1975 S_IS_STABD (symbolS *s)
1976 {
1977   return S_GET_NAME (s) == 0;
1978 }
1979
1980 int
1981 S_IS_VOLATILE (const symbolS *s)
1982 {
1983   if (LOCAL_SYMBOL_CHECK (s))
1984     return 0;
1985   return s->sy_volatile;
1986 }
1987
1988 int
1989 S_IS_FORWARD_REF (const symbolS *s)
1990 {
1991   if (LOCAL_SYMBOL_CHECK (s))
1992     return 0;
1993   return s->sy_forward_ref;
1994 }
1995
1996 const char *
1997 S_GET_NAME (symbolS *s)
1998 {
1999   if (LOCAL_SYMBOL_CHECK (s))
2000     return ((struct local_symbol *) s)->lsy_name;
2001   return s->bsym->name;
2002 }
2003
2004 segT
2005 S_GET_SEGMENT (symbolS *s)
2006 {
2007   if (LOCAL_SYMBOL_CHECK (s))
2008     return ((struct local_symbol *) s)->lsy_section;
2009   return s->bsym->section;
2010 }
2011
2012 void
2013 S_SET_SEGMENT (symbolS *s, segT seg)
2014 {
2015   /* Don't reassign section symbols.  The direct reason is to prevent seg
2016      faults assigning back to const global symbols such as *ABS*, but it
2017      shouldn't happen anyway.  */
2018
2019   if (LOCAL_SYMBOL_CHECK (s))
2020     {
2021       if (seg == reg_section)
2022         s = local_symbol_convert ((struct local_symbol *) s);
2023       else
2024         {
2025           ((struct local_symbol *) s)->lsy_section = seg;
2026           return;
2027         }
2028     }
2029
2030   if (s->bsym->flags & BSF_SECTION_SYM)
2031     {
2032       if (s->bsym->section != seg)
2033         abort ();
2034     }
2035   else
2036     s->bsym->section = seg;
2037 }
2038
2039 void
2040 S_SET_EXTERNAL (symbolS *s)
2041 {
2042   if (LOCAL_SYMBOL_CHECK (s))
2043     s = local_symbol_convert ((struct local_symbol *) s);
2044   if ((s->bsym->flags & BSF_WEAK) != 0)
2045     {
2046       /* Let .weak override .global.  */
2047       return;
2048     }
2049   if (s->bsym->flags & BSF_SECTION_SYM)
2050     {
2051       char * file;
2052       unsigned int line;
2053
2054       /* Do not reassign section symbols.  */
2055       as_where (& file, & line);
2056       as_warn_where (file, line,
2057                      _("section symbols are already global"));
2058       return;
2059     }
2060   s->bsym->flags |= BSF_GLOBAL;
2061   s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2062
2063 #ifdef USE_UNIQUE
2064   if (! an_external_name && S_GET_NAME(s)[0] != '.')
2065     an_external_name = S_GET_NAME (s);
2066 #endif
2067 }
2068
2069 void
2070 S_CLEAR_EXTERNAL (symbolS *s)
2071 {
2072   if (LOCAL_SYMBOL_CHECK (s))
2073     return;
2074   if ((s->bsym->flags & BSF_WEAK) != 0)
2075     {
2076       /* Let .weak override.  */
2077       return;
2078     }
2079   s->bsym->flags |= BSF_LOCAL;
2080   s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2081 }
2082
2083 void
2084 S_SET_WEAK (symbolS *s)
2085 {
2086   if (LOCAL_SYMBOL_CHECK (s))
2087     s = local_symbol_convert ((struct local_symbol *) s);
2088 #ifdef obj_set_weak_hook
2089   obj_set_weak_hook (s);
2090 #endif
2091   s->bsym->flags |= BSF_WEAK;
2092   s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2093 }
2094
2095 void
2096 S_SET_WEAKREFR (symbolS *s)
2097 {
2098   if (LOCAL_SYMBOL_CHECK (s))
2099     s = local_symbol_convert ((struct local_symbol *) s);
2100   s->sy_weakrefr = 1;
2101   /* If the alias was already used, make sure we mark the target as
2102      used as well, otherwise it might be dropped from the symbol
2103      table.  This may have unintended side effects if the alias is
2104      later redirected to another symbol, such as keeping the unused
2105      previous target in the symbol table.  Since it will be weak, it's
2106      not a big deal.  */
2107   if (s->sy_used)
2108     symbol_mark_used (s->sy_value.X_add_symbol);
2109 }
2110
2111 void
2112 S_CLEAR_WEAKREFR (symbolS *s)
2113 {
2114   if (LOCAL_SYMBOL_CHECK (s))
2115     return;
2116   s->sy_weakrefr = 0;
2117 }
2118
2119 void
2120 S_SET_WEAKREFD (symbolS *s)
2121 {
2122   if (LOCAL_SYMBOL_CHECK (s))
2123     s = local_symbol_convert ((struct local_symbol *) s);
2124   s->sy_weakrefd = 1;
2125   S_SET_WEAK (s);
2126 }
2127
2128 void
2129 S_CLEAR_WEAKREFD (symbolS *s)
2130 {
2131   if (LOCAL_SYMBOL_CHECK (s))
2132     return;
2133   if (s->sy_weakrefd)
2134     {
2135       s->sy_weakrefd = 0;
2136       /* If a weakref target symbol is weak, then it was never
2137          referenced directly before, not even in a .global directive,
2138          so decay it to local.  If it remains undefined, it will be
2139          later turned into a global, like any other undefined
2140          symbol.  */
2141       if (s->bsym->flags & BSF_WEAK)
2142         {
2143 #ifdef obj_clear_weak_hook
2144           obj_clear_weak_hook (s);
2145 #endif
2146           s->bsym->flags &= ~BSF_WEAK;
2147           s->bsym->flags |= BSF_LOCAL;
2148         }
2149     }
2150 }
2151
2152 void
2153 S_SET_THREAD_LOCAL (symbolS *s)
2154 {
2155   if (LOCAL_SYMBOL_CHECK (s))
2156     s = local_symbol_convert ((struct local_symbol *) s);
2157   if (bfd_is_com_section (s->bsym->section)
2158       && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2159     return;
2160   s->bsym->flags |= BSF_THREAD_LOCAL;
2161   if ((s->bsym->flags & BSF_FUNCTION) != 0)
2162     as_bad (_("Accessing function `%s' as thread-local object"),
2163             S_GET_NAME (s));
2164   else if (! bfd_is_und_section (s->bsym->section)
2165            && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2166     as_bad (_("Accessing `%s' as thread-local object"),
2167             S_GET_NAME (s));
2168 }
2169
2170 void
2171 S_SET_NAME (symbolS *s, const char *name)
2172 {
2173   if (LOCAL_SYMBOL_CHECK (s))
2174     {
2175       ((struct local_symbol *) s)->lsy_name = name;
2176       return;
2177     }
2178   s->bsym->name = name;
2179 }
2180
2181 void
2182 S_SET_VOLATILE (symbolS *s)
2183 {
2184   if (LOCAL_SYMBOL_CHECK (s))
2185     s = local_symbol_convert ((struct local_symbol *) s);
2186   s->sy_volatile = 1;
2187 }
2188
2189 void
2190 S_SET_FORWARD_REF (symbolS *s)
2191 {
2192   if (LOCAL_SYMBOL_CHECK (s))
2193     s = local_symbol_convert ((struct local_symbol *) s);
2194   s->sy_forward_ref = 1;
2195 }
2196
2197 /* Return the previous symbol in a chain.  */
2198
2199 symbolS *
2200 symbol_previous (symbolS *s)
2201 {
2202   if (LOCAL_SYMBOL_CHECK (s))
2203     abort ();
2204   return s->sy_previous;
2205 }
2206
2207 /* Return the next symbol in a chain.  */
2208
2209 symbolS *
2210 symbol_next (symbolS *s)
2211 {
2212   if (LOCAL_SYMBOL_CHECK (s))
2213     abort ();
2214   return s->sy_next;
2215 }
2216
2217 /* Return a pointer to the value of a symbol as an expression.  */
2218
2219 expressionS *
2220 symbol_get_value_expression (symbolS *s)
2221 {
2222   if (LOCAL_SYMBOL_CHECK (s))
2223     s = local_symbol_convert ((struct local_symbol *) s);
2224   return &s->sy_value;
2225 }
2226
2227 /* Set the value of a symbol to an expression.  */
2228
2229 void
2230 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2231 {
2232   if (LOCAL_SYMBOL_CHECK (s))
2233     s = local_symbol_convert ((struct local_symbol *) s);
2234   s->sy_value = *exp;
2235   S_CLEAR_WEAKREFR (s);
2236 }
2237
2238 /* Return a pointer to the X_add_number component of a symbol.  */
2239
2240 offsetT *
2241 symbol_X_add_number (symbolS *s)
2242 {
2243   if (LOCAL_SYMBOL_CHECK (s))
2244     return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2245
2246   return &s->sy_value.X_add_number;
2247 }
2248
2249 /* Set the value of SYM to the current position in the current segment.  */
2250
2251 void
2252 symbol_set_value_now (symbolS *sym)
2253 {
2254   S_SET_SEGMENT (sym, now_seg);
2255   S_SET_VALUE (sym, frag_now_fix ());
2256   symbol_set_frag (sym, frag_now);
2257 }
2258
2259 /* Set the frag of a symbol.  */
2260
2261 void
2262 symbol_set_frag (symbolS *s, fragS *f)
2263 {
2264   if (LOCAL_SYMBOL_CHECK (s))
2265     {
2266       local_symbol_set_frag ((struct local_symbol *) s, f);
2267       return;
2268     }
2269   s->sy_frag = f;
2270   S_CLEAR_WEAKREFR (s);
2271 }
2272
2273 /* Return the frag of a symbol.  */
2274
2275 fragS *
2276 symbol_get_frag (symbolS *s)
2277 {
2278   if (LOCAL_SYMBOL_CHECK (s))
2279     return local_symbol_get_frag ((struct local_symbol *) s);
2280   return s->sy_frag;
2281 }
2282
2283 /* Mark a symbol as having been used.  */
2284
2285 void
2286 symbol_mark_used (symbolS *s)
2287 {
2288   if (LOCAL_SYMBOL_CHECK (s))
2289     return;
2290   s->sy_used = 1;
2291   if (S_IS_WEAKREFR (s))
2292     symbol_mark_used (s->sy_value.X_add_symbol);
2293 }
2294
2295 /* Clear the mark of whether a symbol has been used.  */
2296
2297 void
2298 symbol_clear_used (symbolS *s)
2299 {
2300   if (LOCAL_SYMBOL_CHECK (s))
2301     s = local_symbol_convert ((struct local_symbol *) s);
2302   s->sy_used = 0;
2303 }
2304
2305 /* Return whether a symbol has been used.  */
2306
2307 int
2308 symbol_used_p (symbolS *s)
2309 {
2310   if (LOCAL_SYMBOL_CHECK (s))
2311     return 1;
2312   return s->sy_used;
2313 }
2314
2315 /* Mark a symbol as having been used in a reloc.  */
2316
2317 void
2318 symbol_mark_used_in_reloc (symbolS *s)
2319 {
2320   if (LOCAL_SYMBOL_CHECK (s))
2321     s = local_symbol_convert ((struct local_symbol *) s);
2322   s->sy_used_in_reloc = 1;
2323 }
2324
2325 /* Clear the mark of whether a symbol has been used in a reloc.  */
2326
2327 void
2328 symbol_clear_used_in_reloc (symbolS *s)
2329 {
2330   if (LOCAL_SYMBOL_CHECK (s))
2331     return;
2332   s->sy_used_in_reloc = 0;
2333 }
2334
2335 /* Return whether a symbol has been used in a reloc.  */
2336
2337 int
2338 symbol_used_in_reloc_p (symbolS *s)
2339 {
2340   if (LOCAL_SYMBOL_CHECK (s))
2341     return 0;
2342   return s->sy_used_in_reloc;
2343 }
2344
2345 /* Mark a symbol as an MRI common symbol.  */
2346
2347 void
2348 symbol_mark_mri_common (symbolS *s)
2349 {
2350   if (LOCAL_SYMBOL_CHECK (s))
2351     s = local_symbol_convert ((struct local_symbol *) s);
2352   s->sy_mri_common = 1;
2353 }
2354
2355 /* Clear the mark of whether a symbol is an MRI common symbol.  */
2356
2357 void
2358 symbol_clear_mri_common (symbolS *s)
2359 {
2360   if (LOCAL_SYMBOL_CHECK (s))
2361     return;
2362   s->sy_mri_common = 0;
2363 }
2364
2365 /* Return whether a symbol is an MRI common symbol.  */
2366
2367 int
2368 symbol_mri_common_p (symbolS *s)
2369 {
2370   if (LOCAL_SYMBOL_CHECK (s))
2371     return 0;
2372   return s->sy_mri_common;
2373 }
2374
2375 /* Mark a symbol as having been written.  */
2376
2377 void
2378 symbol_mark_written (symbolS *s)
2379 {
2380   if (LOCAL_SYMBOL_CHECK (s))
2381     return;
2382   s->written = 1;
2383 }
2384
2385 /* Clear the mark of whether a symbol has been written.  */
2386
2387 void
2388 symbol_clear_written (symbolS *s)
2389 {
2390   if (LOCAL_SYMBOL_CHECK (s))
2391     return;
2392   s->written = 0;
2393 }
2394
2395 /* Return whether a symbol has been written.  */
2396
2397 int
2398 symbol_written_p (symbolS *s)
2399 {
2400   if (LOCAL_SYMBOL_CHECK (s))
2401     return 0;
2402   return s->written;
2403 }
2404
2405 /* Mark a symbol has having been resolved.  */
2406
2407 void
2408 symbol_mark_resolved (symbolS *s)
2409 {
2410   if (LOCAL_SYMBOL_CHECK (s))
2411     {
2412       local_symbol_mark_resolved ((struct local_symbol *) s);
2413       return;
2414     }
2415   s->sy_resolved = 1;
2416 }
2417
2418 /* Return whether a symbol has been resolved.  */
2419
2420 int
2421 symbol_resolved_p (symbolS *s)
2422 {
2423   if (LOCAL_SYMBOL_CHECK (s))
2424     return local_symbol_resolved_p ((struct local_symbol *) s);
2425   return s->sy_resolved;
2426 }
2427
2428 /* Return whether a symbol is a section symbol.  */
2429
2430 int
2431 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2432 {
2433   if (LOCAL_SYMBOL_CHECK (s))
2434     return 0;
2435   return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2436 }
2437
2438 /* Return whether a symbol is equated to another symbol.  */
2439
2440 int
2441 symbol_equated_p (symbolS *s)
2442 {
2443   if (LOCAL_SYMBOL_CHECK (s))
2444     return 0;
2445   return s->sy_value.X_op == O_symbol;
2446 }
2447
2448 /* Return whether a symbol is equated to another symbol, and should be
2449    treated specially when writing out relocs.  */
2450
2451 int
2452 symbol_equated_reloc_p (symbolS *s)
2453 {
2454   if (LOCAL_SYMBOL_CHECK (s))
2455     return 0;
2456   /* X_op_symbol, normally not used for O_symbol, is set by
2457      resolve_symbol_value to flag expression syms that have been
2458      equated.  */
2459   return (s->sy_value.X_op == O_symbol
2460 #if defined (OBJ_COFF) && defined (TE_PE)
2461           && ! S_IS_WEAK (s)
2462 #endif
2463           && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2464               || ! S_IS_DEFINED (s)
2465               || S_IS_COMMON (s)));
2466 }
2467
2468 /* Return whether a symbol has a constant value.  */
2469
2470 int
2471 symbol_constant_p (symbolS *s)
2472 {
2473   if (LOCAL_SYMBOL_CHECK (s))
2474     return 1;
2475   return s->sy_value.X_op == O_constant;
2476 }
2477
2478 /* Return the BFD symbol for a symbol.  */
2479
2480 asymbol *
2481 symbol_get_bfdsym (symbolS *s)
2482 {
2483   if (LOCAL_SYMBOL_CHECK (s))
2484     s = local_symbol_convert ((struct local_symbol *) s);
2485   return s->bsym;
2486 }
2487
2488 /* Set the BFD symbol for a symbol.  */
2489
2490 void
2491 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2492 {
2493   if (LOCAL_SYMBOL_CHECK (s))
2494     s = local_symbol_convert ((struct local_symbol *) s);
2495   /* Usually, it is harmless to reset a symbol to a BFD section
2496      symbol. For example, obj_elf_change_section sets the BFD symbol
2497      of an old symbol with the newly created section symbol. But when
2498      we have multiple sections with the same name, the newly created
2499      section may have the same name as an old section. We check if the
2500      old symbol has been already marked as a section symbol before
2501      resetting it.  */
2502   if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2503     s->bsym = bsym;
2504   /* else XXX - What do we do now ?  */
2505 }
2506
2507 #ifdef OBJ_SYMFIELD_TYPE
2508
2509 /* Get a pointer to the object format information for a symbol.  */
2510
2511 OBJ_SYMFIELD_TYPE *
2512 symbol_get_obj (symbolS *s)
2513 {
2514   if (LOCAL_SYMBOL_CHECK (s))
2515     s = local_symbol_convert ((struct local_symbol *) s);
2516   return &s->sy_obj;
2517 }
2518
2519 /* Set the object format information for a symbol.  */
2520
2521 void
2522 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2523 {
2524   if (LOCAL_SYMBOL_CHECK (s))
2525     s = local_symbol_convert ((struct local_symbol *) s);
2526   s->sy_obj = *o;
2527 }
2528
2529 #endif /* OBJ_SYMFIELD_TYPE */
2530
2531 #ifdef TC_SYMFIELD_TYPE
2532
2533 /* Get a pointer to the processor information for a symbol.  */
2534
2535 TC_SYMFIELD_TYPE *
2536 symbol_get_tc (symbolS *s)
2537 {
2538   if (LOCAL_SYMBOL_CHECK (s))
2539     s = local_symbol_convert ((struct local_symbol *) s);
2540   return &s->sy_tc;
2541 }
2542
2543 /* Set the processor information for a symbol.  */
2544
2545 void
2546 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2547 {
2548   if (LOCAL_SYMBOL_CHECK (s))
2549     s = local_symbol_convert ((struct local_symbol *) s);
2550   s->sy_tc = *o;
2551 }
2552
2553 #endif /* TC_SYMFIELD_TYPE */
2554
2555 void
2556 symbol_begin (void)
2557 {
2558   symbol_lastP = NULL;
2559   symbol_rootP = NULL;          /* In case we have 0 symbols (!!)  */
2560   sy_hash = hash_new ();
2561   local_hash = hash_new ();
2562
2563   memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2564 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2565   abs_symbol.bsym = bfd_abs_section.symbol;
2566 #endif
2567   abs_symbol.sy_value.X_op = O_constant;
2568   abs_symbol.sy_frag = &zero_address_frag;
2569
2570   if (LOCAL_LABELS_FB)
2571     fb_label_init ();
2572 }
2573 \f
2574 int indent_level;
2575
2576 /* Maximum indent level.
2577    Available for modification inside a gdb session.  */
2578 static int max_indent_level = 8;
2579
2580 void
2581 print_symbol_value_1 (FILE *file, symbolS *sym)
2582 {
2583   const char *name = S_GET_NAME (sym);
2584   if (!name || !name[0])
2585     name = "(unnamed)";
2586   fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2587
2588   if (LOCAL_SYMBOL_CHECK (sym))
2589     {
2590       struct local_symbol *locsym = (struct local_symbol *) sym;
2591       if (local_symbol_get_frag (locsym) != &zero_address_frag
2592           && local_symbol_get_frag (locsym) != NULL)
2593         fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2594       if (local_symbol_resolved_p (locsym))
2595         fprintf (file, " resolved");
2596       fprintf (file, " local");
2597     }
2598   else
2599     {
2600       if (sym->sy_frag != &zero_address_frag)
2601         fprintf (file, " frag %lx", (long) sym->sy_frag);
2602       if (sym->written)
2603         fprintf (file, " written");
2604       if (sym->sy_resolved)
2605         fprintf (file, " resolved");
2606       else if (sym->sy_resolving)
2607         fprintf (file, " resolving");
2608       if (sym->sy_used_in_reloc)
2609         fprintf (file, " used-in-reloc");
2610       if (sym->sy_used)
2611         fprintf (file, " used");
2612       if (S_IS_LOCAL (sym))
2613         fprintf (file, " local");
2614       if (S_IS_EXTERNAL (sym))
2615         fprintf (file, " extern");
2616       if (S_IS_WEAK (sym))
2617         fprintf (file, " weak");
2618       if (S_IS_DEBUG (sym))
2619         fprintf (file, " debug");
2620       if (S_IS_DEFINED (sym))
2621         fprintf (file, " defined");
2622     }
2623   if (S_IS_WEAKREFR (sym))
2624     fprintf (file, " weakrefr");
2625   if (S_IS_WEAKREFD (sym))
2626     fprintf (file, " weakrefd");
2627   fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2628   if (symbol_resolved_p (sym))
2629     {
2630       segT s = S_GET_SEGMENT (sym);
2631
2632       if (s != undefined_section
2633           && s != expr_section)
2634         fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2635     }
2636   else if (indent_level < max_indent_level
2637            && S_GET_SEGMENT (sym) != undefined_section)
2638     {
2639       indent_level++;
2640       fprintf (file, "\n%*s<", indent_level * 4, "");
2641       if (LOCAL_SYMBOL_CHECK (sym))
2642         fprintf (file, "constant %lx",
2643                  (long) ((struct local_symbol *) sym)->lsy_value);
2644       else
2645         print_expr_1 (file, &sym->sy_value);
2646       fprintf (file, ">");
2647       indent_level--;
2648     }
2649   fflush (file);
2650 }
2651
2652 void
2653 print_symbol_value (symbolS *sym)
2654 {
2655   indent_level = 0;
2656   print_symbol_value_1 (stderr, sym);
2657   fprintf (stderr, "\n");
2658 }
2659
2660 static void
2661 print_binary (FILE *file, const char *name, expressionS *exp)
2662 {
2663   indent_level++;
2664   fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2665   print_symbol_value_1 (file, exp->X_add_symbol);
2666   fprintf (file, ">\n%*s<", indent_level * 4, "");
2667   print_symbol_value_1 (file, exp->X_op_symbol);
2668   fprintf (file, ">");
2669   indent_level--;
2670 }
2671
2672 void
2673 print_expr_1 (FILE *file, expressionS *exp)
2674 {
2675   fprintf (file, "expr %lx ", (long) exp);
2676   switch (exp->X_op)
2677     {
2678     case O_illegal:
2679       fprintf (file, "illegal");
2680       break;
2681     case O_absent:
2682       fprintf (file, "absent");
2683       break;
2684     case O_constant:
2685       fprintf (file, "constant %lx", (long) exp->X_add_number);
2686       break;
2687     case O_symbol:
2688       indent_level++;
2689       fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2690       print_symbol_value_1 (file, exp->X_add_symbol);
2691       fprintf (file, ">");
2692     maybe_print_addnum:
2693       if (exp->X_add_number)
2694         fprintf (file, "\n%*s%lx", indent_level * 4, "",
2695                  (long) exp->X_add_number);
2696       indent_level--;
2697       break;
2698     case O_register:
2699       fprintf (file, "register #%d", (int) exp->X_add_number);
2700       break;
2701     case O_big:
2702       fprintf (file, "big");
2703       break;
2704     case O_uminus:
2705       fprintf (file, "uminus -<");
2706       indent_level++;
2707       print_symbol_value_1 (file, exp->X_add_symbol);
2708       fprintf (file, ">");
2709       goto maybe_print_addnum;
2710     case O_bit_not:
2711       fprintf (file, "bit_not");
2712       break;
2713     case O_multiply:
2714       print_binary (file, "multiply", exp);
2715       break;
2716     case O_divide:
2717       print_binary (file, "divide", exp);
2718       break;
2719     case O_modulus:
2720       print_binary (file, "modulus", exp);
2721       break;
2722     case O_left_shift:
2723       print_binary (file, "lshift", exp);
2724       break;
2725     case O_right_shift:
2726       print_binary (file, "rshift", exp);
2727       break;
2728     case O_bit_inclusive_or:
2729       print_binary (file, "bit_ior", exp);
2730       break;
2731     case O_bit_exclusive_or:
2732       print_binary (file, "bit_xor", exp);
2733       break;
2734     case O_bit_and:
2735       print_binary (file, "bit_and", exp);
2736       break;
2737     case O_eq:
2738       print_binary (file, "eq", exp);
2739       break;
2740     case O_ne:
2741       print_binary (file, "ne", exp);
2742       break;
2743     case O_lt:
2744       print_binary (file, "lt", exp);
2745       break;
2746     case O_le:
2747       print_binary (file, "le", exp);
2748       break;
2749     case O_ge:
2750       print_binary (file, "ge", exp);
2751       break;
2752     case O_gt:
2753       print_binary (file, "gt", exp);
2754       break;
2755     case O_logical_and:
2756       print_binary (file, "logical_and", exp);
2757       break;
2758     case O_logical_or:
2759       print_binary (file, "logical_or", exp);
2760       break;
2761     case O_add:
2762       indent_level++;
2763       fprintf (file, "add\n%*s<", indent_level * 4, "");
2764       print_symbol_value_1 (file, exp->X_add_symbol);
2765       fprintf (file, ">\n%*s<", indent_level * 4, "");
2766       print_symbol_value_1 (file, exp->X_op_symbol);
2767       fprintf (file, ">");
2768       goto maybe_print_addnum;
2769     case O_subtract:
2770       indent_level++;
2771       fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2772       print_symbol_value_1 (file, exp->X_add_symbol);
2773       fprintf (file, ">\n%*s<", indent_level * 4, "");
2774       print_symbol_value_1 (file, exp->X_op_symbol);
2775       fprintf (file, ">");
2776       goto maybe_print_addnum;
2777     default:
2778       fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2779       break;
2780     }
2781   fflush (stdout);
2782 }
2783
2784 void
2785 print_expr (expressionS *exp)
2786 {
2787   print_expr_1 (stderr, exp);
2788   fprintf (stderr, "\n");
2789 }
2790
2791 void
2792 symbol_print_statistics (FILE *file)
2793 {
2794   hash_print_statistics (file, "symbol table", sy_hash);
2795   hash_print_statistics (file, "mini local symbol table", local_hash);
2796   fprintf (file, "%lu mini local symbols created, %lu converted\n",
2797            local_symbol_count, local_symbol_conversion_count);
2798 }