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