gas/symbols.c

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