1 /* symbols.c -symbol table-
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
24 #include "safe-ctype.h"
25 #include "obstack.h" /* For "symbols.h" */
27 #include "struc-symbol.h"
29 /* This is non-zero if symbols are case sensitive, which is the
31 int symbols_case_sensitive
= 1;
33 #ifndef WORKING_DOT_WORD
34 extern int new_broken_words
;
37 /* symbol-name => struct symbol pointer */
38 static struct hash_control
*sy_hash
;
40 /* Table of local symbols. */
41 static struct hash_control
*local_hash
;
43 /* Below are commented in "symbols.h". */
44 symbolS
*symbol_rootP
;
45 symbolS
*symbol_lastP
;
50 #define debug_verify_symchain verify_symbol_chain
52 #define debug_verify_symchain(root, last) ((void) 0)
55 #define DOLLAR_LABEL_CHAR '\001'
56 #define LOCAL_LABEL_CHAR '\002'
58 #ifndef TC_LABEL_IS_LOCAL
59 #define TC_LABEL_IS_LOCAL(name) 0
64 /* The name of an external symbol which is
65 used to make weak PE symbol names unique. */
66 const char * an_external_name
;
69 static char *save_symbol_name (const char *);
70 static void fb_label_init (void);
71 static long dollar_label_instance (long);
72 static long fb_label_instance (long);
74 static void print_binary (FILE *, const char *, expressionS
*);
76 /* Return a pointer to a new symbol. Die if we can't make a new
77 symbol. Fill in the symbol's values. Add symbol to end of symbol
80 This function should be called in the general case of creating a
81 symbol. However, if the output file symbol table has already been
82 set, and you are certain that this symbol won't be wanted in the
83 output file, you can call symbol_create. */
86 symbol_new (const char *name
, segT segment
, valueT valu
, fragS
*frag
)
88 symbolS
*symbolP
= symbol_create (name
, segment
, valu
, frag
);
90 /* Link to end of symbol chain. */
92 extern int symbol_table_frozen
;
93 if (symbol_table_frozen
)
96 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
101 /* Save a symbol name on a permanent obstack, and convert it according
102 to the object file format. */
105 save_symbol_name (const char *name
)
110 name_length
= strlen (name
) + 1; /* +1 for \0. */
111 obstack_grow (¬es
, name
, name_length
);
112 ret
= (char *) obstack_finish (¬es
);
114 #ifdef tc_canonicalize_symbol_name
115 ret
= tc_canonicalize_symbol_name (ret
);
118 if (! symbols_case_sensitive
)
122 for (s
= ret
; *s
!= '\0'; s
++)
130 symbol_create (const char *name
, /* It is copied, the caller can destroy/modify. */
131 segT segment
, /* Segment identifier (SEG_<something>). */
132 valueT valu
, /* Symbol value. */
133 fragS
*frag
/* Associated fragment. */)
135 char *preserved_copy_of_name
;
138 preserved_copy_of_name
= save_symbol_name (name
);
140 symbolP
= (symbolS
*) obstack_alloc (¬es
, sizeof (symbolS
));
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP
, 0, sizeof (symbolS
));
145 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
146 if (symbolP
->bsym
== NULL
)
147 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
148 S_SET_NAME (symbolP
, preserved_copy_of_name
);
150 S_SET_SEGMENT (symbolP
, segment
);
151 S_SET_VALUE (symbolP
, valu
);
152 symbol_clear_list_pointers (symbolP
);
154 symbolP
->sy_frag
= frag
;
156 obj_symbol_new_hook (symbolP
);
158 #ifdef tc_symbol_new_hook
159 tc_symbol_new_hook (symbolP
);
166 /* Local symbol support. If we can get away with it, we keep only a
167 small amount of information for local symbols. */
169 static symbolS
*local_symbol_convert (struct local_symbol
*);
171 /* Used for statistics. */
173 static unsigned long local_symbol_count
;
174 static unsigned long local_symbol_conversion_count
;
176 /* This macro is called with a symbol argument passed by reference.
177 It returns whether this is a local symbol. If necessary, it
178 changes its argument to the real symbol. */
180 #define LOCAL_SYMBOL_CHECK(s) \
181 (s->sy_flags.sy_local_symbol \
182 ? (local_symbol_converted_p ((struct local_symbol *) s) \
183 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
188 /* Create a local symbol and insert it into the local hash table. */
190 struct local_symbol
*
191 local_symbol_make (const char *name
, segT section
, valueT val
, fragS
*frag
)
194 struct local_symbol
*ret
;
196 ++local_symbol_count
;
198 name_copy
= save_symbol_name (name
);
200 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
201 ret
->lsy_flags
.sy_local_symbol
= 1;
202 ret
->lsy_flags
.sy_resolved
= 0;
203 ret
->lsy_name
= name_copy
;
204 ret
->lsy_section
= section
;
205 local_symbol_set_frag (ret
, frag
);
206 ret
->lsy_value
= val
;
208 hash_jam (local_hash
, name_copy
, (void *) ret
);
213 /* Convert a local symbol into a real symbol. Note that we do not
214 reclaim the space used by the local symbol. */
217 local_symbol_convert (struct local_symbol
*locsym
)
221 gas_assert (locsym
->lsy_flags
.sy_local_symbol
);
222 if (local_symbol_converted_p (locsym
))
223 return local_symbol_get_real_symbol (locsym
);
225 ++local_symbol_conversion_count
;
227 ret
= symbol_new (locsym
->lsy_name
, locsym
->lsy_section
, locsym
->lsy_value
,
228 local_symbol_get_frag (locsym
));
230 if (local_symbol_resolved_p (locsym
))
231 ret
->sy_flags
.sy_resolved
= 1;
233 /* Local symbols are always either defined or used. */
234 ret
->sy_flags
.sy_used
= 1;
236 #ifdef TC_LOCAL_SYMFIELD_CONVERT
237 TC_LOCAL_SYMFIELD_CONVERT (locsym
, ret
);
240 symbol_table_insert (ret
);
242 local_symbol_mark_converted (locsym
);
243 local_symbol_set_real_symbol (locsym
, ret
);
245 hash_jam (local_hash
, locsym
->lsy_name
, NULL
);
251 define_sym_at_dot (symbolS
*symbolP
)
253 symbolP
->sy_frag
= frag_now
;
254 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
255 S_SET_SEGMENT (symbolP
, now_seg
);
258 /* We have just seen "<name>:".
259 Creates a struct symbol unless it already exists.
261 Gripes if we are redefining a symbol incompatibly (and ignores it). */
264 colon (/* Just seen "x:" - rattle symbols & frags. */
265 const char *sym_name
/* Symbol name, as a cannonical string. */
266 /* We copy this string: OK to alter later. */)
268 symbolS
*symbolP
; /* Symbol we are working with. */
270 /* Sun local labels go out of scope whenever a non-local symbol is
272 if (LOCAL_LABELS_DOLLAR
273 && !bfd_is_local_label_name (stdoutput
, sym_name
))
274 dollar_label_clear ();
276 #ifndef WORKING_DOT_WORD
277 if (new_broken_words
)
279 struct broken_word
*a
;
284 if (now_seg
== absolute_section
)
286 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
290 possible_bytes
= (md_short_jump_size
291 + new_broken_words
* md_long_jump_size
);
294 frag_opcode
= frag_var (rs_broken_word
,
298 (symbolS
*) broken_words
,
302 /* We want to store the pointer to where to insert the jump
303 table in the fr_opcode of the rs_broken_word frag. This
304 requires a little hackery. */
306 && (frag_tmp
->fr_type
!= rs_broken_word
307 || frag_tmp
->fr_opcode
))
308 frag_tmp
= frag_tmp
->fr_next
;
310 frag_tmp
->fr_opcode
= frag_opcode
;
311 new_broken_words
= 0;
313 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
314 a
->dispfrag
= frag_tmp
;
316 #endif /* WORKING_DOT_WORD */
318 #ifdef obj_frob_colon
319 obj_frob_colon (sym_name
);
322 if ((symbolP
= symbol_find (sym_name
)) != 0)
324 S_CLEAR_WEAKREFR (symbolP
);
325 #ifdef RESOLVE_SYMBOL_REDEFINITION
326 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
329 /* Now check for undefined symbols. */
330 if (LOCAL_SYMBOL_CHECK (symbolP
))
332 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
334 if (locsym
->lsy_section
!= undefined_section
335 && (local_symbol_get_frag (locsym
) != frag_now
336 || locsym
->lsy_section
!= now_seg
337 || locsym
->lsy_value
!= frag_now_fix ()))
339 as_bad (_("symbol `%s' is already defined"), sym_name
);
343 locsym
->lsy_section
= now_seg
;
344 local_symbol_set_frag (locsym
, frag_now
);
345 locsym
->lsy_value
= frag_now_fix ();
347 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
348 || S_IS_COMMON (symbolP
)
349 || S_IS_VOLATILE (symbolP
))
351 if (S_IS_VOLATILE (symbolP
))
353 symbolP
= symbol_clone (symbolP
, 1);
354 S_SET_VALUE (symbolP
, 0);
355 S_CLEAR_VOLATILE (symbolP
);
357 if (S_GET_VALUE (symbolP
) == 0)
359 define_sym_at_dot (symbolP
);
362 #endif /* if we have one, it better be zero. */
367 /* There are still several cases to check:
369 A .comm/.lcomm symbol being redefined as initialized
372 A .comm/.lcomm symbol being redefined with a larger
375 This only used to be allowed on VMS gas, but Sun cc
376 on the sparc also depends on it. */
378 if (((!S_IS_DEBUG (symbolP
)
379 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
380 && S_IS_EXTERNAL (symbolP
))
381 || S_GET_SEGMENT (symbolP
) == bss_section
)
382 && (now_seg
== data_section
383 || now_seg
== bss_section
384 || now_seg
== S_GET_SEGMENT (symbolP
)))
386 /* Select which of the 2 cases this is. */
387 if (now_seg
!= data_section
)
389 /* New .comm for prev .comm symbol.
391 If the new size is larger we just change its
392 value. If the new size is smaller, we ignore
394 if (S_GET_VALUE (symbolP
)
395 < ((unsigned) frag_now_fix ()))
397 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
402 /* It is a .comm/.lcomm being converted to initialized
404 define_sym_at_dot (symbolP
);
409 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
410 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
411 static const char *od_buf
= "";
415 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
416 sprintf (od_buf
, "%d.%d.",
417 S_GET_OTHER (symbolP
),
418 S_GET_DESC (symbolP
));
420 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
422 segment_name (S_GET_SEGMENT (symbolP
)),
424 (long) S_GET_VALUE (symbolP
));
426 } /* if the undefined symbol has no value */
430 /* Don't blow up if the definition is the same. */
431 if (!(frag_now
== symbolP
->sy_frag
432 && S_GET_VALUE (symbolP
) == frag_now_fix ()
433 && S_GET_SEGMENT (symbolP
) == now_seg
))
435 as_bad (_("symbol `%s' is already defined"), sym_name
);
436 symbolP
= symbol_clone (symbolP
, 0);
437 define_sym_at_dot (symbolP
);
442 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
444 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
,
445 (valueT
) frag_now_fix (),
450 symbolP
= symbol_new (sym_name
, now_seg
, (valueT
) frag_now_fix (),
453 symbol_table_insert (symbolP
);
456 if (mri_common_symbol
!= NULL
)
458 /* This symbol is actually being defined within an MRI common
459 section. This requires special handling. */
460 if (LOCAL_SYMBOL_CHECK (symbolP
))
461 symbolP
= local_symbol_convert ((struct local_symbol
*) symbolP
);
462 symbolP
->sy_value
.X_op
= O_symbol
;
463 symbolP
->sy_value
.X_add_symbol
= mri_common_symbol
;
464 symbolP
->sy_value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
465 symbolP
->sy_frag
= &zero_address_frag
;
466 S_SET_SEGMENT (symbolP
, expr_section
);
467 symbolP
->sy_flags
.sy_mri_common
= 1;
471 tc_frob_label (symbolP
);
473 #ifdef obj_frob_label
474 obj_frob_label (symbolP
);
480 /* Die if we can't insert the symbol. */
483 symbol_table_insert (symbolS
*symbolP
)
485 const char *error_string
;
488 know (S_GET_NAME (symbolP
));
490 if (LOCAL_SYMBOL_CHECK (symbolP
))
492 error_string
= hash_jam (local_hash
, S_GET_NAME (symbolP
),
494 if (error_string
!= NULL
)
495 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
496 S_GET_NAME (symbolP
), error_string
);
500 if ((error_string
= hash_jam (sy_hash
, S_GET_NAME (symbolP
), (void *) symbolP
)))
502 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
503 S_GET_NAME (symbolP
), error_string
);
507 /* If a symbol name does not exist, create it as undefined, and insert
508 it into the symbol table. Return a pointer to it. */
511 symbol_find_or_make (const char *name
)
515 symbolP
= symbol_find (name
);
519 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
521 symbolP
= md_undefined_symbol ((char *) name
);
525 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
531 symbolP
= symbol_make (name
);
533 symbol_table_insert (symbolP
);
534 } /* if symbol wasn't found */
540 symbol_make (const char *name
)
544 /* Let the machine description default it, e.g. for register names. */
545 symbolP
= md_undefined_symbol ((char *) name
);
548 symbolP
= symbol_new (name
, undefined_section
, (valueT
) 0, &zero_address_frag
);
554 symbol_clone (symbolS
*orgsymP
, int replace
)
557 asymbol
*bsymorg
, *bsymnew
;
559 /* Make sure we never clone the dot special symbol. */
560 gas_assert (orgsymP
!= &dot_symbol
);
562 /* Running local_symbol_convert on a clone that's not the one currently
563 in local_hash would incorrectly replace the hash entry. Thus the
564 symbol must be converted here. Note that the rest of the function
565 depends on not encountering an unconverted symbol. */
566 if (LOCAL_SYMBOL_CHECK (orgsymP
))
567 orgsymP
= local_symbol_convert ((struct local_symbol
*) orgsymP
);
568 bsymorg
= orgsymP
->bsym
;
570 newsymP
= (symbolS
*) obstack_alloc (¬es
, sizeof (*newsymP
));
572 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
574 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
575 newsymP
->bsym
= bsymnew
;
576 bsymnew
->name
= bsymorg
->name
;
577 bsymnew
->flags
= bsymorg
->flags
& ~BSF_SECTION_SYM
;
578 bsymnew
->section
= bsymorg
->section
;
579 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
580 bfd_asymbol_bfd (bsymnew
), bsymnew
);
582 #ifdef obj_symbol_clone_hook
583 obj_symbol_clone_hook (newsymP
, orgsymP
);
586 #ifdef tc_symbol_clone_hook
587 tc_symbol_clone_hook (newsymP
, orgsymP
);
592 if (symbol_rootP
== orgsymP
)
593 symbol_rootP
= newsymP
;
594 else if (orgsymP
->sy_previous
)
596 orgsymP
->sy_previous
->sy_next
= newsymP
;
597 orgsymP
->sy_previous
= NULL
;
599 if (symbol_lastP
== orgsymP
)
600 symbol_lastP
= newsymP
;
601 else if (orgsymP
->sy_next
)
602 orgsymP
->sy_next
->sy_previous
= newsymP
;
604 /* Symbols that won't be output can't be external. */
605 S_CLEAR_EXTERNAL (orgsymP
);
606 orgsymP
->sy_previous
= orgsymP
->sy_next
= orgsymP
;
607 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
609 symbol_table_insert (newsymP
);
613 /* Symbols that won't be output can't be external. */
614 S_CLEAR_EXTERNAL (newsymP
);
615 newsymP
->sy_previous
= newsymP
->sy_next
= newsymP
;
621 /* Referenced symbols, if they are forward references, need to be cloned
622 (without replacing the original) so that the value of the referenced
623 symbols at the point of use . */
625 #undef symbol_clone_if_forward_ref
627 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
629 if (symbolP
&& !LOCAL_SYMBOL_CHECK (symbolP
))
631 symbolS
*add_symbol
= symbolP
->sy_value
.X_add_symbol
;
632 symbolS
*op_symbol
= symbolP
->sy_value
.X_op_symbol
;
634 if (symbolP
->sy_flags
.sy_forward_ref
)
639 /* assign_symbol() clones volatile symbols; pre-existing expressions
640 hold references to the original instance, but want the current
641 value. Just repeat the lookup. */
642 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
643 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
644 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
645 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
648 /* Re-using sy_resolving here, as this routine cannot get called from
649 symbol resolution code. */
650 if ((symbolP
->bsym
->section
== expr_section
651 || symbolP
->sy_flags
.sy_forward_ref
)
652 && !symbolP
->sy_flags
.sy_resolving
)
654 symbolP
->sy_flags
.sy_resolving
= 1;
655 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
656 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
657 symbolP
->sy_flags
.sy_resolving
= 0;
660 if (symbolP
->sy_flags
.sy_forward_ref
661 || add_symbol
!= symbolP
->sy_value
.X_add_symbol
662 || op_symbol
!= symbolP
->sy_value
.X_op_symbol
)
664 if (symbolP
!= &dot_symbol
)
666 symbolP
= symbol_clone (symbolP
, 0);
667 symbolP
->sy_flags
.sy_resolving
= 0;
671 symbolP
= symbol_temp_new_now ();
672 #ifdef tc_new_dot_label
673 tc_new_dot_label (symbolP
);
678 symbolP
->sy_value
.X_add_symbol
= add_symbol
;
679 symbolP
->sy_value
.X_op_symbol
= op_symbol
;
686 symbol_temp_new (segT seg
, valueT ofs
, fragS
*frag
)
688 return symbol_new (FAKE_LABEL_NAME
, seg
, ofs
, frag
);
692 symbol_temp_new_now (void)
694 return symbol_temp_new (now_seg
, frag_now_fix (), frag_now
);
698 symbol_temp_make (void)
700 return symbol_make (FAKE_LABEL_NAME
);
703 /* Implement symbol table lookup.
704 In: A symbol's name as a string: '\0' can't be part of a symbol name.
705 Out: NULL if the name was not in the symbol table, else the address
706 of a struct symbol associated with that name. */
709 symbol_find_exact (const char *name
)
711 return symbol_find_exact_noref (name
, 0);
715 symbol_find_exact_noref (const char *name
, int noref
)
717 struct local_symbol
*locsym
;
720 locsym
= (struct local_symbol
*) hash_find (local_hash
, name
);
722 return (symbolS
*) locsym
;
724 sym
= ((symbolS
*) hash_find (sy_hash
, name
));
726 /* Any references to the symbol, except for the reference in
727 .weakref, must clear this flag, such that the symbol does not
728 turn into a weak symbol. Note that we don't have to handle the
729 local_symbol case, since a weakrefd is always promoted out of the
730 local_symbol table when it is turned into a weak symbol. */
732 S_CLEAR_WEAKREFD (sym
);
738 symbol_find (const char *name
)
740 return symbol_find_noref (name
, 0);
744 symbol_find_noref (const char *name
, int noref
)
746 #ifdef tc_canonicalize_symbol_name
749 size_t len
= strlen (name
) + 1;
751 copy
= (char *) alloca (len
);
752 memcpy (copy
, name
, len
);
753 name
= tc_canonicalize_symbol_name (copy
);
757 if (! symbols_case_sensitive
)
764 name
= copy
= (char *) alloca (strlen (name
) + 1);
766 while ((c
= *orig
++) != '\0')
768 *copy
++ = TOUPPER (c
);
773 return symbol_find_exact_noref (name
, noref
);
776 /* Once upon a time, symbols were kept in a singly linked list. At
777 least coff needs to be able to rearrange them from time to time, for
778 which a doubly linked list is much more convenient. Loic did these
779 as macros which seemed dangerous to me so they're now functions.
782 /* Link symbol ADDME after symbol TARGET in the chain. */
785 symbol_append (symbolS
*addme
, symbolS
*target
,
786 symbolS
**rootPP
, symbolS
**lastPP
)
788 if (LOCAL_SYMBOL_CHECK (addme
))
790 if (target
!= NULL
&& LOCAL_SYMBOL_CHECK (target
))
795 know (*rootPP
== NULL
);
796 know (*lastPP
== NULL
);
797 addme
->sy_next
= NULL
;
798 addme
->sy_previous
= NULL
;
802 } /* if the list is empty */
804 if (target
->sy_next
!= NULL
)
806 target
->sy_next
->sy_previous
= addme
;
810 know (*lastPP
== target
);
812 } /* if we have a next */
814 addme
->sy_next
= target
->sy_next
;
815 target
->sy_next
= addme
;
816 addme
->sy_previous
= target
;
818 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
821 /* Set the chain pointers of SYMBOL to null. */
824 symbol_clear_list_pointers (symbolS
*symbolP
)
826 if (LOCAL_SYMBOL_CHECK (symbolP
))
828 symbolP
->sy_next
= NULL
;
829 symbolP
->sy_previous
= NULL
;
832 /* Remove SYMBOLP from the list. */
835 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
837 if (LOCAL_SYMBOL_CHECK (symbolP
))
840 if (symbolP
== *rootPP
)
842 *rootPP
= symbolP
->sy_next
;
843 } /* if it was the root */
845 if (symbolP
== *lastPP
)
847 *lastPP
= symbolP
->sy_previous
;
848 } /* if it was the tail */
850 if (symbolP
->sy_next
!= NULL
)
852 symbolP
->sy_next
->sy_previous
= symbolP
->sy_previous
;
855 if (symbolP
->sy_previous
!= NULL
)
857 symbolP
->sy_previous
->sy_next
= symbolP
->sy_next
;
860 debug_verify_symchain (*rootPP
, *lastPP
);
863 /* Link symbol ADDME before symbol TARGET in the chain. */
866 symbol_insert (symbolS
*addme
, symbolS
*target
,
867 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
869 if (LOCAL_SYMBOL_CHECK (addme
))
871 if (LOCAL_SYMBOL_CHECK (target
))
874 if (target
->sy_previous
!= NULL
)
876 target
->sy_previous
->sy_next
= addme
;
880 know (*rootPP
== target
);
884 addme
->sy_previous
= target
->sy_previous
;
885 target
->sy_previous
= addme
;
886 addme
->sy_next
= target
;
888 debug_verify_symchain (*rootPP
, *lastPP
);
892 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
894 symbolS
*symbolP
= rootP
;
899 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
901 gas_assert (symbolP
->bsym
!= NULL
);
902 gas_assert (symbolP
->sy_flags
.sy_local_symbol
== 0);
903 gas_assert (symbolP
->sy_next
->sy_previous
== symbolP
);
906 gas_assert (lastP
== symbolP
);
909 #ifdef OBJ_COMPLEX_RELC
912 use_complex_relocs_for (symbolS
* symp
)
914 switch (symp
->sy_value
.X_op
)
924 if ( (S_IS_COMMON (symp
->sy_value
.X_add_symbol
)
925 || S_IS_LOCAL (symp
->sy_value
.X_add_symbol
))
927 (S_IS_DEFINED (symp
->sy_value
.X_add_symbol
)
928 && S_GET_SEGMENT (symp
->sy_value
.X_add_symbol
) != expr_section
))
937 case O_bit_inclusive_or
:
939 case O_bit_exclusive_or
:
952 if ( (S_IS_COMMON (symp
->sy_value
.X_add_symbol
)
953 || S_IS_LOCAL (symp
->sy_value
.X_add_symbol
))
955 (S_IS_COMMON (symp
->sy_value
.X_op_symbol
)
956 || S_IS_LOCAL (symp
->sy_value
.X_op_symbol
))
958 && S_IS_DEFINED (symp
->sy_value
.X_add_symbol
)
959 && S_IS_DEFINED (symp
->sy_value
.X_op_symbol
)
960 && S_GET_SEGMENT (symp
->sy_value
.X_add_symbol
) != expr_section
961 && S_GET_SEGMENT (symp
->sy_value
.X_op_symbol
) != expr_section
)
973 report_op_error (symbolS
*symp
, symbolS
*left
, operatorT op
, symbolS
*right
)
977 segT seg_left
= left
? S_GET_SEGMENT (left
) : 0;
978 segT seg_right
= S_GET_SEGMENT (right
);
987 case O_uminus
: opname
= "-"; break;
988 case O_bit_not
: opname
= "~"; break;
989 case O_logical_not
: opname
= "!"; break;
990 case O_multiply
: opname
= "*"; break;
991 case O_divide
: opname
= "/"; break;
992 case O_modulus
: opname
= "%"; break;
993 case O_left_shift
: opname
= "<<"; break;
994 case O_right_shift
: opname
= ">>"; break;
995 case O_bit_inclusive_or
: opname
= "|"; break;
996 case O_bit_or_not
: opname
= "|~"; break;
997 case O_bit_exclusive_or
: opname
= "^"; break;
998 case O_bit_and
: opname
= "&"; break;
999 case O_add
: opname
= "+"; break;
1000 case O_subtract
: opname
= "-"; break;
1001 case O_eq
: opname
= "=="; break;
1002 case O_ne
: opname
= "!="; break;
1003 case O_lt
: opname
= "<"; break;
1004 case O_le
: opname
= "<="; break;
1005 case O_ge
: opname
= ">="; break;
1006 case O_gt
: opname
= ">"; break;
1007 case O_logical_and
: opname
= "&&"; break;
1008 case O_logical_or
: opname
= "||"; break;
1011 if (expr_symbol_where (symp
, &file
, &line
))
1014 as_bad_where (file
, line
,
1015 _("invalid operands (%s and %s sections) for `%s'"),
1016 seg_left
->name
, seg_right
->name
, opname
);
1018 as_bad_where (file
, line
,
1019 _("invalid operand (%s section) for `%s'"),
1020 seg_right
->name
, opname
);
1024 const char *sname
= S_GET_NAME (symp
);
1027 as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1028 seg_left
->name
, seg_right
->name
, opname
, sname
);
1030 as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1031 seg_right
->name
, opname
, sname
);
1035 /* Resolve the value of a symbol. This is called during the final
1036 pass over the symbol table to resolve any symbols with complex
1040 resolve_symbol_value (symbolS
*symp
)
1043 valueT final_val
= 0;
1046 if (LOCAL_SYMBOL_CHECK (symp
))
1048 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1050 final_val
= locsym
->lsy_value
;
1051 if (local_symbol_resolved_p (locsym
))
1054 final_val
+= local_symbol_get_frag (locsym
)->fr_address
/ OCTETS_PER_BYTE
;
1058 locsym
->lsy_value
= final_val
;
1059 local_symbol_mark_resolved (locsym
);
1065 if (symp
->sy_flags
.sy_resolved
)
1067 if (symp
->sy_value
.X_op
== O_constant
)
1068 return (valueT
) symp
->sy_value
.X_add_number
;
1074 final_seg
= S_GET_SEGMENT (symp
);
1076 if (symp
->sy_flags
.sy_resolving
)
1079 as_bad (_("symbol definition loop encountered at `%s'"),
1084 #ifdef OBJ_COMPLEX_RELC
1085 else if (final_seg
== expr_section
1086 && use_complex_relocs_for (symp
))
1088 symbolS
* relc_symbol
= NULL
;
1089 char * relc_symbol_name
= NULL
;
1091 relc_symbol_name
= symbol_relc_make_expr (& symp
->sy_value
);
1093 /* For debugging, print out conversion input & output. */
1095 print_expr (& symp
->sy_value
);
1096 if (relc_symbol_name
)
1097 fprintf (stderr
, "-> relc symbol: %s\n", relc_symbol_name
);
1100 if (relc_symbol_name
!= NULL
)
1101 relc_symbol
= symbol_new (relc_symbol_name
, undefined_section
,
1102 0, & zero_address_frag
);
1104 if (relc_symbol
== NULL
)
1106 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1112 symbol_table_insert (relc_symbol
);
1114 /* S_CLEAR_EXTERNAL (relc_symbol); */
1115 if (symp
->bsym
->flags
& BSF_SRELC
)
1116 relc_symbol
->bsym
->flags
|= BSF_SRELC
;
1118 relc_symbol
->bsym
->flags
|= BSF_RELC
;
1119 /* symp->bsym->flags |= BSF_RELC; */
1120 copy_symbol_attributes (symp
, relc_symbol
);
1121 symp
->sy_value
.X_op
= O_symbol
;
1122 symp
->sy_value
.X_add_symbol
= relc_symbol
;
1123 symp
->sy_value
.X_add_number
= 0;
1127 final_seg
= undefined_section
;
1128 goto exit_dont_set_value
;
1133 symbolS
*add_symbol
, *op_symbol
;
1134 offsetT left
, right
;
1135 segT seg_left
, seg_right
;
1139 symp
->sy_flags
.sy_resolving
= 1;
1141 /* Help out with CSE. */
1142 add_symbol
= symp
->sy_value
.X_add_symbol
;
1143 op_symbol
= symp
->sy_value
.X_op_symbol
;
1144 final_val
= symp
->sy_value
.X_add_number
;
1145 op
= symp
->sy_value
.X_op
;
1158 final_val
+= symp
->sy_frag
->fr_address
/ OCTETS_PER_BYTE
;
1159 if (final_seg
== expr_section
)
1160 final_seg
= absolute_section
;
1169 left
= resolve_symbol_value (add_symbol
);
1170 seg_left
= S_GET_SEGMENT (add_symbol
);
1172 symp
->sy_value
.X_op_symbol
= NULL
;
1175 if (S_IS_WEAKREFR (symp
))
1177 gas_assert (final_val
== 0);
1178 if (S_IS_WEAKREFR (add_symbol
))
1180 gas_assert (add_symbol
->sy_value
.X_op
== O_symbol
1181 && add_symbol
->sy_value
.X_add_number
== 0);
1182 add_symbol
= add_symbol
->sy_value
.X_add_symbol
;
1183 gas_assert (! S_IS_WEAKREFR (add_symbol
));
1184 symp
->sy_value
.X_add_symbol
= add_symbol
;
1188 if (symp
->sy_flags
.sy_mri_common
)
1190 /* This is a symbol inside an MRI common section. The
1191 relocation routines are going to handle it specially.
1192 Don't change the value. */
1193 resolved
= symbol_resolved_p (add_symbol
);
1197 if (finalize_syms
&& final_val
== 0)
1199 if (LOCAL_SYMBOL_CHECK (add_symbol
))
1200 add_symbol
= local_symbol_convert ((struct local_symbol
*)
1202 copy_symbol_attributes (symp
, add_symbol
);
1205 /* If we have equated this symbol to an undefined or common
1206 symbol, keep X_op set to O_symbol, and don't change
1207 X_add_number. This permits the routine which writes out
1208 relocation to detect this case, and convert the
1209 relocation to be against the symbol to which this symbol
1211 if (! S_IS_DEFINED (add_symbol
)
1212 #if defined (OBJ_COFF) && defined (TE_PE)
1213 || S_IS_WEAK (add_symbol
)
1215 || S_IS_COMMON (add_symbol
))
1219 symp
->sy_value
.X_op
= O_symbol
;
1220 symp
->sy_value
.X_add_symbol
= add_symbol
;
1221 symp
->sy_value
.X_add_number
= final_val
;
1222 /* Use X_op_symbol as a flag. */
1223 symp
->sy_value
.X_op_symbol
= add_symbol
;
1225 final_seg
= seg_left
;
1227 resolved
= symbol_resolved_p (add_symbol
);
1228 symp
->sy_flags
.sy_resolving
= 0;
1229 goto exit_dont_set_value
;
1231 else if (finalize_syms
1232 && ((final_seg
== expr_section
&& seg_left
!= expr_section
)
1233 || symbol_shadow_p (symp
)))
1235 /* If the symbol is an expression symbol, do similarly
1236 as for undefined and common syms above. Handles
1237 "sym +/- expr" where "expr" cannot be evaluated
1238 immediately, and we want relocations to be against
1239 "sym", eg. because it is weak. */
1240 symp
->sy_value
.X_op
= O_symbol
;
1241 symp
->sy_value
.X_add_symbol
= add_symbol
;
1242 symp
->sy_value
.X_add_number
= final_val
;
1243 symp
->sy_value
.X_op_symbol
= add_symbol
;
1244 final_seg
= seg_left
;
1245 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1246 resolved
= symbol_resolved_p (add_symbol
);
1247 symp
->sy_flags
.sy_resolving
= 0;
1248 goto exit_dont_set_value
;
1252 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1253 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1254 final_seg
= seg_left
;
1257 resolved
= symbol_resolved_p (add_symbol
);
1258 if (S_IS_WEAKREFR (symp
))
1259 goto exit_dont_set_value
;
1265 left
= resolve_symbol_value (add_symbol
);
1266 seg_left
= S_GET_SEGMENT (add_symbol
);
1268 /* By reducing these to the relevant dyadic operator, we get
1269 !S -> S == 0 permitted on anything,
1270 -S -> 0 - S only permitted on absolute
1271 ~S -> S ^ ~0 only permitted on absolute */
1272 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1274 report_op_error (symp
, NULL
, op
, add_symbol
);
1276 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1277 final_seg
= absolute_section
;
1281 else if (op
== O_logical_not
)
1286 final_val
+= left
+ symp
->sy_frag
->fr_address
;
1288 resolved
= symbol_resolved_p (add_symbol
);
1296 case O_bit_inclusive_or
:
1298 case O_bit_exclusive_or
:
1310 left
= resolve_symbol_value (add_symbol
);
1311 right
= resolve_symbol_value (op_symbol
);
1312 seg_left
= S_GET_SEGMENT (add_symbol
);
1313 seg_right
= S_GET_SEGMENT (op_symbol
);
1315 /* Simplify addition or subtraction of a constant by folding the
1316 constant into X_add_number. */
1319 if (seg_right
== absolute_section
)
1324 else if (seg_left
== absolute_section
)
1327 add_symbol
= op_symbol
;
1329 seg_left
= seg_right
;
1333 else if (op
== O_subtract
)
1335 if (seg_right
== absolute_section
)
1343 /* Equality and non-equality tests are permitted on anything.
1344 Subtraction, and other comparison operators are permitted if
1345 both operands are in the same section. Otherwise, both
1346 operands must be absolute. We already handled the case of
1347 addition or subtraction of a constant above. This will
1348 probably need to be changed for an object file format which
1349 supports arbitrary expressions, such as IEEE-695. */
1350 if (!(seg_left
== absolute_section
1351 && seg_right
== absolute_section
)
1352 && !(op
== O_eq
|| op
== O_ne
)
1353 && !((op
== O_subtract
1354 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1355 && seg_left
== seg_right
1356 && (seg_left
!= undefined_section
1357 || add_symbol
== op_symbol
)))
1359 /* Don't emit messages unless we're finalizing the symbol value,
1360 otherwise we may get the same message multiple times. */
1362 report_op_error (symp
, add_symbol
, op
, op_symbol
);
1363 /* However do not move the symbol into the absolute section
1364 if it cannot currently be resolved - this would confuse
1365 other parts of the assembler into believing that the
1366 expression had been evaluated to zero. */
1372 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1373 final_seg
= absolute_section
;
1375 /* Check for division by zero. */
1376 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1378 /* If seg_right is not absolute_section, then we've
1379 already issued a warning about using a bad symbol. */
1380 if (seg_right
== absolute_section
&& finalize_syms
)
1385 if (expr_symbol_where (symp
, &file
, &line
))
1386 as_bad_where (file
, line
, _("division by zero"));
1388 as_bad (_("division by zero when setting `%s'"),
1395 switch (symp
->sy_value
.X_op
)
1397 case O_multiply
: left
*= right
; break;
1398 case O_divide
: left
/= right
; break;
1399 case O_modulus
: left
%= right
; break;
1400 case O_left_shift
: left
<<= right
; break;
1401 case O_right_shift
: left
>>= right
; break;
1402 case O_bit_inclusive_or
: left
|= right
; break;
1403 case O_bit_or_not
: left
|= ~right
; break;
1404 case O_bit_exclusive_or
: left
^= right
; break;
1405 case O_bit_and
: left
&= right
; break;
1406 case O_add
: left
+= right
; break;
1407 case O_subtract
: left
-= right
; break;
1410 left
= (left
== right
&& seg_left
== seg_right
1411 && (seg_left
!= undefined_section
1412 || add_symbol
== op_symbol
)
1413 ? ~ (offsetT
) 0 : 0);
1414 if (symp
->sy_value
.X_op
== O_ne
)
1417 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1418 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1419 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1420 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1421 case O_logical_and
: left
= left
&& right
; break;
1422 case O_logical_or
: left
= left
|| right
; break;
1426 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1427 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1429 if (seg_left
== undefined_section
1430 || seg_right
== undefined_section
)
1431 final_seg
= undefined_section
;
1432 else if (seg_left
== absolute_section
)
1433 final_seg
= seg_right
;
1435 final_seg
= seg_left
;
1437 resolved
= (symbol_resolved_p (add_symbol
)
1438 && symbol_resolved_p (op_symbol
));
1443 /* Give an error (below) if not in expr_section. We don't
1444 want to worry about expr_section symbols, because they
1445 are fictional (they are created as part of expression
1446 resolution), and any problems may not actually mean
1451 symp
->sy_flags
.sy_resolving
= 0;
1455 S_SET_VALUE (symp
, final_val
);
1457 exit_dont_set_value
:
1458 /* Always set the segment, even if not finalizing the value.
1459 The segment is used to determine whether a symbol is defined. */
1460 S_SET_SEGMENT (symp
, final_seg
);
1462 /* Don't worry if we can't resolve an expr_section symbol. */
1466 symp
->sy_flags
.sy_resolved
= 1;
1467 else if (S_GET_SEGMENT (symp
) != expr_section
)
1469 as_bad (_("can't resolve value for symbol `%s'"),
1471 symp
->sy_flags
.sy_resolved
= 1;
1478 static void resolve_local_symbol (const char *, void *);
1480 /* A static function passed to hash_traverse. */
1483 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED
, void *value
)
1486 resolve_symbol_value ((symbolS
*) value
);
1489 /* Resolve all local symbols. */
1492 resolve_local_symbol_values (void)
1494 hash_traverse (local_hash
, resolve_local_symbol
);
1497 /* Obtain the current value of a symbol without changing any
1498 sub-expressions used. */
1501 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1503 symbolS
*symbolP
= *symbolPP
;
1505 if (LOCAL_SYMBOL_CHECK (symbolP
))
1507 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1509 *valueP
= locsym
->lsy_value
;
1510 *segP
= locsym
->lsy_section
;
1511 *fragPP
= local_symbol_get_frag (locsym
);
1515 expressionS exp
= symbolP
->sy_value
;
1517 if (!symbolP
->sy_flags
.sy_resolved
&& exp
.X_op
!= O_illegal
)
1521 if (symbolP
->sy_flags
.sy_resolving
)
1523 symbolP
->sy_flags
.sy_resolving
= 1;
1524 resolved
= resolve_expression (&exp
);
1525 symbolP
->sy_flags
.sy_resolving
= 0;
1533 if (!symbol_equated_p (symbolP
))
1538 symbolP
= exp
.X_add_symbol
;
1545 *symbolPP
= symbolP
;
1546 *valueP
= exp
.X_add_number
;
1547 *segP
= symbolP
->bsym
->section
;
1548 *fragPP
= symbolP
->sy_frag
;
1550 if (*segP
== expr_section
)
1553 case O_constant
: *segP
= absolute_section
; break;
1554 case O_register
: *segP
= reg_section
; break;
1562 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1563 They are *really* local. That is, they go out of scope whenever we see a
1564 label that isn't local. Also, like fb labels, there can be multiple
1565 instances of a dollar label. Therefor, we name encode each instance with
1566 the instance number, keep a list of defined symbols separate from the real
1567 symbol table, and we treat these buggers as a sparse array. */
1569 static long *dollar_labels
;
1570 static long *dollar_label_instances
;
1571 static char *dollar_label_defines
;
1572 static unsigned long dollar_label_count
;
1573 static unsigned long dollar_label_max
;
1576 dollar_label_defined (long label
)
1580 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1582 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1584 return dollar_label_defines
[i
- dollar_labels
];
1586 /* If we get here, label isn't defined. */
1591 dollar_label_instance (long label
)
1595 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1597 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1599 return (dollar_label_instances
[i
- dollar_labels
]);
1601 /* If we get here, we haven't seen the label before.
1602 Therefore its instance count is zero. */
1607 dollar_label_clear (void)
1609 memset (dollar_label_defines
, '\0', (unsigned int) dollar_label_count
);
1612 #define DOLLAR_LABEL_BUMP_BY 10
1615 define_dollar_label (long label
)
1619 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1622 ++dollar_label_instances
[i
- dollar_labels
];
1623 dollar_label_defines
[i
- dollar_labels
] = 1;
1627 /* If we get to here, we don't have label listed yet. */
1629 if (dollar_labels
== NULL
)
1631 dollar_labels
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1632 dollar_label_instances
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1633 dollar_label_defines
= (char *) xmalloc (DOLLAR_LABEL_BUMP_BY
);
1634 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1635 dollar_label_count
= 0;
1637 else if (dollar_label_count
== dollar_label_max
)
1639 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1640 dollar_labels
= (long *) xrealloc ((char *) dollar_labels
,
1641 dollar_label_max
* sizeof (long));
1642 dollar_label_instances
= (long *) xrealloc ((char *) dollar_label_instances
,
1643 dollar_label_max
* sizeof (long));
1644 dollar_label_defines
= (char *) xrealloc (dollar_label_defines
, dollar_label_max
);
1645 } /* if we needed to grow */
1647 dollar_labels
[dollar_label_count
] = label
;
1648 dollar_label_instances
[dollar_label_count
] = 1;
1649 dollar_label_defines
[dollar_label_count
] = 1;
1650 ++dollar_label_count
;
1653 /* Caller must copy returned name: we re-use the area for the next name.
1655 The mth occurence of label n: is turned into the symbol "Ln^Am"
1656 where n is the label number and m is the instance number. "L" makes
1657 it a label discarded unless debugging and "^A"('\1') ensures no
1658 ordinary symbol SHOULD get the same name as a local label
1659 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1661 fb labels get the same treatment, except that ^B is used in place
1664 char * /* Return local label name. */
1665 dollar_label_name (long n
, /* we just saw "n$:" : n a number. */
1666 int augend
/* 0 for current instance, 1 for new instance. */)
1669 /* Returned to caller, then copied. Used for created names ("4f"). */
1670 static char symbol_name_build
[24];
1673 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1676 know (augend
== 0 || augend
== 1);
1677 p
= symbol_name_build
;
1678 #ifdef LOCAL_LABEL_PREFIX
1679 *p
++ = LOCAL_LABEL_PREFIX
;
1683 /* Next code just does sprintf( {}, "%d", n); */
1685 q
= symbol_name_temporary
;
1686 for (*q
++ = 0, i
= n
; i
; ++q
)
1691 while ((*p
= *--q
) != '\0')
1694 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1696 /* Instance number. */
1697 q
= symbol_name_temporary
;
1698 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1703 while ((*p
++ = *--q
) != '\0');
1705 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1706 return symbol_name_build
;
1709 /* Somebody else's idea of local labels. They are made by "n:" where n
1710 is any decimal digit. Refer to them with
1711 "nb" for previous (backward) n:
1712 or "nf" for next (forward) n:.
1714 We do a little better and let n be any number, not just a single digit, but
1715 since the other guy's assembler only does ten, we treat the first ten
1718 Like someone else's assembler, we have one set of local label counters for
1719 entire assembly, not one set per (sub)segment like in most assemblers. This
1720 implies that one can refer to a label in another segment, and indeed some
1721 crufty compilers have done just that.
1723 Since there could be a LOT of these things, treat them as a sparse
1726 #define FB_LABEL_SPECIAL (10)
1728 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1729 static long *fb_labels
;
1730 static long *fb_label_instances
;
1731 static long fb_label_count
;
1732 static long fb_label_max
;
1734 /* This must be more than FB_LABEL_SPECIAL. */
1735 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1738 fb_label_init (void)
1740 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1743 /* Add one to the instance number of this fb label. */
1746 fb_label_instance_inc (long label
)
1750 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
1752 ++fb_low_counter
[label
];
1756 if (fb_labels
!= NULL
)
1758 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1759 i
< fb_labels
+ fb_label_count
; ++i
)
1763 ++fb_label_instances
[i
- fb_labels
];
1765 } /* if we find it */
1766 } /* for each existing label */
1769 /* If we get to here, we don't have label listed yet. */
1771 if (fb_labels
== NULL
)
1773 fb_labels
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1774 fb_label_instances
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1775 fb_label_max
= FB_LABEL_BUMP_BY
;
1776 fb_label_count
= FB_LABEL_SPECIAL
;
1779 else if (fb_label_count
== fb_label_max
)
1781 fb_label_max
+= FB_LABEL_BUMP_BY
;
1782 fb_labels
= (long *) xrealloc ((char *) fb_labels
,
1783 fb_label_max
* sizeof (long));
1784 fb_label_instances
= (long *) xrealloc ((char *) fb_label_instances
,
1785 fb_label_max
* sizeof (long));
1786 } /* if we needed to grow */
1788 fb_labels
[fb_label_count
] = label
;
1789 fb_label_instances
[fb_label_count
] = 1;
1794 fb_label_instance (long label
)
1798 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
1800 return (fb_low_counter
[label
]);
1803 if (fb_labels
!= NULL
)
1805 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1806 i
< fb_labels
+ fb_label_count
; ++i
)
1810 return (fb_label_instances
[i
- fb_labels
]);
1811 } /* if we find it */
1812 } /* for each existing label */
1815 /* We didn't find the label, so this must be a reference to the
1820 /* Caller must copy returned name: we re-use the area for the next name.
1822 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1823 where n is the label number and m is the instance number. "L" makes
1824 it a label discarded unless debugging and "^B"('\2') ensures no
1825 ordinary symbol SHOULD get the same name as a local label
1826 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1828 dollar labels get the same treatment, except that ^A is used in
1831 char * /* Return local label name. */
1832 fb_label_name (long n
, /* We just saw "n:", "nf" or "nb" : n a number. */
1833 long augend
/* 0 for nb, 1 for n:, nf. */)
1836 /* Returned to caller, then copied. Used for created names ("4f"). */
1837 static char symbol_name_build
[24];
1840 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1844 know ((unsigned long) augend
<= 2 /* See mmix_fb_label. */);
1846 know ((unsigned long) augend
<= 1);
1848 p
= symbol_name_build
;
1849 #ifdef LOCAL_LABEL_PREFIX
1850 *p
++ = LOCAL_LABEL_PREFIX
;
1854 /* Next code just does sprintf( {}, "%d", n); */
1856 q
= symbol_name_temporary
;
1857 for (*q
++ = 0, i
= n
; i
; ++q
)
1862 while ((*p
= *--q
) != '\0')
1865 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
1867 /* Instance number. */
1868 q
= symbol_name_temporary
;
1869 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
1874 while ((*p
++ = *--q
) != '\0');
1876 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1877 return (symbol_name_build
);
1880 /* Decode name that may have been generated by foo_label_name() above.
1881 If the name wasn't generated by foo_label_name(), then return it
1882 unaltered. This is used for error messages. */
1885 decode_local_label_name (char *s
)
1888 char *symbol_decode
;
1890 int instance_number
;
1892 const char *message_format
;
1895 #ifdef LOCAL_LABEL_PREFIX
1896 if (s
[lindex
] == LOCAL_LABEL_PREFIX
)
1900 if (s
[lindex
] != 'L')
1903 for (label_number
= 0, p
= s
+ lindex
+ 1; ISDIGIT (*p
); ++p
)
1904 label_number
= (10 * label_number
) + *p
- '0';
1906 if (*p
== DOLLAR_LABEL_CHAR
)
1908 else if (*p
== LOCAL_LABEL_CHAR
)
1913 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
1914 instance_number
= (10 * instance_number
) + *p
- '0';
1916 message_format
= _("\"%d\" (instance number %d of a %s label)");
1917 symbol_decode
= (char *) obstack_alloc (¬es
, strlen (message_format
) + 30);
1918 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
1920 return symbol_decode
;
1923 /* Get the value of a symbol. */
1926 S_GET_VALUE (symbolS
*s
)
1928 if (LOCAL_SYMBOL_CHECK (s
))
1929 return resolve_symbol_value (s
);
1931 if (!s
->sy_flags
.sy_resolved
)
1933 valueT val
= resolve_symbol_value (s
);
1937 if (S_IS_WEAKREFR (s
))
1938 return S_GET_VALUE (s
->sy_value
.X_add_symbol
);
1940 if (s
->sy_value
.X_op
!= O_constant
)
1942 if (! s
->sy_flags
.sy_resolved
1943 || s
->sy_value
.X_op
!= O_symbol
1944 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
1945 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1948 return (valueT
) s
->sy_value
.X_add_number
;
1951 /* Set the value of a symbol. */
1954 S_SET_VALUE (symbolS
*s
, valueT val
)
1956 if (LOCAL_SYMBOL_CHECK (s
))
1958 ((struct local_symbol
*) s
)->lsy_value
= val
;
1962 s
->sy_value
.X_op
= O_constant
;
1963 s
->sy_value
.X_add_number
= (offsetT
) val
;
1964 s
->sy_value
.X_unsigned
= 0;
1965 S_CLEAR_WEAKREFR (s
);
1969 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
1971 if (LOCAL_SYMBOL_CHECK (dest
))
1972 dest
= local_symbol_convert ((struct local_symbol
*) dest
);
1973 if (LOCAL_SYMBOL_CHECK (src
))
1974 src
= local_symbol_convert ((struct local_symbol
*) src
);
1976 /* In an expression, transfer the settings of these flags.
1977 The user can override later, of course. */
1978 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
1979 | BSF_GNU_INDIRECT_FUNCTION)
1980 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
1982 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1983 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
1986 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1987 TC_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
1992 S_IS_FUNCTION (symbolS
*s
)
1996 if (LOCAL_SYMBOL_CHECK (s
))
1999 flags
= s
->bsym
->flags
;
2001 return (flags
& BSF_FUNCTION
) != 0;
2005 S_IS_EXTERNAL (symbolS
*s
)
2009 if (LOCAL_SYMBOL_CHECK (s
))
2012 flags
= s
->bsym
->flags
;
2015 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2018 return (flags
& BSF_GLOBAL
) != 0;
2022 S_IS_WEAK (symbolS
*s
)
2024 if (LOCAL_SYMBOL_CHECK (s
))
2026 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2027 could probably handle a WEAKREFR as always weak though. E.g., if
2028 the referenced symbol has lost its weak status, there's no reason
2029 to keep handling the weakrefr as if it was weak. */
2030 if (S_IS_WEAKREFR (s
))
2031 return S_IS_WEAK (s
->sy_value
.X_add_symbol
);
2032 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
2036 S_IS_WEAKREFR (symbolS
*s
)
2038 if (LOCAL_SYMBOL_CHECK (s
))
2040 return s
->sy_flags
.sy_weakrefr
!= 0;
2044 S_IS_WEAKREFD (symbolS
*s
)
2046 if (LOCAL_SYMBOL_CHECK (s
))
2048 return s
->sy_flags
.sy_weakrefd
!= 0;
2052 S_IS_COMMON (symbolS
*s
)
2054 if (LOCAL_SYMBOL_CHECK (s
))
2056 return bfd_is_com_section (s
->bsym
->section
);
2060 S_IS_DEFINED (symbolS
*s
)
2062 if (LOCAL_SYMBOL_CHECK (s
))
2063 return ((struct local_symbol
*) s
)->lsy_section
!= undefined_section
;
2064 return s
->bsym
->section
!= undefined_section
;
2068 #ifndef EXTERN_FORCE_RELOC
2069 #define EXTERN_FORCE_RELOC IS_ELF
2072 /* Return true for symbols that should not be reduced to section
2073 symbols or eliminated from expressions, because they may be
2074 overridden by the linker. */
2076 S_FORCE_RELOC (symbolS
*s
, int strict
)
2078 if (LOCAL_SYMBOL_CHECK (s
))
2079 return ((struct local_symbol
*) s
)->lsy_section
== undefined_section
;
2082 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
2083 || (EXTERN_FORCE_RELOC
2084 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
2085 || (s
->bsym
->flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0
2086 || s
->bsym
->section
== undefined_section
2087 || bfd_is_com_section (s
->bsym
->section
));
2091 S_IS_DEBUG (symbolS
*s
)
2093 if (LOCAL_SYMBOL_CHECK (s
))
2095 if (s
->bsym
->flags
& BSF_DEBUGGING
)
2101 S_IS_LOCAL (symbolS
*s
)
2106 if (LOCAL_SYMBOL_CHECK (s
))
2109 flags
= s
->bsym
->flags
;
2112 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2115 if (bfd_get_section (s
->bsym
) == reg_section
)
2118 if (flag_strip_local_absolute
2119 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2120 the source file even when the object file is stripped. */
2121 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
2122 && bfd_get_section (s
->bsym
) == absolute_section
)
2125 name
= S_GET_NAME (s
);
2126 return (name
!= NULL
2128 && (strchr (name
, DOLLAR_LABEL_CHAR
)
2129 || strchr (name
, LOCAL_LABEL_CHAR
)
2130 || TC_LABEL_IS_LOCAL (name
)
2131 || (! flag_keep_locals
2132 && (bfd_is_local_label (stdoutput
, s
->bsym
)
2135 && name
[1] == '?')))));
2139 S_IS_STABD (symbolS
*s
)
2141 return S_GET_NAME (s
) == 0;
2145 S_CAN_BE_REDEFINED (const symbolS
*s
)
2147 if (LOCAL_SYMBOL_CHECK (s
))
2148 return (local_symbol_get_frag ((struct local_symbol
*) s
)
2149 == &predefined_address_frag
);
2150 /* Permit register names to be redefined. */
2151 return s
->bsym
->section
== reg_section
;
2155 S_IS_VOLATILE (const symbolS
*s
)
2157 if (LOCAL_SYMBOL_CHECK (s
))
2159 return s
->sy_flags
.sy_volatile
;
2163 S_IS_FORWARD_REF (const symbolS
*s
)
2165 if (LOCAL_SYMBOL_CHECK (s
))
2167 return s
->sy_flags
.sy_forward_ref
;
2171 S_GET_NAME (symbolS
*s
)
2173 if (LOCAL_SYMBOL_CHECK (s
))
2174 return ((struct local_symbol
*) s
)->lsy_name
;
2175 return s
->bsym
->name
;
2179 S_GET_SEGMENT (symbolS
*s
)
2181 if (LOCAL_SYMBOL_CHECK (s
))
2182 return ((struct local_symbol
*) s
)->lsy_section
;
2183 return s
->bsym
->section
;
2187 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2189 /* Don't reassign section symbols. The direct reason is to prevent seg
2190 faults assigning back to const global symbols such as *ABS*, but it
2191 shouldn't happen anyway. */
2193 if (LOCAL_SYMBOL_CHECK (s
))
2195 if (seg
== reg_section
)
2196 s
= local_symbol_convert ((struct local_symbol
*) s
);
2199 ((struct local_symbol
*) s
)->lsy_section
= seg
;
2204 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2206 if (s
->bsym
->section
!= seg
)
2210 s
->bsym
->section
= seg
;
2214 S_SET_EXTERNAL (symbolS
*s
)
2216 if (LOCAL_SYMBOL_CHECK (s
))
2217 s
= local_symbol_convert ((struct local_symbol
*) s
);
2218 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2220 /* Let .weak override .global. */
2223 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2225 /* Do not reassign section symbols. */
2226 as_warn (_("section symbols are already global"));
2229 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2230 if (S_GET_SEGMENT (s
) == reg_section
)
2232 as_bad ("can't make register symbol `%s' global",
2237 s
->bsym
->flags
|= BSF_GLOBAL
;
2238 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2241 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2242 an_external_name
= S_GET_NAME (s
);
2247 S_CLEAR_EXTERNAL (symbolS
*s
)
2249 if (LOCAL_SYMBOL_CHECK (s
))
2251 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2253 /* Let .weak override. */
2256 s
->bsym
->flags
|= BSF_LOCAL
;
2257 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2261 S_SET_WEAK (symbolS
*s
)
2263 if (LOCAL_SYMBOL_CHECK (s
))
2264 s
= local_symbol_convert ((struct local_symbol
*) s
);
2265 #ifdef obj_set_weak_hook
2266 obj_set_weak_hook (s
);
2268 s
->bsym
->flags
|= BSF_WEAK
;
2269 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2273 S_SET_WEAKREFR (symbolS
*s
)
2275 if (LOCAL_SYMBOL_CHECK (s
))
2276 s
= local_symbol_convert ((struct local_symbol
*) s
);
2277 s
->sy_flags
.sy_weakrefr
= 1;
2278 /* If the alias was already used, make sure we mark the target as
2279 used as well, otherwise it might be dropped from the symbol
2280 table. This may have unintended side effects if the alias is
2281 later redirected to another symbol, such as keeping the unused
2282 previous target in the symbol table. Since it will be weak, it's
2284 if (s
->sy_flags
.sy_used
)
2285 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2289 S_CLEAR_WEAKREFR (symbolS
*s
)
2291 if (LOCAL_SYMBOL_CHECK (s
))
2293 s
->sy_flags
.sy_weakrefr
= 0;
2297 S_SET_WEAKREFD (symbolS
*s
)
2299 if (LOCAL_SYMBOL_CHECK (s
))
2300 s
= local_symbol_convert ((struct local_symbol
*) s
);
2301 s
->sy_flags
.sy_weakrefd
= 1;
2306 S_CLEAR_WEAKREFD (symbolS
*s
)
2308 if (LOCAL_SYMBOL_CHECK (s
))
2310 if (s
->sy_flags
.sy_weakrefd
)
2312 s
->sy_flags
.sy_weakrefd
= 0;
2313 /* If a weakref target symbol is weak, then it was never
2314 referenced directly before, not even in a .global directive,
2315 so decay it to local. If it remains undefined, it will be
2316 later turned into a global, like any other undefined
2318 if (s
->bsym
->flags
& BSF_WEAK
)
2320 #ifdef obj_clear_weak_hook
2321 obj_clear_weak_hook (s
);
2323 s
->bsym
->flags
&= ~BSF_WEAK
;
2324 s
->bsym
->flags
|= BSF_LOCAL
;
2330 S_SET_THREAD_LOCAL (symbolS
*s
)
2332 if (LOCAL_SYMBOL_CHECK (s
))
2333 s
= local_symbol_convert ((struct local_symbol
*) s
);
2334 if (bfd_is_com_section (s
->bsym
->section
)
2335 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2337 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2338 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2339 as_bad (_("Accessing function `%s' as thread-local object"),
2341 else if (! bfd_is_und_section (s
->bsym
->section
)
2342 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2343 as_bad (_("Accessing `%s' as thread-local object"),
2348 S_SET_NAME (symbolS
*s
, const char *name
)
2350 if (LOCAL_SYMBOL_CHECK (s
))
2352 ((struct local_symbol
*) s
)->lsy_name
= name
;
2355 s
->bsym
->name
= name
;
2359 S_SET_VOLATILE (symbolS
*s
)
2361 if (LOCAL_SYMBOL_CHECK (s
))
2362 s
= local_symbol_convert ((struct local_symbol
*) s
);
2363 s
->sy_flags
.sy_volatile
= 1;
2367 S_CLEAR_VOLATILE (symbolS
*s
)
2369 if (!LOCAL_SYMBOL_CHECK (s
))
2370 s
->sy_flags
.sy_volatile
= 0;
2374 S_SET_FORWARD_REF (symbolS
*s
)
2376 if (LOCAL_SYMBOL_CHECK (s
))
2377 s
= local_symbol_convert ((struct local_symbol
*) s
);
2378 s
->sy_flags
.sy_forward_ref
= 1;
2381 /* Return the previous symbol in a chain. */
2384 symbol_previous (symbolS
*s
)
2386 if (LOCAL_SYMBOL_CHECK (s
))
2388 return s
->sy_previous
;
2391 /* Return the next symbol in a chain. */
2394 symbol_next (symbolS
*s
)
2396 if (LOCAL_SYMBOL_CHECK (s
))
2401 /* Return a pointer to the value of a symbol as an expression. */
2404 symbol_get_value_expression (symbolS
*s
)
2406 if (LOCAL_SYMBOL_CHECK (s
))
2407 s
= local_symbol_convert ((struct local_symbol
*) s
);
2408 return &s
->sy_value
;
2411 /* Set the value of a symbol to an expression. */
2414 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2416 if (LOCAL_SYMBOL_CHECK (s
))
2417 s
= local_symbol_convert ((struct local_symbol
*) s
);
2419 S_CLEAR_WEAKREFR (s
);
2422 /* Return whether 2 symbols are the same. */
2425 symbol_same_p (symbolS
*s1
, symbolS
*s2
)
2427 if (s1
->sy_flags
.sy_local_symbol
2428 && local_symbol_converted_p ((struct local_symbol
*) s1
))
2429 s1
= local_symbol_get_real_symbol ((struct local_symbol
*) s1
);
2430 if (s2
->sy_flags
.sy_local_symbol
2431 && local_symbol_converted_p ((struct local_symbol
*) s2
))
2432 s2
= local_symbol_get_real_symbol ((struct local_symbol
*) s2
);
2436 /* Return a pointer to the X_add_number component of a symbol. */
2439 symbol_X_add_number (symbolS
*s
)
2441 if (LOCAL_SYMBOL_CHECK (s
))
2442 return (offsetT
*) &((struct local_symbol
*) s
)->lsy_value
;
2444 return &s
->sy_value
.X_add_number
;
2447 /* Set the value of SYM to the current position in the current segment. */
2450 symbol_set_value_now (symbolS
*sym
)
2452 S_SET_SEGMENT (sym
, now_seg
);
2453 S_SET_VALUE (sym
, frag_now_fix ());
2454 symbol_set_frag (sym
, frag_now
);
2457 /* Set the frag of a symbol. */
2460 symbol_set_frag (symbolS
*s
, fragS
*f
)
2462 if (LOCAL_SYMBOL_CHECK (s
))
2464 local_symbol_set_frag ((struct local_symbol
*) s
, f
);
2468 S_CLEAR_WEAKREFR (s
);
2471 /* Return the frag of a symbol. */
2474 symbol_get_frag (symbolS
*s
)
2476 if (LOCAL_SYMBOL_CHECK (s
))
2477 return local_symbol_get_frag ((struct local_symbol
*) s
);
2481 /* Mark a symbol as having been used. */
2484 symbol_mark_used (symbolS
*s
)
2486 if (LOCAL_SYMBOL_CHECK (s
))
2488 s
->sy_flags
.sy_used
= 1;
2489 if (S_IS_WEAKREFR (s
))
2490 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2493 /* Clear the mark of whether a symbol has been used. */
2496 symbol_clear_used (symbolS
*s
)
2498 if (LOCAL_SYMBOL_CHECK (s
))
2499 s
= local_symbol_convert ((struct local_symbol
*) s
);
2500 s
->sy_flags
.sy_used
= 0;
2503 /* Return whether a symbol has been used. */
2506 symbol_used_p (symbolS
*s
)
2508 if (LOCAL_SYMBOL_CHECK (s
))
2510 return s
->sy_flags
.sy_used
;
2513 /* Mark a symbol as having been used in a reloc. */
2516 symbol_mark_used_in_reloc (symbolS
*s
)
2518 if (LOCAL_SYMBOL_CHECK (s
))
2519 s
= local_symbol_convert ((struct local_symbol
*) s
);
2520 s
->sy_flags
.sy_used_in_reloc
= 1;
2523 /* Clear the mark of whether a symbol has been used in a reloc. */
2526 symbol_clear_used_in_reloc (symbolS
*s
)
2528 if (LOCAL_SYMBOL_CHECK (s
))
2530 s
->sy_flags
.sy_used_in_reloc
= 0;
2533 /* Return whether a symbol has been used in a reloc. */
2536 symbol_used_in_reloc_p (symbolS
*s
)
2538 if (LOCAL_SYMBOL_CHECK (s
))
2540 return s
->sy_flags
.sy_used_in_reloc
;
2543 /* Mark a symbol as an MRI common symbol. */
2546 symbol_mark_mri_common (symbolS
*s
)
2548 if (LOCAL_SYMBOL_CHECK (s
))
2549 s
= local_symbol_convert ((struct local_symbol
*) s
);
2550 s
->sy_flags
.sy_mri_common
= 1;
2553 /* Clear the mark of whether a symbol is an MRI common symbol. */
2556 symbol_clear_mri_common (symbolS
*s
)
2558 if (LOCAL_SYMBOL_CHECK (s
))
2560 s
->sy_flags
.sy_mri_common
= 0;
2563 /* Return whether a symbol is an MRI common symbol. */
2566 symbol_mri_common_p (symbolS
*s
)
2568 if (LOCAL_SYMBOL_CHECK (s
))
2570 return s
->sy_flags
.sy_mri_common
;
2573 /* Mark a symbol as having been written. */
2576 symbol_mark_written (symbolS
*s
)
2578 if (LOCAL_SYMBOL_CHECK (s
))
2580 s
->sy_flags
.sy_written
= 1;
2583 /* Clear the mark of whether a symbol has been written. */
2586 symbol_clear_written (symbolS
*s
)
2588 if (LOCAL_SYMBOL_CHECK (s
))
2590 s
->sy_flags
.sy_written
= 0;
2593 /* Return whether a symbol has been written. */
2596 symbol_written_p (symbolS
*s
)
2598 if (LOCAL_SYMBOL_CHECK (s
))
2600 return s
->sy_flags
.sy_written
;
2603 /* Mark a symbol has having been resolved. */
2606 symbol_mark_resolved (symbolS
*s
)
2608 if (LOCAL_SYMBOL_CHECK (s
))
2610 local_symbol_mark_resolved ((struct local_symbol
*) s
);
2613 s
->sy_flags
.sy_resolved
= 1;
2616 /* Return whether a symbol has been resolved. */
2619 symbol_resolved_p (symbolS
*s
)
2621 if (LOCAL_SYMBOL_CHECK (s
))
2622 return local_symbol_resolved_p ((struct local_symbol
*) s
);
2623 return s
->sy_flags
.sy_resolved
;
2626 /* Return whether a symbol is a section symbol. */
2629 symbol_section_p (symbolS
*s ATTRIBUTE_UNUSED
)
2631 if (LOCAL_SYMBOL_CHECK (s
))
2633 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2636 /* Return whether a symbol is equated to another symbol. */
2639 symbol_equated_p (symbolS
*s
)
2641 if (LOCAL_SYMBOL_CHECK (s
))
2643 return s
->sy_value
.X_op
== O_symbol
;
2646 /* Return whether a symbol is equated to another symbol, and should be
2647 treated specially when writing out relocs. */
2650 symbol_equated_reloc_p (symbolS
*s
)
2652 if (LOCAL_SYMBOL_CHECK (s
))
2654 /* X_op_symbol, normally not used for O_symbol, is set by
2655 resolve_symbol_value to flag expression syms that have been
2657 return (s
->sy_value
.X_op
== O_symbol
2658 #if defined (OBJ_COFF) && defined (TE_PE)
2661 && ((s
->sy_flags
.sy_resolved
&& s
->sy_value
.X_op_symbol
!= NULL
)
2662 || ! S_IS_DEFINED (s
)
2663 || S_IS_COMMON (s
)));
2666 /* Return whether a symbol has a constant value. */
2669 symbol_constant_p (symbolS
*s
)
2671 if (LOCAL_SYMBOL_CHECK (s
))
2673 return s
->sy_value
.X_op
== O_constant
;
2676 /* Return whether a symbol was cloned and thus removed from the global
2680 symbol_shadow_p (symbolS
*s
)
2682 if (LOCAL_SYMBOL_CHECK (s
))
2684 return s
->sy_next
== s
;
2687 /* Return the BFD symbol for a symbol. */
2690 symbol_get_bfdsym (symbolS
*s
)
2692 if (LOCAL_SYMBOL_CHECK (s
))
2693 s
= local_symbol_convert ((struct local_symbol
*) s
);
2697 /* Set the BFD symbol for a symbol. */
2700 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2702 if (LOCAL_SYMBOL_CHECK (s
))
2703 s
= local_symbol_convert ((struct local_symbol
*) s
);
2704 /* Usually, it is harmless to reset a symbol to a BFD section
2705 symbol. For example, obj_elf_change_section sets the BFD symbol
2706 of an old symbol with the newly created section symbol. But when
2707 we have multiple sections with the same name, the newly created
2708 section may have the same name as an old section. We check if the
2709 old symbol has been already marked as a section symbol before
2711 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2713 /* else XXX - What do we do now ? */
2716 #ifdef OBJ_SYMFIELD_TYPE
2718 /* Get a pointer to the object format information for a symbol. */
2721 symbol_get_obj (symbolS
*s
)
2723 if (LOCAL_SYMBOL_CHECK (s
))
2724 s
= local_symbol_convert ((struct local_symbol
*) s
);
2728 /* Set the object format information for a symbol. */
2731 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
2733 if (LOCAL_SYMBOL_CHECK (s
))
2734 s
= local_symbol_convert ((struct local_symbol
*) s
);
2738 #endif /* OBJ_SYMFIELD_TYPE */
2740 #ifdef TC_SYMFIELD_TYPE
2742 /* Get a pointer to the processor information for a symbol. */
2745 symbol_get_tc (symbolS
*s
)
2747 if (LOCAL_SYMBOL_CHECK (s
))
2748 s
= local_symbol_convert ((struct local_symbol
*) s
);
2752 /* Set the processor information for a symbol. */
2755 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
2757 if (LOCAL_SYMBOL_CHECK (s
))
2758 s
= local_symbol_convert ((struct local_symbol
*) s
);
2762 #endif /* TC_SYMFIELD_TYPE */
2767 symbol_lastP
= NULL
;
2768 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2769 sy_hash
= hash_new ();
2770 local_hash
= hash_new ();
2772 memset ((char *) (&abs_symbol
), '\0', sizeof (abs_symbol
));
2773 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2774 abs_symbol
.bsym
= bfd_abs_section_ptr
->symbol
;
2776 abs_symbol
.sy_value
.X_op
= O_constant
;
2777 abs_symbol
.sy_frag
= &zero_address_frag
;
2779 if (LOCAL_LABELS_FB
)
2784 dot_symbol_init (void)
2786 dot_symbol
.bsym
= bfd_make_empty_symbol (stdoutput
);
2787 if (dot_symbol
.bsym
== NULL
)
2788 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
2789 dot_symbol
.bsym
->name
= ".";
2790 dot_symbol
.sy_flags
.sy_forward_ref
= 1;
2791 dot_symbol
.sy_value
.X_op
= O_constant
;
2796 /* Maximum indent level.
2797 Available for modification inside a gdb session. */
2798 static int max_indent_level
= 8;
2801 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
2803 const char *name
= S_GET_NAME (sym
);
2804 if (!name
|| !name
[0])
2806 fprintf (file
, "sym ");
2807 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
));
2808 fprintf (file
, " %s", name
);
2810 if (LOCAL_SYMBOL_CHECK (sym
))
2812 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
2814 if (local_symbol_get_frag (locsym
) != & zero_address_frag
2815 && local_symbol_get_frag (locsym
) != NULL
)
2817 fprintf (file
, " frag ");
2818 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) local_symbol_get_frag (locsym
)));
2820 if (local_symbol_resolved_p (locsym
))
2821 fprintf (file
, " resolved");
2822 fprintf (file
, " local");
2826 if (sym
->sy_frag
!= &zero_address_frag
)
2828 fprintf (file
, " frag ");
2829 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
->sy_frag
));
2831 if (sym
->sy_flags
.sy_written
)
2832 fprintf (file
, " written");
2833 if (sym
->sy_flags
.sy_resolved
)
2834 fprintf (file
, " resolved");
2835 else if (sym
->sy_flags
.sy_resolving
)
2836 fprintf (file
, " resolving");
2837 if (sym
->sy_flags
.sy_used_in_reloc
)
2838 fprintf (file
, " used-in-reloc");
2839 if (sym
->sy_flags
.sy_used
)
2840 fprintf (file
, " used");
2841 if (S_IS_LOCAL (sym
))
2842 fprintf (file
, " local");
2843 if (S_IS_EXTERNAL (sym
))
2844 fprintf (file
, " extern");
2845 if (S_IS_WEAK (sym
))
2846 fprintf (file
, " weak");
2847 if (S_IS_DEBUG (sym
))
2848 fprintf (file
, " debug");
2849 if (S_IS_DEFINED (sym
))
2850 fprintf (file
, " defined");
2852 if (S_IS_WEAKREFR (sym
))
2853 fprintf (file
, " weakrefr");
2854 if (S_IS_WEAKREFD (sym
))
2855 fprintf (file
, " weakrefd");
2856 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
2857 if (symbol_resolved_p (sym
))
2859 segT s
= S_GET_SEGMENT (sym
);
2861 if (s
!= undefined_section
2862 && s
!= expr_section
)
2863 fprintf (file
, " %lx", (unsigned long) S_GET_VALUE (sym
));
2865 else if (indent_level
< max_indent_level
2866 && S_GET_SEGMENT (sym
) != undefined_section
)
2869 fprintf (file
, "\n%*s<", indent_level
* 4, "");
2870 if (LOCAL_SYMBOL_CHECK (sym
))
2871 fprintf (file
, "constant %lx",
2872 (unsigned long) ((struct local_symbol
*) sym
)->lsy_value
);
2874 print_expr_1 (file
, &sym
->sy_value
);
2875 fprintf (file
, ">");
2882 print_symbol_value (symbolS
*sym
)
2885 print_symbol_value_1 (stderr
, sym
);
2886 fprintf (stderr
, "\n");
2890 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
2893 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
2894 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2895 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2896 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2897 fprintf (file
, ">");
2902 print_expr_1 (FILE *file
, expressionS
*exp
)
2904 fprintf (file
, "expr ");
2905 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) exp
));
2906 fprintf (file
, " ");
2910 fprintf (file
, "illegal");
2913 fprintf (file
, "absent");
2916 fprintf (file
, "constant %lx", (unsigned long) exp
->X_add_number
);
2920 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
2921 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2922 fprintf (file
, ">");
2924 if (exp
->X_add_number
)
2925 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
2926 (unsigned long) exp
->X_add_number
);
2930 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
2933 fprintf (file
, "big");
2936 fprintf (file
, "uminus -<");
2938 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2939 fprintf (file
, ">");
2940 goto maybe_print_addnum
;
2942 fprintf (file
, "bit_not");
2945 print_binary (file
, "multiply", exp
);
2948 print_binary (file
, "divide", exp
);
2951 print_binary (file
, "modulus", exp
);
2954 print_binary (file
, "lshift", exp
);
2957 print_binary (file
, "rshift", exp
);
2959 case O_bit_inclusive_or
:
2960 print_binary (file
, "bit_ior", exp
);
2962 case O_bit_exclusive_or
:
2963 print_binary (file
, "bit_xor", exp
);
2966 print_binary (file
, "bit_and", exp
);
2969 print_binary (file
, "eq", exp
);
2972 print_binary (file
, "ne", exp
);
2975 print_binary (file
, "lt", exp
);
2978 print_binary (file
, "le", exp
);
2981 print_binary (file
, "ge", exp
);
2984 print_binary (file
, "gt", exp
);
2987 print_binary (file
, "logical_and", exp
);
2990 print_binary (file
, "logical_or", exp
);
2994 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
2995 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2996 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2997 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2998 fprintf (file
, ">");
2999 goto maybe_print_addnum
;
3002 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
3003 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3004 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3005 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3006 fprintf (file
, ">");
3007 goto maybe_print_addnum
;
3009 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
3016 print_expr (expressionS
*exp
)
3018 print_expr_1 (stderr
, exp
);
3019 fprintf (stderr
, "\n");
3023 symbol_print_statistics (FILE *file
)
3025 hash_print_statistics (file
, "symbol table", sy_hash
);
3026 hash_print_statistics (file
, "mini local symbol table", local_hash
);
3027 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
3028 local_symbol_count
, local_symbol_conversion_count
);
3031 #ifdef OBJ_COMPLEX_RELC
3033 /* Convert given symbol to a new complex-relocation symbol name. This
3034 may be a recursive function, since it might be called for non-leaf
3035 nodes (plain symbols) in the expression tree. The caller owns the
3036 returning string, so should free it eventually. Errors are
3037 indicated via as_bad and a NULL return value. The given symbol
3038 is marked with sy_used_in_reloc. */
3041 symbol_relc_make_sym (symbolS
* sym
)
3043 char * terminal
= NULL
;
3048 gas_assert (sym
!= NULL
);
3050 /* Recurse to symbol_relc_make_expr if this symbol
3051 is defined as an expression or a plain value. */
3052 if ( S_GET_SEGMENT (sym
) == expr_section
3053 || S_GET_SEGMENT (sym
) == absolute_section
)
3054 return symbol_relc_make_expr (& sym
->sy_value
);
3056 /* This may be a "fake symbol" L0\001, referring to ".".
3057 Write out a special null symbol to refer to this position. */
3058 if (! strcmp (S_GET_NAME (sym
), FAKE_LABEL_NAME
))
3059 return xstrdup (".");
3061 /* We hope this is a plain leaf symbol. Construct the encoding
3062 as {S,s}II...:CCCCCCC....
3063 where 'S'/'s' means section symbol / plain symbol
3064 III is decimal for the symbol name length
3065 CCC is the symbol name itself. */
3066 symbol_mark_used_in_reloc (sym
);
3068 sname
= S_GET_NAME (sym
);
3069 sname_len
= strlen (sname
);
3070 typetag
= symbol_section_p (sym
) ? 'S' : 's';
3072 terminal
= xmalloc (1 /* S or s */
3073 + 8 /* sname_len in decimal */
3075 + sname_len
/* name itself */
3078 sprintf (terminal
, "%c%d:%s", typetag
, sname_len
, sname
);
3082 /* Convert given value to a new complex-relocation symbol name. This
3083 is a non-recursive function, since it is be called for leaf nodes
3084 (plain values) in the expression tree. The caller owns the
3085 returning string, so should free() it eventually. No errors. */
3088 symbol_relc_make_value (offsetT val
)
3090 char * terminal
= xmalloc (28); /* Enough for long long. */
3093 bfd_sprintf_vma (stdoutput
, terminal
+ 1, val
);
3097 /* Convert given expression to a new complex-relocation symbol name.
3098 This is a recursive function, since it traverses the entire given
3099 expression tree. The caller owns the returning string, so should
3100 free() it eventually. Errors are indicated via as_bad() and a NULL
3104 symbol_relc_make_expr (expressionS
* exp
)
3106 char * opstr
= NULL
; /* Operator prefix string. */
3107 int arity
= 0; /* Arity of this operator. */
3108 char * operands
[3]; /* Up to three operands. */
3109 char * concat_string
= NULL
;
3111 operands
[0] = operands
[1] = operands
[2] = NULL
;
3113 gas_assert (exp
!= NULL
);
3115 /* Match known operators -> fill in opstr, arity, operands[] and fall
3116 through to construct subexpression fragments; may instead return
3117 string directly for leaf nodes. */
3119 /* See expr.h for the meaning of all these enums. Many operators
3120 have an unnatural arity (X_add_number implicitly added). The
3121 conversion logic expands them to explicit "+" subexpressions. */
3126 as_bad ("Unknown expression operator (enum %d)", exp
->X_op
);
3131 return symbol_relc_make_value (exp
->X_add_number
);
3134 if (exp
->X_add_number
)
3138 operands
[0] = symbol_relc_make_sym (exp
->X_add_symbol
);
3139 operands
[1] = symbol_relc_make_value (exp
->X_add_number
);
3143 return symbol_relc_make_sym (exp
->X_add_symbol
);
3145 /* Helper macros for nesting nodes. */
3147 #define HANDLE_XADD_OPT1(str_) \
3148 if (exp->X_add_number) \
3151 opstr = "+:" str_; \
3152 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3153 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3160 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3164 #define HANDLE_XADD_OPT2(str_) \
3165 if (exp->X_add_number) \
3168 opstr = "+:" str_; \
3169 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3170 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3171 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3177 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3178 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3182 /* Nesting nodes. */
3184 case O_uminus
: HANDLE_XADD_OPT1 ("0-");
3185 case O_bit_not
: HANDLE_XADD_OPT1 ("~");
3186 case O_logical_not
: HANDLE_XADD_OPT1 ("!");
3187 case O_multiply
: HANDLE_XADD_OPT2 ("*");
3188 case O_divide
: HANDLE_XADD_OPT2 ("/");
3189 case O_modulus
: HANDLE_XADD_OPT2 ("%");
3190 case O_left_shift
: HANDLE_XADD_OPT2 ("<<");
3191 case O_right_shift
: HANDLE_XADD_OPT2 (">>");
3192 case O_bit_inclusive_or
: HANDLE_XADD_OPT2 ("|");
3193 case O_bit_exclusive_or
: HANDLE_XADD_OPT2 ("^");
3194 case O_bit_and
: HANDLE_XADD_OPT2 ("&");
3195 case O_add
: HANDLE_XADD_OPT2 ("+");
3196 case O_subtract
: HANDLE_XADD_OPT2 ("-");
3197 case O_eq
: HANDLE_XADD_OPT2 ("==");
3198 case O_ne
: HANDLE_XADD_OPT2 ("!=");
3199 case O_lt
: HANDLE_XADD_OPT2 ("<");
3200 case O_le
: HANDLE_XADD_OPT2 ("<=");
3201 case O_ge
: HANDLE_XADD_OPT2 (">=");
3202 case O_gt
: HANDLE_XADD_OPT2 (">");
3203 case O_logical_and
: HANDLE_XADD_OPT2 ("&&");
3204 case O_logical_or
: HANDLE_XADD_OPT2 ("||");
3207 /* Validate & reject early. */
3208 if (arity
>= 1 && ((operands
[0] == NULL
) || (strlen (operands
[0]) == 0)))
3210 if (arity
>= 2 && ((operands
[1] == NULL
) || (strlen (operands
[1]) == 0)))
3212 if (arity
>= 3 && ((operands
[2] == NULL
) || (strlen (operands
[2]) == 0)))
3216 concat_string
= NULL
;
3219 /* Allocate new string; include inter-operand padding gaps etc. */
3220 concat_string
= xmalloc (strlen (opstr
)
3222 + (arity
>= 1 ? (strlen (operands
[0]) + 1 ) : 0)
3223 + (arity
>= 2 ? (strlen (operands
[1]) + 1 ) : 0)
3224 + (arity
>= 3 ? (strlen (operands
[2]) + 0 ) : 0)
3226 gas_assert (concat_string
!= NULL
);
3228 /* Format the thing. */
3229 sprintf (concat_string
,
3230 (arity
== 0 ? "%s" :
3231 arity
== 1 ? "%s:%s" :
3232 arity
== 2 ? "%s:%s:%s" :
3233 /* arity == 3 */ "%s:%s:%s:%s"),
3234 opstr
, operands
[0], operands
[1], operands
[2]);
3237 /* Free operand strings (not opstr). */
3238 if (arity
>= 1) xfree (operands
[0]);
3239 if (arity
>= 2) xfree (operands
[1]);
3240 if (arity
>= 3) xfree (operands
[2]);
3242 return concat_string
;