1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
27 #include "safe-ctype.h"
28 #include "obstack.h" /* For "symbols.h" */
31 #include "struc-symbol.h"
33 /* This is non-zero if symbols are case sensitive, which is the
35 int symbols_case_sensitive = 1;
37 #ifndef WORKING_DOT_WORD
38 extern int new_broken_words;
41 /* symbol-name => struct symbol pointer */
42 static struct hash_control *sy_hash;
44 /* Table of local symbols. */
45 static struct hash_control *local_hash;
47 /* Below are commented in "symbols.h". */
48 symbolS *symbol_rootP;
49 symbolS *symbol_lastP;
53 #define debug_verify_symchain verify_symbol_chain
55 #define debug_verify_symchain(root, last) ((void) 0)
58 #define DOLLAR_LABEL_CHAR '\001'
59 #define LOCAL_LABEL_CHAR '\002'
63 /* The name of an external symbol which is
64 used to make weak PE symbol names unique. */
65 const char * an_external_name;
68 static char *save_symbol_name (const char *);
69 static void fb_label_init (void);
70 static long dollar_label_instance (long);
71 static long fb_label_instance (long);
73 static void print_binary (FILE *, const char *, expressionS *);
74 static void report_op_error (symbolS *, symbolS *, symbolS *);
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
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. */
86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
88 symbolS *symbolP = symbol_create (name, segment, valu, frag);
90 /* Link to end of symbol chain. */
92 extern int symbol_table_frozen;
93 if (symbol_table_frozen)
96 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
101 /* Save a symbol name on a permanent obstack, and convert it according
102 to the object file format. */
105 save_symbol_name (const char *name)
107 unsigned int name_length;
110 name_length = strlen (name) + 1; /* +1 for \0. */
111 obstack_grow (¬es, name, name_length);
112 ret = (char *) obstack_finish (¬es);
114 #ifdef tc_canonicalize_symbol_name
115 ret = tc_canonicalize_symbol_name (ret);
118 if (! symbols_case_sensitive)
122 for (s = ret; *s != '\0'; s++)
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. */)
135 char *preserved_copy_of_name;
138 preserved_copy_of_name = save_symbol_name (name);
140 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP, 0, sizeof (symbolS));
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);
150 S_SET_SEGMENT (symbolP, segment);
151 S_SET_VALUE (symbolP, valu);
152 symbol_clear_list_pointers (symbolP);
154 symbolP->sy_frag = frag;
156 obj_symbol_new_hook (symbolP);
158 #ifdef tc_symbol_new_hook
159 tc_symbol_new_hook (symbolP);
166 /* Local symbol support. If we can get away with it, we keep only a
167 small amount of information for local symbols. */
169 static symbolS *local_symbol_convert (struct local_symbol *);
171 /* Used for statistics. */
173 static unsigned long local_symbol_count;
174 static unsigned long local_symbol_conversion_count;
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. */
180 #define LOCAL_SYMBOL_CHECK(s) \
182 ? (local_symbol_converted_p ((struct local_symbol *) s) \
183 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
188 /* Create a local symbol and insert it into the local hash table. */
190 static struct local_symbol *
191 local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
194 struct local_symbol *ret;
196 ++local_symbol_count;
198 name_copy = save_symbol_name (name);
200 ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
201 ret->lsy_marker = NULL;
202 ret->lsy_name = name_copy;
203 ret->lsy_section = section;
204 local_symbol_set_frag (ret, frag);
205 ret->lsy_value = value;
207 hash_jam (local_hash, name_copy, (void *) ret);
212 /* Convert a local symbol into a real symbol. Note that we do not
213 reclaim the space used by the local symbol. */
216 local_symbol_convert (struct local_symbol *locsym)
220 gas_assert (locsym->lsy_marker == NULL);
221 if (local_symbol_converted_p (locsym))
222 return local_symbol_get_real_symbol (locsym);
224 ++local_symbol_conversion_count;
226 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
227 local_symbol_get_frag (locsym));
229 if (local_symbol_resolved_p (locsym))
230 ret->sy_resolved = 1;
232 /* Local symbols are always either defined or used. */
235 #ifdef TC_LOCAL_SYMFIELD_CONVERT
236 TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
239 symbol_table_insert (ret);
241 local_symbol_mark_converted (locsym);
242 local_symbol_set_real_symbol (locsym, ret);
244 hash_jam (local_hash, locsym->lsy_name, NULL);
250 define_sym_at_dot (symbolS *symbolP)
252 symbolP->sy_frag = frag_now;
254 S_SET_OTHER (symbolP, const_flag);
256 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
257 S_SET_SEGMENT (symbolP, now_seg);
260 /* We have just seen "<name>:".
261 Creates a struct symbol unless it already exists.
263 Gripes if we are redefining a symbol incompatibly (and ignores it). */
266 colon (/* Just seen "x:" - rattle symbols & frags. */
267 const char *sym_name /* Symbol name, as a cannonical string. */
268 /* We copy this string: OK to alter later. */)
270 register symbolS *symbolP; /* Symbol we are working with. */
272 /* Sun local labels go out of scope whenever a non-local symbol is
274 if (LOCAL_LABELS_DOLLAR
275 && !bfd_is_local_label_name (stdoutput, sym_name))
276 dollar_label_clear ();
278 #ifndef WORKING_DOT_WORD
279 if (new_broken_words)
281 struct broken_word *a;
286 if (now_seg == absolute_section)
288 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
292 possible_bytes = (md_short_jump_size
293 + new_broken_words * md_long_jump_size);
296 frag_opcode = frag_var (rs_broken_word,
300 (symbolS *) broken_words,
304 /* We want to store the pointer to where to insert the jump
305 table in the fr_opcode of the rs_broken_word frag. This
306 requires a little hackery. */
308 && (frag_tmp->fr_type != rs_broken_word
309 || frag_tmp->fr_opcode))
310 frag_tmp = frag_tmp->fr_next;
312 frag_tmp->fr_opcode = frag_opcode;
313 new_broken_words = 0;
315 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
316 a->dispfrag = frag_tmp;
318 #endif /* WORKING_DOT_WORD */
320 if ((symbolP = symbol_find (sym_name)) != 0)
322 S_CLEAR_WEAKREFR (symbolP);
323 #ifdef RESOLVE_SYMBOL_REDEFINITION
324 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
327 /* Now check for undefined symbols. */
328 if (LOCAL_SYMBOL_CHECK (symbolP))
330 struct local_symbol *locsym = (struct local_symbol *) symbolP;
332 if (locsym->lsy_section != undefined_section
333 && (local_symbol_get_frag (locsym) != frag_now
334 || locsym->lsy_section != now_seg
335 || locsym->lsy_value != frag_now_fix ()))
337 as_bad (_("symbol `%s' is already defined"), sym_name);
341 locsym->lsy_section = now_seg;
342 local_symbol_set_frag (locsym, frag_now);
343 locsym->lsy_value = frag_now_fix ();
345 else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
346 || S_IS_COMMON (symbolP)
347 || S_IS_VOLATILE (symbolP))
349 if (S_IS_VOLATILE (symbolP))
351 symbolP = symbol_clone (symbolP, 1);
352 S_SET_VALUE (symbolP, 0);
353 S_CLEAR_VOLATILE (symbolP);
355 if (S_GET_VALUE (symbolP) == 0)
357 define_sym_at_dot (symbolP);
360 #endif /* if we have one, it better be zero. */
365 /* There are still several cases to check:
367 A .comm/.lcomm symbol being redefined as initialized
370 A .comm/.lcomm symbol being redefined with a larger
373 This only used to be allowed on VMS gas, but Sun cc
374 on the sparc also depends on it. */
376 if (((!S_IS_DEBUG (symbolP)
377 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
378 && S_IS_EXTERNAL (symbolP))
379 || S_GET_SEGMENT (symbolP) == bss_section)
380 && (now_seg == data_section
381 || now_seg == bss_section
382 || now_seg == S_GET_SEGMENT (symbolP)))
384 /* Select which of the 2 cases this is. */
385 if (now_seg != data_section)
387 /* New .comm for prev .comm symbol.
389 If the new size is larger we just change its
390 value. If the new size is smaller, we ignore
392 if (S_GET_VALUE (symbolP)
393 < ((unsigned) frag_now_fix ()))
395 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
400 /* It is a .comm/.lcomm being converted to initialized
402 define_sym_at_dot (symbolP);
407 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
408 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
409 static const char *od_buf = "";
413 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
414 sprintf (od_buf, "%d.%d.",
415 S_GET_OTHER (symbolP),
416 S_GET_DESC (symbolP));
418 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
420 segment_name (S_GET_SEGMENT (symbolP)),
422 (long) S_GET_VALUE (symbolP));
424 } /* if the undefined symbol has no value */
428 /* Don't blow up if the definition is the same. */
429 if (!(frag_now == symbolP->sy_frag
430 && S_GET_VALUE (symbolP) == frag_now_fix ()
431 && S_GET_SEGMENT (symbolP) == now_seg))
433 as_bad (_("symbol `%s' is already defined"), sym_name);
434 symbolP = symbol_clone (symbolP, 0);
435 define_sym_at_dot (symbolP);
440 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
442 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
443 (valueT) frag_now_fix (),
448 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
451 S_SET_OTHER (symbolP, const_flag);
454 symbol_table_insert (symbolP);
457 if (mri_common_symbol != NULL)
459 /* This symbol is actually being defined within an MRI common
460 section. This requires special handling. */
461 if (LOCAL_SYMBOL_CHECK (symbolP))
462 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
463 symbolP->sy_value.X_op = O_symbol;
464 symbolP->sy_value.X_add_symbol = mri_common_symbol;
465 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
466 symbolP->sy_frag = &zero_address_frag;
467 S_SET_SEGMENT (symbolP, expr_section);
468 symbolP->sy_mri_common = 1;
472 tc_frob_label (symbolP);
474 #ifdef obj_frob_label
475 obj_frob_label (symbolP);
481 /* Die if we can't insert the symbol. */
484 symbol_table_insert (symbolS *symbolP)
486 register const char *error_string;
489 know (S_GET_NAME (symbolP));
491 if (LOCAL_SYMBOL_CHECK (symbolP))
493 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
495 if (error_string != NULL)
496 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
497 S_GET_NAME (symbolP), error_string);
501 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
503 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
504 S_GET_NAME (symbolP), error_string);
508 /* If a symbol name does not exist, create it as undefined, and insert
509 it into the symbol table. Return a pointer to it. */
512 symbol_find_or_make (const char *name)
514 register symbolS *symbolP;
516 symbolP = symbol_find (name);
520 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
522 symbolP = md_undefined_symbol ((char *) name);
526 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
532 symbolP = symbol_make (name);
534 symbol_table_insert (symbolP);
535 } /* if symbol wasn't found */
541 symbol_make (const char *name)
545 /* Let the machine description default it, e.g. for register names. */
546 symbolP = md_undefined_symbol ((char *) name);
549 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
555 symbol_clone (symbolS *orgsymP, int replace)
558 asymbol *bsymorg, *bsymnew;
560 /* Running local_symbol_convert on a clone that's not the one currently
561 in local_hash would incorrectly replace the hash entry. Thus the
562 symbol must be converted here. Note that the rest of the function
563 depends on not encountering an unconverted symbol. */
564 if (LOCAL_SYMBOL_CHECK (orgsymP))
565 orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
566 bsymorg = orgsymP->bsym;
568 newsymP = (symbolS *) obstack_alloc (¬es, sizeof (*newsymP));
570 bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
572 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
573 newsymP->bsym = bsymnew;
574 bsymnew->name = bsymorg->name;
575 bsymnew->flags = bsymorg->flags;
576 bsymnew->section = bsymorg->section;
577 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
578 bfd_asymbol_bfd (bsymnew), bsymnew);
580 #ifdef obj_symbol_clone_hook
581 obj_symbol_clone_hook (newsymP, orgsymP);
584 #ifdef tc_symbol_clone_hook
585 tc_symbol_clone_hook (newsymP, orgsymP);
590 if (symbol_rootP == orgsymP)
591 symbol_rootP = newsymP;
592 else if (orgsymP->sy_previous)
594 orgsymP->sy_previous->sy_next = newsymP;
595 orgsymP->sy_previous = NULL;
597 if (symbol_lastP == orgsymP)
598 symbol_lastP = newsymP;
599 else if (orgsymP->sy_next)
600 orgsymP->sy_next->sy_previous = newsymP;
602 /* Symbols that won't be output can't be external. */
603 S_CLEAR_EXTERNAL (orgsymP);
604 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
605 debug_verify_symchain (symbol_rootP, symbol_lastP);
607 symbol_table_insert (newsymP);
611 /* Symbols that won't be output can't be external. */
612 S_CLEAR_EXTERNAL (newsymP);
613 newsymP->sy_previous = newsymP->sy_next = newsymP;
619 /* Referenced symbols, if they are forward references, need to be cloned
620 (without replacing the original) so that the value of the referenced
621 symbols at the point of use . */
623 #undef symbol_clone_if_forward_ref
625 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
627 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
629 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
630 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
632 if (symbolP->sy_forward_ref)
637 /* assign_symbol() clones volatile symbols; pre-existing expressions
638 hold references to the original instance, but want the current
639 value. Just repeat the lookup. */
640 if (add_symbol && S_IS_VOLATILE (add_symbol))
641 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
642 if (op_symbol && S_IS_VOLATILE (op_symbol))
643 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
646 /* Re-using sy_resolving here, as this routine cannot get called from
647 symbol resolution code. */
648 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
650 symbolP->sy_resolving = 1;
651 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
652 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
653 symbolP->sy_resolving = 0;
656 if (symbolP->sy_forward_ref
657 || add_symbol != symbolP->sy_value.X_add_symbol
658 || op_symbol != symbolP->sy_value.X_op_symbol)
659 symbolP = symbol_clone (symbolP, 0);
661 symbolP->sy_value.X_add_symbol = add_symbol;
662 symbolP->sy_value.X_op_symbol = op_symbol;
669 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
671 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
675 symbol_temp_new_now (void)
677 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
681 symbol_temp_make (void)
683 return symbol_make (FAKE_LABEL_NAME);
686 /* Implement symbol table lookup.
687 In: A symbol's name as a string: '\0' can't be part of a symbol name.
688 Out: NULL if the name was not in the symbol table, else the address
689 of a struct symbol associated with that name. */
692 symbol_find_exact (const char *name)
694 return symbol_find_exact_noref (name, 0);
698 symbol_find_exact_noref (const char *name, int noref)
700 struct local_symbol *locsym;
703 locsym = (struct local_symbol *) hash_find (local_hash, name);
705 return (symbolS *) locsym;
707 sym = ((symbolS *) hash_find (sy_hash, name));
709 /* Any references to the symbol, except for the reference in
710 .weakref, must clear this flag, such that the symbol does not
711 turn into a weak symbol. Note that we don't have to handle the
712 local_symbol case, since a weakrefd is always promoted out of the
713 local_symbol table when it is turned into a weak symbol. */
715 S_CLEAR_WEAKREFD (sym);
721 symbol_find (const char *name)
723 return symbol_find_noref (name, 0);
727 symbol_find_noref (const char *name, int noref)
729 #ifdef tc_canonicalize_symbol_name
732 size_t len = strlen (name) + 1;
734 copy = (char *) alloca (len);
735 memcpy (copy, name, len);
736 name = tc_canonicalize_symbol_name (copy);
740 if (! symbols_case_sensitive)
747 name = copy = (char *) alloca (strlen (name) + 1);
749 while ((c = *orig++) != '\0')
751 *copy++ = TOUPPER (c);
756 return symbol_find_exact_noref (name, noref);
759 /* Once upon a time, symbols were kept in a singly linked list. At
760 least coff needs to be able to rearrange them from time to time, for
761 which a doubly linked list is much more convenient. Loic did these
762 as macros which seemed dangerous to me so they're now functions.
765 /* Link symbol ADDME after symbol TARGET in the chain. */
768 symbol_append (symbolS *addme, symbolS *target,
769 symbolS **rootPP, symbolS **lastPP)
771 if (LOCAL_SYMBOL_CHECK (addme))
773 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
778 know (*rootPP == NULL);
779 know (*lastPP == NULL);
780 addme->sy_next = NULL;
781 addme->sy_previous = NULL;
785 } /* if the list is empty */
787 if (target->sy_next != NULL)
789 target->sy_next->sy_previous = addme;
793 know (*lastPP == target);
795 } /* if we have a next */
797 addme->sy_next = target->sy_next;
798 target->sy_next = addme;
799 addme->sy_previous = target;
801 debug_verify_symchain (symbol_rootP, symbol_lastP);
804 /* Set the chain pointers of SYMBOL to null. */
807 symbol_clear_list_pointers (symbolS *symbolP)
809 if (LOCAL_SYMBOL_CHECK (symbolP))
811 symbolP->sy_next = NULL;
812 symbolP->sy_previous = NULL;
815 /* Remove SYMBOLP from the list. */
818 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
820 if (LOCAL_SYMBOL_CHECK (symbolP))
823 if (symbolP == *rootPP)
825 *rootPP = symbolP->sy_next;
826 } /* if it was the root */
828 if (symbolP == *lastPP)
830 *lastPP = symbolP->sy_previous;
831 } /* if it was the tail */
833 if (symbolP->sy_next != NULL)
835 symbolP->sy_next->sy_previous = symbolP->sy_previous;
838 if (symbolP->sy_previous != NULL)
840 symbolP->sy_previous->sy_next = symbolP->sy_next;
843 debug_verify_symchain (*rootPP, *lastPP);
846 /* Link symbol ADDME before symbol TARGET in the chain. */
849 symbol_insert (symbolS *addme, symbolS *target,
850 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
852 if (LOCAL_SYMBOL_CHECK (addme))
854 if (LOCAL_SYMBOL_CHECK (target))
857 if (target->sy_previous != NULL)
859 target->sy_previous->sy_next = addme;
863 know (*rootPP == target);
867 addme->sy_previous = target->sy_previous;
868 target->sy_previous = addme;
869 addme->sy_next = target;
871 debug_verify_symchain (*rootPP, *lastPP);
875 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
877 symbolS *symbolP = rootP;
882 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
884 gas_assert (symbolP->bsym != NULL);
885 gas_assert (symbolP->sy_next->sy_previous == symbolP);
888 gas_assert (lastP == symbolP);
891 #ifdef OBJ_COMPLEX_RELC
894 use_complex_relocs_for (symbolS * symp)
896 switch (symp->sy_value.X_op)
906 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
907 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
909 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
910 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
919 case O_bit_inclusive_or:
921 case O_bit_exclusive_or:
934 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
935 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
937 (S_IS_COMMON (symp->sy_value.X_op_symbol)
938 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
940 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
941 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
942 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
943 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
955 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
959 segT seg_left = S_GET_SEGMENT (left);
960 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
962 if (expr_symbol_where (symp, &file, &line))
964 if (seg_left == undefined_section)
965 as_bad_where (file, line,
966 _("undefined symbol `%s' in operation"),
968 if (seg_right == undefined_section)
969 as_bad_where (file, line,
970 _("undefined symbol `%s' in operation"),
972 if (seg_left != undefined_section
973 && seg_right != undefined_section)
976 as_bad_where (file, line,
977 _("invalid sections for operation on `%s' and `%s'"),
978 S_GET_NAME (left), S_GET_NAME (right));
980 as_bad_where (file, line,
981 _("invalid section for operation on `%s'"),
988 if (seg_left == undefined_section)
989 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
990 S_GET_NAME (left), S_GET_NAME (symp));
991 if (seg_right == undefined_section)
992 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
993 S_GET_NAME (right), S_GET_NAME (symp));
994 if (seg_left != undefined_section
995 && seg_right != undefined_section)
998 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
999 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
1001 as_bad (_("invalid section for operation on `%s' setting `%s'"),
1002 S_GET_NAME (left), S_GET_NAME (symp));
1007 /* Resolve the value of a symbol. This is called during the final
1008 pass over the symbol table to resolve any symbols with complex
1012 resolve_symbol_value (symbolS *symp)
1015 valueT final_val = 0;
1018 if (LOCAL_SYMBOL_CHECK (symp))
1020 struct local_symbol *locsym = (struct local_symbol *) symp;
1022 final_val = locsym->lsy_value;
1023 if (local_symbol_resolved_p (locsym))
1026 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1030 locsym->lsy_value = final_val;
1031 local_symbol_mark_resolved (locsym);
1037 if (symp->sy_resolved)
1039 if (symp->sy_value.X_op == O_constant)
1040 return (valueT) symp->sy_value.X_add_number;
1046 final_seg = S_GET_SEGMENT (symp);
1048 if (symp->sy_resolving)
1051 as_bad (_("symbol definition loop encountered at `%s'"),
1056 #ifdef OBJ_COMPLEX_RELC
1057 else if (final_seg == expr_section
1058 && use_complex_relocs_for (symp))
1060 symbolS * relc_symbol = NULL;
1061 char * relc_symbol_name = NULL;
1063 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1065 /* For debugging, print out conversion input & output. */
1067 print_expr (& symp->sy_value);
1068 if (relc_symbol_name)
1069 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1072 if (relc_symbol_name != NULL)
1073 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1074 0, & zero_address_frag);
1076 if (relc_symbol == NULL)
1078 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1084 symbol_table_insert (relc_symbol);
1086 /* S_CLEAR_EXTERNAL (relc_symbol); */
1087 if (symp->bsym->flags & BSF_SRELC)
1088 relc_symbol->bsym->flags |= BSF_SRELC;
1090 relc_symbol->bsym->flags |= BSF_RELC;
1091 /* symp->bsym->flags |= BSF_RELC; */
1092 copy_symbol_attributes (symp, relc_symbol);
1093 symp->sy_value.X_op = O_symbol;
1094 symp->sy_value.X_add_symbol = relc_symbol;
1095 symp->sy_value.X_add_number = 0;
1099 final_seg = undefined_section;
1100 goto exit_dont_set_value;
1105 symbolS *add_symbol, *op_symbol;
1106 offsetT left, right;
1107 segT seg_left, seg_right;
1111 symp->sy_resolving = 1;
1113 /* Help out with CSE. */
1114 add_symbol = symp->sy_value.X_add_symbol;
1115 op_symbol = symp->sy_value.X_op_symbol;
1116 final_val = symp->sy_value.X_add_number;
1117 op = symp->sy_value.X_op;
1130 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1131 if (final_seg == expr_section)
1132 final_seg = absolute_section;
1141 left = resolve_symbol_value (add_symbol);
1142 seg_left = S_GET_SEGMENT (add_symbol);
1144 symp->sy_value.X_op_symbol = NULL;
1147 if (S_IS_WEAKREFR (symp))
1149 gas_assert (final_val == 0);
1150 if (S_IS_WEAKREFR (add_symbol))
1152 gas_assert (add_symbol->sy_value.X_op == O_symbol
1153 && add_symbol->sy_value.X_add_number == 0);
1154 add_symbol = add_symbol->sy_value.X_add_symbol;
1155 gas_assert (! S_IS_WEAKREFR (add_symbol));
1156 symp->sy_value.X_add_symbol = add_symbol;
1160 if (symp->sy_mri_common)
1162 /* This is a symbol inside an MRI common section. The
1163 relocation routines are going to handle it specially.
1164 Don't change the value. */
1165 resolved = symbol_resolved_p (add_symbol);
1169 if (finalize_syms && final_val == 0)
1171 if (LOCAL_SYMBOL_CHECK (add_symbol))
1172 add_symbol = local_symbol_convert ((struct local_symbol *)
1174 copy_symbol_attributes (symp, add_symbol);
1177 /* If we have equated this symbol to an undefined or common
1178 symbol, keep X_op set to O_symbol, and don't change
1179 X_add_number. This permits the routine which writes out
1180 relocation to detect this case, and convert the
1181 relocation to be against the symbol to which this symbol
1183 if (! S_IS_DEFINED (add_symbol)
1184 #if defined (OBJ_COFF) && defined (TE_PE)
1185 || S_IS_WEAK (add_symbol)
1187 || S_IS_COMMON (add_symbol))
1191 symp->sy_value.X_op = O_symbol;
1192 symp->sy_value.X_add_symbol = add_symbol;
1193 symp->sy_value.X_add_number = final_val;
1194 /* Use X_op_symbol as a flag. */
1195 symp->sy_value.X_op_symbol = add_symbol;
1196 final_seg = seg_left;
1199 resolved = symbol_resolved_p (add_symbol);
1200 symp->sy_resolving = 0;
1201 goto exit_dont_set_value;
1203 else if (finalize_syms
1204 && ((final_seg == expr_section && seg_left != expr_section)
1205 || symbol_shadow_p (symp)))
1207 /* If the symbol is an expression symbol, do similarly
1208 as for undefined and common syms above. Handles
1209 "sym +/- expr" where "expr" cannot be evaluated
1210 immediately, and we want relocations to be against
1211 "sym", eg. because it is weak. */
1212 symp->sy_value.X_op = O_symbol;
1213 symp->sy_value.X_add_symbol = add_symbol;
1214 symp->sy_value.X_add_number = final_val;
1215 symp->sy_value.X_op_symbol = add_symbol;
1216 final_seg = seg_left;
1217 final_val += symp->sy_frag->fr_address + left;
1218 resolved = symbol_resolved_p (add_symbol);
1219 symp->sy_resolving = 0;
1220 goto exit_dont_set_value;
1224 final_val += symp->sy_frag->fr_address + left;
1225 if (final_seg == expr_section || final_seg == undefined_section)
1226 final_seg = seg_left;
1229 resolved = symbol_resolved_p (add_symbol);
1230 if (S_IS_WEAKREFR (symp))
1231 goto exit_dont_set_value;
1237 left = resolve_symbol_value (add_symbol);
1238 seg_left = S_GET_SEGMENT (add_symbol);
1240 /* By reducing these to the relevant dyadic operator, we get
1241 !S -> S == 0 permitted on anything,
1242 -S -> 0 - S only permitted on absolute
1243 ~S -> S ^ ~0 only permitted on absolute */
1244 if (op != O_logical_not && seg_left != absolute_section
1246 report_op_error (symp, add_symbol, NULL);
1248 if (final_seg == expr_section || final_seg == undefined_section)
1249 final_seg = absolute_section;
1253 else if (op == O_logical_not)
1258 final_val += left + symp->sy_frag->fr_address;
1260 resolved = symbol_resolved_p (add_symbol);
1268 case O_bit_inclusive_or:
1270 case O_bit_exclusive_or:
1282 left = resolve_symbol_value (add_symbol);
1283 right = resolve_symbol_value (op_symbol);
1284 seg_left = S_GET_SEGMENT (add_symbol);
1285 seg_right = S_GET_SEGMENT (op_symbol);
1287 /* Simplify addition or subtraction of a constant by folding the
1288 constant into X_add_number. */
1291 if (seg_right == absolute_section)
1296 else if (seg_left == absolute_section)
1299 add_symbol = op_symbol;
1301 seg_left = seg_right;
1305 else if (op == O_subtract)
1307 if (seg_right == absolute_section)
1315 /* Equality and non-equality tests are permitted on anything.
1316 Subtraction, and other comparison operators are permitted if
1317 both operands are in the same section. Otherwise, both
1318 operands must be absolute. We already handled the case of
1319 addition or subtraction of a constant above. This will
1320 probably need to be changed for an object file format which
1321 supports arbitrary expressions, such as IEEE-695. */
1322 if (!(seg_left == absolute_section
1323 && seg_right == absolute_section)
1324 && !(op == O_eq || op == O_ne)
1325 && !((op == O_subtract
1326 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1327 && seg_left == seg_right
1328 && (seg_left != undefined_section
1329 || add_symbol == op_symbol)))
1331 /* Don't emit messages unless we're finalizing the symbol value,
1332 otherwise we may get the same message multiple times. */
1334 report_op_error (symp, add_symbol, op_symbol);
1335 /* However do not move the symbol into the absolute section
1336 if it cannot currently be resolved - this would confuse
1337 other parts of the assembler into believing that the
1338 expression had been evaluated to zero. */
1344 && (final_seg == expr_section || final_seg == undefined_section))
1345 final_seg = absolute_section;
1347 /* Check for division by zero. */
1348 if ((op == O_divide || op == O_modulus) && right == 0)
1350 /* If seg_right is not absolute_section, then we've
1351 already issued a warning about using a bad symbol. */
1352 if (seg_right == absolute_section && finalize_syms)
1357 if (expr_symbol_where (symp, &file, &line))
1358 as_bad_where (file, line, _("division by zero"));
1360 as_bad (_("division by zero when setting `%s'"),
1367 switch (symp->sy_value.X_op)
1369 case O_multiply: left *= right; break;
1370 case O_divide: left /= right; break;
1371 case O_modulus: left %= right; break;
1372 case O_left_shift: left <<= right; break;
1373 case O_right_shift: left >>= right; break;
1374 case O_bit_inclusive_or: left |= right; break;
1375 case O_bit_or_not: left |= ~right; break;
1376 case O_bit_exclusive_or: left ^= right; break;
1377 case O_bit_and: left &= right; break;
1378 case O_add: left += right; break;
1379 case O_subtract: left -= right; break;
1382 left = (left == right && seg_left == seg_right
1383 && (seg_left != undefined_section
1384 || add_symbol == op_symbol)
1385 ? ~ (offsetT) 0 : 0);
1386 if (symp->sy_value.X_op == O_ne)
1389 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1390 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1391 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1392 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1393 case O_logical_and: left = left && right; break;
1394 case O_logical_or: left = left || right; break;
1398 final_val += symp->sy_frag->fr_address + left;
1399 if (final_seg == expr_section || final_seg == undefined_section)
1401 if (seg_left == undefined_section
1402 || seg_right == undefined_section)
1403 final_seg = undefined_section;
1404 else if (seg_left == absolute_section)
1405 final_seg = seg_right;
1407 final_seg = seg_left;
1409 resolved = (symbol_resolved_p (add_symbol)
1410 && symbol_resolved_p (op_symbol));
1415 /* Give an error (below) if not in expr_section. We don't
1416 want to worry about expr_section symbols, because they
1417 are fictional (they are created as part of expression
1418 resolution), and any problems may not actually mean
1423 symp->sy_resolving = 0;
1427 S_SET_VALUE (symp, final_val);
1429 exit_dont_set_value:
1430 /* Always set the segment, even if not finalizing the value.
1431 The segment is used to determine whether a symbol is defined. */
1432 S_SET_SEGMENT (symp, final_seg);
1434 /* Don't worry if we can't resolve an expr_section symbol. */
1438 symp->sy_resolved = 1;
1439 else if (S_GET_SEGMENT (symp) != expr_section)
1441 as_bad (_("can't resolve value for symbol `%s'"),
1443 symp->sy_resolved = 1;
1450 static void resolve_local_symbol (const char *, void *);
1452 /* A static function passed to hash_traverse. */
1455 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1458 resolve_symbol_value ((symbolS *) value);
1461 /* Resolve all local symbols. */
1464 resolve_local_symbol_values (void)
1466 hash_traverse (local_hash, resolve_local_symbol);
1469 /* Obtain the current value of a symbol without changing any
1470 sub-expressions used. */
1473 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1475 symbolS *symbolP = *symbolPP;
1477 if (LOCAL_SYMBOL_CHECK (symbolP))
1479 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1481 *valueP = locsym->lsy_value;
1482 *segP = locsym->lsy_section;
1483 *fragPP = local_symbol_get_frag (locsym);
1487 expressionS expr = symbolP->sy_value;
1489 if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1493 if (symbolP->sy_resolving)
1495 symbolP->sy_resolving = 1;
1496 resolved = resolve_expression (&expr);
1497 symbolP->sy_resolving = 0;
1505 if (!symbol_equated_p (symbolP))
1510 symbolP = expr.X_add_symbol;
1517 /* Never change a defined symbol. */
1518 if (symbolP->bsym->section == undefined_section
1519 || symbolP->bsym->section == expr_section)
1520 *symbolPP = symbolP;
1521 *valueP = expr.X_add_number;
1522 *segP = symbolP->bsym->section;
1523 *fragPP = symbolP->sy_frag;
1525 if (*segP == expr_section)
1528 case O_constant: *segP = absolute_section; break;
1529 case O_register: *segP = reg_section; break;
1537 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1538 They are *really* local. That is, they go out of scope whenever we see a
1539 label that isn't local. Also, like fb labels, there can be multiple
1540 instances of a dollar label. Therefor, we name encode each instance with
1541 the instance number, keep a list of defined symbols separate from the real
1542 symbol table, and we treat these buggers as a sparse array. */
1544 static long *dollar_labels;
1545 static long *dollar_label_instances;
1546 static char *dollar_label_defines;
1547 static unsigned long dollar_label_count;
1548 static unsigned long dollar_label_max;
1551 dollar_label_defined (long label)
1555 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1557 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1559 return dollar_label_defines[i - dollar_labels];
1561 /* If we get here, label isn't defined. */
1566 dollar_label_instance (long label)
1570 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1572 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1574 return (dollar_label_instances[i - dollar_labels]);
1576 /* If we get here, we haven't seen the label before.
1577 Therefore its instance count is zero. */
1582 dollar_label_clear (void)
1584 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1587 #define DOLLAR_LABEL_BUMP_BY 10
1590 define_dollar_label (long label)
1594 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1597 ++dollar_label_instances[i - dollar_labels];
1598 dollar_label_defines[i - dollar_labels] = 1;
1602 /* If we get to here, we don't have label listed yet. */
1604 if (dollar_labels == NULL)
1606 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1607 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1608 dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
1609 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1610 dollar_label_count = 0;
1612 else if (dollar_label_count == dollar_label_max)
1614 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1615 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1616 dollar_label_max * sizeof (long));
1617 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1618 dollar_label_max * sizeof (long));
1619 dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
1620 } /* if we needed to grow */
1622 dollar_labels[dollar_label_count] = label;
1623 dollar_label_instances[dollar_label_count] = 1;
1624 dollar_label_defines[dollar_label_count] = 1;
1625 ++dollar_label_count;
1628 /* Caller must copy returned name: we re-use the area for the next name.
1630 The mth occurence of label n: is turned into the symbol "Ln^Am"
1631 where n is the label number and m is the instance number. "L" makes
1632 it a label discarded unless debugging and "^A"('\1') ensures no
1633 ordinary symbol SHOULD get the same name as a local label
1634 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1636 fb labels get the same treatment, except that ^B is used in place
1639 char * /* Return local label name. */
1640 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1641 register int augend /* 0 for current instance, 1 for new instance. */)
1644 /* Returned to caller, then copied. Used for created names ("4f"). */
1645 static char symbol_name_build[24];
1648 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1651 know (augend == 0 || augend == 1);
1652 p = symbol_name_build;
1653 #ifdef LOCAL_LABEL_PREFIX
1654 *p++ = LOCAL_LABEL_PREFIX;
1658 /* Next code just does sprintf( {}, "%d", n); */
1660 q = symbol_name_temporary;
1661 for (*q++ = 0, i = n; i; ++q)
1666 while ((*p = *--q) != '\0')
1669 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1671 /* Instance number. */
1672 q = symbol_name_temporary;
1673 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1678 while ((*p++ = *--q) != '\0');;
1680 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1681 return symbol_name_build;
1684 /* Somebody else's idea of local labels. They are made by "n:" where n
1685 is any decimal digit. Refer to them with
1686 "nb" for previous (backward) n:
1687 or "nf" for next (forward) n:.
1689 We do a little better and let n be any number, not just a single digit, but
1690 since the other guy's assembler only does ten, we treat the first ten
1693 Like someone else's assembler, we have one set of local label counters for
1694 entire assembly, not one set per (sub)segment like in most assemblers. This
1695 implies that one can refer to a label in another segment, and indeed some
1696 crufty compilers have done just that.
1698 Since there could be a LOT of these things, treat them as a sparse
1701 #define FB_LABEL_SPECIAL (10)
1703 static long fb_low_counter[FB_LABEL_SPECIAL];
1704 static long *fb_labels;
1705 static long *fb_label_instances;
1706 static long fb_label_count;
1707 static long fb_label_max;
1709 /* This must be more than FB_LABEL_SPECIAL. */
1710 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1713 fb_label_init (void)
1715 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1718 /* Add one to the instance number of this fb label. */
1721 fb_label_instance_inc (long label)
1725 if (label < FB_LABEL_SPECIAL)
1727 ++fb_low_counter[label];
1731 if (fb_labels != NULL)
1733 for (i = fb_labels + FB_LABEL_SPECIAL;
1734 i < fb_labels + fb_label_count; ++i)
1738 ++fb_label_instances[i - fb_labels];
1740 } /* if we find it */
1741 } /* for each existing label */
1744 /* If we get to here, we don't have label listed yet. */
1746 if (fb_labels == NULL)
1748 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1749 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1750 fb_label_max = FB_LABEL_BUMP_BY;
1751 fb_label_count = FB_LABEL_SPECIAL;
1754 else if (fb_label_count == fb_label_max)
1756 fb_label_max += FB_LABEL_BUMP_BY;
1757 fb_labels = (long *) xrealloc ((char *) fb_labels,
1758 fb_label_max * sizeof (long));
1759 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1760 fb_label_max * sizeof (long));
1761 } /* if we needed to grow */
1763 fb_labels[fb_label_count] = label;
1764 fb_label_instances[fb_label_count] = 1;
1769 fb_label_instance (long label)
1773 if (label < FB_LABEL_SPECIAL)
1775 return (fb_low_counter[label]);
1778 if (fb_labels != NULL)
1780 for (i = fb_labels + FB_LABEL_SPECIAL;
1781 i < fb_labels + fb_label_count; ++i)
1785 return (fb_label_instances[i - fb_labels]);
1786 } /* if we find it */
1787 } /* for each existing label */
1790 /* We didn't find the label, so this must be a reference to the
1795 /* Caller must copy returned name: we re-use the area for the next name.
1797 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1798 where n is the label number and m is the instance number. "L" makes
1799 it a label discarded unless debugging and "^B"('\2') ensures no
1800 ordinary symbol SHOULD get the same name as a local label
1801 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1803 dollar labels get the same treatment, except that ^A is used in
1806 char * /* Return local label name. */
1807 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1808 long augend /* 0 for nb, 1 for n:, nf. */)
1811 /* Returned to caller, then copied. Used for created names ("4f"). */
1812 static char symbol_name_build[24];
1815 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1819 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1821 know ((unsigned long) augend <= 1);
1823 p = symbol_name_build;
1824 #ifdef LOCAL_LABEL_PREFIX
1825 *p++ = LOCAL_LABEL_PREFIX;
1829 /* Next code just does sprintf( {}, "%d", n); */
1831 q = symbol_name_temporary;
1832 for (*q++ = 0, i = n; i; ++q)
1837 while ((*p = *--q) != '\0')
1840 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1842 /* Instance number. */
1843 q = symbol_name_temporary;
1844 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1849 while ((*p++ = *--q) != '\0');;
1851 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1852 return (symbol_name_build);
1855 /* Decode name that may have been generated by foo_label_name() above.
1856 If the name wasn't generated by foo_label_name(), then return it
1857 unaltered. This is used for error messages. */
1860 decode_local_label_name (char *s)
1863 char *symbol_decode;
1865 int instance_number;
1867 const char *message_format;
1870 #ifdef LOCAL_LABEL_PREFIX
1871 if (s[index] == LOCAL_LABEL_PREFIX)
1875 if (s[index] != 'L')
1878 for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1879 label_number = (10 * label_number) + *p - '0';
1881 if (*p == DOLLAR_LABEL_CHAR)
1883 else if (*p == LOCAL_LABEL_CHAR)
1888 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1889 instance_number = (10 * instance_number) + *p - '0';
1891 message_format = _("\"%d\" (instance number %d of a %s label)");
1892 symbol_decode = (char *) obstack_alloc (¬es, strlen (message_format) + 30);
1893 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1895 return symbol_decode;
1898 /* Get the value of a symbol. */
1901 S_GET_VALUE (symbolS *s)
1903 if (LOCAL_SYMBOL_CHECK (s))
1904 return resolve_symbol_value (s);
1906 if (!s->sy_resolved)
1908 valueT val = resolve_symbol_value (s);
1912 if (S_IS_WEAKREFR (s))
1913 return S_GET_VALUE (s->sy_value.X_add_symbol);
1915 if (s->sy_value.X_op != O_constant)
1917 if (! s->sy_resolved
1918 || s->sy_value.X_op != O_symbol
1919 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1920 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1923 return (valueT) s->sy_value.X_add_number;
1926 /* Set the value of a symbol. */
1929 S_SET_VALUE (symbolS *s, valueT val)
1931 if (LOCAL_SYMBOL_CHECK (s))
1933 ((struct local_symbol *) s)->lsy_value = val;
1937 s->sy_value.X_op = O_constant;
1938 s->sy_value.X_add_number = (offsetT) val;
1939 s->sy_value.X_unsigned = 0;
1940 S_CLEAR_WEAKREFR (s);
1944 copy_symbol_attributes (symbolS *dest, symbolS *src)
1946 if (LOCAL_SYMBOL_CHECK (dest))
1947 dest = local_symbol_convert ((struct local_symbol *) dest);
1948 if (LOCAL_SYMBOL_CHECK (src))
1949 src = local_symbol_convert ((struct local_symbol *) src);
1951 /* In an expression, transfer the settings of these flags.
1952 The user can override later, of course. */
1953 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
1954 | BSF_GNU_INDIRECT_FUNCTION)
1955 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1957 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1958 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1961 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1962 TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
1967 S_IS_FUNCTION (symbolS *s)
1971 if (LOCAL_SYMBOL_CHECK (s))
1974 flags = s->bsym->flags;
1976 return (flags & BSF_FUNCTION) != 0;
1980 S_IS_EXTERNAL (symbolS *s)
1984 if (LOCAL_SYMBOL_CHECK (s))
1987 flags = s->bsym->flags;
1990 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1993 return (flags & BSF_GLOBAL) != 0;
1997 S_IS_WEAK (symbolS *s)
1999 if (LOCAL_SYMBOL_CHECK (s))
2001 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2002 could probably handle a WEAKREFR as always weak though. E.g., if
2003 the referenced symbol has lost its weak status, there's no reason
2004 to keep handling the weakrefr as if it was weak. */
2005 if (S_IS_WEAKREFR (s))
2006 return S_IS_WEAK (s->sy_value.X_add_symbol);
2007 return (s->bsym->flags & BSF_WEAK) != 0;
2011 S_IS_WEAKREFR (symbolS *s)
2013 if (LOCAL_SYMBOL_CHECK (s))
2015 return s->sy_weakrefr != 0;
2019 S_IS_WEAKREFD (symbolS *s)
2021 if (LOCAL_SYMBOL_CHECK (s))
2023 return s->sy_weakrefd != 0;
2027 S_IS_COMMON (symbolS *s)
2029 if (LOCAL_SYMBOL_CHECK (s))
2031 return bfd_is_com_section (s->bsym->section);
2035 S_IS_DEFINED (symbolS *s)
2037 if (LOCAL_SYMBOL_CHECK (s))
2038 return ((struct local_symbol *) s)->lsy_section != undefined_section;
2039 return s->bsym->section != undefined_section;
2043 #ifndef EXTERN_FORCE_RELOC
2044 #define EXTERN_FORCE_RELOC IS_ELF
2047 /* Return true for symbols that should not be reduced to section
2048 symbols or eliminated from expressions, because they may be
2049 overridden by the linker. */
2051 S_FORCE_RELOC (symbolS *s, int strict)
2053 if (LOCAL_SYMBOL_CHECK (s))
2054 return ((struct local_symbol *) s)->lsy_section == undefined_section;
2057 && ((s->bsym->flags & BSF_WEAK) != 0
2058 || (s->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0
2059 || (EXTERN_FORCE_RELOC
2060 && (s->bsym->flags & BSF_GLOBAL) != 0)))
2061 || s->bsym->section == undefined_section
2062 || bfd_is_com_section (s->bsym->section));
2066 S_IS_DEBUG (symbolS *s)
2068 if (LOCAL_SYMBOL_CHECK (s))
2070 if (s->bsym->flags & BSF_DEBUGGING)
2076 S_IS_LOCAL (symbolS *s)
2081 if (LOCAL_SYMBOL_CHECK (s))
2084 flags = s->bsym->flags;
2087 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2090 if (bfd_get_section (s->bsym) == reg_section)
2093 if (flag_strip_local_absolute
2094 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2095 the source file even when the object file is stripped. */
2096 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2097 && bfd_get_section (s->bsym) == absolute_section)
2100 name = S_GET_NAME (s);
2101 return (name != NULL
2103 && (strchr (name, DOLLAR_LABEL_CHAR)
2104 || strchr (name, LOCAL_LABEL_CHAR)
2105 || (! flag_keep_locals
2106 && (bfd_is_local_label (stdoutput, s->bsym)
2109 && name[1] == '?')))));
2113 S_IS_STABD (symbolS *s)
2115 return S_GET_NAME (s) == 0;
2119 S_IS_VOLATILE (const symbolS *s)
2121 if (LOCAL_SYMBOL_CHECK (s))
2123 return s->sy_volatile;
2127 S_IS_FORWARD_REF (const symbolS *s)
2129 if (LOCAL_SYMBOL_CHECK (s))
2131 return s->sy_forward_ref;
2135 S_GET_NAME (symbolS *s)
2137 if (LOCAL_SYMBOL_CHECK (s))
2138 return ((struct local_symbol *) s)->lsy_name;
2139 return s->bsym->name;
2143 S_GET_SEGMENT (symbolS *s)
2145 if (LOCAL_SYMBOL_CHECK (s))
2146 return ((struct local_symbol *) s)->lsy_section;
2147 return s->bsym->section;
2151 S_SET_SEGMENT (symbolS *s, segT seg)
2153 /* Don't reassign section symbols. The direct reason is to prevent seg
2154 faults assigning back to const global symbols such as *ABS*, but it
2155 shouldn't happen anyway. */
2157 if (LOCAL_SYMBOL_CHECK (s))
2159 if (seg == reg_section)
2160 s = local_symbol_convert ((struct local_symbol *) s);
2163 ((struct local_symbol *) s)->lsy_section = seg;
2168 if (s->bsym->flags & BSF_SECTION_SYM)
2170 if (s->bsym->section != seg)
2174 s->bsym->section = seg;
2178 S_SET_EXTERNAL (symbolS *s)
2180 if (LOCAL_SYMBOL_CHECK (s))
2181 s = local_symbol_convert ((struct local_symbol *) s);
2182 if ((s->bsym->flags & BSF_WEAK) != 0)
2184 /* Let .weak override .global. */
2187 if (s->bsym->flags & BSF_SECTION_SYM)
2192 /* Do not reassign section symbols. */
2193 as_where (& file, & line);
2194 as_warn_where (file, line,
2195 _("section symbols are already global"));
2198 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2199 if (S_GET_SEGMENT (s) == reg_section)
2201 as_bad ("can't make register symbol `%s' global",
2206 s->bsym->flags |= BSF_GLOBAL;
2207 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2210 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2211 an_external_name = S_GET_NAME (s);
2216 S_CLEAR_EXTERNAL (symbolS *s)
2218 if (LOCAL_SYMBOL_CHECK (s))
2220 if ((s->bsym->flags & BSF_WEAK) != 0)
2222 /* Let .weak override. */
2225 s->bsym->flags |= BSF_LOCAL;
2226 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2230 S_SET_WEAK (symbolS *s)
2232 if (LOCAL_SYMBOL_CHECK (s))
2233 s = local_symbol_convert ((struct local_symbol *) s);
2234 #ifdef obj_set_weak_hook
2235 obj_set_weak_hook (s);
2237 s->bsym->flags |= BSF_WEAK;
2238 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2242 S_SET_WEAKREFR (symbolS *s)
2244 if (LOCAL_SYMBOL_CHECK (s))
2245 s = local_symbol_convert ((struct local_symbol *) s);
2247 /* If the alias was already used, make sure we mark the target as
2248 used as well, otherwise it might be dropped from the symbol
2249 table. This may have unintended side effects if the alias is
2250 later redirected to another symbol, such as keeping the unused
2251 previous target in the symbol table. Since it will be weak, it's
2254 symbol_mark_used (s->sy_value.X_add_symbol);
2258 S_CLEAR_WEAKREFR (symbolS *s)
2260 if (LOCAL_SYMBOL_CHECK (s))
2266 S_SET_WEAKREFD (symbolS *s)
2268 if (LOCAL_SYMBOL_CHECK (s))
2269 s = local_symbol_convert ((struct local_symbol *) s);
2275 S_CLEAR_WEAKREFD (symbolS *s)
2277 if (LOCAL_SYMBOL_CHECK (s))
2282 /* If a weakref target symbol is weak, then it was never
2283 referenced directly before, not even in a .global directive,
2284 so decay it to local. If it remains undefined, it will be
2285 later turned into a global, like any other undefined
2287 if (s->bsym->flags & BSF_WEAK)
2289 #ifdef obj_clear_weak_hook
2290 obj_clear_weak_hook (s);
2292 s->bsym->flags &= ~BSF_WEAK;
2293 s->bsym->flags |= BSF_LOCAL;
2299 S_SET_THREAD_LOCAL (symbolS *s)
2301 if (LOCAL_SYMBOL_CHECK (s))
2302 s = local_symbol_convert ((struct local_symbol *) s);
2303 if (bfd_is_com_section (s->bsym->section)
2304 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2306 s->bsym->flags |= BSF_THREAD_LOCAL;
2307 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2308 as_bad (_("Accessing function `%s' as thread-local object"),
2310 else if (! bfd_is_und_section (s->bsym->section)
2311 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2312 as_bad (_("Accessing `%s' as thread-local object"),
2317 S_SET_NAME (symbolS *s, const char *name)
2319 if (LOCAL_SYMBOL_CHECK (s))
2321 ((struct local_symbol *) s)->lsy_name = name;
2324 s->bsym->name = name;
2328 S_SET_VOLATILE (symbolS *s)
2330 if (LOCAL_SYMBOL_CHECK (s))
2331 s = local_symbol_convert ((struct local_symbol *) s);
2336 S_CLEAR_VOLATILE (symbolS *s)
2338 if (!LOCAL_SYMBOL_CHECK (s))
2343 S_SET_FORWARD_REF (symbolS *s)
2345 if (LOCAL_SYMBOL_CHECK (s))
2346 s = local_symbol_convert ((struct local_symbol *) s);
2347 s->sy_forward_ref = 1;
2350 /* Return the previous symbol in a chain. */
2353 symbol_previous (symbolS *s)
2355 if (LOCAL_SYMBOL_CHECK (s))
2357 return s->sy_previous;
2360 /* Return the next symbol in a chain. */
2363 symbol_next (symbolS *s)
2365 if (LOCAL_SYMBOL_CHECK (s))
2370 /* Return a pointer to the value of a symbol as an expression. */
2373 symbol_get_value_expression (symbolS *s)
2375 if (LOCAL_SYMBOL_CHECK (s))
2376 s = local_symbol_convert ((struct local_symbol *) s);
2377 return &s->sy_value;
2380 /* Set the value of a symbol to an expression. */
2383 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2385 if (LOCAL_SYMBOL_CHECK (s))
2386 s = local_symbol_convert ((struct local_symbol *) s);
2388 S_CLEAR_WEAKREFR (s);
2391 /* Return a pointer to the X_add_number component of a symbol. */
2394 symbol_X_add_number (symbolS *s)
2396 if (LOCAL_SYMBOL_CHECK (s))
2397 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2399 return &s->sy_value.X_add_number;
2402 /* Set the value of SYM to the current position in the current segment. */
2405 symbol_set_value_now (symbolS *sym)
2407 S_SET_SEGMENT (sym, now_seg);
2408 S_SET_VALUE (sym, frag_now_fix ());
2409 symbol_set_frag (sym, frag_now);
2412 /* Set the frag of a symbol. */
2415 symbol_set_frag (symbolS *s, fragS *f)
2417 if (LOCAL_SYMBOL_CHECK (s))
2419 local_symbol_set_frag ((struct local_symbol *) s, f);
2423 S_CLEAR_WEAKREFR (s);
2426 /* Return the frag of a symbol. */
2429 symbol_get_frag (symbolS *s)
2431 if (LOCAL_SYMBOL_CHECK (s))
2432 return local_symbol_get_frag ((struct local_symbol *) s);
2436 /* Mark a symbol as having been used. */
2439 symbol_mark_used (symbolS *s)
2441 if (LOCAL_SYMBOL_CHECK (s))
2444 if (S_IS_WEAKREFR (s))
2445 symbol_mark_used (s->sy_value.X_add_symbol);
2448 /* Clear the mark of whether a symbol has been used. */
2451 symbol_clear_used (symbolS *s)
2453 if (LOCAL_SYMBOL_CHECK (s))
2454 s = local_symbol_convert ((struct local_symbol *) s);
2458 /* Return whether a symbol has been used. */
2461 symbol_used_p (symbolS *s)
2463 if (LOCAL_SYMBOL_CHECK (s))
2468 /* Mark a symbol as having been used in a reloc. */
2471 symbol_mark_used_in_reloc (symbolS *s)
2473 if (LOCAL_SYMBOL_CHECK (s))
2474 s = local_symbol_convert ((struct local_symbol *) s);
2475 s->sy_used_in_reloc = 1;
2478 /* Clear the mark of whether a symbol has been used in a reloc. */
2481 symbol_clear_used_in_reloc (symbolS *s)
2483 if (LOCAL_SYMBOL_CHECK (s))
2485 s->sy_used_in_reloc = 0;
2488 /* Return whether a symbol has been used in a reloc. */
2491 symbol_used_in_reloc_p (symbolS *s)
2493 if (LOCAL_SYMBOL_CHECK (s))
2495 return s->sy_used_in_reloc;
2498 /* Mark a symbol as an MRI common symbol. */
2501 symbol_mark_mri_common (symbolS *s)
2503 if (LOCAL_SYMBOL_CHECK (s))
2504 s = local_symbol_convert ((struct local_symbol *) s);
2505 s->sy_mri_common = 1;
2508 /* Clear the mark of whether a symbol is an MRI common symbol. */
2511 symbol_clear_mri_common (symbolS *s)
2513 if (LOCAL_SYMBOL_CHECK (s))
2515 s->sy_mri_common = 0;
2518 /* Return whether a symbol is an MRI common symbol. */
2521 symbol_mri_common_p (symbolS *s)
2523 if (LOCAL_SYMBOL_CHECK (s))
2525 return s->sy_mri_common;
2528 /* Mark a symbol as having been written. */
2531 symbol_mark_written (symbolS *s)
2533 if (LOCAL_SYMBOL_CHECK (s))
2538 /* Clear the mark of whether a symbol has been written. */
2541 symbol_clear_written (symbolS *s)
2543 if (LOCAL_SYMBOL_CHECK (s))
2548 /* Return whether a symbol has been written. */
2551 symbol_written_p (symbolS *s)
2553 if (LOCAL_SYMBOL_CHECK (s))
2558 /* Mark a symbol has having been resolved. */
2561 symbol_mark_resolved (symbolS *s)
2563 if (LOCAL_SYMBOL_CHECK (s))
2565 local_symbol_mark_resolved ((struct local_symbol *) s);
2571 /* Return whether a symbol has been resolved. */
2574 symbol_resolved_p (symbolS *s)
2576 if (LOCAL_SYMBOL_CHECK (s))
2577 return local_symbol_resolved_p ((struct local_symbol *) s);
2578 return s->sy_resolved;
2581 /* Return whether a symbol is a section symbol. */
2584 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2586 if (LOCAL_SYMBOL_CHECK (s))
2588 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2591 /* Return whether a symbol is equated to another symbol. */
2594 symbol_equated_p (symbolS *s)
2596 if (LOCAL_SYMBOL_CHECK (s))
2598 return s->sy_value.X_op == O_symbol;
2601 /* Return whether a symbol is equated to another symbol, and should be
2602 treated specially when writing out relocs. */
2605 symbol_equated_reloc_p (symbolS *s)
2607 if (LOCAL_SYMBOL_CHECK (s))
2609 /* X_op_symbol, normally not used for O_symbol, is set by
2610 resolve_symbol_value to flag expression syms that have been
2612 return (s->sy_value.X_op == O_symbol
2613 #if defined (OBJ_COFF) && defined (TE_PE)
2616 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2617 || ! S_IS_DEFINED (s)
2618 || S_IS_COMMON (s)));
2621 /* Return whether a symbol has a constant value. */
2624 symbol_constant_p (symbolS *s)
2626 if (LOCAL_SYMBOL_CHECK (s))
2628 return s->sy_value.X_op == O_constant;
2631 /* Return whether a symbol was cloned and thus removed from the global
2635 symbol_shadow_p (symbolS *s)
2637 if (LOCAL_SYMBOL_CHECK (s))
2639 return s->sy_next == s;
2642 /* Return the BFD symbol for a symbol. */
2645 symbol_get_bfdsym (symbolS *s)
2647 if (LOCAL_SYMBOL_CHECK (s))
2648 s = local_symbol_convert ((struct local_symbol *) s);
2652 /* Set the BFD symbol for a symbol. */
2655 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2657 if (LOCAL_SYMBOL_CHECK (s))
2658 s = local_symbol_convert ((struct local_symbol *) s);
2659 /* Usually, it is harmless to reset a symbol to a BFD section
2660 symbol. For example, obj_elf_change_section sets the BFD symbol
2661 of an old symbol with the newly created section symbol. But when
2662 we have multiple sections with the same name, the newly created
2663 section may have the same name as an old section. We check if the
2664 old symbol has been already marked as a section symbol before
2666 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2668 /* else XXX - What do we do now ? */
2671 #ifdef OBJ_SYMFIELD_TYPE
2673 /* Get a pointer to the object format information for a symbol. */
2676 symbol_get_obj (symbolS *s)
2678 if (LOCAL_SYMBOL_CHECK (s))
2679 s = local_symbol_convert ((struct local_symbol *) s);
2683 /* Set the object format information for a symbol. */
2686 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2688 if (LOCAL_SYMBOL_CHECK (s))
2689 s = local_symbol_convert ((struct local_symbol *) s);
2693 #endif /* OBJ_SYMFIELD_TYPE */
2695 #ifdef TC_SYMFIELD_TYPE
2697 /* Get a pointer to the processor information for a symbol. */
2700 symbol_get_tc (symbolS *s)
2702 if (LOCAL_SYMBOL_CHECK (s))
2703 s = local_symbol_convert ((struct local_symbol *) s);
2707 /* Set the processor information for a symbol. */
2710 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2712 if (LOCAL_SYMBOL_CHECK (s))
2713 s = local_symbol_convert ((struct local_symbol *) s);
2717 #endif /* TC_SYMFIELD_TYPE */
2722 symbol_lastP = NULL;
2723 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2724 sy_hash = hash_new ();
2725 local_hash = hash_new ();
2727 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2728 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2729 abs_symbol.bsym = bfd_abs_section.symbol;
2731 abs_symbol.sy_value.X_op = O_constant;
2732 abs_symbol.sy_frag = &zero_address_frag;
2734 if (LOCAL_LABELS_FB)
2740 /* Maximum indent level.
2741 Available for modification inside a gdb session. */
2742 static int max_indent_level = 8;
2745 print_symbol_value_1 (FILE *file, symbolS *sym)
2747 const char *name = S_GET_NAME (sym);
2748 if (!name || !name[0])
2750 fprintf (file, "sym ");
2751 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2752 fprintf (file, " %s", name);
2754 if (LOCAL_SYMBOL_CHECK (sym))
2756 struct local_symbol *locsym = (struct local_symbol *) sym;
2758 if (local_symbol_get_frag (locsym) != & zero_address_frag
2759 && local_symbol_get_frag (locsym) != NULL)
2761 fprintf (file, " frag ");
2762 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2764 if (local_symbol_resolved_p (locsym))
2765 fprintf (file, " resolved");
2766 fprintf (file, " local");
2770 if (sym->sy_frag != &zero_address_frag)
2772 fprintf (file, " frag ");
2773 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2776 fprintf (file, " written");
2777 if (sym->sy_resolved)
2778 fprintf (file, " resolved");
2779 else if (sym->sy_resolving)
2780 fprintf (file, " resolving");
2781 if (sym->sy_used_in_reloc)
2782 fprintf (file, " used-in-reloc");
2784 fprintf (file, " used");
2785 if (S_IS_LOCAL (sym))
2786 fprintf (file, " local");
2787 if (S_IS_EXTERNAL (sym))
2788 fprintf (file, " extern");
2789 if (S_IS_WEAK (sym))
2790 fprintf (file, " weak");
2791 if (S_IS_DEBUG (sym))
2792 fprintf (file, " debug");
2793 if (S_IS_DEFINED (sym))
2794 fprintf (file, " defined");
2796 if (S_IS_WEAKREFR (sym))
2797 fprintf (file, " weakrefr");
2798 if (S_IS_WEAKREFD (sym))
2799 fprintf (file, " weakrefd");
2800 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2801 if (symbol_resolved_p (sym))
2803 segT s = S_GET_SEGMENT (sym);
2805 if (s != undefined_section
2806 && s != expr_section)
2807 fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2809 else if (indent_level < max_indent_level
2810 && S_GET_SEGMENT (sym) != undefined_section)
2813 fprintf (file, "\n%*s<", indent_level * 4, "");
2814 if (LOCAL_SYMBOL_CHECK (sym))
2815 fprintf (file, "constant %lx",
2816 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2818 print_expr_1 (file, &sym->sy_value);
2819 fprintf (file, ">");
2826 print_symbol_value (symbolS *sym)
2829 print_symbol_value_1 (stderr, sym);
2830 fprintf (stderr, "\n");
2834 print_binary (FILE *file, const char *name, expressionS *exp)
2837 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2838 print_symbol_value_1 (file, exp->X_add_symbol);
2839 fprintf (file, ">\n%*s<", indent_level * 4, "");
2840 print_symbol_value_1 (file, exp->X_op_symbol);
2841 fprintf (file, ">");
2846 print_expr_1 (FILE *file, expressionS *exp)
2848 fprintf (file, "expr ");
2849 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2850 fprintf (file, " ");
2854 fprintf (file, "illegal");
2857 fprintf (file, "absent");
2860 fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2864 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2865 print_symbol_value_1 (file, exp->X_add_symbol);
2866 fprintf (file, ">");
2868 if (exp->X_add_number)
2869 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2870 (unsigned long) exp->X_add_number);
2874 fprintf (file, "register #%d", (int) exp->X_add_number);
2877 fprintf (file, "big");
2880 fprintf (file, "uminus -<");
2882 print_symbol_value_1 (file, exp->X_add_symbol);
2883 fprintf (file, ">");
2884 goto maybe_print_addnum;
2886 fprintf (file, "bit_not");
2889 print_binary (file, "multiply", exp);
2892 print_binary (file, "divide", exp);
2895 print_binary (file, "modulus", exp);
2898 print_binary (file, "lshift", exp);
2901 print_binary (file, "rshift", exp);
2903 case O_bit_inclusive_or:
2904 print_binary (file, "bit_ior", exp);
2906 case O_bit_exclusive_or:
2907 print_binary (file, "bit_xor", exp);
2910 print_binary (file, "bit_and", exp);
2913 print_binary (file, "eq", exp);
2916 print_binary (file, "ne", exp);
2919 print_binary (file, "lt", exp);
2922 print_binary (file, "le", exp);
2925 print_binary (file, "ge", exp);
2928 print_binary (file, "gt", exp);
2931 print_binary (file, "logical_and", exp);
2934 print_binary (file, "logical_or", exp);
2938 fprintf (file, "add\n%*s<", indent_level * 4, "");
2939 print_symbol_value_1 (file, exp->X_add_symbol);
2940 fprintf (file, ">\n%*s<", indent_level * 4, "");
2941 print_symbol_value_1 (file, exp->X_op_symbol);
2942 fprintf (file, ">");
2943 goto maybe_print_addnum;
2946 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2947 print_symbol_value_1 (file, exp->X_add_symbol);
2948 fprintf (file, ">\n%*s<", indent_level * 4, "");
2949 print_symbol_value_1 (file, exp->X_op_symbol);
2950 fprintf (file, ">");
2951 goto maybe_print_addnum;
2953 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2960 print_expr (expressionS *exp)
2962 print_expr_1 (stderr, exp);
2963 fprintf (stderr, "\n");
2967 symbol_print_statistics (FILE *file)
2969 hash_print_statistics (file, "symbol table", sy_hash);
2970 hash_print_statistics (file, "mini local symbol table", local_hash);
2971 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2972 local_symbol_count, local_symbol_conversion_count);
2975 #ifdef OBJ_COMPLEX_RELC
2977 /* Convert given symbol to a new complex-relocation symbol name. This
2978 may be a recursive function, since it might be called for non-leaf
2979 nodes (plain symbols) in the expression tree. The caller owns the
2980 returning string, so should free it eventually. Errors are
2981 indicated via as_bad and a NULL return value. The given symbol
2982 is marked with sy_used_in_reloc. */
2985 symbol_relc_make_sym (symbolS * sym)
2987 char * terminal = NULL;
2992 gas_assert (sym != NULL);
2994 /* Recurse to symbol_relc_make_expr if this symbol
2995 is defined as an expression or a plain value. */
2996 if ( S_GET_SEGMENT (sym) == expr_section
2997 || S_GET_SEGMENT (sym) == absolute_section)
2998 return symbol_relc_make_expr (& sym->sy_value);
3000 /* This may be a "fake symbol" L0\001, referring to ".".
3001 Write out a special null symbol to refer to this position. */
3002 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
3003 return xstrdup (".");
3005 /* We hope this is a plain leaf symbol. Construct the encoding
3006 as {S,s}II...:CCCCCCC....
3007 where 'S'/'s' means section symbol / plain symbol
3008 III is decimal for the symbol name length
3009 CCC is the symbol name itself. */
3010 symbol_mark_used_in_reloc (sym);
3012 sname = S_GET_NAME (sym);
3013 sname_len = strlen (sname);
3014 typetag = symbol_section_p (sym) ? 'S' : 's';
3016 terminal = xmalloc (1 /* S or s */
3017 + 8 /* sname_len in decimal */
3019 + sname_len /* name itself */
3022 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3026 /* Convert given value to a new complex-relocation symbol name. This
3027 is a non-recursive function, since it is be called for leaf nodes
3028 (plain values) in the expression tree. The caller owns the
3029 returning string, so should free() it eventually. No errors. */
3032 symbol_relc_make_value (offsetT val)
3034 char * terminal = xmalloc (28); /* Enough for long long. */
3037 bfd_sprintf_vma (stdoutput, terminal + 1, val);
3041 /* Convert given expression to a new complex-relocation symbol name.
3042 This is a recursive function, since it traverses the entire given
3043 expression tree. The caller owns the returning string, so should
3044 free() it eventually. Errors are indicated via as_bad() and a NULL
3048 symbol_relc_make_expr (expressionS * exp)
3050 char * opstr = NULL; /* Operator prefix string. */
3051 int arity = 0; /* Arity of this operator. */
3052 char * operands[3]; /* Up to three operands. */
3053 char * concat_string = NULL;
3055 operands[0] = operands[1] = operands[2] = NULL;
3057 gas_assert (exp != NULL);
3059 /* Match known operators -> fill in opstr, arity, operands[] and fall
3060 through to construct subexpression fragments; may instead return
3061 string directly for leaf nodes. */
3063 /* See expr.h for the meaning of all these enums. Many operators
3064 have an unnatural arity (X_add_number implicitly added). The
3065 conversion logic expands them to explicit "+" subexpressions. */
3070 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3075 return symbol_relc_make_value (exp->X_add_number);
3078 if (exp->X_add_number)
3082 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3083 operands[1] = symbol_relc_make_value (exp->X_add_number);
3087 return symbol_relc_make_sym (exp->X_add_symbol);
3089 /* Helper macros for nesting nodes. */
3091 #define HANDLE_XADD_OPT1(str_) \
3092 if (exp->X_add_number) \
3095 opstr = "+:" str_; \
3096 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3097 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3104 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3108 #define HANDLE_XADD_OPT2(str_) \
3109 if (exp->X_add_number) \
3112 opstr = "+:" str_; \
3113 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3114 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3115 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3121 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3122 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3126 /* Nesting nodes. */
3128 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3129 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3130 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3131 case O_multiply: HANDLE_XADD_OPT2 ("*");
3132 case O_divide: HANDLE_XADD_OPT2 ("/");
3133 case O_modulus: HANDLE_XADD_OPT2 ("%");
3134 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3135 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3136 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3137 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3138 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3139 case O_add: HANDLE_XADD_OPT2 ("+");
3140 case O_subtract: HANDLE_XADD_OPT2 ("-");
3141 case O_eq: HANDLE_XADD_OPT2 ("==");
3142 case O_ne: HANDLE_XADD_OPT2 ("!=");
3143 case O_lt: HANDLE_XADD_OPT2 ("<");
3144 case O_le: HANDLE_XADD_OPT2 ("<=");
3145 case O_ge: HANDLE_XADD_OPT2 (">=");
3146 case O_gt: HANDLE_XADD_OPT2 (">");
3147 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3148 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3151 /* Validate & reject early. */
3152 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3154 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3156 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3160 concat_string = NULL;
3163 /* Allocate new string; include inter-operand padding gaps etc. */
3164 concat_string = xmalloc (strlen (opstr)
3166 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3167 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3168 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3170 gas_assert (concat_string != NULL);
3172 /* Format the thing. */
3173 sprintf (concat_string,
3174 (arity == 0 ? "%s" :
3175 arity == 1 ? "%s:%s" :
3176 arity == 2 ? "%s:%s:%s" :
3177 /* arity == 3 */ "%s:%s:%s:%s"),
3178 opstr, operands[0], operands[1], operands[2]);
3181 /* Free operand strings (not opstr). */
3182 if (arity >= 1) xfree (operands[0]);
3183 if (arity >= 2) xfree (operands[1]);
3184 if (arity >= 3) xfree (operands[2]);
3186 return concat_string;