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