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