1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003
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 2, 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, 59 Temple Place - Suite 330, 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 static char *save_symbol_name PARAMS ((const char *));
64 static void fb_label_init PARAMS ((void));
65 static long dollar_label_instance PARAMS ((long));
66 static long fb_label_instance PARAMS ((long));
68 static void print_binary PARAMS ((FILE *, const char *, expressionS *));
69 static void report_op_error PARAMS ((symbolS *, symbolS *, symbolS *));
71 /* Return a pointer to a new symbol. Die if we can't make a new
72 symbol. Fill in the symbol's values. Add symbol to end of symbol
75 This function should be called in the general case of creating a
76 symbol. However, if the output file symbol table has already been
77 set, and you are certain that this symbol won't be wanted in the
78 output file, you can call symbol_create. */
81 symbol_new (name, segment, valu, frag)
87 symbolS *symbolP = symbol_create (name, segment, valu, frag);
89 /* Link to end of symbol chain. */
92 extern int symbol_table_frozen;
93 if (symbol_table_frozen)
97 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
102 /* Save a symbol name on a permanent obstack, and convert it according
103 to the object file format. */
106 save_symbol_name (name)
109 unsigned int name_length;
112 name_length = strlen (name) + 1; /* +1 for \0. */
113 obstack_grow (¬es, name, name_length);
114 ret = obstack_finish (¬es);
116 #ifdef STRIP_UNDERSCORE
121 #ifdef tc_canonicalize_symbol_name
122 ret = tc_canonicalize_symbol_name (ret);
125 if (! symbols_case_sensitive)
129 for (s = ret; *s != '\0'; s++)
137 symbol_create (name, segment, valu, frag)
138 const char *name; /* It is copied, the caller can destroy/modify. */
139 segT segment; /* Segment identifier (SEG_<something>). */
140 valueT valu; /* Symbol value. */
141 fragS *frag; /* Associated fragment. */
143 char *preserved_copy_of_name;
146 preserved_copy_of_name = save_symbol_name (name);
148 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
150 /* symbol must be born in some fixed state. This seems as good as any. */
151 memset (symbolP, 0, sizeof (symbolS));
154 symbolP->bsym = bfd_make_empty_symbol (stdoutput);
155 if (symbolP->bsym == NULL)
156 as_perror ("%s", "bfd_make_empty_symbol");
157 symbolP->bsym->udata.p = (PTR) symbolP;
159 S_SET_NAME (symbolP, preserved_copy_of_name);
161 S_SET_SEGMENT (symbolP, segment);
162 S_SET_VALUE (symbolP, valu);
163 symbol_clear_list_pointers (symbolP);
165 symbolP->sy_frag = frag;
166 #ifndef BFD_ASSEMBLER
167 symbolP->sy_number = ~0;
168 symbolP->sy_name_offset = (unsigned int) ~0;
171 obj_symbol_new_hook (symbolP);
173 #ifdef tc_symbol_new_hook
174 tc_symbol_new_hook (symbolP);
182 /* Local symbol support. If we can get away with it, we keep only a
183 small amount of information for local symbols. */
185 static symbolS *local_symbol_convert PARAMS ((struct local_symbol *));
187 /* Used for statistics. */
189 static unsigned long local_symbol_count;
190 static unsigned long local_symbol_conversion_count;
192 /* This macro is called with a symbol argument passed by reference.
193 It returns whether this is a local symbol. If necessary, it
194 changes its argument to the real symbol. */
196 #define LOCAL_SYMBOL_CHECK(s) \
198 ? (local_symbol_converted_p ((struct local_symbol *) s) \
199 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
204 /* Create a local symbol and insert it into the local hash table. */
206 struct local_symbol *
207 local_symbol_make (name, section, value, frag)
214 struct local_symbol *ret;
216 ++local_symbol_count;
218 name_copy = save_symbol_name (name);
220 ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
221 ret->lsy_marker = NULL;
222 ret->lsy_name = name_copy;
223 ret->lsy_section = section;
224 local_symbol_set_frag (ret, frag);
225 ret->lsy_value = value;
227 hash_jam (local_hash, name_copy, (PTR) ret);
232 /* Convert a local symbol into a real symbol. Note that we do not
233 reclaim the space used by the local symbol. */
236 local_symbol_convert (locsym)
237 struct local_symbol *locsym;
241 assert (locsym->lsy_marker == NULL);
242 if (local_symbol_converted_p (locsym))
243 return local_symbol_get_real_symbol (locsym);
245 ++local_symbol_conversion_count;
247 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
248 local_symbol_get_frag (locsym));
250 if (local_symbol_resolved_p (locsym))
251 ret->sy_resolved = 1;
253 /* Local symbols are always either defined or used. */
256 #ifdef TC_LOCAL_SYMFIELD_CONVERT
257 TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
260 symbol_table_insert (ret);
262 local_symbol_mark_converted (locsym);
263 local_symbol_set_real_symbol (locsym, ret);
265 hash_jam (local_hash, locsym->lsy_name, NULL);
270 #else /* ! BFD_ASSEMBLER */
272 #define LOCAL_SYMBOL_CHECK(s) 0
273 #define local_symbol_convert(s) ((symbolS *) s)
275 #endif /* ! BFD_ASSEMBLER */
277 /* We have just seen "<name>:".
278 Creates a struct symbol unless it already exists.
280 Gripes if we are redefining a symbol incompatibly (and ignores it). */
283 colon (sym_name) /* Just seen "x:" - rattle symbols & frags. */
284 const char *sym_name; /* Symbol name, as a cannonical string. */
285 /* We copy this string: OK to alter later. */
287 register symbolS *symbolP; /* Symbol we are working with. */
289 /* Sun local labels go out of scope whenever a non-local symbol is
291 if (LOCAL_LABELS_DOLLAR)
296 local = bfd_is_local_label_name (stdoutput, sym_name);
298 local = LOCAL_LABEL (sym_name);
302 dollar_label_clear ();
305 #ifndef WORKING_DOT_WORD
306 if (new_broken_words)
308 struct broken_word *a;
313 extern const int md_short_jump_size;
314 extern const int md_long_jump_size;
316 if (now_seg == absolute_section)
318 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
322 possible_bytes = (md_short_jump_size
323 + new_broken_words * md_long_jump_size);
326 frag_opcode = frag_var (rs_broken_word,
330 (symbolS *) broken_words,
334 /* We want to store the pointer to where to insert the jump
335 table in the fr_opcode of the rs_broken_word frag. This
336 requires a little hackery. */
338 && (frag_tmp->fr_type != rs_broken_word
339 || frag_tmp->fr_opcode))
340 frag_tmp = frag_tmp->fr_next;
342 frag_tmp->fr_opcode = frag_opcode;
343 new_broken_words = 0;
345 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
346 a->dispfrag = frag_tmp;
348 #endif /* WORKING_DOT_WORD */
350 if ((symbolP = symbol_find (sym_name)) != 0)
352 #ifdef RESOLVE_SYMBOL_REDEFINITION
353 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
356 /* Now check for undefined symbols. */
357 if (LOCAL_SYMBOL_CHECK (symbolP))
360 struct local_symbol *locsym = (struct local_symbol *) symbolP;
362 if (locsym->lsy_section != undefined_section
363 && (local_symbol_get_frag (locsym) != frag_now
364 || locsym->lsy_section != now_seg
365 || locsym->lsy_value != frag_now_fix ()))
367 as_bad (_("symbol `%s' is already defined"), sym_name);
371 locsym->lsy_section = now_seg;
372 local_symbol_set_frag (locsym, frag_now);
373 locsym->lsy_value = frag_now_fix ();
376 else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
378 if (S_GET_VALUE (symbolP) == 0)
380 symbolP->sy_frag = frag_now;
382 S_SET_OTHER (symbolP, const_flag);
384 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
385 S_SET_SEGMENT (symbolP, now_seg);
388 #endif /* if we have one, it better be zero. */
393 /* There are still several cases to check:
395 A .comm/.lcomm symbol being redefined as initialized
398 A .comm/.lcomm symbol being redefined with a larger
401 This only used to be allowed on VMS gas, but Sun cc
402 on the sparc also depends on it. */
404 if (((!S_IS_DEBUG (symbolP)
405 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
406 && S_IS_EXTERNAL (symbolP))
407 || S_GET_SEGMENT (symbolP) == bss_section)
408 && (now_seg == data_section
409 || now_seg == S_GET_SEGMENT (symbolP)))
411 /* Select which of the 2 cases this is. */
412 if (now_seg != data_section)
414 /* New .comm for prev .comm symbol.
416 If the new size is larger we just change its
417 value. If the new size is smaller, we ignore
419 if (S_GET_VALUE (symbolP)
420 < ((unsigned) frag_now_fix ()))
422 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
427 /* It is a .comm/.lcomm being converted to initialized
429 symbolP->sy_frag = frag_now;
431 S_SET_OTHER (symbolP, const_flag);
433 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
434 S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
439 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
440 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
441 static const char *od_buf = "";
446 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
448 sprintf (od_buf, "%d.%d.",
449 S_GET_OTHER (symbolP),
450 S_GET_DESC (symbolP));
452 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
454 segment_name (S_GET_SEGMENT (symbolP)),
456 (long) S_GET_VALUE (symbolP));
458 } /* if the undefined symbol has no value */
462 /* Don't blow up if the definition is the same. */
463 if (!(frag_now == symbolP->sy_frag
464 && S_GET_VALUE (symbolP) == frag_now_fix ()
465 && S_GET_SEGMENT (symbolP) == now_seg))
466 as_bad (_("symbol `%s' is already defined"), sym_name);
471 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
473 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
474 (valueT) frag_now_fix (),
477 #endif /* BFD_ASSEMBLER */
480 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
483 S_SET_OTHER (symbolP, const_flag);
486 symbol_table_insert (symbolP);
489 if (mri_common_symbol != NULL)
491 /* This symbol is actually being defined within an MRI common
492 section. This requires special handling. */
493 if (LOCAL_SYMBOL_CHECK (symbolP))
494 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
495 symbolP->sy_value.X_op = O_symbol;
496 symbolP->sy_value.X_add_symbol = mri_common_symbol;
497 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
498 symbolP->sy_frag = &zero_address_frag;
499 S_SET_SEGMENT (symbolP, expr_section);
500 symbolP->sy_mri_common = 1;
504 tc_frob_label (symbolP);
506 #ifdef obj_frob_label
507 obj_frob_label (symbolP);
513 /* Die if we can't insert the symbol. */
516 symbol_table_insert (symbolP)
519 register const char *error_string;
522 know (S_GET_NAME (symbolP));
524 if (LOCAL_SYMBOL_CHECK (symbolP))
526 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
528 if (error_string != NULL)
529 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
530 S_GET_NAME (symbolP), error_string);
534 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
536 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
537 S_GET_NAME (symbolP), error_string);
541 /* If a symbol name does not exist, create it as undefined, and insert
542 it into the symbol table. Return a pointer to it. */
545 symbol_find_or_make (name)
548 register symbolS *symbolP;
550 symbolP = symbol_find (name);
555 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
557 symbolP = md_undefined_symbol ((char *) name);
561 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
568 symbolP = symbol_make (name);
570 symbol_table_insert (symbolP);
571 } /* if symbol wasn't found */
582 /* Let the machine description default it, e.g. for register names. */
583 symbolP = md_undefined_symbol ((char *) name);
586 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
591 static const char temp_label_name[] = ".L0\001";
594 symbol_temp_new (seg, ofs, frag)
599 return symbol_new (temp_label_name, seg, ofs, frag);
603 symbol_temp_new_now ()
605 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
611 return symbol_make (temp_label_name);
614 /* Implement symbol table lookup.
615 In: A symbol's name as a string: '\0' can't be part of a symbol name.
616 Out: NULL if the name was not in the symbol table, else the address
617 of a struct symbol associated with that name. */
623 #ifdef STRIP_UNDERSCORE
624 return (symbol_find_base (name, 1));
625 #else /* STRIP_UNDERSCORE */
626 return (symbol_find_base (name, 0));
627 #endif /* STRIP_UNDERSCORE */
631 symbol_find_exact (name)
636 struct local_symbol *locsym;
638 locsym = (struct local_symbol *) hash_find (local_hash, name);
640 return (symbolS *) locsym;
644 return ((symbolS *) hash_find (sy_hash, name));
648 symbol_find_base (name, strip_underscore)
650 int strip_underscore;
652 if (strip_underscore && *name == '_')
655 #ifdef tc_canonicalize_symbol_name
658 size_t len = strlen (name) + 1;
660 copy = (char *) alloca (len);
661 memcpy (copy, name, len);
662 name = tc_canonicalize_symbol_name (copy);
666 if (! symbols_case_sensitive)
673 name = copy = (char *) alloca (strlen (name) + 1);
675 while ((c = *orig++) != '\0')
677 *copy++ = TOUPPER (c);
682 return symbol_find_exact (name);
685 /* Once upon a time, symbols were kept in a singly linked list. At
686 least coff needs to be able to rearrange them from time to time, for
687 which a doubly linked list is much more convenient. Loic did these
688 as macros which seemed dangerous to me so they're now functions.
691 /* Link symbol ADDME after symbol TARGET in the chain. */
694 symbol_append (addme, target, rootPP, lastPP)
700 if (LOCAL_SYMBOL_CHECK (addme))
702 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
707 know (*rootPP == NULL);
708 know (*lastPP == NULL);
709 addme->sy_next = NULL;
710 #ifdef SYMBOLS_NEED_BACKPOINTERS
711 addme->sy_previous = NULL;
716 } /* if the list is empty */
718 if (target->sy_next != NULL)
720 #ifdef SYMBOLS_NEED_BACKPOINTERS
721 target->sy_next->sy_previous = addme;
722 #endif /* SYMBOLS_NEED_BACKPOINTERS */
726 know (*lastPP == target);
728 } /* if we have a next */
730 addme->sy_next = target->sy_next;
731 target->sy_next = addme;
733 #ifdef SYMBOLS_NEED_BACKPOINTERS
734 addme->sy_previous = target;
735 #endif /* SYMBOLS_NEED_BACKPOINTERS */
737 debug_verify_symchain (symbol_rootP, symbol_lastP);
740 /* Set the chain pointers of SYMBOL to null. */
743 symbol_clear_list_pointers (symbolP)
746 if (LOCAL_SYMBOL_CHECK (symbolP))
748 symbolP->sy_next = NULL;
749 #ifdef SYMBOLS_NEED_BACKPOINTERS
750 symbolP->sy_previous = NULL;
754 #ifdef SYMBOLS_NEED_BACKPOINTERS
755 /* Remove SYMBOLP from the list. */
758 symbol_remove (symbolP, rootPP, lastPP)
763 if (LOCAL_SYMBOL_CHECK (symbolP))
766 if (symbolP == *rootPP)
768 *rootPP = symbolP->sy_next;
769 } /* if it was the root */
771 if (symbolP == *lastPP)
773 *lastPP = symbolP->sy_previous;
774 } /* if it was the tail */
776 if (symbolP->sy_next != NULL)
778 symbolP->sy_next->sy_previous = symbolP->sy_previous;
781 if (symbolP->sy_previous != NULL)
783 symbolP->sy_previous->sy_next = symbolP->sy_next;
786 debug_verify_symchain (*rootPP, *lastPP);
789 /* Link symbol ADDME before symbol TARGET in the chain. */
792 symbol_insert (addme, target, rootPP, lastPP)
796 symbolS **lastPP ATTRIBUTE_UNUSED;
798 if (LOCAL_SYMBOL_CHECK (addme))
800 if (LOCAL_SYMBOL_CHECK (target))
803 if (target->sy_previous != NULL)
805 target->sy_previous->sy_next = addme;
809 know (*rootPP == target);
813 addme->sy_previous = target->sy_previous;
814 target->sy_previous = addme;
815 addme->sy_next = target;
817 debug_verify_symchain (*rootPP, *lastPP);
820 #endif /* SYMBOLS_NEED_BACKPOINTERS */
823 verify_symbol_chain (rootP, lastP)
827 symbolS *symbolP = rootP;
832 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
835 assert (symbolP->bsym != NULL);
837 #ifdef SYMBOLS_NEED_BACKPOINTERS
838 assert (symbolP->sy_next->sy_previous == symbolP);
840 /* Walk the list anyways, to make sure pointers are still good. */
842 #endif /* SYMBOLS_NEED_BACKPOINTERS */
845 assert (lastP == symbolP);
849 verify_symbol_chain_2 (sym)
852 symbolS *p = sym, *n = sym;
853 #ifdef SYMBOLS_NEED_BACKPOINTERS
854 while (symbol_previous (p))
855 p = symbol_previous (p);
857 while (symbol_next (n))
859 verify_symbol_chain (p, n);
863 report_op_error (symp, left, right)
865 symbolS *left, *right;
869 segT seg_left = S_GET_SEGMENT (left);
870 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
872 if (expr_symbol_where (symp, &file, &line))
874 if (seg_left == undefined_section)
875 as_bad_where (file, line,
876 _("undefined symbol `%s' in operation"),
878 if (seg_right == undefined_section)
879 as_bad_where (file, line,
880 _("undefined symbol `%s' in operation"),
882 if (seg_left != undefined_section
883 && seg_right != undefined_section)
886 as_bad_where (file, line,
887 _("invalid sections for operation on `%s' and `%s'"),
888 S_GET_NAME (left), S_GET_NAME (right));
890 as_bad_where (file, line,
891 _("invalid section for operation on `%s'"),
898 if (seg_left == undefined_section)
899 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
900 S_GET_NAME (left), S_GET_NAME (symp));
901 if (seg_right == undefined_section)
902 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
903 S_GET_NAME (right), S_GET_NAME (symp));
904 if (seg_left != undefined_section
905 && seg_right != undefined_section)
908 as_bad_where (file, line,
909 _("invalid sections for operation on `%s' and `%s' setting `%s'"),
910 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
912 as_bad_where (file, line,
913 _("invalid section for operation on `%s' setting `%s'"),
914 S_GET_NAME (left), S_GET_NAME (symp));
919 /* Resolve the value of a symbol. This is called during the final
920 pass over the symbol table to resolve any symbols with complex
924 resolve_symbol_value (symp)
928 valueT final_val = 0;
932 if (LOCAL_SYMBOL_CHECK (symp))
934 struct local_symbol *locsym = (struct local_symbol *) symp;
936 final_val = locsym->lsy_value;
937 if (local_symbol_resolved_p (locsym))
940 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
944 locsym->lsy_value = final_val;
945 local_symbol_mark_resolved (locsym);
952 if (symp->sy_resolved)
954 if (symp->sy_value.X_op == O_constant)
955 return (valueT) symp->sy_value.X_add_number;
961 final_seg = S_GET_SEGMENT (symp);
963 if (symp->sy_resolving)
966 as_bad (_("symbol definition loop encountered at `%s'"),
973 symbolS *add_symbol, *op_symbol;
975 segT seg_left, seg_right;
978 symp->sy_resolving = 1;
980 /* Help out with CSE. */
981 add_symbol = symp->sy_value.X_add_symbol;
982 op_symbol = symp->sy_value.X_op_symbol;
983 final_val = symp->sy_value.X_add_number;
984 op = symp->sy_value.X_op;
997 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
998 if (final_seg == expr_section)
999 final_seg = absolute_section;
1005 left = resolve_symbol_value (add_symbol);
1006 seg_left = S_GET_SEGMENT (add_symbol);
1008 symp->sy_value.X_op_symbol = NULL;
1011 if (symp->sy_mri_common)
1013 /* This is a symbol inside an MRI common section. The
1014 relocation routines are going to handle it specially.
1015 Don't change the value. */
1016 resolved = symbol_resolved_p (add_symbol);
1020 if (finalize_syms && final_val == 0)
1022 if (LOCAL_SYMBOL_CHECK (add_symbol))
1023 add_symbol = local_symbol_convert ((struct local_symbol *)
1025 copy_symbol_attributes (symp, add_symbol);
1028 /* If we have equated this symbol to an undefined or common
1029 symbol, keep X_op set to O_symbol, and don't change
1030 X_add_number. This permits the routine which writes out
1031 relocation to detect this case, and convert the
1032 relocation to be against the symbol to which this symbol
1034 if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol))
1038 symp->sy_value.X_op = O_symbol;
1039 symp->sy_value.X_add_symbol = add_symbol;
1040 symp->sy_value.X_add_number = final_val;
1041 /* Use X_op_symbol as a flag. */
1042 symp->sy_value.X_op_symbol = add_symbol;
1043 final_seg = seg_left;
1046 resolved = symbol_resolved_p (add_symbol);
1047 symp->sy_resolving = 0;
1048 goto exit_dont_set_value;
1050 else if (finalize_syms && final_seg == expr_section
1051 && seg_left != expr_section)
1053 /* If the symbol is an expression symbol, do similarly
1054 as for undefined and common syms above. Handles
1055 "sym +/- expr" where "expr" cannot be evaluated
1056 immediately, and we want relocations to be against
1057 "sym", eg. because it is weak. */
1058 symp->sy_value.X_op = O_symbol;
1059 symp->sy_value.X_add_symbol = add_symbol;
1060 symp->sy_value.X_add_number = final_val;
1061 symp->sy_value.X_op_symbol = add_symbol;
1062 final_seg = seg_left;
1063 final_val += symp->sy_frag->fr_address + left;
1064 resolved = symbol_resolved_p (add_symbol);
1065 symp->sy_resolving = 0;
1066 goto exit_dont_set_value;
1070 final_val += symp->sy_frag->fr_address + left;
1071 if (final_seg == expr_section || final_seg == undefined_section)
1072 final_seg = seg_left;
1075 resolved = symbol_resolved_p (add_symbol);
1081 left = resolve_symbol_value (add_symbol);
1082 seg_left = S_GET_SEGMENT (add_symbol);
1084 /* By reducing these to the relevant dyadic operator, we get
1085 !S -> S == 0 permitted on anything,
1086 -S -> 0 - S only permitted on absolute
1087 ~S -> S ^ ~0 only permitted on absolute */
1088 if (op != O_logical_not && seg_left != absolute_section
1090 report_op_error (symp, add_symbol, NULL);
1092 if (final_seg == expr_section || final_seg == undefined_section)
1093 final_seg = absolute_section;
1097 else if (op == O_logical_not)
1102 final_val += left + symp->sy_frag->fr_address;
1104 resolved = symbol_resolved_p (add_symbol);
1112 case O_bit_inclusive_or:
1114 case O_bit_exclusive_or:
1126 left = resolve_symbol_value (add_symbol);
1127 right = resolve_symbol_value (op_symbol);
1128 seg_left = S_GET_SEGMENT (add_symbol);
1129 seg_right = S_GET_SEGMENT (op_symbol);
1131 /* Simplify addition or subtraction of a constant by folding the
1132 constant into X_add_number. */
1135 if (seg_right == absolute_section)
1140 else if (seg_left == absolute_section)
1143 add_symbol = op_symbol;
1145 seg_left = seg_right;
1149 else if (op == O_subtract)
1151 if (seg_right == absolute_section)
1158 /* Equality and non-equality tests are permitted on anything.
1159 Subtraction, and other comparison operators are permitted if
1160 both operands are in the same section. Otherwise, both
1161 operands must be absolute. We already handled the case of
1162 addition or subtraction of a constant above. This will
1163 probably need to be changed for an object file format which
1164 supports arbitrary expressions, such as IEEE-695.
1166 Don't emit messages unless we're finalizing the symbol value,
1167 otherwise we may get the same message multiple times. */
1169 && !(seg_left == absolute_section
1170 && seg_right == absolute_section)
1171 && !(op == O_eq || op == O_ne)
1172 && !((op == O_subtract
1173 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1174 && seg_left == seg_right
1175 && (seg_left != undefined_section
1176 || add_symbol == op_symbol)))
1177 report_op_error (symp, add_symbol, op_symbol);
1179 if (final_seg == expr_section || final_seg == undefined_section)
1180 final_seg = absolute_section;
1182 /* Check for division by zero. */
1183 if ((op == O_divide || op == O_modulus) && right == 0)
1185 /* If seg_right is not absolute_section, then we've
1186 already issued a warning about using a bad symbol. */
1187 if (seg_right == absolute_section && finalize_syms)
1192 if (expr_symbol_where (symp, &file, &line))
1193 as_bad_where (file, line, _("division by zero"));
1195 as_bad (_("division by zero when setting `%s'"),
1202 switch (symp->sy_value.X_op)
1204 case O_multiply: left *= right; break;
1205 case O_divide: left /= right; break;
1206 case O_modulus: left %= right; break;
1207 case O_left_shift: left <<= right; break;
1208 case O_right_shift: left >>= right; break;
1209 case O_bit_inclusive_or: left |= right; break;
1210 case O_bit_or_not: left |= ~right; break;
1211 case O_bit_exclusive_or: left ^= right; break;
1212 case O_bit_and: left &= right; break;
1213 case O_add: left += right; break;
1214 case O_subtract: left -= right; break;
1217 left = (left == right && seg_left == seg_right
1218 && (seg_left != undefined_section
1219 || add_symbol == op_symbol)
1220 ? ~ (offsetT) 0 : 0);
1221 if (symp->sy_value.X_op == O_ne)
1224 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1225 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1226 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1227 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1228 case O_logical_and: left = left && right; break;
1229 case O_logical_or: left = left || right; break;
1233 final_val += symp->sy_frag->fr_address + left;
1234 if (final_seg == expr_section || final_seg == undefined_section)
1236 if (seg_left == undefined_section
1237 || seg_right == undefined_section)
1238 final_seg = undefined_section;
1239 else if (seg_left == absolute_section)
1240 final_seg = seg_right;
1242 final_seg = seg_left;
1244 resolved = (symbol_resolved_p (add_symbol)
1245 && symbol_resolved_p (op_symbol));
1251 /* Give an error (below) if not in expr_section. We don't
1252 want to worry about expr_section symbols, because they
1253 are fictional (they are created as part of expression
1254 resolution), and any problems may not actually mean
1259 symp->sy_resolving = 0;
1263 S_SET_VALUE (symp, final_val);
1265 exit_dont_set_value:
1266 /* Always set the segment, even if not finalizing the value.
1267 The segment is used to determine whether a symbol is defined. */
1268 #if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)
1269 /* The old a.out backend does not handle S_SET_SEGMENT correctly
1270 for a stab symbol, so we use this bad hack. */
1271 if (final_seg != S_GET_SEGMENT (symp))
1273 S_SET_SEGMENT (symp, final_seg);
1275 /* Don't worry if we can't resolve an expr_section symbol. */
1279 symp->sy_resolved = 1;
1280 else if (S_GET_SEGMENT (symp) != expr_section)
1282 as_bad (_("can't resolve value for symbol `%s'"),
1284 symp->sy_resolved = 1;
1291 #ifdef BFD_ASSEMBLER
1293 static void resolve_local_symbol PARAMS ((const char *, PTR));
1295 /* A static function passed to hash_traverse. */
1298 resolve_local_symbol (key, value)
1299 const char *key ATTRIBUTE_UNUSED;
1303 resolve_symbol_value (value);
1308 /* Resolve all local symbols. */
1311 resolve_local_symbol_values ()
1313 #ifdef BFD_ASSEMBLER
1314 hash_traverse (local_hash, resolve_local_symbol);
1318 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1319 They are *really* local. That is, they go out of scope whenever we see a
1320 label that isn't local. Also, like fb labels, there can be multiple
1321 instances of a dollar label. Therefor, we name encode each instance with
1322 the instance number, keep a list of defined symbols separate from the real
1323 symbol table, and we treat these buggers as a sparse array. */
1325 static long *dollar_labels;
1326 static long *dollar_label_instances;
1327 static char *dollar_label_defines;
1328 static unsigned long dollar_label_count;
1329 static unsigned long dollar_label_max;
1332 dollar_label_defined (label)
1337 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1339 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1341 return dollar_label_defines[i - dollar_labels];
1343 /* If we get here, label isn't defined. */
1348 dollar_label_instance (label)
1353 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1355 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1357 return (dollar_label_instances[i - dollar_labels]);
1359 /* If we get here, we haven't seen the label before.
1360 Therefore its instance count is zero. */
1365 dollar_label_clear ()
1367 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1370 #define DOLLAR_LABEL_BUMP_BY 10
1373 define_dollar_label (label)
1378 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1381 ++dollar_label_instances[i - dollar_labels];
1382 dollar_label_defines[i - dollar_labels] = 1;
1386 /* If we get to here, we don't have label listed yet. */
1388 if (dollar_labels == NULL)
1390 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1391 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1392 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1393 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1394 dollar_label_count = 0;
1396 else if (dollar_label_count == dollar_label_max)
1398 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1399 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1400 dollar_label_max * sizeof (long));
1401 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1402 dollar_label_max * sizeof (long));
1403 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1404 } /* if we needed to grow */
1406 dollar_labels[dollar_label_count] = label;
1407 dollar_label_instances[dollar_label_count] = 1;
1408 dollar_label_defines[dollar_label_count] = 1;
1409 ++dollar_label_count;
1412 /* Caller must copy returned name: we re-use the area for the next name.
1414 The mth occurence of label n: is turned into the symbol "Ln^Am"
1415 where n is the label number and m is the instance number. "L" makes
1416 it a label discarded unless debugging and "^A"('\1') ensures no
1417 ordinary symbol SHOULD get the same name as a local label
1418 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1420 fb labels get the same treatment, except that ^B is used in place
1423 char * /* Return local label name. */
1424 dollar_label_name (n, augend)
1425 register long n; /* we just saw "n$:" : n a number. */
1426 register int augend; /* 0 for current instance, 1 for new instance. */
1429 /* Returned to caller, then copied. Used for created names ("4f"). */
1430 static char symbol_name_build[24];
1433 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1436 know (augend == 0 || augend == 1);
1437 p = symbol_name_build;
1438 #ifdef LOCAL_LABEL_PREFIX
1439 *p++ = LOCAL_LABEL_PREFIX;
1443 /* Next code just does sprintf( {}, "%d", n); */
1445 q = symbol_name_temporary;
1446 for (*q++ = 0, i = n; i; ++q)
1451 while ((*p = *--q) != '\0')
1454 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1456 /* Instance number. */
1457 q = symbol_name_temporary;
1458 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1463 while ((*p++ = *--q) != '\0');;
1465 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1466 return symbol_name_build;
1469 /* Sombody else's idea of local labels. They are made by "n:" where n
1470 is any decimal digit. Refer to them with
1471 "nb" for previous (backward) n:
1472 or "nf" for next (forward) n:.
1474 We do a little better and let n be any number, not just a single digit, but
1475 since the other guy's assembler only does ten, we treat the first ten
1478 Like someone else's assembler, we have one set of local label counters for
1479 entire assembly, not one set per (sub)segment like in most assemblers. This
1480 implies that one can refer to a label in another segment, and indeed some
1481 crufty compilers have done just that.
1483 Since there could be a LOT of these things, treat them as a sparse
1486 #define FB_LABEL_SPECIAL (10)
1488 static long fb_low_counter[FB_LABEL_SPECIAL];
1489 static long *fb_labels;
1490 static long *fb_label_instances;
1491 static long fb_label_count;
1492 static long fb_label_max;
1494 /* This must be more than FB_LABEL_SPECIAL. */
1495 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1500 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1503 /* Add one to the instance number of this fb label. */
1506 fb_label_instance_inc (label)
1511 if (label < FB_LABEL_SPECIAL)
1513 ++fb_low_counter[label];
1517 if (fb_labels != NULL)
1519 for (i = fb_labels + FB_LABEL_SPECIAL;
1520 i < fb_labels + fb_label_count; ++i)
1524 ++fb_label_instances[i - fb_labels];
1526 } /* if we find it */
1527 } /* for each existing label */
1530 /* If we get to here, we don't have label listed yet. */
1532 if (fb_labels == NULL)
1534 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1535 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1536 fb_label_max = FB_LABEL_BUMP_BY;
1537 fb_label_count = FB_LABEL_SPECIAL;
1540 else if (fb_label_count == fb_label_max)
1542 fb_label_max += FB_LABEL_BUMP_BY;
1543 fb_labels = (long *) xrealloc ((char *) fb_labels,
1544 fb_label_max * sizeof (long));
1545 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1546 fb_label_max * sizeof (long));
1547 } /* if we needed to grow */
1549 fb_labels[fb_label_count] = label;
1550 fb_label_instances[fb_label_count] = 1;
1555 fb_label_instance (label)
1560 if (label < FB_LABEL_SPECIAL)
1562 return (fb_low_counter[label]);
1565 if (fb_labels != NULL)
1567 for (i = fb_labels + FB_LABEL_SPECIAL;
1568 i < fb_labels + fb_label_count; ++i)
1572 return (fb_label_instances[i - fb_labels]);
1573 } /* if we find it */
1574 } /* for each existing label */
1577 /* We didn't find the label, so this must be a reference to the
1582 /* Caller must copy returned name: we re-use the area for the next name.
1584 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1585 where n is the label number and m is the instance number. "L" makes
1586 it a label discarded unless debugging and "^B"('\2') ensures no
1587 ordinary symbol SHOULD get the same name as a local label
1588 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1590 dollar labels get the same treatment, except that ^A is used in
1593 char * /* Return local label name. */
1594 fb_label_name (n, augend)
1595 long n; /* We just saw "n:", "nf" or "nb" : n a number. */
1596 long augend; /* 0 for nb, 1 for n:, nf. */
1599 /* Returned to caller, then copied. Used for created names ("4f"). */
1600 static char symbol_name_build[24];
1603 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1606 know (augend == 0 || augend == 1);
1607 p = symbol_name_build;
1608 #ifdef LOCAL_LABEL_PREFIX
1609 *p++ = LOCAL_LABEL_PREFIX;
1613 /* Next code just does sprintf( {}, "%d", n); */
1615 q = symbol_name_temporary;
1616 for (*q++ = 0, i = n; i; ++q)
1621 while ((*p = *--q) != '\0')
1624 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1626 /* Instance number. */
1627 q = symbol_name_temporary;
1628 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1633 while ((*p++ = *--q) != '\0');;
1635 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1636 return (symbol_name_build);
1639 /* Decode name that may have been generated by foo_label_name() above.
1640 If the name wasn't generated by foo_label_name(), then return it
1641 unaltered. This is used for error messages. */
1644 decode_local_label_name (s)
1648 char *symbol_decode;
1650 int instance_number;
1652 const char *message_format;
1655 #ifdef LOCAL_LABEL_PREFIX
1656 if (s[index] == LOCAL_LABEL_PREFIX)
1660 if (s[index] != 'L')
1663 for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1664 label_number = (10 * label_number) + *p - '0';
1666 if (*p == DOLLAR_LABEL_CHAR)
1668 else if (*p == LOCAL_LABEL_CHAR)
1673 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1674 instance_number = (10 * instance_number) + *p - '0';
1676 message_format = _("\"%d\" (instance number %d of a %s label)");
1677 symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30);
1678 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1680 return symbol_decode;
1683 /* Get the value of a symbol. */
1689 #ifdef BFD_ASSEMBLER
1690 if (LOCAL_SYMBOL_CHECK (s))
1691 return resolve_symbol_value (s);
1694 if (!s->sy_resolved)
1696 valueT val = resolve_symbol_value (s);
1700 if (s->sy_value.X_op != O_constant)
1702 static symbolS *recur;
1704 /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
1705 may call S_GET_VALUE. We use a static symbol to avoid the
1706 immediate recursion. */
1708 return (valueT) s->sy_value.X_add_number;
1710 if (! s->sy_resolved
1711 || s->sy_value.X_op != O_symbol
1712 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1713 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1717 return (valueT) s->sy_value.X_add_number;
1720 /* Set the value of a symbol. */
1723 S_SET_VALUE (s, val)
1727 #ifdef BFD_ASSEMBLER
1728 if (LOCAL_SYMBOL_CHECK (s))
1730 ((struct local_symbol *) s)->lsy_value = val;
1735 s->sy_value.X_op = O_constant;
1736 s->sy_value.X_add_number = (offsetT) val;
1737 s->sy_value.X_unsigned = 0;
1741 copy_symbol_attributes (dest, src)
1742 symbolS *dest, *src;
1744 if (LOCAL_SYMBOL_CHECK (dest))
1745 dest = local_symbol_convert ((struct local_symbol *) dest);
1746 if (LOCAL_SYMBOL_CHECK (src))
1747 src = local_symbol_convert ((struct local_symbol *) src);
1749 #ifdef BFD_ASSEMBLER
1750 /* In an expression, transfer the settings of these flags.
1751 The user can override later, of course. */
1752 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1753 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1756 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1757 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1761 #ifdef BFD_ASSEMBLER
1769 if (LOCAL_SYMBOL_CHECK (s))
1772 flags = s->bsym->flags;
1774 return (flags & BSF_FUNCTION) != 0;
1783 if (LOCAL_SYMBOL_CHECK (s))
1786 flags = s->bsym->flags;
1789 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1792 return (flags & BSF_GLOBAL) != 0;
1799 if (LOCAL_SYMBOL_CHECK (s))
1801 return (s->bsym->flags & BSF_WEAK) != 0;
1808 if (LOCAL_SYMBOL_CHECK (s))
1810 return bfd_is_com_section (s->bsym->section);
1817 if (LOCAL_SYMBOL_CHECK (s))
1818 return ((struct local_symbol *) s)->lsy_section != undefined_section;
1819 return s->bsym->section != undefined_section;
1823 #ifndef EXTERN_FORCE_RELOC
1824 #define EXTERN_FORCE_RELOC IS_ELF
1827 /* Return true for symbols that should not be reduced to section
1828 symbols or eliminated from expressions, because they may be
1829 overridden by the linker. */
1831 S_FORCE_RELOC (s, strict)
1835 if (LOCAL_SYMBOL_CHECK (s))
1836 return ((struct local_symbol *) s)->lsy_section == undefined_section;
1839 && ((s->bsym->flags & BSF_WEAK) != 0
1840 || (EXTERN_FORCE_RELOC
1841 && (s->bsym->flags & BSF_GLOBAL) != 0)))
1842 || s->bsym->section == undefined_section
1843 || bfd_is_com_section (s->bsym->section));
1850 if (LOCAL_SYMBOL_CHECK (s))
1852 if (s->bsym->flags & BSF_DEBUGGING)
1864 if (LOCAL_SYMBOL_CHECK (s))
1867 flags = s->bsym->flags;
1870 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1873 if (bfd_get_section (s->bsym) == reg_section)
1876 if (flag_strip_local_absolute
1877 && (flags & BSF_GLOBAL) == 0
1878 && bfd_get_section (s->bsym) == absolute_section)
1881 name = S_GET_NAME (s);
1882 return (name != NULL
1884 && (strchr (name, DOLLAR_LABEL_CHAR)
1885 || strchr (name, LOCAL_LABEL_CHAR)
1886 || (! flag_keep_locals
1887 && (bfd_is_local_label (stdoutput, s->bsym)
1890 && name[1] == '?')))));
1897 return S_IS_EXTERNAL (s);
1904 return S_GET_NAME (s) == 0;
1911 if (LOCAL_SYMBOL_CHECK (s))
1912 return ((struct local_symbol *) s)->lsy_name;
1913 return s->bsym->name;
1920 if (LOCAL_SYMBOL_CHECK (s))
1921 return ((struct local_symbol *) s)->lsy_section;
1922 return s->bsym->section;
1926 S_SET_SEGMENT (s, seg)
1930 /* Don't reassign section symbols. The direct reason is to prevent seg
1931 faults assigning back to const global symbols such as *ABS*, but it
1932 shouldn't happen anyway. */
1934 if (LOCAL_SYMBOL_CHECK (s))
1936 if (seg == reg_section)
1937 s = local_symbol_convert ((struct local_symbol *) s);
1940 ((struct local_symbol *) s)->lsy_section = seg;
1945 if (s->bsym->flags & BSF_SECTION_SYM)
1947 if (s->bsym->section != seg)
1951 s->bsym->section = seg;
1958 if (LOCAL_SYMBOL_CHECK (s))
1959 s = local_symbol_convert ((struct local_symbol *) s);
1960 if ((s->bsym->flags & BSF_WEAK) != 0)
1962 /* Let .weak override .global. */
1965 if (s->bsym->flags & BSF_SECTION_SYM)
1970 /* Do not reassign section symbols. */
1971 as_where (& file, & line);
1972 as_warn_where (file, line,
1973 _("section symbols are already global"));
1976 s->bsym->flags |= BSF_GLOBAL;
1977 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
1981 S_CLEAR_EXTERNAL (s)
1984 if (LOCAL_SYMBOL_CHECK (s))
1986 if ((s->bsym->flags & BSF_WEAK) != 0)
1988 /* Let .weak override. */
1991 s->bsym->flags |= BSF_LOCAL;
1992 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
1999 if (LOCAL_SYMBOL_CHECK (s))
2000 s = local_symbol_convert ((struct local_symbol *) s);
2001 s->bsym->flags |= BSF_WEAK;
2002 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2006 S_SET_THREAD_LOCAL (s)
2009 if (LOCAL_SYMBOL_CHECK (s))
2010 s = local_symbol_convert ((struct local_symbol *) s);
2011 if (bfd_is_com_section (s->bsym->section)
2012 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2014 s->bsym->flags |= BSF_THREAD_LOCAL;
2015 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2016 as_bad (_("Accessing function `%s' as thread-local object"),
2018 else if (! bfd_is_und_section (s->bsym->section)
2019 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2020 as_bad (_("Accessing `%s' as thread-local object"),
2025 S_SET_NAME (s, name)
2029 if (LOCAL_SYMBOL_CHECK (s))
2031 ((struct local_symbol *) s)->lsy_name = name;
2034 s->bsym->name = name;
2036 #endif /* BFD_ASSEMBLER */
2038 #ifdef SYMBOLS_NEED_BACKPOINTERS
2040 /* Return the previous symbol in a chain. */
2046 if (LOCAL_SYMBOL_CHECK (s))
2048 return s->sy_previous;
2051 #endif /* SYMBOLS_NEED_BACKPOINTERS */
2053 /* Return the next symbol in a chain. */
2059 if (LOCAL_SYMBOL_CHECK (s))
2064 /* Return a pointer to the value of a symbol as an expression. */
2067 symbol_get_value_expression (s)
2070 if (LOCAL_SYMBOL_CHECK (s))
2071 s = local_symbol_convert ((struct local_symbol *) s);
2072 return &s->sy_value;
2075 /* Set the value of a symbol to an expression. */
2078 symbol_set_value_expression (s, exp)
2080 const expressionS *exp;
2082 if (LOCAL_SYMBOL_CHECK (s))
2083 s = local_symbol_convert ((struct local_symbol *) s);
2087 /* Set the value of SYM to the current position in the current segment. */
2090 symbol_set_value_now (sym)
2093 S_SET_SEGMENT (sym, now_seg);
2094 S_SET_VALUE (sym, frag_now_fix ());
2095 symbol_set_frag (sym, frag_now);
2098 /* Set the frag of a symbol. */
2101 symbol_set_frag (s, f)
2105 #ifdef BFD_ASSEMBLER
2106 if (LOCAL_SYMBOL_CHECK (s))
2108 local_symbol_set_frag ((struct local_symbol *) s, f);
2115 /* Return the frag of a symbol. */
2121 #ifdef BFD_ASSEMBLER
2122 if (LOCAL_SYMBOL_CHECK (s))
2123 return local_symbol_get_frag ((struct local_symbol *) s);
2128 /* Mark a symbol as having been used. */
2131 symbol_mark_used (s)
2134 if (LOCAL_SYMBOL_CHECK (s))
2139 /* Clear the mark of whether a symbol has been used. */
2142 symbol_clear_used (s)
2145 if (LOCAL_SYMBOL_CHECK (s))
2146 s = local_symbol_convert ((struct local_symbol *) s);
2150 /* Return whether a symbol has been used. */
2156 if (LOCAL_SYMBOL_CHECK (s))
2161 /* Mark a symbol as having been used in a reloc. */
2164 symbol_mark_used_in_reloc (s)
2167 if (LOCAL_SYMBOL_CHECK (s))
2168 s = local_symbol_convert ((struct local_symbol *) s);
2169 s->sy_used_in_reloc = 1;
2172 /* Clear the mark of whether a symbol has been used in a reloc. */
2175 symbol_clear_used_in_reloc (s)
2178 if (LOCAL_SYMBOL_CHECK (s))
2180 s->sy_used_in_reloc = 0;
2183 /* Return whether a symbol has been used in a reloc. */
2186 symbol_used_in_reloc_p (s)
2189 if (LOCAL_SYMBOL_CHECK (s))
2191 return s->sy_used_in_reloc;
2194 /* Mark a symbol as an MRI common symbol. */
2197 symbol_mark_mri_common (s)
2200 if (LOCAL_SYMBOL_CHECK (s))
2201 s = local_symbol_convert ((struct local_symbol *) s);
2202 s->sy_mri_common = 1;
2205 /* Clear the mark of whether a symbol is an MRI common symbol. */
2208 symbol_clear_mri_common (s)
2211 if (LOCAL_SYMBOL_CHECK (s))
2213 s->sy_mri_common = 0;
2216 /* Return whether a symbol is an MRI common symbol. */
2219 symbol_mri_common_p (s)
2222 if (LOCAL_SYMBOL_CHECK (s))
2224 return s->sy_mri_common;
2227 /* Mark a symbol as having been written. */
2230 symbol_mark_written (s)
2233 if (LOCAL_SYMBOL_CHECK (s))
2238 /* Clear the mark of whether a symbol has been written. */
2241 symbol_clear_written (s)
2244 if (LOCAL_SYMBOL_CHECK (s))
2249 /* Return whether a symbol has been written. */
2252 symbol_written_p (s)
2255 if (LOCAL_SYMBOL_CHECK (s))
2260 /* Mark a symbol has having been resolved. */
2263 symbol_mark_resolved (s)
2266 #ifdef BFD_ASSEMBLER
2267 if (LOCAL_SYMBOL_CHECK (s))
2269 local_symbol_mark_resolved ((struct local_symbol *) s);
2276 /* Return whether a symbol has been resolved. */
2279 symbol_resolved_p (s)
2282 #ifdef BFD_ASSEMBLER
2283 if (LOCAL_SYMBOL_CHECK (s))
2284 return local_symbol_resolved_p ((struct local_symbol *) s);
2286 return s->sy_resolved;
2289 /* Return whether a symbol is a section symbol. */
2292 symbol_section_p (s)
2293 symbolS *s ATTRIBUTE_UNUSED;
2295 if (LOCAL_SYMBOL_CHECK (s))
2297 #ifdef BFD_ASSEMBLER
2298 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2305 /* Return whether a symbol is equated to another symbol. */
2308 symbol_equated_p (s)
2311 if (LOCAL_SYMBOL_CHECK (s))
2313 return s->sy_value.X_op == O_symbol;
2316 /* Return whether a symbol is equated to another symbol, and should be
2317 treated specially when writing out relocs. */
2320 symbol_equated_reloc_p (s)
2323 if (LOCAL_SYMBOL_CHECK (s))
2325 /* X_op_symbol, normally not used for O_symbol, is set by
2326 resolve_symbol_value to flag expression syms that have been
2328 return (s->sy_value.X_op == O_symbol
2329 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2330 || ! S_IS_DEFINED (s)
2331 || S_IS_COMMON (s)));
2334 /* Return whether a symbol has a constant value. */
2337 symbol_constant_p (s)
2340 if (LOCAL_SYMBOL_CHECK (s))
2342 return s->sy_value.X_op == O_constant;
2345 #ifdef BFD_ASSEMBLER
2347 /* Return the BFD symbol for a symbol. */
2350 symbol_get_bfdsym (s)
2353 if (LOCAL_SYMBOL_CHECK (s))
2354 s = local_symbol_convert ((struct local_symbol *) s);
2358 /* Set the BFD symbol for a symbol. */
2361 symbol_set_bfdsym (s, bsym)
2365 if (LOCAL_SYMBOL_CHECK (s))
2366 s = local_symbol_convert ((struct local_symbol *) s);
2370 #endif /* BFD_ASSEMBLER */
2372 #ifdef OBJ_SYMFIELD_TYPE
2374 /* Get a pointer to the object format information for a symbol. */
2380 if (LOCAL_SYMBOL_CHECK (s))
2381 s = local_symbol_convert ((struct local_symbol *) s);
2385 /* Set the object format information for a symbol. */
2388 symbol_set_obj (s, o)
2390 OBJ_SYMFIELD_TYPE *o;
2392 if (LOCAL_SYMBOL_CHECK (s))
2393 s = local_symbol_convert ((struct local_symbol *) s);
2397 #endif /* OBJ_SYMFIELD_TYPE */
2399 #ifdef TC_SYMFIELD_TYPE
2401 /* Get a pointer to the processor information for a symbol. */
2407 if (LOCAL_SYMBOL_CHECK (s))
2408 s = local_symbol_convert ((struct local_symbol *) s);
2412 /* Set the processor information for a symbol. */
2415 symbol_set_tc (s, o)
2417 TC_SYMFIELD_TYPE *o;
2419 if (LOCAL_SYMBOL_CHECK (s))
2420 s = local_symbol_convert ((struct local_symbol *) s);
2424 #endif /* TC_SYMFIELD_TYPE */
2429 symbol_lastP = NULL;
2430 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2431 sy_hash = hash_new ();
2432 #ifdef BFD_ASSEMBLER
2433 local_hash = hash_new ();
2436 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2437 #ifdef BFD_ASSEMBLER
2438 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2439 abs_symbol.bsym = bfd_abs_section.symbol;
2442 /* Can't initialise a union. Sigh. */
2443 S_SET_SEGMENT (&abs_symbol, absolute_section);
2445 abs_symbol.sy_value.X_op = O_constant;
2446 abs_symbol.sy_frag = &zero_address_frag;
2448 if (LOCAL_LABELS_FB)
2454 /* Maximum indent level.
2455 Available for modification inside a gdb session. */
2456 int max_indent_level = 8;
2463 printf ("%*s", indent_level * 4, "");
2469 print_symbol_value_1 (file, sym)
2473 const char *name = S_GET_NAME (sym);
2474 if (!name || !name[0])
2476 fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2478 if (LOCAL_SYMBOL_CHECK (sym))
2480 #ifdef BFD_ASSEMBLER
2481 struct local_symbol *locsym = (struct local_symbol *) sym;
2482 if (local_symbol_get_frag (locsym) != &zero_address_frag
2483 && local_symbol_get_frag (locsym) != NULL)
2484 fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2485 if (local_symbol_resolved_p (locsym))
2486 fprintf (file, " resolved");
2487 fprintf (file, " local");
2492 if (sym->sy_frag != &zero_address_frag)
2493 fprintf (file, " frag %lx", (long) sym->sy_frag);
2495 fprintf (file, " written");
2496 if (sym->sy_resolved)
2497 fprintf (file, " resolved");
2498 else if (sym->sy_resolving)
2499 fprintf (file, " resolving");
2500 if (sym->sy_used_in_reloc)
2501 fprintf (file, " used-in-reloc");
2503 fprintf (file, " used");
2504 if (S_IS_LOCAL (sym))
2505 fprintf (file, " local");
2506 if (S_IS_EXTERN (sym))
2507 fprintf (file, " extern");
2508 if (S_IS_DEBUG (sym))
2509 fprintf (file, " debug");
2510 if (S_IS_DEFINED (sym))
2511 fprintf (file, " defined");
2513 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2514 if (symbol_resolved_p (sym))
2516 segT s = S_GET_SEGMENT (sym);
2518 if (s != undefined_section
2519 && s != expr_section)
2520 fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2522 else if (indent_level < max_indent_level
2523 && S_GET_SEGMENT (sym) != undefined_section)
2526 fprintf (file, "\n%*s<", indent_level * 4, "");
2527 #ifdef BFD_ASSEMBLER
2528 if (LOCAL_SYMBOL_CHECK (sym))
2529 fprintf (file, "constant %lx",
2530 (long) ((struct local_symbol *) sym)->lsy_value);
2533 print_expr_1 (file, &sym->sy_value);
2534 fprintf (file, ">");
2541 print_symbol_value (sym)
2545 print_symbol_value_1 (stderr, sym);
2546 fprintf (stderr, "\n");
2550 print_binary (file, name, exp)
2556 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2557 print_symbol_value_1 (file, exp->X_add_symbol);
2558 fprintf (file, ">\n%*s<", indent_level * 4, "");
2559 print_symbol_value_1 (file, exp->X_op_symbol);
2560 fprintf (file, ">");
2565 print_expr_1 (file, exp)
2569 fprintf (file, "expr %lx ", (long) exp);
2573 fprintf (file, "illegal");
2576 fprintf (file, "absent");
2579 fprintf (file, "constant %lx", (long) exp->X_add_number);
2583 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2584 print_symbol_value_1 (file, exp->X_add_symbol);
2585 fprintf (file, ">");
2587 if (exp->X_add_number)
2588 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2589 (long) exp->X_add_number);
2593 fprintf (file, "register #%d", (int) exp->X_add_number);
2596 fprintf (file, "big");
2599 fprintf (file, "uminus -<");
2601 print_symbol_value_1 (file, exp->X_add_symbol);
2602 fprintf (file, ">");
2603 goto maybe_print_addnum;
2605 fprintf (file, "bit_not");
2608 print_binary (file, "multiply", exp);
2611 print_binary (file, "divide", exp);
2614 print_binary (file, "modulus", exp);
2617 print_binary (file, "lshift", exp);
2620 print_binary (file, "rshift", exp);
2622 case O_bit_inclusive_or:
2623 print_binary (file, "bit_ior", exp);
2625 case O_bit_exclusive_or:
2626 print_binary (file, "bit_xor", exp);
2629 print_binary (file, "bit_and", exp);
2632 print_binary (file, "eq", exp);
2635 print_binary (file, "ne", exp);
2638 print_binary (file, "lt", exp);
2641 print_binary (file, "le", exp);
2644 print_binary (file, "ge", exp);
2647 print_binary (file, "gt", exp);
2650 print_binary (file, "logical_and", exp);
2653 print_binary (file, "logical_or", exp);
2657 fprintf (file, "add\n%*s<", indent_level * 4, "");
2658 print_symbol_value_1 (file, exp->X_add_symbol);
2659 fprintf (file, ">\n%*s<", indent_level * 4, "");
2660 print_symbol_value_1 (file, exp->X_op_symbol);
2661 fprintf (file, ">");
2662 goto maybe_print_addnum;
2665 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2666 print_symbol_value_1 (file, exp->X_add_symbol);
2667 fprintf (file, ">\n%*s<", indent_level * 4, "");
2668 print_symbol_value_1 (file, exp->X_op_symbol);
2669 fprintf (file, ">");
2670 goto maybe_print_addnum;
2672 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2682 print_expr_1 (stderr, exp);
2683 fprintf (stderr, "\n");
2687 symbol_print_statistics (file)
2690 hash_print_statistics (file, "symbol table", sy_hash);
2691 #ifdef BFD_ASSEMBLER
2692 hash_print_statistics (file, "mini local symbol table", local_hash);
2693 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2694 local_symbol_count, local_symbol_conversion_count);