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