1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
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
*));
70 /* Return a pointer to a new symbol. Die if we can't make a new
71 symbol. Fill in the symbol's values. Add symbol to end of symbol
74 This function should be called in the general case of creating a
75 symbol. However, if the output file symbol table has already been
76 set, and you are certain that this symbol won't be wanted in the
77 output file, you can call symbol_create. */
80 symbol_new (name
, segment
, valu
, frag
)
86 symbolS
*symbolP
= symbol_create (name
, segment
, valu
, frag
);
88 /* Link to end of symbol chain. */
91 extern int symbol_table_frozen
;
92 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 (name
)
108 unsigned int name_length
;
111 name_length
= strlen (name
) + 1; /* +1 for \0. */
112 obstack_grow (¬es
, name
, name_length
);
113 ret
= obstack_finish (¬es
);
115 #ifdef STRIP_UNDERSCORE
120 #ifdef tc_canonicalize_symbol_name
121 ret
= tc_canonicalize_symbol_name (ret
);
124 if (! symbols_case_sensitive
)
128 for (s
= ret
; *s
!= '\0'; s
++)
136 symbol_create (name
, segment
, valu
, frag
)
137 const char *name
; /* It is copied, the caller can destroy/modify. */
138 segT segment
; /* Segment identifier (SEG_<something>). */
139 valueT valu
; /* Symbol value. */
140 fragS
*frag
; /* Associated fragment. */
142 char *preserved_copy_of_name
;
145 preserved_copy_of_name
= save_symbol_name (name
);
147 symbolP
= (symbolS
*) obstack_alloc (¬es
, sizeof (symbolS
));
149 /* symbol must be born in some fixed state. This seems as good as any. */
150 memset (symbolP
, 0, sizeof (symbolS
));
153 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
154 if (symbolP
->bsym
== NULL
)
155 as_perror ("%s", "bfd_make_empty_symbol");
156 symbolP
->bsym
->udata
.p
= (PTR
) symbolP
;
158 S_SET_NAME (symbolP
, preserved_copy_of_name
);
160 S_SET_SEGMENT (symbolP
, segment
);
161 S_SET_VALUE (symbolP
, valu
);
162 symbol_clear_list_pointers (symbolP
);
164 symbolP
->sy_frag
= frag
;
165 #ifndef BFD_ASSEMBLER
166 symbolP
->sy_number
= ~0;
167 symbolP
->sy_name_offset
= (unsigned int) ~0;
170 obj_symbol_new_hook (symbolP
);
172 #ifdef tc_symbol_new_hook
173 tc_symbol_new_hook (symbolP
);
181 /* Local symbol support. If we can get away with it, we keep only a
182 small amount of information for local symbols. */
184 static struct local_symbol
*local_symbol_make
PARAMS ((const char *, segT
,
186 static symbolS
*local_symbol_convert
PARAMS ((struct local_symbol
*));
188 /* Used for statistics. */
190 static unsigned long local_symbol_count
;
191 static unsigned long local_symbol_conversion_count
;
193 /* This macro is called with a symbol argument passed by reference.
194 It returns whether this is a local symbol. If necessary, it
195 changes its argument to the real symbol. */
197 #define LOCAL_SYMBOL_CHECK(s) \
199 ? (local_symbol_converted_p ((struct local_symbol *) s) \
200 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
205 /* Create a local symbol and insert it into the local hash table. */
207 static struct local_symbol
*
208 local_symbol_make (name
, section
, value
, frag
)
215 struct local_symbol
*ret
;
217 ++local_symbol_count
;
219 name_copy
= save_symbol_name (name
);
221 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
222 ret
->lsy_marker
= NULL
;
223 ret
->lsy_name
= name_copy
;
224 ret
->lsy_section
= section
;
225 local_symbol_set_frag (ret
, frag
);
226 ret
->lsy_value
= value
;
228 hash_jam (local_hash
, name_copy
, (PTR
) ret
);
233 /* Convert a local symbol into a real symbol. Note that we do not
234 reclaim the space used by the local symbol. */
237 local_symbol_convert (locsym
)
238 struct local_symbol
*locsym
;
242 assert (locsym
->lsy_marker
== NULL
);
243 if (local_symbol_converted_p (locsym
))
244 return local_symbol_get_real_symbol (locsym
);
246 ++local_symbol_conversion_count
;
248 ret
= symbol_new (locsym
->lsy_name
, locsym
->lsy_section
, locsym
->lsy_value
,
249 local_symbol_get_frag (locsym
));
251 if (local_symbol_resolved_p (locsym
))
252 ret
->sy_resolved
= 1;
254 /* Local symbols are always either defined or used. */
257 #ifdef TC_LOCAL_SYMFIELD_CONVERT
258 TC_LOCAL_SYMFIELD_CONVERT (locsym
, ret
);
261 symbol_table_insert (ret
);
263 local_symbol_mark_converted (locsym
);
264 local_symbol_set_real_symbol (locsym
, ret
);
266 hash_jam (local_hash
, locsym
->lsy_name
, NULL
);
271 #else /* ! BFD_ASSEMBLER */
273 #define LOCAL_SYMBOL_CHECK(s) 0
274 #define local_symbol_convert(s) ((symbolS *) s)
276 #endif /* ! BFD_ASSEMBLER */
278 /* We have just seen "<name>:".
279 Creates a struct symbol unless it already exists.
281 Gripes if we are redefining a symbol incompatibly (and ignores it). */
284 colon (sym_name
) /* Just seen "x:" - rattle symbols & frags. */
285 const char *sym_name
; /* Symbol name, as a cannonical string. */
286 /* We copy this string: OK to alter later. */
288 register symbolS
*symbolP
; /* Symbol we are working with. */
290 if (now_seg
== absolute_section
)
292 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
296 /* Sun local labels go out of scope whenever a non-local symbol is
298 if (LOCAL_LABELS_DOLLAR
)
303 local
= bfd_is_local_label_name (stdoutput
, sym_name
);
305 local
= LOCAL_LABEL (sym_name
);
309 dollar_label_clear ();
312 #ifndef WORKING_DOT_WORD
313 if (new_broken_words
)
315 struct broken_word
*a
;
320 extern const int md_short_jump_size
;
321 extern const int md_long_jump_size
;
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 /* Implement symbol table lookup.
592 In: A symbol's name as a string: '\0' can't be part of a symbol name.
593 Out: NULL if the name was not in the symbol table, else the address
594 of a struct symbol associated with that name. */
600 #ifdef STRIP_UNDERSCORE
601 return (symbol_find_base (name
, 1));
602 #else /* STRIP_UNDERSCORE */
603 return (symbol_find_base (name
, 0));
604 #endif /* STRIP_UNDERSCORE */
608 symbol_find_exact (name
)
613 struct local_symbol
*locsym
;
615 locsym
= (struct local_symbol
*) hash_find (local_hash
, name
);
617 return (symbolS
*) locsym
;
621 return ((symbolS
*) hash_find (sy_hash
, name
));
625 symbol_find_base (name
, strip_underscore
)
627 int strip_underscore
;
629 if (strip_underscore
&& *name
== '_')
632 #ifdef tc_canonicalize_symbol_name
635 size_t len
= strlen (name
) + 1;
637 copy
= (char *) alloca (len
);
638 memcpy (copy
, name
, len
);
639 name
= tc_canonicalize_symbol_name (copy
);
643 if (! symbols_case_sensitive
)
650 name
= copy
= (char *) alloca (strlen (name
) + 1);
652 while ((c
= *orig
++) != '\0')
654 *copy
++ = TOUPPER (c
);
659 return symbol_find_exact (name
);
662 /* Once upon a time, symbols were kept in a singly linked list. At
663 least coff needs to be able to rearrange them from time to time, for
664 which a doubly linked list is much more convenient. Loic did these
665 as macros which seemed dangerous to me so they're now functions.
668 /* Link symbol ADDME after symbol TARGET in the chain. */
671 symbol_append (addme
, target
, rootPP
, lastPP
)
677 if (LOCAL_SYMBOL_CHECK (addme
))
679 if (target
!= NULL
&& LOCAL_SYMBOL_CHECK (target
))
684 know (*rootPP
== NULL
);
685 know (*lastPP
== NULL
);
686 addme
->sy_next
= NULL
;
687 #ifdef SYMBOLS_NEED_BACKPOINTERS
688 addme
->sy_previous
= NULL
;
693 } /* if the list is empty */
695 if (target
->sy_next
!= NULL
)
697 #ifdef SYMBOLS_NEED_BACKPOINTERS
698 target
->sy_next
->sy_previous
= addme
;
699 #endif /* SYMBOLS_NEED_BACKPOINTERS */
703 know (*lastPP
== target
);
705 } /* if we have a next */
707 addme
->sy_next
= target
->sy_next
;
708 target
->sy_next
= addme
;
710 #ifdef SYMBOLS_NEED_BACKPOINTERS
711 addme
->sy_previous
= target
;
712 #endif /* SYMBOLS_NEED_BACKPOINTERS */
714 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
717 /* Set the chain pointers of SYMBOL to null. */
720 symbol_clear_list_pointers (symbolP
)
723 if (LOCAL_SYMBOL_CHECK (symbolP
))
725 symbolP
->sy_next
= NULL
;
726 #ifdef SYMBOLS_NEED_BACKPOINTERS
727 symbolP
->sy_previous
= NULL
;
731 #ifdef SYMBOLS_NEED_BACKPOINTERS
732 /* Remove SYMBOLP from the list. */
735 symbol_remove (symbolP
, rootPP
, lastPP
)
740 if (LOCAL_SYMBOL_CHECK (symbolP
))
743 if (symbolP
== *rootPP
)
745 *rootPP
= symbolP
->sy_next
;
746 } /* if it was the root */
748 if (symbolP
== *lastPP
)
750 *lastPP
= symbolP
->sy_previous
;
751 } /* if it was the tail */
753 if (symbolP
->sy_next
!= NULL
)
755 symbolP
->sy_next
->sy_previous
= symbolP
->sy_previous
;
758 if (symbolP
->sy_previous
!= NULL
)
760 symbolP
->sy_previous
->sy_next
= symbolP
->sy_next
;
763 debug_verify_symchain (*rootPP
, *lastPP
);
766 /* Link symbol ADDME before symbol TARGET in the chain. */
769 symbol_insert (addme
, target
, rootPP
, lastPP
)
773 symbolS
**lastPP ATTRIBUTE_UNUSED
;
775 if (LOCAL_SYMBOL_CHECK (addme
))
777 if (LOCAL_SYMBOL_CHECK (target
))
780 if (target
->sy_previous
!= NULL
)
782 target
->sy_previous
->sy_next
= addme
;
786 know (*rootPP
== target
);
790 addme
->sy_previous
= target
->sy_previous
;
791 target
->sy_previous
= addme
;
792 addme
->sy_next
= target
;
794 debug_verify_symchain (*rootPP
, *lastPP
);
797 #endif /* SYMBOLS_NEED_BACKPOINTERS */
800 verify_symbol_chain (rootP
, lastP
)
804 symbolS
*symbolP
= rootP
;
809 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
812 assert (symbolP
->bsym
!= NULL
);
814 #ifdef SYMBOLS_NEED_BACKPOINTERS
815 assert (symbolP
->sy_next
->sy_previous
== symbolP
);
817 /* Walk the list anyways, to make sure pointers are still good. */
819 #endif /* SYMBOLS_NEED_BACKPOINTERS */
822 assert (lastP
== symbolP
);
826 verify_symbol_chain_2 (sym
)
829 symbolS
*p
= sym
, *n
= sym
;
830 #ifdef SYMBOLS_NEED_BACKPOINTERS
831 while (symbol_previous (p
))
832 p
= symbol_previous (p
);
834 while (symbol_next (n
))
836 verify_symbol_chain (p
, n
);
839 /* Resolve the value of a symbol. This is called during the final
840 pass over the symbol table to resolve any symbols with complex
844 resolve_symbol_value (symp
)
848 valueT final_val
= 0;
852 if (LOCAL_SYMBOL_CHECK (symp
))
854 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
856 final_val
= locsym
->lsy_value
;
857 if (local_symbol_resolved_p (locsym
))
860 final_val
+= local_symbol_get_frag (locsym
)->fr_address
/ OCTETS_PER_BYTE
;
864 locsym
->lsy_value
= final_val
;
865 local_symbol_mark_resolved (locsym
);
872 if (symp
->sy_resolved
)
874 if (symp
->sy_value
.X_op
== O_constant
)
875 return (valueT
) symp
->sy_value
.X_add_number
;
881 final_seg
= S_GET_SEGMENT (symp
);
883 if (symp
->sy_resolving
)
886 as_bad (_("symbol definition loop encountered at `%s'"),
893 symbolS
*add_symbol
, *op_symbol
;
895 segT seg_left
, seg_right
;
898 symp
->sy_resolving
= 1;
900 /* Help out with CSE. */
901 add_symbol
= symp
->sy_value
.X_add_symbol
;
902 op_symbol
= symp
->sy_value
.X_op_symbol
;
903 final_val
= symp
->sy_value
.X_add_number
;
904 op
= symp
->sy_value
.X_op
;
917 final_val
+= symp
->sy_frag
->fr_address
/ OCTETS_PER_BYTE
;
918 if (final_seg
== expr_section
)
919 final_seg
= absolute_section
;
925 left
= resolve_symbol_value (add_symbol
);
926 seg_left
= S_GET_SEGMENT (add_symbol
);
928 symp
->sy_value
.X_op_symbol
= NULL
;
931 if (symp
->sy_mri_common
)
933 /* This is a symbol inside an MRI common section. The
934 relocation routines are going to handle it specially.
935 Don't change the value. */
936 resolved
= symbol_resolved_p (add_symbol
);
940 if (finalize_syms
&& final_val
== 0)
942 if (LOCAL_SYMBOL_CHECK (add_symbol
))
943 add_symbol
= local_symbol_convert ((struct local_symbol
*)
945 copy_symbol_attributes (symp
, add_symbol
);
948 /* If we have equated this symbol to an undefined or common
949 symbol, keep X_op set to O_symbol, and don't change
950 X_add_number. This permits the routine which writes out
951 relocation to detect this case, and convert the
952 relocation to be against the symbol to which this symbol
954 if (! S_IS_DEFINED (add_symbol
) || S_IS_COMMON (add_symbol
))
958 symp
->sy_value
.X_op
= O_symbol
;
959 symp
->sy_value
.X_add_symbol
= add_symbol
;
960 symp
->sy_value
.X_add_number
= final_val
;
961 /* Use X_op_symbol as a flag. */
962 symp
->sy_value
.X_op_symbol
= add_symbol
;
963 final_seg
= seg_left
;
966 resolved
= symbol_resolved_p (add_symbol
);
967 symp
->sy_resolving
= 0;
968 goto exit_dont_set_value
;
970 else if (finalize_syms
&& final_seg
== expr_section
971 && seg_left
!= expr_section
)
973 /* If the symbol is an expression symbol, do similarly
974 as for undefined and common syms above. Handles
975 "sym +/- expr" where "expr" cannot be evaluated
976 immediately, and we want relocations to be against
977 "sym", eg. because it is weak. */
978 symp
->sy_value
.X_op
= O_symbol
;
979 symp
->sy_value
.X_add_symbol
= add_symbol
;
980 symp
->sy_value
.X_add_number
= final_val
;
981 symp
->sy_value
.X_op_symbol
= add_symbol
;
982 final_seg
= seg_left
;
983 final_val
+= symp
->sy_frag
->fr_address
+ left
;
984 resolved
= symbol_resolved_p (add_symbol
);
985 symp
->sy_resolving
= 0;
986 goto exit_dont_set_value
;
990 final_val
+= symp
->sy_frag
->fr_address
+ left
;
991 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
992 final_seg
= seg_left
;
995 resolved
= symbol_resolved_p (add_symbol
);
1001 left
= resolve_symbol_value (add_symbol
);
1002 seg_left
= S_GET_SEGMENT (add_symbol
);
1006 else if (op
== O_logical_not
)
1011 final_val
+= left
+ symp
->sy_frag
->fr_address
;
1012 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1013 final_seg
= seg_left
;
1015 resolved
= symbol_resolved_p (add_symbol
);
1023 case O_bit_inclusive_or
:
1025 case O_bit_exclusive_or
:
1037 left
= resolve_symbol_value (add_symbol
);
1038 right
= resolve_symbol_value (op_symbol
);
1039 seg_left
= S_GET_SEGMENT (add_symbol
);
1040 seg_right
= S_GET_SEGMENT (op_symbol
);
1042 /* Simplify addition or subtraction of a constant by folding the
1043 constant into X_add_number. */
1046 if (seg_right
== absolute_section
)
1051 else if (seg_left
== absolute_section
)
1054 add_symbol
= op_symbol
;
1056 seg_left
= seg_right
;
1060 else if (op
== O_subtract
)
1062 if (seg_right
== absolute_section
)
1069 /* Equality and non-equality tests are permitted on anything.
1070 Subtraction, and other comparison operators are permitted if
1071 both operands are in the same section. Otherwise, both
1072 operands must be absolute. We already handled the case of
1073 addition or subtraction of a constant above. This will
1074 probably need to be changed for an object file format which
1075 supports arbitrary expressions, such as IEEE-695.
1077 Don't emit messages unless we're finalizing the symbol value,
1078 otherwise we may get the same message multiple times. */
1079 if ((op
== O_eq
|| op
== O_ne
)
1080 || ((op
== O_subtract
1081 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1082 && seg_left
== seg_right
1083 && (seg_left
!= undefined_section
1084 || add_symbol
== op_symbol
))
1085 || (seg_left
== absolute_section
1086 && seg_right
== absolute_section
))
1088 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1089 final_seg
= absolute_section
;
1091 else if (finalize_syms
)
1096 if (expr_symbol_where (symp
, &file
, &line
))
1098 if (seg_left
== undefined_section
)
1099 as_bad_where (file
, line
,
1100 _("undefined symbol `%s' in operation"),
1101 S_GET_NAME (symp
->sy_value
.X_add_symbol
));
1102 if (seg_right
== undefined_section
)
1103 as_bad_where (file
, line
,
1104 _("undefined symbol `%s' in operation"),
1105 S_GET_NAME (symp
->sy_value
.X_op_symbol
));
1106 if (seg_left
!= undefined_section
1107 && seg_right
!= undefined_section
)
1108 as_bad_where (file
, line
,
1109 _("invalid section for operation"));
1113 if (seg_left
== undefined_section
)
1114 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
1115 S_GET_NAME (symp
->sy_value
.X_add_symbol
),
1117 if (seg_right
== undefined_section
)
1118 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
1119 S_GET_NAME (symp
->sy_value
.X_op_symbol
),
1121 if (seg_left
!= undefined_section
1122 && seg_right
!= undefined_section
)
1123 as_bad (_("invalid section for operation setting `%s'"),
1126 /* Prevent the error propagating. */
1127 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1128 final_seg
= absolute_section
;
1131 /* Check for division by zero. */
1132 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1134 /* If seg_right is not absolute_section, then we've
1135 already issued a warning about using a bad symbol. */
1136 if (seg_right
== absolute_section
&& finalize_syms
)
1141 if (expr_symbol_where (symp
, &file
, &line
))
1142 as_bad_where (file
, line
, _("division by zero"));
1144 as_bad (_("division by zero when setting `%s'"),
1151 switch (symp
->sy_value
.X_op
)
1153 case O_multiply
: left
*= right
; break;
1154 case O_divide
: left
/= right
; break;
1155 case O_modulus
: left
%= right
; break;
1156 case O_left_shift
: left
<<= right
; break;
1157 case O_right_shift
: left
>>= right
; break;
1158 case O_bit_inclusive_or
: left
|= right
; break;
1159 case O_bit_or_not
: left
|= ~right
; break;
1160 case O_bit_exclusive_or
: left
^= right
; break;
1161 case O_bit_and
: left
&= right
; break;
1162 case O_add
: left
+= right
; break;
1163 case O_subtract
: left
-= right
; break;
1166 left
= (left
== right
&& seg_left
== seg_right
1167 && (seg_left
!= undefined_section
1168 || add_symbol
== op_symbol
)
1169 ? ~ (offsetT
) 0 : 0);
1170 if (symp
->sy_value
.X_op
== O_ne
)
1173 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1174 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1175 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1176 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1177 case O_logical_and
: left
= left
&& right
; break;
1178 case O_logical_or
: left
= left
|| right
; break;
1182 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1183 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1185 if (seg_left
== undefined_section
1186 || seg_right
== undefined_section
)
1187 final_seg
= undefined_section
;
1188 else if (seg_left
== absolute_section
)
1189 final_seg
= seg_right
;
1191 final_seg
= seg_left
;
1193 resolved
= (symbol_resolved_p (add_symbol
)
1194 && symbol_resolved_p (op_symbol
));
1200 /* Give an error (below) if not in expr_section. We don't
1201 want to worry about expr_section symbols, because they
1202 are fictional (they are created as part of expression
1203 resolution), and any problems may not actually mean
1208 symp
->sy_resolving
= 0;
1212 S_SET_VALUE (symp
, final_val
);
1214 exit_dont_set_value
:
1215 /* Always set the segment, even if not finalizing the value.
1216 The segment is used to determine whether a symbol is defined. */
1217 #if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)
1218 /* The old a.out backend does not handle S_SET_SEGMENT correctly
1219 for a stab symbol, so we use this bad hack. */
1220 if (final_seg
!= S_GET_SEGMENT (symp
))
1222 S_SET_SEGMENT (symp
, final_seg
);
1224 /* Don't worry if we can't resolve an expr_section symbol. */
1228 symp
->sy_resolved
= 1;
1229 else if (S_GET_SEGMENT (symp
) != expr_section
)
1231 as_bad (_("can't resolve value for symbol `%s'"),
1233 symp
->sy_resolved
= 1;
1240 #ifdef BFD_ASSEMBLER
1242 static void resolve_local_symbol
PARAMS ((const char *, PTR
));
1244 /* A static function passed to hash_traverse. */
1247 resolve_local_symbol (key
, value
)
1248 const char *key ATTRIBUTE_UNUSED
;
1252 resolve_symbol_value (value
);
1257 /* Resolve all local symbols. */
1260 resolve_local_symbol_values ()
1262 #ifdef BFD_ASSEMBLER
1263 hash_traverse (local_hash
, resolve_local_symbol
);
1267 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1268 They are *really* local. That is, they go out of scope whenever we see a
1269 label that isn't local. Also, like fb labels, there can be multiple
1270 instances of a dollar label. Therefor, we name encode each instance with
1271 the instance number, keep a list of defined symbols separate from the real
1272 symbol table, and we treat these buggers as a sparse array. */
1274 static long *dollar_labels
;
1275 static long *dollar_label_instances
;
1276 static char *dollar_label_defines
;
1277 static unsigned long dollar_label_count
;
1278 static unsigned long dollar_label_max
;
1281 dollar_label_defined (label
)
1286 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1288 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1290 return dollar_label_defines
[i
- dollar_labels
];
1292 /* If we get here, label isn't defined. */
1297 dollar_label_instance (label
)
1302 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1304 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1306 return (dollar_label_instances
[i
- dollar_labels
]);
1308 /* If we get here, we haven't seen the label before.
1309 Therefore its instance count is zero. */
1314 dollar_label_clear ()
1316 memset (dollar_label_defines
, '\0', (unsigned int) dollar_label_count
);
1319 #define DOLLAR_LABEL_BUMP_BY 10
1322 define_dollar_label (label
)
1327 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1330 ++dollar_label_instances
[i
- dollar_labels
];
1331 dollar_label_defines
[i
- dollar_labels
] = 1;
1335 /* If we get to here, we don't have label listed yet. */
1337 if (dollar_labels
== NULL
)
1339 dollar_labels
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1340 dollar_label_instances
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1341 dollar_label_defines
= xmalloc (DOLLAR_LABEL_BUMP_BY
);
1342 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1343 dollar_label_count
= 0;
1345 else if (dollar_label_count
== dollar_label_max
)
1347 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1348 dollar_labels
= (long *) xrealloc ((char *) dollar_labels
,
1349 dollar_label_max
* sizeof (long));
1350 dollar_label_instances
= (long *) xrealloc ((char *) dollar_label_instances
,
1351 dollar_label_max
* sizeof (long));
1352 dollar_label_defines
= xrealloc (dollar_label_defines
, dollar_label_max
);
1353 } /* if we needed to grow */
1355 dollar_labels
[dollar_label_count
] = label
;
1356 dollar_label_instances
[dollar_label_count
] = 1;
1357 dollar_label_defines
[dollar_label_count
] = 1;
1358 ++dollar_label_count
;
1361 /* Caller must copy returned name: we re-use the area for the next name.
1363 The mth occurence of label n: is turned into the symbol "Ln^Am"
1364 where n is the label number and m is the instance number. "L" makes
1365 it a label discarded unless debugging and "^A"('\1') ensures no
1366 ordinary symbol SHOULD get the same name as a local label
1367 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1369 fb labels get the same treatment, except that ^B is used in place
1372 char * /* Return local label name. */
1373 dollar_label_name (n
, augend
)
1374 register long n
; /* we just saw "n$:" : n a number. */
1375 register int augend
; /* 0 for current instance, 1 for new instance. */
1378 /* Returned to caller, then copied. Used for created names ("4f"). */
1379 static char symbol_name_build
[24];
1382 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1385 know (augend
== 0 || augend
== 1);
1386 p
= symbol_name_build
;
1387 #ifdef LOCAL_LABEL_PREFIX
1388 *p
++ = LOCAL_LABEL_PREFIX
;
1392 /* Next code just does sprintf( {}, "%d", n); */
1394 q
= symbol_name_temporary
;
1395 for (*q
++ = 0, i
= n
; i
; ++q
)
1400 while ((*p
= *--q
) != '\0')
1403 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1405 /* Instance number. */
1406 q
= symbol_name_temporary
;
1407 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1412 while ((*p
++ = *--q
) != '\0');;
1414 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1415 return symbol_name_build
;
1418 /* Sombody else's idea of local labels. They are made by "n:" where n
1419 is any decimal digit. Refer to them with
1420 "nb" for previous (backward) n:
1421 or "nf" for next (forward) n:.
1423 We do a little better and let n be any number, not just a single digit, but
1424 since the other guy's assembler only does ten, we treat the first ten
1427 Like someone else's assembler, we have one set of local label counters for
1428 entire assembly, not one set per (sub)segment like in most assemblers. This
1429 implies that one can refer to a label in another segment, and indeed some
1430 crufty compilers have done just that.
1432 Since there could be a LOT of these things, treat them as a sparse
1435 #define FB_LABEL_SPECIAL (10)
1437 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1438 static long *fb_labels
;
1439 static long *fb_label_instances
;
1440 static long fb_label_count
;
1441 static long fb_label_max
;
1443 /* This must be more than FB_LABEL_SPECIAL. */
1444 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1449 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1452 /* Add one to the instance number of this fb label. */
1455 fb_label_instance_inc (label
)
1460 if (label
< FB_LABEL_SPECIAL
)
1462 ++fb_low_counter
[label
];
1466 if (fb_labels
!= NULL
)
1468 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1469 i
< fb_labels
+ fb_label_count
; ++i
)
1473 ++fb_label_instances
[i
- fb_labels
];
1475 } /* if we find it */
1476 } /* for each existing label */
1479 /* If we get to here, we don't have label listed yet. */
1481 if (fb_labels
== NULL
)
1483 fb_labels
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1484 fb_label_instances
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1485 fb_label_max
= FB_LABEL_BUMP_BY
;
1486 fb_label_count
= FB_LABEL_SPECIAL
;
1489 else if (fb_label_count
== fb_label_max
)
1491 fb_label_max
+= FB_LABEL_BUMP_BY
;
1492 fb_labels
= (long *) xrealloc ((char *) fb_labels
,
1493 fb_label_max
* sizeof (long));
1494 fb_label_instances
= (long *) xrealloc ((char *) fb_label_instances
,
1495 fb_label_max
* sizeof (long));
1496 } /* if we needed to grow */
1498 fb_labels
[fb_label_count
] = label
;
1499 fb_label_instances
[fb_label_count
] = 1;
1504 fb_label_instance (label
)
1509 if (label
< FB_LABEL_SPECIAL
)
1511 return (fb_low_counter
[label
]);
1514 if (fb_labels
!= NULL
)
1516 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1517 i
< fb_labels
+ fb_label_count
; ++i
)
1521 return (fb_label_instances
[i
- fb_labels
]);
1522 } /* if we find it */
1523 } /* for each existing label */
1526 /* We didn't find the label, so this must be a reference to the
1531 /* Caller must copy returned name: we re-use the area for the next name.
1533 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1534 where n is the label number and m is the instance number. "L" makes
1535 it a label discarded unless debugging and "^B"('\2') ensures no
1536 ordinary symbol SHOULD get the same name as a local label
1537 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1539 dollar labels get the same treatment, except that ^A is used in
1542 char * /* Return local label name. */
1543 fb_label_name (n
, augend
)
1544 long n
; /* We just saw "n:", "nf" or "nb" : n a number. */
1545 long augend
; /* 0 for nb, 1 for n:, nf. */
1548 /* Returned to caller, then copied. Used for created names ("4f"). */
1549 static char symbol_name_build
[24];
1552 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1555 know (augend
== 0 || augend
== 1);
1556 p
= symbol_name_build
;
1557 #ifdef LOCAL_LABEL_PREFIX
1558 *p
++ = LOCAL_LABEL_PREFIX
;
1562 /* Next code just does sprintf( {}, "%d", n); */
1564 q
= symbol_name_temporary
;
1565 for (*q
++ = 0, i
= n
; i
; ++q
)
1570 while ((*p
= *--q
) != '\0')
1573 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
1575 /* Instance number. */
1576 q
= symbol_name_temporary
;
1577 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
1582 while ((*p
++ = *--q
) != '\0');;
1584 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1585 return (symbol_name_build
);
1588 /* Decode name that may have been generated by foo_label_name() above.
1589 If the name wasn't generated by foo_label_name(), then return it
1590 unaltered. This is used for error messages. */
1593 decode_local_label_name (s
)
1597 char *symbol_decode
;
1599 int instance_number
;
1601 const char *message_format
;
1604 #ifdef LOCAL_LABEL_PREFIX
1605 if (s
[index
] == LOCAL_LABEL_PREFIX
)
1609 if (s
[index
] != 'L')
1612 for (label_number
= 0, p
= s
+ index
+ 1; ISDIGIT (*p
); ++p
)
1613 label_number
= (10 * label_number
) + *p
- '0';
1615 if (*p
== DOLLAR_LABEL_CHAR
)
1617 else if (*p
== LOCAL_LABEL_CHAR
)
1622 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
1623 instance_number
= (10 * instance_number
) + *p
- '0';
1625 message_format
= _("\"%d\" (instance number %d of a %s label)");
1626 symbol_decode
= obstack_alloc (¬es
, strlen (message_format
) + 30);
1627 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
1629 return symbol_decode
;
1632 /* Get the value of a symbol. */
1638 #ifdef BFD_ASSEMBLER
1639 if (LOCAL_SYMBOL_CHECK (s
))
1640 return resolve_symbol_value (s
);
1643 if (!s
->sy_resolved
)
1645 valueT val
= resolve_symbol_value (s
);
1649 if (s
->sy_value
.X_op
!= O_constant
)
1651 static symbolS
*recur
;
1653 /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
1654 may call S_GET_VALUE. We use a static symbol to avoid the
1655 immediate recursion. */
1657 return (valueT
) s
->sy_value
.X_add_number
;
1659 if (! s
->sy_resolved
1660 || s
->sy_value
.X_op
!= O_symbol
1661 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
1662 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1666 return (valueT
) s
->sy_value
.X_add_number
;
1669 /* Set the value of a symbol. */
1672 S_SET_VALUE (s
, val
)
1676 #ifdef BFD_ASSEMBLER
1677 if (LOCAL_SYMBOL_CHECK (s
))
1679 ((struct local_symbol
*) s
)->lsy_value
= val
;
1684 s
->sy_value
.X_op
= O_constant
;
1685 s
->sy_value
.X_add_number
= (offsetT
) val
;
1686 s
->sy_value
.X_unsigned
= 0;
1690 copy_symbol_attributes (dest
, src
)
1691 symbolS
*dest
, *src
;
1693 if (LOCAL_SYMBOL_CHECK (dest
))
1694 dest
= local_symbol_convert ((struct local_symbol
*) dest
);
1695 if (LOCAL_SYMBOL_CHECK (src
))
1696 src
= local_symbol_convert ((struct local_symbol
*) src
);
1698 #ifdef BFD_ASSEMBLER
1699 /* In an expression, transfer the settings of these flags.
1700 The user can override later, of course. */
1701 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1702 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
1705 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1706 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
1710 #ifdef BFD_ASSEMBLER
1718 if (LOCAL_SYMBOL_CHECK (s
))
1721 flags
= s
->bsym
->flags
;
1723 return (flags
& BSF_FUNCTION
) != 0;
1732 if (LOCAL_SYMBOL_CHECK (s
))
1735 flags
= s
->bsym
->flags
;
1738 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
1741 return (flags
& BSF_GLOBAL
) != 0;
1748 if (LOCAL_SYMBOL_CHECK (s
))
1750 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
1757 if (LOCAL_SYMBOL_CHECK (s
))
1759 return bfd_is_com_section (s
->bsym
->section
);
1766 if (LOCAL_SYMBOL_CHECK (s
))
1767 return ((struct local_symbol
*) s
)->lsy_section
!= undefined_section
;
1768 return s
->bsym
->section
!= undefined_section
;
1772 #ifndef EXTERN_FORCE_RELOC
1773 #define EXTERN_FORCE_RELOC IS_ELF
1776 /* Return true for symbols that should not be reduced to section
1777 symbols or eliminated from expressions, because they may be
1778 overridden by the linker. */
1783 if (LOCAL_SYMBOL_CHECK (s
))
1784 return ((struct local_symbol
*) s
)->lsy_section
== undefined_section
;
1786 return ((s
->bsym
->flags
& BSF_WEAK
) != 0
1787 || (EXTERN_FORCE_RELOC
1788 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)
1789 || s
->bsym
->section
== undefined_section
1790 || bfd_is_com_section (s
->bsym
->section
));
1797 if (LOCAL_SYMBOL_CHECK (s
))
1799 if (s
->bsym
->flags
& BSF_DEBUGGING
)
1811 if (LOCAL_SYMBOL_CHECK (s
))
1814 flags
= s
->bsym
->flags
;
1817 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
1820 if (bfd_get_section (s
->bsym
) == reg_section
)
1823 if (flag_strip_local_absolute
1824 && (flags
& BSF_GLOBAL
) == 0
1825 && bfd_get_section (s
->bsym
) == absolute_section
)
1828 name
= S_GET_NAME (s
);
1829 return (name
!= NULL
1831 && (strchr (name
, DOLLAR_LABEL_CHAR
)
1832 || strchr (name
, LOCAL_LABEL_CHAR
)
1833 || (! flag_keep_locals
1834 && (bfd_is_local_label (stdoutput
, s
->bsym
)
1837 && name
[1] == '?')))));
1844 return S_IS_EXTERNAL (s
);
1851 return S_GET_NAME (s
) == 0;
1858 if (LOCAL_SYMBOL_CHECK (s
))
1859 return ((struct local_symbol
*) s
)->lsy_name
;
1860 return s
->bsym
->name
;
1867 if (LOCAL_SYMBOL_CHECK (s
))
1868 return ((struct local_symbol
*) s
)->lsy_section
;
1869 return s
->bsym
->section
;
1873 S_SET_SEGMENT (s
, seg
)
1877 /* Don't reassign section symbols. The direct reason is to prevent seg
1878 faults assigning back to const global symbols such as *ABS*, but it
1879 shouldn't happen anyway. */
1881 if (LOCAL_SYMBOL_CHECK (s
))
1883 if (seg
== reg_section
)
1884 s
= local_symbol_convert ((struct local_symbol
*) s
);
1887 ((struct local_symbol
*) s
)->lsy_section
= seg
;
1892 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
1894 if (s
->bsym
->section
!= seg
)
1898 s
->bsym
->section
= seg
;
1905 if (LOCAL_SYMBOL_CHECK (s
))
1906 s
= local_symbol_convert ((struct local_symbol
*) s
);
1907 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
1909 /* Let .weak override .global. */
1912 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
1917 /* Do not reassign section symbols. */
1918 as_where (& file
, & line
);
1919 as_warn_where (file
, line
,
1920 _("section symbols are already global"));
1923 s
->bsym
->flags
|= BSF_GLOBAL
;
1924 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
1928 S_CLEAR_EXTERNAL (s
)
1931 if (LOCAL_SYMBOL_CHECK (s
))
1933 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
1935 /* Let .weak override. */
1938 s
->bsym
->flags
|= BSF_LOCAL
;
1939 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
1946 if (LOCAL_SYMBOL_CHECK (s
))
1947 s
= local_symbol_convert ((struct local_symbol
*) s
);
1948 s
->bsym
->flags
|= BSF_WEAK
;
1949 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
1953 S_SET_NAME (s
, name
)
1957 if (LOCAL_SYMBOL_CHECK (s
))
1959 ((struct local_symbol
*) s
)->lsy_name
= name
;
1962 s
->bsym
->name
= name
;
1964 #endif /* BFD_ASSEMBLER */
1966 #ifdef SYMBOLS_NEED_BACKPOINTERS
1968 /* Return the previous symbol in a chain. */
1974 if (LOCAL_SYMBOL_CHECK (s
))
1976 return s
->sy_previous
;
1979 #endif /* SYMBOLS_NEED_BACKPOINTERS */
1981 /* Return the next symbol in a chain. */
1987 if (LOCAL_SYMBOL_CHECK (s
))
1992 /* Return a pointer to the value of a symbol as an expression. */
1995 symbol_get_value_expression (s
)
1998 if (LOCAL_SYMBOL_CHECK (s
))
1999 s
= local_symbol_convert ((struct local_symbol
*) s
);
2000 return &s
->sy_value
;
2003 /* Set the value of a symbol to an expression. */
2006 symbol_set_value_expression (s
, exp
)
2008 const expressionS
*exp
;
2010 if (LOCAL_SYMBOL_CHECK (s
))
2011 s
= local_symbol_convert ((struct local_symbol
*) s
);
2015 /* Set the frag of a symbol. */
2018 symbol_set_frag (s
, f
)
2022 #ifdef BFD_ASSEMBLER
2023 if (LOCAL_SYMBOL_CHECK (s
))
2025 local_symbol_set_frag ((struct local_symbol
*) s
, f
);
2032 /* Return the frag of a symbol. */
2038 #ifdef BFD_ASSEMBLER
2039 if (LOCAL_SYMBOL_CHECK (s
))
2040 return local_symbol_get_frag ((struct local_symbol
*) s
);
2045 /* Mark a symbol as having been used. */
2048 symbol_mark_used (s
)
2051 if (LOCAL_SYMBOL_CHECK (s
))
2056 /* Clear the mark of whether a symbol has been used. */
2059 symbol_clear_used (s
)
2062 if (LOCAL_SYMBOL_CHECK (s
))
2063 s
= local_symbol_convert ((struct local_symbol
*) s
);
2067 /* Return whether a symbol has been used. */
2073 if (LOCAL_SYMBOL_CHECK (s
))
2078 /* Mark a symbol as having been used in a reloc. */
2081 symbol_mark_used_in_reloc (s
)
2084 if (LOCAL_SYMBOL_CHECK (s
))
2085 s
= local_symbol_convert ((struct local_symbol
*) s
);
2086 s
->sy_used_in_reloc
= 1;
2089 /* Clear the mark of whether a symbol has been used in a reloc. */
2092 symbol_clear_used_in_reloc (s
)
2095 if (LOCAL_SYMBOL_CHECK (s
))
2097 s
->sy_used_in_reloc
= 0;
2100 /* Return whether a symbol has been used in a reloc. */
2103 symbol_used_in_reloc_p (s
)
2106 if (LOCAL_SYMBOL_CHECK (s
))
2108 return s
->sy_used_in_reloc
;
2111 /* Mark a symbol as an MRI common symbol. */
2114 symbol_mark_mri_common (s
)
2117 if (LOCAL_SYMBOL_CHECK (s
))
2118 s
= local_symbol_convert ((struct local_symbol
*) s
);
2119 s
->sy_mri_common
= 1;
2122 /* Clear the mark of whether a symbol is an MRI common symbol. */
2125 symbol_clear_mri_common (s
)
2128 if (LOCAL_SYMBOL_CHECK (s
))
2130 s
->sy_mri_common
= 0;
2133 /* Return whether a symbol is an MRI common symbol. */
2136 symbol_mri_common_p (s
)
2139 if (LOCAL_SYMBOL_CHECK (s
))
2141 return s
->sy_mri_common
;
2144 /* Mark a symbol as having been written. */
2147 symbol_mark_written (s
)
2150 if (LOCAL_SYMBOL_CHECK (s
))
2155 /* Clear the mark of whether a symbol has been written. */
2158 symbol_clear_written (s
)
2161 if (LOCAL_SYMBOL_CHECK (s
))
2166 /* Return whether a symbol has been written. */
2169 symbol_written_p (s
)
2172 if (LOCAL_SYMBOL_CHECK (s
))
2177 /* Mark a symbol has having been resolved. */
2180 symbol_mark_resolved (s
)
2183 #ifdef BFD_ASSEMBLER
2184 if (LOCAL_SYMBOL_CHECK (s
))
2186 local_symbol_mark_resolved ((struct local_symbol
*) s
);
2193 /* Return whether a symbol has been resolved. */
2196 symbol_resolved_p (s
)
2199 #ifdef BFD_ASSEMBLER
2200 if (LOCAL_SYMBOL_CHECK (s
))
2201 return local_symbol_resolved_p ((struct local_symbol
*) s
);
2203 return s
->sy_resolved
;
2206 /* Return whether a symbol is a section symbol. */
2209 symbol_section_p (s
)
2210 symbolS
*s ATTRIBUTE_UNUSED
;
2212 if (LOCAL_SYMBOL_CHECK (s
))
2214 #ifdef BFD_ASSEMBLER
2215 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2222 /* Return whether a symbol is equated to another symbol. */
2225 symbol_equated_p (s
)
2228 if (LOCAL_SYMBOL_CHECK (s
))
2230 return s
->sy_value
.X_op
== O_symbol
;
2233 /* Return whether a symbol is equated to another symbol, and should be
2234 treated specially when writing out relocs. */
2237 symbol_equated_reloc_p (s
)
2240 if (LOCAL_SYMBOL_CHECK (s
))
2242 /* X_op_symbol, normally not used for O_symbol, is set by
2243 resolve_symbol_value to flag expression syms that have been
2245 return (s
->sy_value
.X_op
== O_symbol
2246 && ((s
->sy_resolved
&& s
->sy_value
.X_op_symbol
!= NULL
)
2247 || ! S_IS_DEFINED (s
)
2248 || S_IS_COMMON (s
)));
2251 /* Return whether a symbol has a constant value. */
2254 symbol_constant_p (s
)
2257 if (LOCAL_SYMBOL_CHECK (s
))
2259 return s
->sy_value
.X_op
== O_constant
;
2262 #ifdef BFD_ASSEMBLER
2264 /* Return the BFD symbol for a symbol. */
2267 symbol_get_bfdsym (s
)
2270 if (LOCAL_SYMBOL_CHECK (s
))
2271 s
= local_symbol_convert ((struct local_symbol
*) s
);
2275 /* Set the BFD symbol for a symbol. */
2278 symbol_set_bfdsym (s
, bsym
)
2282 if (LOCAL_SYMBOL_CHECK (s
))
2283 s
= local_symbol_convert ((struct local_symbol
*) s
);
2287 #endif /* BFD_ASSEMBLER */
2289 #ifdef OBJ_SYMFIELD_TYPE
2291 /* Get a pointer to the object format information for a symbol. */
2297 if (LOCAL_SYMBOL_CHECK (s
))
2298 s
= local_symbol_convert ((struct local_symbol
*) s
);
2302 /* Set the object format information for a symbol. */
2305 symbol_set_obj (s
, o
)
2307 OBJ_SYMFIELD_TYPE
*o
;
2309 if (LOCAL_SYMBOL_CHECK (s
))
2310 s
= local_symbol_convert ((struct local_symbol
*) s
);
2314 #endif /* OBJ_SYMFIELD_TYPE */
2316 #ifdef TC_SYMFIELD_TYPE
2318 /* Get a pointer to the processor information for a symbol. */
2324 if (LOCAL_SYMBOL_CHECK (s
))
2325 s
= local_symbol_convert ((struct local_symbol
*) s
);
2329 /* Set the processor information for a symbol. */
2332 symbol_set_tc (s
, o
)
2334 TC_SYMFIELD_TYPE
*o
;
2336 if (LOCAL_SYMBOL_CHECK (s
))
2337 s
= local_symbol_convert ((struct local_symbol
*) s
);
2341 #endif /* TC_SYMFIELD_TYPE */
2346 symbol_lastP
= NULL
;
2347 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2348 sy_hash
= hash_new ();
2349 #ifdef BFD_ASSEMBLER
2350 local_hash
= hash_new ();
2353 memset ((char *) (&abs_symbol
), '\0', sizeof (abs_symbol
));
2354 #ifdef BFD_ASSEMBLER
2355 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2356 abs_symbol
.bsym
= bfd_abs_section
.symbol
;
2359 /* Can't initialise a union. Sigh. */
2360 S_SET_SEGMENT (&abs_symbol
, absolute_section
);
2362 abs_symbol
.sy_value
.X_op
= O_constant
;
2363 abs_symbol
.sy_frag
= &zero_address_frag
;
2365 if (LOCAL_LABELS_FB
)
2371 /* Maximum indent level.
2372 Available for modification inside a gdb session. */
2373 int max_indent_level
= 8;
2380 printf ("%*s", indent_level
* 4, "");
2386 print_symbol_value_1 (file
, sym
)
2390 const char *name
= S_GET_NAME (sym
);
2391 if (!name
|| !name
[0])
2393 fprintf (file
, "sym %lx %s", (unsigned long) sym
, name
);
2395 if (LOCAL_SYMBOL_CHECK (sym
))
2397 #ifdef BFD_ASSEMBLER
2398 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
2399 if (local_symbol_get_frag (locsym
) != &zero_address_frag
2400 && local_symbol_get_frag (locsym
) != NULL
)
2401 fprintf (file
, " frag %lx", (long) local_symbol_get_frag (locsym
));
2402 if (local_symbol_resolved_p (locsym
))
2403 fprintf (file
, " resolved");
2404 fprintf (file
, " local");
2409 if (sym
->sy_frag
!= &zero_address_frag
)
2410 fprintf (file
, " frag %lx", (long) sym
->sy_frag
);
2412 fprintf (file
, " written");
2413 if (sym
->sy_resolved
)
2414 fprintf (file
, " resolved");
2415 else if (sym
->sy_resolving
)
2416 fprintf (file
, " resolving");
2417 if (sym
->sy_used_in_reloc
)
2418 fprintf (file
, " used-in-reloc");
2420 fprintf (file
, " used");
2421 if (S_IS_LOCAL (sym
))
2422 fprintf (file
, " local");
2423 if (S_IS_EXTERN (sym
))
2424 fprintf (file
, " extern");
2425 if (S_IS_DEBUG (sym
))
2426 fprintf (file
, " debug");
2427 if (S_IS_DEFINED (sym
))
2428 fprintf (file
, " defined");
2430 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
2431 if (symbol_resolved_p (sym
))
2433 segT s
= S_GET_SEGMENT (sym
);
2435 if (s
!= undefined_section
2436 && s
!= expr_section
)
2437 fprintf (file
, " %lx", (long) S_GET_VALUE (sym
));
2439 else if (indent_level
< max_indent_level
2440 && S_GET_SEGMENT (sym
) != undefined_section
)
2443 fprintf (file
, "\n%*s<", indent_level
* 4, "");
2444 #ifdef BFD_ASSEMBLER
2445 if (LOCAL_SYMBOL_CHECK (sym
))
2446 fprintf (file
, "constant %lx",
2447 (long) ((struct local_symbol
*) sym
)->lsy_value
);
2450 print_expr_1 (file
, &sym
->sy_value
);
2451 fprintf (file
, ">");
2458 print_symbol_value (sym
)
2462 print_symbol_value_1 (stderr
, sym
);
2463 fprintf (stderr
, "\n");
2467 print_binary (file
, name
, exp
)
2473 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
2474 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2475 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2476 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2477 fprintf (file
, ">");
2482 print_expr_1 (file
, exp
)
2486 fprintf (file
, "expr %lx ", (long) exp
);
2490 fprintf (file
, "illegal");
2493 fprintf (file
, "absent");
2496 fprintf (file
, "constant %lx", (long) exp
->X_add_number
);
2500 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
2501 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2502 fprintf (file
, ">");
2504 if (exp
->X_add_number
)
2505 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
2506 (long) exp
->X_add_number
);
2510 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
2513 fprintf (file
, "big");
2516 fprintf (file
, "uminus -<");
2518 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2519 fprintf (file
, ">");
2520 goto maybe_print_addnum
;
2522 fprintf (file
, "bit_not");
2525 print_binary (file
, "multiply", exp
);
2528 print_binary (file
, "divide", exp
);
2531 print_binary (file
, "modulus", exp
);
2534 print_binary (file
, "lshift", exp
);
2537 print_binary (file
, "rshift", exp
);
2539 case O_bit_inclusive_or
:
2540 print_binary (file
, "bit_ior", exp
);
2542 case O_bit_exclusive_or
:
2543 print_binary (file
, "bit_xor", exp
);
2546 print_binary (file
, "bit_and", exp
);
2549 print_binary (file
, "eq", exp
);
2552 print_binary (file
, "ne", exp
);
2555 print_binary (file
, "lt", exp
);
2558 print_binary (file
, "le", exp
);
2561 print_binary (file
, "ge", exp
);
2564 print_binary (file
, "gt", exp
);
2567 print_binary (file
, "logical_and", exp
);
2570 print_binary (file
, "logical_or", exp
);
2574 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
2575 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2576 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2577 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2578 fprintf (file
, ">");
2579 goto maybe_print_addnum
;
2582 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
2583 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2584 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2585 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2586 fprintf (file
, ">");
2587 goto maybe_print_addnum
;
2589 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
2599 print_expr_1 (stderr
, exp
);
2600 fprintf (stderr
, "\n");
2604 symbol_print_statistics (file
)
2607 hash_print_statistics (file
, "symbol table", sy_hash
);
2608 #ifdef BFD_ASSEMBLER
2609 hash_print_statistics (file
, "mini local symbol table", local_hash
);
2610 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
2611 local_symbol_count
, local_symbol_conversion_count
);