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